flickrmocks 0.8.5

data/spec/models/photo_details_spec.rb

@@ -0,0 +1,224 @@
+require 'spec_helper'
+
+describe APP::PhotoDetails do  
+  let(:klass){APP::PhotoDetails}
+  let(:fixtures){APP::Fixtures.new}
+
+  let(:basic_photo) { APP::Photo.new fixtures.photo }
+  let(:extended_photo) { APP::Photo.new fixtures.photo_details }
+  let(:photo_sizes) { APP::PhotoSizes.new fixtures.photo_sizes }
+
+  let(:photo_details_basic){klass.new(basic_photo,photo_sizes)}
+  let(:photo_details_extended){klass.new(extended_photo,photo_sizes)}
+
+  
+  describe "initialization" do
+    it "returns object of proper class when extended PhotoDetails and PhotoSizes supplied" do
+      klass.new(extended_photo,photo_sizes).should be_a(klass)
+    end
+    it "returns object of proper class when basic PhotoDetails and PhotoSizes supplied" do
+      klass.new(basic_photo,photo_sizes).should be_a(klass)
+    end
+    it "returns object of expected class when proper flickr responses supplied for sizes and photo" do
+      klass.new(fixtures.photo_details,fixtures.photo_sizes).should be_a(klass)
+    end
+    it "raises an error when Array supplied for photo" do
+      lambda{APP::PhotoDetails.new [],photo_sizes}.should raise_error ArgumentError
+    end
+    it "raises an error when Array supplied for photo_details" do
+      lambda{APP::PhotoDetails.new extended_photo,[]}.should raise_error ArgumentError
+    end
+    it "raises error when nil supplied for photo_sizes" do
+      lambda{APP::PhotoDetails.new extended_photo,nil}.should raise_error ArgumentError
+    end
+    it "raises error when nil supplied for photo_details" do
+      lambda{APP::PhotoDetails.new nil,photo_sizes}.should raise_error ArgumentError
+    end
+  end
+
+  context "instance methods" do
+    subject {photo_details_extended}
+    specify {subject.should respond_to(:owner_name)}
+    context "#owner_name" do
+      it "returns expected name for owner" do
+        subject.owner_name.should == fixtures.photo_details.owner.realname
+      end
+    end
+
+    specify {subject.should respond_to(:owner_username)}
+    context "#owner_username" do
+      it "returns expected name for owner" do
+        subject.owner_username.should == fixtures.photo_details.owner.username
+      end
+    end
+
+    specify {subject.should respond_to(:dimensions)}
+    context "#dimensions" do
+      it "returns expected PhotoSize object" do
+        subject.dimensions.should == photo_sizes
+      end
+    end
+
+    specify {subject.should respond_to(:possible_sizes)}
+    context "#possible_sizes" do
+      it "returns list of all possible sizes" do
+        subject.possible_sizes.should == FlickrMocks::Models::Helpers.possible_sizes
+      end
+    end
+
+    specify {subject.should respond_to(:photo)}
+    context "#photo" do
+      it "returns expected Photo object when basic photo" do
+        subject.photo.should == extended_photo
+      end
+    end
+
+    specify {subject.should respond_to(:==)}
+    context "#==" do
+      it "returns true when object is compared to itself" do
+        subject.should == subject
+      end
+      it "returns true when object is compared to clone of itself" do
+        subject.should == subject.clone
+      end
+      it "returns false when object is compared to an Array" do
+        subject.should_not == [1,2,3]
+      end
+      it "returns false when a single dimension is different" do
+        other = subject.clone
+        other.dimensions[0].instance_eval('@delegated_to_object').instance_eval('@h["width"]=-22')
+        subject.should_not == other
+      end
+      it "returns false when a single photo attribute is different" do
+        other = subject.clone
+        subject.photo.instance_eval('@delegated_to_object').instance_eval('@h["farm"]=-22')
+        subject.should_not == other
+      end
+    end
+
+    context "methods that are delegated to photo object" do
+      context "basic photo object" do
+        subject {photo_details_basic}
+        it "returns expected result delegated to non-url helpers for basic photo" do
+          subject.photo.delegated_instance_methods.each do |method|
+            subject.send(method).should == subject.photo.send(method)
+          end
+        end
+      it "returns expected result delegated to url helpers for basic photo" do
+          reference = APP::Photo.new(fixtures.photo)
+          FlickrMocks::Models::Helpers.possible_sizes.each do |size|
+            subject.send(size).should == reference.send(size)
+          end
+      end
+      end
+      context "detailed photo object" do
+        subject {photo_details_extended}
+        eval('specify {subject.should respond_to(:id)}')
+        it "returns expected result for basic delegated photos" do
+          subject.photo.delegated_instance_methods.each do |method|
+            subject.send(method).should == subject.photo.send(method)
+          end
+        end
+        it "returns expected result delegated to url helpers for detailed photo" do
+          reference = APP::Photo.new(fixtures.photo_details)
+          FlickrMocks::Models::Helpers.possible_sizes.each do |size|
+            subject.send(size).should == reference.send(size)
+          end
+        end
+      end
+    end
+
+    context "iteration methods delegated to dimensions (PhotoSizes)" do    
+        let(:reference){photo_sizes}
+        it_should_behave_like "object with delegated Array accessor helpers"
+      end
+  end
+
+
+  context "metaprogramming methods" do    
+    context "#respond_to?" do
+      context "with basic photo" do
+        subject {photo_details_basic}
+        specify {subject.should respond_to(:respond_to?)}
+        it "returns true for all methods including the ones that are delegated to sizes and basic photo" do
+          subject.methods.each do |method|
+            subject.should respond_to(method)
+          end
+        end
+      end
+
+      context "with extended photo" do
+        subject {photo_details_extended}
+        specify {subject.should respond_to(:respond_to?)}
+        it "returns true for all methods including the ones that are delegated to sizes and extended photo" do
+          subject.methods.each do |method|
+            subject.should respond_to(method)
+          end
+        end
+      end
+    end
+
+    context "#methods" do
+      context "with basic photo" do
+        subject {photo_details_basic}
+        specify {subject.should respond_to(:methods)}
+        it "resturns methods including those delegated to sizes and basic photo" do
+          subject.methods.sort.should == (subject.old_methods + subject.delegated_instance_methods).sort
+        end
+      end
+
+      context "with extended photo" do
+        subject {photo_details_extended}
+        specify {subject.should respond_to(:methods)}
+        it "returns methods including those delegated to sizes and extended photo" do
+          subject.methods.sort.should == (subject.old_methods + subject.delegated_instance_methods).sort
+        end
+      end
+    end
+
+    context "#delegated_instance_methods" do
+      context "with basic photo" do
+        subject {photo_details_basic}
+        specify {subject.should respond_to(:delegated_instance_methods)}
+        it "returns methods including those delegated to sizes and basic photo" do
+          subject.delegated_instance_methods.sort.should ==  
+            (subject.photo.delegated_instance_methods +
+              FlickrMocks::Models::Helpers.array_accessor_methods +
+              FlickrMocks::Models::Helpers.possible_sizes +
+              [:owner_id]).sort
+        end
+      end
+      context "with extended photo" do
+        subject {photo_details_extended}
+        specify {subject.should respond_to(:delegated_instance_methods)}
+        it "returns methods including those delegated to sizes and extended photo" do
+          subject.delegated_instance_methods.sort.should ==
+            (subject.photo.delegated_instance_methods +
+              FlickrMocks::Models::Helpers.array_accessor_methods +
+              FlickrMocks::Models::Helpers.possible_sizes +
+              [:owner_id]).sort
+        end
+      end
+    end
+  end
+
+
+  context "custom cloning methods" do
+    subject{photo_details_extended}
+    context "#initialize_copy" do
+      it "returns cloned object with distinct __id__ for dimensions" do
+        subject.dimensions.__id__.should_not == subject.clone.dimensions.__id__
+      end
+      it "returns cloned object with distinct __id__ for photo" do
+        subject.instance_eval('@delegated_to_object.__id__').should_not ==
+          subject.clone.instance_eval('@delegated_to_object.__id__')
+      end
+    end
+  end
+
+end
+
+
+
+
+

