flickrmocks 0.8.5

data/spec/models/photos_spec.rb

@@ -0,0 +1,305 @@
+require 'spec_helper'
+
+
+describe APP::Photos do
+  let(:api) {APP::Api}
+  let(:klass) {APP::Photos}
+  let(:fixtures){APP::Fixtures.new}
+  let(:photos_fixture) {fixtures.photos}
+  let(:interesting_photos_fixture){fixtures.interesting_photos}
+
+  subject {klass.new photos_fixture}
+  let(:max_pages){subject.default(:max_entries)/subject.default(:per_page)}
+
+  context "class methods" do 
+    specify { klass.should respond_to(:defaults)}
+    
+    context "defaults" do
+      before(:each) do
+        @defaults = klass.defaults.clone
+      end
+      after(:each) do
+        klass.defaults = @defaults
+      end
+      specify {klass.defaults.should have_key(:max_entries)}
+      specify {klass.defaults.should have_key(:per_page)}
+
+      it "should behave like a Hash" do
+        klass.defaults.keys.each do |key|
+          setter = (key.to_s + '=').to_sym
+          value = klass.defaults.send(:[],key)
+          expected = value*2
+          klass.defaults.send(:[]=,key,expected)
+          klass.defaults.send(:[],key).should == expected
+        end
+      end
+    end   
+  end
+
+  context "class instance variables" do    
+    context "@defaults" do
+      specify { klass.defaults.should have_key(:max_entries) }
+      specify { klass.defaults.should have_key(:per_page) }
+      
+      it "returns 50 for argument :per_page" do
+        klass.defaults[:per_page].should == 50
+      end
+      it "returns 4000 for argument :max_entries" do
+        klass.defaults[:max_entries].should == 4000
+      end
+    end
+  end
+
+
+  context "initialization" do
+    it "returns object of a proper class when photos FlickRaw::ResponseList provided" do
+      klass.new(fixtures.photos).class.should == klass
+    end
+    it "raises an error when FlickRaw::Response provided" do
+      expect {klass.new(fixtures.photo)}.to raise_error(ArgumentError)
+    end
+    it "raises an error when an Array class specified" do
+      expect {klass.new([1,2,3,4])}.to raise_error(ArgumentError)
+    end
+    it "raises an error when sizes FlickRaw::ResponseList provided" do
+      expect {klass.new(fixtures.sizes)}.to raise_error
+    end
+  end
+
+  context "instance methods" do
+    specify {  subject.should respond_to(:default) }
+    context "#default" do
+      it "accepts a string for argument" do
+        klass.defaults.each_pair do |key,value|
+          subject.default(key.to_s).should == value
+        end
+      end
+      it "accepts a symbol for argument" do
+        klass.defaults.each_pair do |key,value|
+          subject.default(key.to_sym).should == value
+        end
+      end
+      it "returns 50 for :per_page" do
+        subject.default(:per_page).should == klass.defaults[:per_page]
+      end
+      it "returns 4000 for :max_entries" do
+        subject.default(:max_entries).should == klass.defaults[:max_entries]
+      end
+    end
+
+    specify {  subject.should respond_to(:current_page) }
+    context "#current_page" do
+      it "returns expected page" do
+        subject.current_page.should == photos_fixture.page
+      end
+      it "returns kind of type Fixnum" do
+        subject.current_page.should be_a(Fixnum)
+      end
+    end
+
+    specify {  subject.should respond_to(:per_page) }
+    describe "#per_page" do
+      it "returns maximum entries possible for a page" do
+        subject.per_page.should == photos_fixture.perpage
+      end
+      it "returns kind of Fixnum" do
+        subject.per_page.should be_a(Fixnum)
+      end
+    end
+
+    specify {  subject.should respond_to(:perpage) }
+    describe "#perpage" do
+      it "returns maximum entries possible for a page" do
+        subject.perpage.should == photos_fixture.perpage
+      end
+      it "returns kind of Fixnum" do
+        subject.perpage.should be_a(Fixnum)
+      end
+    end
+
+    specify { subject.should respond_to(:total_entries) }
+    describe "#total_entries" do
+      it "returns total of photos" do
+        subject.total_entries.should == photos_fixture.total.to_i
+      end
+      specify{ subject.total_entries.should be_a(Fixnum)}
+    end
+
+    specify {subject.should respond_to(:capped_entries)}
+    describe "#capped_entries"  do
+      it "returns total_entries when total_entries <= max_entries" do
+        subject.stub(:total_entries).and_return(subject.max_entries)
+        subject.capped_entries.should == subject.total_entries
+      end
+      it "returns max_entries when total_entries > max_entries" do
+        subject.stub(:total_entries).and_return(subject.max_entries + 200)
+        subject.capped_entries.should < subject.total_entries
+        subject.capped_entries.should == subject.max_entries
+      end
+    end
+
+    specify { subject.should respond_to(:max_entries) }
+    describe "#max_entries" do
+      it "returns maximum possible entries returned by flickr" do
+        subject.max_entries.should == subject.default(:max_entries)
+      end
+      it "returns kind of Fixnum" do
+        subject.max_entries.should be_a(Fixnum)
+      end
+    end
+
+    specify { subject.should respond_to(:pages) }
+    describe "#pages" do
+      it "limits the number of pages when total_pages > max_pages" do
+        subject.stub(:total_pages).and_return(max_pages+20)
+        subject.pages.should == max_pages
+      end
+      it "returns total pages when total_pages <= max_pages" do
+        pages = max_pages() - 1
+        subject.stub(:total_pages).and_return(pages)
+        subject.pages.should == pages
+      end
+      it "returns kind of Fixnum" do
+        subject.pages.should be_a(Fixnum)
+      end
+    end
+
+    specify {  subject.should respond_to(:capped?) }
+    describe "#capped?" do
+      it "returns true when partial number of entries returned" do
+        subject.stub(:total_entries).and_return(subject.default(:max_entries)+1)
+        subject.should be_capped
+      end
+      it "returns false when all entries returned" do
+        subject.stub(:total_entries).and_return(subject.default(:max_entries))
+        subject.should_not be_capped
+      end
+    end
+
+    specify { subject.should respond_to(:photos) }
+    describe "#photos" do
+      it "returns kind of Array" do
+        subject.photos.should be_an(Array)
+      end
+      it "returns Array containing elements of class FlickrMocks::Photo " do
+        subject.photos.each do |photo|
+          photo.should be_instance_of(APP::Photo)
+        end
+      end
+      it "returns expected number of photos" do
+        subject.photos.length.should == fixtures.photos.map(&:id).length
+      end
+    end
+
+
+    specify {subject.should respond_to(:==)}
+    context "#==" do
+      it "returns true when comparing object to self" do
+        subject.should == subject
+      end
+      it "returns true when comparing object to clone of self" do
+        subject.should == subject.clone
+      end
+      it "returns false when object compared to random object" do
+        subject.should_not == [1,2,3,4]
+      end
+      it "returns false when object compard to nil" do
+        subject.should_not == nil
+      end
+      it "returns false when object compared to object that is different in only one element" do
+        other = subject.clone
+        other.photos.last.instance_eval('@delegated_to_object').instance_eval('@h["farm"]=1234321')
+        subject.should_not == other
+      end
+    end
+
+    specify {subject.should respond_to(:collection)}
+    context "#collection" do
+      context "usable argument set to nil" do
+        let(:reference){
+          OpenStruct.new :current_page => subject.current_page,
+          :per_page => subject.per_page,
+          :total_entries => subject.capped_entries,
+          :collection => subject.photos
+        }
+        it_behaves_like "object that responds to collection"
+      end
+
+      context "usable argument set to true" do
+        subject {klass.new(interesting_photos_fixture)}
+        let(:collection){subject.photos.clone.keep_if do |p| p.license.to_i > 3 end}
+        let(:reference) {
+          OpenStruct.new :current_page => 1,
+          :per_page => subject.perpage,
+          :total_entries => collection.length,
+          :collection => collection
+        }
+        it_behaves_like "object that responds to collection with usable option"
+      end
+
+      context "empty collection" do
+        let(:reference) {
+        OpenStruct.new :current_page => 1,
+          :per_page => fixtures.empty_photos.perpage,
+          :total_entries => 0,
+          :collection => []
+        }
+        let(:subject){klass.new(fixtures.empty_photos)}
+        it_behaves_like "object with no items that responds to collection"
+      end
+    end
+
+    specify {subject.should respond_to(:usable_photos)}
+    context "#usable_items" do
+      it "returns all items if every item is usable" do
+        subject.usable_photos == subject.photos
+      end
+      it "returns subset of items if not all items are usable" do
+        subject.usable_photos == subject.photos.clone.keep_if(&:usable?)
+      end
+    end
+
+    context "meta-programming" do
+      specify{ subject.should respond_to(:delegated_instance_methods)}
+      context "#delegated_instance_methods" do
+        it "returns expected list of methods that are delegated to other objects" do
+          subject.delegated_instance_methods.should == APP::Models::Helpers.array_accessor_methods
+        end
+      end
+
+      specify { subject.should respond_to(:methods)}
+      context "#methods" do
+        it "should return all methods as well as array iteration methods" do
+          subject.methods.sort.should == (subject.old_methods + subject.delegated_instance_methods).sort
+        end
+      end
+      
+      specify{ subject.should respond_to(:respond_to?)}
+      context "#respond_to?" do
+        it "recognizes all methods returned by #methods" do
+          subject.methods.each do |method|
+            subject.should respond_to(method)
+          end
+        end
+      end
+      context "iteratable methods" do
+        let(:reference) {subject.photos}
+        it_behaves_like "object with delegated Array accessor helpers"
+      end
+    end
+
+    context "custom cloning methods" do
+      context "#initialize_copy" do
+        it "returns photo objects that have distinct ids from the cloned object" do
+          other = subject.clone
+          index = 0
+          subject.photos.each do |photo|
+            photo.__id__.should_not == other.photos[index].__id__
+            index += 1
+          end
+        end
+      end
+    end
+  end
+
+end