data/spec/models/photo_dimensions_spec.rb

@@ -0,0 +1,208 @@
+require 'spec_helper'
+
+describe APP::PhotoDimensions do
+  let(:dimensions_string) {'square:1x11,thumbnail:2x12,small:3x13,medium:4x14,medium_640:5x15,large:6x16,original:7x17'}
+  let(:expected_sizes) { [:square, :thumbnail, :small, :medium,:medium_640, :large, :original] }
+  let(:klass) {APP::PhotoDimensions}
+
+  subject { APP::PhotoDimensions.new(dimensions_string) }
+
+  context "class methods" do
+    specify {klass.should respond_to(:regexp_size)}
+    context "regexp_size" do
+      it "returns match when provided with valid string such as: 'square:1x11,thumbnail:2x12'" do
+        klass.regexp_size.match('square:1x11,thumbnail:2x12').should_not be_nil
+      end
+      it "returns nil when string contains an extra comma" do
+        klass.regexp_size.match('square:1x11,thumbnail:2x12,').should be_nil
+      end
+      it "returns nil when string is missing a comma" do
+        klass.regexp_size.match('square1x11,thumbnail:2x12').should be_nil
+      end
+    end
+  end
+  
+  context "initialize" do
+    context "valid initialization strings" do
+      it "returns object of proper class with valid string" do
+        klass.new('square:1x11,thumbnail:2x12,small:3x13,medium:4x14,medium_640:5x15,large:6x16,original:7x17').class.should == klass
+      end
+      it "returns object of proper class with string containing only a single dimension" do
+        klass.new('medium:4x14').class.should == klass
+      end
+    end
+    
+    context "initialization with invalid arguments" do
+      it "raises exception when string contains invalid size" do
+        lambda {klass.new('square:1x11,howdy:2x12')}.should raise_error(ArgumentError)
+      end
+      it "raises exception when string contains extraneous comma" do
+        lambda {klass.new('square:1x11,thumbnail:3x2,')}.should raise_error(ArgumentError)
+      end
+      it "raises exception when argument does not respond to to_s method" do
+        lambda {klass.new('square:1x11,thumbnail:3x2'.stub(:to_s).and_return(nil))}.should raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context "instance methods" do
+    specify {subject.should respond_to(:available_sizes)}
+    context "#available_sizes" do
+      it "returns list of available sizes" do
+        subject.available_sizes.should == expected_sizes
+      end
+    end
+
+    specify {subject.should respond_to(:collection)}
+    context "#collection" do
+      let(:reference){
+        OpenStruct.new :current_page => 1,
+        :per_page => subject.available_sizes.length,
+        :total_entries => subject.available_sizes.length,
+        :collection => subject.dimensions
+      }
+      it_behaves_like "object that responds to collection"
+    end
+
+    specify {subject.should respond_to(:to_s)}
+    describe "#to_s method" do
+      it "returns expected string that represents the size and dimensions of the photo" do
+        subject.to_s.should == dimensions_string
+      end
+    end
+
+    specify {subject.should respond_to(:==)}
+    context "#==" do
+      it "returns true when object compared to itself" do
+        subject.should == subject
+      end
+      it "returns true when object compared to clone of itself" do
+        subject.should == subject.clone
+      end
+      it "returns false when single element is different" do
+        other = subject.clone
+        other.first.width=77123
+        subject.should_not == other
+      end
+    end
+
+    specify {subject.should respond_to(:possible_sizes)}
+    context "#possible_sizes" do
+      it "returns expected set of sizes" do
+        subject.possible_sizes.should == FlickrMocks::Models::Helpers.possible_sizes
+      end
+    end
+
+
+    context "size methods" do
+      context "fully specified dimension" do
+        let(:dimensions) {[[1,11],[2,12],[3,13],[4,14],[5,15],[6,16],[7,17]]}
+        def reference
+          index = expected_sizes.find_index(size)
+          OpenStruct.new :size => size,
+            :width => dimensions[index][0],
+            :height => dimensions[index][1]
+        end
+
+        specify{subject.should respond_to(:square)}
+        context "#square" do
+          let(:size){:square}
+          it_behaves_like "object with size accessor"
+        end
+
+        specify{subject.should respond_to(:thumbnail)}
+        context "#thumbnail" do
+          let(:size){:thumbnail}
+          it_behaves_like "object with size accessor"
+        end
+
+        specify{subject.should respond_to(:small)}
+        context "#small" do
+          let(:size){:small}
+          it_behaves_like "object with size accessor"
+        end
+
+        specify{subject.should respond_to(:medium)}
+        context "#medium" do
+          let(:size){:medium}
+          it_behaves_like "object with size accessor"
+        end
+
+        specify{subject.should respond_to(:medium_640)}
+        context "#medium_640" do
+          let(:size){:medium_640}
+          it_behaves_like "object with size accessor"
+        end
+
+        specify{subject.should respond_to(:large)}
+        context "#large" do
+          let(:size){:large}
+          it_behaves_like "object with size accessor"
+        end
+
+        specify{subject.should respond_to(:original)}
+        context "#large" do
+          let(:size){:original}
+          it_behaves_like "object with size accessor"
+        end
+      end
+
+      context "partially specified dimensions" do
+        subject {APP::PhotoDimensions.new('square:1x11')}
+        it "should return object for dimensions that are specified" do
+          subject.send(:square).should_not be_nil
+        end
+        it "should return nil for dimensions that are not specified" do
+          [:thumbnail, :small, :medium,:medium_640, :large, :original].each do |method|
+            subject.send(method).should be_nil
+          end
+        end
+      end
+    end
+    
+    context "iteratable methods" do
+      let(:reference){subject.dimensions}
+      it_behaves_like "object with delegated Array accessor helpers"
+    end
+
+    
+  end
+
+  context "metapragramming methods" do
+    specify {subject.should respond_to(:methods)}
+    context "#methods" do
+      it "returns expected set of methods" do
+        subject.methods.sort.should == (subject.old_methods +
+                                           subject.delegated_instance_methods +
+                                           subject.possible_sizes).sort
+      end
+    end
+
+    specify {subject.should respond_to(:respond_to?)}
+    context "#respond_to?" do
+      it "returns true with return value from methods" do
+        subject.methods.each do |method|
+          subject.should respond_to(method)
+        end
+      end
+
+      specify {subject.should respond_to(:delegated_instance_methods)}
+      context "#delegated_instance_methods" do
+        it "returns methods that include array accessors" do
+          subject.delegated_instance_methods.sort.should == ( 
+              FlickrMocks::Models::Helpers.array_accessor_methods ).sort
+        end
+      end
+    end
+  end
+
+  context "custom cloning methods" do
+    context "#initialize_copy" do
+      it "returns cloned object that has distinct id as compared with original"do
+        subject.dimensions.each.map do |value| value.__id__ end.should_not ==
+          subject.clone.dimensions.each.map do |value| value.__id__ end
+      end
+    end
+  end
+end
+

data/spec/models/photo_search_spec.rb

@@ -0,0 +1,255 @@
+require 'spec_helper'
+
+describe APP::PhotoSearch do
+  let(:api) {APP::Api}
+  let(:klass) {APP::PhotoSearch}
+  let(:fixtures){APP::Fixtures.new}
+  let(:options) {{:search_terms => 'iran', :page => '20', :date => '2010-10-03'}}
+
+  subject { klass.new fixtures.photos,options }
+
+  context "class instance variables" do
+    specify {klass.should respond_to(:defaults)}
+    context "defaults" do
+      it "returns expected set of defaults" do
+        klass.defaults.should == {:page => 1}
+      end
+    end
+
+    specify {klass.should respond_to(:delegated_instance_methods)}
+    it "returns expected set of methods" do
+      klass.delegated_instance_methods.sort.should == [:current_page, :per_page,
+        :total_entries,:perpage, :capped?, :max_entries, :collection,:capped_entries].sort
+    end
+  end
+
+  context "initialization" do
+    context "photos argument" do
+      let(:options){{:search_terms => 'shiraz,iran',:page => 1,:date => '2010-09-10'}}
+      it "returns object of proper class when photos responselist object specified" do
+        klass.new(fixtures.photos, options).class.should == klass
+      end
+      it "returns object of proper class when APP::Photos object is provided" do
+        klass.new(APP::Photos.new(fixtures.photos),options).class.should == klass
+      end
+      it "raises an error when an array is provided" do
+        expect {
+          klass.new([],options)
+        }.to raise_error(ArgumentError)
+      end
+      it "raises an error when photo response object specified" do
+        expect {
+          klass.new(fixtures.photo,options)
+        }.to raise_error(ArgumentError)
+      end
+
+    end
+
+    context "options hash argument" do
+      it "returns object of proper class when all options specified" do
+        klass.new(fixtures.photos,{:search_terms => 'shiraz,iran',
+            :page => 1,:date => '2010-09-10'}).class.should == klass
+      end
+      it "returns object of proper class when date is nil" do
+        klass.new(fixtures.photos,{:search_terms => 'shiraz,iran',:page => 1,:date => nil}).class.should == klass
+      end
+      it "raises an error when date is a Fixnum" do
+        expect {
+          klass.new(fixtures.photos,{:date => 222})
+        }.to raise_error(ArgumentError)
+      end
+      it "raises an error when date is invalid string" do
+        expect {
+          klass.new(fixtures.photos,{:date => '2010'})
+        }.to raise_error(ArgumentError)
+      end
+      it "raises an error when search_terms is an integer" do
+        expect {
+          klass.new(fixtures.photos,{:search_terms => 22})
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context "instance methods" do
+    specify {subject.should respond_to(:search_terms)}
+    context "#search_terms" do
+      let(:search_terms){'shiraz,iran'}
+      subject {klass.new(fixtures.photos,{:search_terms => search_terms})}
+
+      it "returns expected has of search_terms" do
+        subject.search_terms.should == search_terms
+      end
+
+      it "returns empty string when no search_terms supplied during initialization" do
+        klass.new(fixtures.photos,{}).search_terms.should be_empty
+      end
+    end
+
+
+    specify {subject.should respond_to(:page)}
+    context "#page" do
+      let(:page) {20}
+      subject {klass.new(fixtures.photos,{:page => page})}
+      it "returns expected page number when specified at initialization" do
+        subject.page.should == page
+      end
+      it "returns 1 if no page specified at initialization" do
+        klass.new(fixtures.photos,{}).page.should == 1
+      end
+    end
+
+    specify {subject.should respond_to(:date)}
+    context "#date" do
+      let(:date) {'2010-09-10'}
+      subject {klass.new(fixtures.photos,{:date => date})}
+      it "returns expected date" do
+        subject.date.should == date
+      end
+      it "returns nil when called on object with no :date specified" do
+        klass.new(fixtures.photos,{}).date.should be_nil
+      end
+    end
+
+    specify {subject.should respond_to(:total_results)}
+    context "#total_results" do
+      it "returns same value as #total_entries" do
+        subject.total_results.should == subject.total_entries
+      end
+    end
+
+    specify {subject.should respond_to(:capped_entries)}
+    context "#capped_entries" do
+      it "returns same as total_entries when <= max_entries" do
+        subject.photos.stub(:total_entries).and_return(subject.photos.max_entries() -1)
+        subject.capped_entries.should == subject.photos.capped_entries
+      end
+      it "returns max_entries when total_entries > max_entries" do
+        subject.photos.stub(:total_entries).and_return(subject.photos.max_entries()+1)
+        subject.capped_entries.should == subject.photos.capped_entries
+      end
+    end
+
+
+    specify{subject.should respond_to(:url_params)}
+    context "url_params" do
+      it "returns expected parameters when all options specified" do
+        options = {:date => '2010-12-20', :search_terms => 'iran,shiraz'}
+        klass.new(fixtures.photos,options).url_params.should == options
+      end
+      it "returns only search_terms when only search_terms is specified" do
+        options = {:date => nil, :search_terms => 'iran,shiraz'}
+        klass.new(fixtures.photos,options).url_params.should == {:search_terms => 'iran,shiraz'}
+      end
+      it "returns yesterday for date when no options are specified" do
+        options = {:date => nil, :search_terms => nil}
+        klass.new(fixtures.photos,options).url_params.should == {:date => APP::Api.time}
+      end
+      it "returns date when valid date and no search terms is provided" do
+        options = {:date => '2010-01-01', :search_terms => nil}
+        klass.new(fixtures.photos,options).url_params.should == {:date => '2010-01-01'}
+      end
+    end
+
+    specify {subject.should respond_to(:==)}
+    context "#==" do
+      it "returns true when object is compared to itself" do
+        subject.should == subject
+      end
+      it "returns true when object is compared to clone of itself" do
+        subject.should == subject.clone
+      end
+      it "returns false when object compared to an Array" do
+        subject.should_not == []
+      end
+      it "returns false when object is compared to an object with a single difference" do
+        other = subject.clone
+        other.photos.last.instance_eval('@delegated_to_object').instance_eval('@h["server"]="1234321"')
+        subject.should_not == other
+      end
+    end
+
+    context "methods delegated to other object" do
+      context "methods delegated to photos object" do
+        it "returns identical results as direct call to photos object" do
+          klass.delegated_instance_methods.each do |method|
+            subject.send(method).should == subject.photos.send(method)
+          end
+        end
+      end
+      
+      specify {subject.should respond_to(:collection)}
+      context "#collection" do
+        context "usable photos 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 photos set to true" do
+        subject { klass.new fixtures.interesting_photos,options }
+        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
+
+    end
+
+
+      context "array accessor methods" do
+        let(:reference){subject.photos}
+        it_behaves_like "object with delegated Array accessor helpers"
+      end
+    end
+  end
+
+
+  context "metaprogramming methods" do
+    specify {subject.should respond_to(:methods)}
+    context "#methods" do
+      it "return complete list that including the delegated_instance_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 "return true for all methods returned by #methods" do
+        subject.methods.each do |method|
+          subject.should respond_to(method)
+        end
+      end
+    end
+
+    specify {subject.should respond_to(:delegated_instance_methods)}
+    context "#delegated_instance_methods" do
+      it "returns array accessor methods as well as other methods delegated to photos" do
+        subject.delegated_instance_methods.sort.should == (FlickrMocks::PhotoSearch.delegated_instance_methods +
+            FlickrMocks::Models::Helpers.array_accessor_methods).sort
+      end
+    end
+  end
+
+
+  context "custom cloning methods" do
+    context "initialization" do
+      it "returns photos with independent indices" do
+        other = subject.clone
+        subject.photos.each_index do |index|
+          subject.photos[index].__id__.should_not == other.photos[index].__id__
+        end
+      end
+    end
+  end
+
+end