data/spec/shared_examples/array_accessor.rb

@@ -0,0 +1,157 @@
+shared_examples_for "object with delegated Array accessor helpers" do
+  # NOTE: need to define:
+  # =>  subject : that returns item under test, which has accessor
+  # => references : object that gets delegated to
+  specify{subject.should respond_to(:[])}
+  specify{subject.should respond_to(:at)}
+  specify{subject.should respond_to(:fetch)}
+  specify{subject.should respond_to(:first)}
+  specify{subject.should respond_to(:last)}
+  specify{subject.should respond_to(:each)}
+  specify{subject.should respond_to(:each_index)}
+  specify{subject.should respond_to(:reverse_each)}
+  specify{subject.should respond_to(:length)}
+  specify{subject.should respond_to(:size)}
+  specify{subject.should respond_to(:empty?)}
+  specify{subject.should respond_to(:find_index)}
+  specify{subject.should respond_to(:index)}
+  specify{subject.should respond_to(:rindex)}
+  specify{subject.should respond_to(:collect)}
+  specify{subject.should respond_to(:map)}
+  specify{subject.should respond_to(:select)}
+  specify{subject.should respond_to(:keep_if)}
+  specify{subject.should respond_to(:values_at)}
+
+  context "#[]" do
+    it "returns same reference for index 0" do
+      subject[0].should == reference[0]
+    end
+    it "returns same reference for index -1" do
+      subject[-1].should == reference[-1]
+    end
+  end
+
+  context "#at" do
+    it "returns same as reference element 0" do
+      subject.at(0).should == reference.at(0)
+    end
+  end
+
+  context "#values_at" do
+    it "returns same value as element 0" do
+      subject.values_at(0).should == reference.values_at(0)
+    end
+  end
+
+  context "#fetch" do
+    it "returns same as reference for element 0" do
+      subject.fetch(0).should == reference.fetch(0)
+    end
+  end
+
+  context "#first" do
+    it "returns same element as reference" do
+      subject.first == reference.first
+    end
+  end
+
+  context "#last" do
+    it "returns same element as reference" do
+      subject.last == reference.last
+    end
+  end
+
+  context "#length" do
+    it "returns same value as reference" do
+      subject.length.should == reference.length
+    end
+  end
+
+  context "#size" do
+    it "returns same value as reference" do
+      subject.size.should == reference.size
+    end
+  end
+
+  context "#find_index" do
+    it "returns same index as reference" do
+      subject.find_index(subject[0]).should == reference.find_index(subject[0])
+    end
+  end
+
+  context "#index" do
+    it "returns same index as reference" do
+      subject.index(subject[0]).should == reference.index(subject[0])
+    end
+  end
+
+  context "#empty?" do
+    it "returns same value as reference" do
+      subject.empty?.should == reference.empty?
+    end
+  end
+
+  context "#each" do
+    it "returns same list as reference" do
+      actual = []
+      expected =[]
+      subject.each {|v| actual.push v}
+      reference.each{|v| expected.push v}
+      actual.should == expected
+    end
+  end
+
+
+  context "#each_index" do
+    it "returns same list as reference" do
+      compare_iterator(:each_index)
+    end
+  end
+
+  context "#reverse_each" do
+    it "returns same list as reference" do
+      compare_iterator(:reverse_each)
+    end
+  end
+
+  context "#rindex" do
+    it "returns same list as reference" do
+      compare_iterator(:rindex)
+    end
+  end
+
+  context "#select" do
+    it "returns same list as reference" do
+      actual = []
+      expected = []
+      subject.select {|v| true }.should == reference.select {|v| true }
+    end
+  end
+
+  context "#collect" do
+    it "returns same as reference" do
+      subject.collect { |v| v }.should == reference.collect { |v| v }
+    end
+  end
+
+  context "#map" do
+    it "returns same as reference" do
+      subject.map {|v| v.__id__ }.should == reference.map { |v| v.__id__ }
+    end
+  end
+
+  context "#keep_if" do
+    it "returns same as reference" do
+      subject.keep_if {|v| true}.should == reference.keep_if {|v| true}
+    end
+  end
+
+  private
+
+  def compare_iterator(method)
+    actual = []
+    expected = []
+    subject.send(method) {|v| actual.push(v) }.should ==  reference.send(method) { |v| expected.push(v) }
+  end
+end
+

data/spec/shared_examples/collection.rb

@@ -0,0 +1,49 @@
+# subject is object under test
+# reference is an object that responds to: :current_page,:per_page,:total_entries,:collection
+shared_examples_for "object that responds to collection" do
+  specify {subject.collection.class.should == WillPaginate::Collection}
+  it "returns object with expected current_page" do
+    subject.collection.current_page.should == reference.current_page
+  end
+  it "returns object with expected per_page" do
+    subject.collection.per_page.should == reference.per_page
+  end
+  it "returns object with expected total_entries" do
+    subject.collection.total_entries.should == reference.total_entries
+  end
+  it "returns object with expected elements" do
+    subject.collection.map do |item| item end.should == reference.collection.map do |item|  item end
+  end
+end
+
+shared_examples_for "object with no items that responds to collection" do
+    specify {subject.should respond_to(:collection)}
+    it "returns object with expected current_page" do
+      subject.collection.current_page.should == reference.current_page
+    end
+    it "returns object with expected per_page" do
+      subject.collection.per_page.should == reference.per_page
+    end
+    it "returns object with expected total_entries" do
+      subject.collection.total_entries.should == reference.total_entries
+    end
+    it "returns object with no elements" do
+      subject.collection.should == reference.collection
+    end
+end
+
+shared_examples_for "object that responds to collection with usable option" do
+    specify {subject.collection(true).class.should == WillPaginate::Collection}
+    it "returns collection that includes only usable photos" do
+      subject.collection(true).should == reference.collection
+    end
+    it "returns object with current_page set to 1" do
+      subject.collection(true).current_page.should == reference.current_page
+    end
+    it "returns object with total_entries set to number of usable entries in current page" do
+      subject.collection(true).total_entries.should == reference.total_entries
+    end
+    it "returns object with per_page set ot number of usable entries on current page" do
+      subject.collection(true).per_page.should == reference.per_page
+    end
+end

data/spec/shared_examples/image_url_helpers.rb

@@ -0,0 +1,56 @@
+shared_examples_for "object with flickr image url helpers" do  
+  specify {subject.should respond_to(:square)}
+  let(:base_url){"http://farm%s.static.flickr.com/%s/%s_%s" %[
+            subject.farm,
+            subject.server,
+            subject.id,
+            subject.secret
+          ]}
+  context "#square" do
+    it "returns expected url for squre flickr image" do
+      subject.square.should == "#{base_url}_s.jpg"
+    end
+  end
+
+  specify {subject.should respond_to(:thumbnail)}
+  context "#thumbnail_url" do
+    it "returns expected url for thumbnail image" do
+      subject.thumbnail.should == "#{base_url}_t.jpg"
+    end
+  end
+
+  specify {subject.should respond_to(:small)}
+  context "#small" do
+    it "returns expected url for small image" do
+      subject.small.should == "#{base_url}_m.jpg"
+    end
+  end
+
+  specify {subject.should respond_to(:medium)}
+  context "#medium" do
+    it "returns expected url for medium" do
+      subject.medium.should == "#{base_url}.jpg"
+    end
+  end
+
+  specify {subject.should respond_to(:large)}
+  context "#large" do
+    it "returns expected url for large image" do
+      subject.large.should == "#{base_url}_b.jpg"
+    end
+  end
+
+  specify {subject.should respond_to(:medium_640)}
+  context "#medium_640" do
+    it "returns expected url for medium 640 image" do
+      subject.medium_640.should == "#{base_url}_z.jpg"
+    end
+  end
+
+  specify {subject.should respond_to(:'medium 640')}
+  context "#'medium 640'" do
+    it "returns expected url for medium 640 image" do
+      subject.send(:'medium 640').should == "#{base_url}_z.jpg"
+    end
+  end
+end

data/spec/shared_examples/size_accessor.rb

@@ -0,0 +1,13 @@
+shared_examples_for "object with size accessor" do
+  it "returns object with expected size" do
+    subject.send(size).size.should == reference.size
+  end
+
+  it "returns object with expected width" do
+    subject.send(size).width.should == reference.width
+  end
+
+  it "returns object with expected height" do
+    subject.send(size).height.should == reference.height
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'rspec'
+
+require 'faker'
+
+require 'chronic_duration'
+require 'flickraw-cached'
+require 'ruby-debug'
+
+require 'shared_examples/array_accessor'
+require 'shared_examples/image_url_helpers'
+require 'shared_examples/size_accessor'
+require 'shared_examples/collection'
+
+require 'flickrmocks'
+
+Rspec.configure do |c|
+#  c.mock_with :mocha
+
+  APP = FlickrMocks
+  FlickrFixtures = APP::Fixtures.new
+end
+
+