flickrmocks 0.8.15 → 0.9.0

data/spec/api/sanitize_spec.rb

@@ -1,90 +1,205 @@
 require 'spec_helper'
 
-describe APP::Api do
-  let(:klass) {APP::Api}
-  
+describe APP::Api::Sanitize do
+  let(:klass) {APP::Api::Sanitize}
+  let(:api){APP::Api}
   
   context "class methods" do
-    specify {klass.should respond_to(:sanitize_tags)}
-    context "sanitize_tags" do
-      it "returns expected tags when specified" do
-        klass.sanitize_tags('iran,shiraz').should == 'iran,shiraz'
-      end
-      it "returns lower cased version of tags when mixed case tag is specified" do
-        klass.sanitize_tags('IrAn,ShiRaZ').should == 'iran,shiraz'
-      end
-      it "returns tags stripped of extraneous spaces between tags" do
-        klass.sanitize_tags('iran ,        shiraz   ').should == 'iran,shiraz'
-      end
-      it "returns tags that preserve spaces within a tag" do
-        klass.sanitize_tags('iran ,      shiraz hafez, isfehan').should == 'iran,shiraz hafez,isfehan'
+    specify {klass.should respond_to(:tags)}
+    context "tags" do
+      it "returns nil when nil supplied" do
+        klass.tags(nil).should == nil
+      end
+      context "specified as a string" do
+        it "returns expected tags when specified" do
+          klass.tags('iran,shiraz').should == 'iran,shiraz'
+        end
+        it "returns lower cased version of tags when mixed case tag is specified" do
+          klass.tags('IrAn,ShiRaZ').should == 'iran,shiraz'
+        end
+        it "returns tags stripped of extraneous spaces between tags" do
+          klass.tags('iran ,        shiraz   ').should == 'iran,shiraz'
+        end
+        it "returns tags that preserve spaces within a tag" do
+          klass.tags('iran ,      shiraz hafez, isfehan').should == 'iran,shiraz hafez,isfehan'
+        end
+      end
+      context "error conditions" do
+        it "raises error when Array supplied" do
+          expect {
+            klass.tags([])
+          }.to raise_error(ArgumentError)
+        end
+        it "raises error when Integer supplied" do
+          expect {
+            klass.tags(1)
+          }.to raise_error(ArgumentError)
+        end
       end
     end
-
-    specify {klass.should respond_to(:sanitize_per_page)}
-    context "sanitize_per_page" do
-      it "returns expected per_page when per_page specified" do
-        klass.sanitize_per_page(:per_page => '2').should == '2'
+    
+    specify {klass.should respond_to(:tags_hash)}
+    context ":tags_hash" do
+      it "returns tags when :search_terms supplied" do
+        klass.tags_hash(:search_terms => "lyon,france").should ==
+          "lyon,france"
       end
-      it "returns default per_page when per_page is not specified" do
-        klass.sanitize_per_page({}).should == klass.default(:per_page)
+      it "returns nil when :search_terms is nil supplied" do
+        klass.tags_hash(:search_terms => nil).should be_nil
       end
-      it "returns expected per_page when perpage specified" do
-        klass.sanitize_per_page(:perpage => '33').should == '33'
+      it "returns nil when :search_terms not supplied" do
+        klass.tags_hash({}).should be_nil
       end
-      it "returns per_page when both :perpage and per_page is specified" do
-        klass.sanitize_per_page(:per_page => '222', :perpage => '333').should == '222'
+      it "raises argument error when Array supplied" do
+        expect {
+          klass.tags_hash([])
+        }.to raise_error(ArgumentError)
       end
     end
 
-    specify {klass.should respond_to(:sanitize_page)}
-    context "sanitize_page" do
-      it "returns specified page number when given" do
-        klass.sanitize_page(:page => 2).should == '2'
-      end
-      it "returns '1' when page number not specified" do
-        klass.sanitize_page({}).should == '1'
-      end
-      it "returns '1' when string '0' specified for page number" do
-        klass.sanitize_page(:page => '0').should == '1'
-      end
-      it "returns '1' when number 0 specified as page number" do
-        klass.sanitize_page(:page => 0).should == '1'
+    specify {klass.should respond_to(:per_page)}
+    context "per_page" do
+      it "returns default per_page when nil provided" do
+        klass.per_page(nil).should == api.default(:per_page)
+      end
+      context "option as string" do
+        it "returns value when string containing integer greater than 0" do
+          klass.per_page('2').should == '2'
+        end
+        it "returns default per_page value when string is less than 1" do
+          klass.per_page('-1').should == FlickrMocks::Api.default(:per_page)
+        end
+        it "returns default per_page value when string is '0'" do
+          klass.per_page('0').should == FlickrMocks::Api.default(:per_page)
+        end
+      end
+      context "option as integer" do
+        it "returns value.to_s when option is greater than 0" do
+          klass.per_page(2).should == '2'
+        end
+        it "returns default :per_page when option is 0" do
+          klass.per_page(0).should == FlickrMocks::Api.default(:per_page)
+        end
+        it "returns default :per_page when option is negative" do
+          klass.per_page(-1).should == FlickrMocks::Api.default(:per_page)
+        end
+      end
+      context "error conditions" do
+        it "raises an error when an array provided" do
+          expect {
+            klass.per_page([])
+          }.to raise_error(ArgumentError)
+        end
       end
     end
 
-    specify {klass.should respond_to(:sanitize_tag_mode)}
-    context "sanitize_tag_mode" do
-      it "returns 'any' if specified" do
-        klass.sanitize_tag_mode(:tag_mode => 'any').should == 'any'
-      end
-      it "returns default tag_mode when non-specified" do
-        klass.sanitize_tag_mode.should == klass.default(:tag_mode)
-      end
-      it "returns default tag_mode when garbage specified" do
-        klass.sanitize_tag_mode(:tag_mode => 'garbage').should == klass.default(:tag_mode)
+    specify {klass.should respond_to(:per_page_hash)}
+    context ":per_page_hash" do
+      let(:options){{}}
+      let(:method){:per_page_hash}
+      it_behaves_like "per page hash option"
+    end
+
+    # returns the page entry that is a positive non-zero integer
+    specify {klass.should respond_to(:page)}
+    context "page" do
+      it "returns '1' when page number is nil" do
+        klass.page(nil).should == '1'
+      end
+      context "integer argument" do
+        it "returns default page when number is 0" do
+          klass.page(0).should == FlickrMocks::Api.default(:page)
+        end
+        it "returns default page when number < 0" do
+          klass.page(-1).should == FlickrMocks::Api.default(:page)
+        end
+        it "returns page when number > 0" do
+          klass.page(20).should == '20'
+        end
+      end
+      context "string argument" do
+        it "returns specified page number when given" do
+          klass.page(2).should == '2'
+        end
+        it "returns '1' when string '0' specified for page number" do
+          klass.page('0').should == FlickrMocks::Api.default(:page)
+        end
+        it "returns '1' when number 0 specified as page number" do
+          klass.page(0).should == FlickrMocks::Api.default(:page)
+        end
+      end
+      context "error conditions" do
+        it "raises error when Array specified" do
+          expect {
+            klass.page([])
+          }.to raise_error(ArgumentError)
+        end
       end
+    end
+    specify {klass.should respond_to(:page_hash)}
+    context ":page_hash" do
+      let(:options){{}}
+      let(:method){:page_hash}
+      it_behaves_like "page hash option"
+    end
+
+    specify {klass.should respond_to(:tag_mode)}
+    context "tag_mode" do
       it "returns default tag mode if nil given" do
-        klass.sanitize_tag_mode(:tag_mode => nil).should == klass.default(:tag_mode)
-      end
-      it "returns 'all' if specified" do
-        klass.sanitize_tag_mode(:tag_mode => 'all').should == 'all'
+        klass.tag_mode(nil).should == api.default(:tag_mode)
+      end
+      context "options specified as string" do
+        it "returns 'any' if specified" do
+          klass.tag_mode('any').should == 'any'
+        end
+        it "returns default tag_mode when non-specified" do
+          klass.tag_mode.should == api.default(:tag_mode)
+        end
+        it "returns default tag_mode when garbage specified" do
+          klass.tag_mode('garbage').should == api.default(:tag_mode)
+        end
+        it "returns 'all' if specified" do
+          klass.tag_mode('all').should == 'all'
+        end
+      end
+      context "error conditions" do
+        it "raises error when array provided" do
+          expect {
+            klass.tag_mode([])
+          }.to raise_error(ArgumentError)
+
+        end
       end
     end
 
-    specify {klass.should respond_to(:sanitize_time)}
-    context "sanitize_time" do
+    specify {klass.should respond_to(:tag_mode_hash)}
+    context ":tag_mode_hash" do
+      let(:options){{}}
+      let(:method){:tag_mode_hash}
+      it_behaves_like "tag mode hash option"
+    end
+
+    specify {klass.should respond_to(:date)}
+    context "date" do
       it "returns expected date when format '2010-12-22'" do
-        klass.sanitize_time(:date => '2010-12-22').should == '2010-12-22'
+        klass.date('2010-12-22').should == '2010-12-22'
       end
       it "returns expected date when format 'Jan 1 2003'" do
         date = Chronic.parse('Jan 1 2003').strftime('%Y-%m-%d')
-        klass.sanitize_time(:date => 'Jan 1 2003').should == date
+        klass.date('Jan 1 2003').should == date
       end
       it "returns yesterday if no date specified" do
         date = Chronic.parse('yesterday').strftime('%Y-%m-%d')
-        klass.sanitize_time.should == date
+        klass.date.should == date
       end
     end
+
+    specify {klass.should respond_to(:date_hash)}
+    context ":date_hash" do
+      let(:options){{}}
+      let(:method){:date_hash}
+      it_behaves_like "date hash option"
+    end
+
   end
 end

data/spec/base/stubs_spec.rb

@@ -6,9 +6,10 @@ describe APP::Stubs do
   let(:flickr_stubs){klass::Flickr}
   let(:api_stubs){klass::Api}
   let(:api){APP::Api}
+  let(:models){APP::Models}
+  
   context "class methods" do
-    context "Flickr Stubs" do
-
+    context "Flickr" do
       specify{flickr_stubs.should respond_to(:all)}
       context "all" do
         before(:each) do
@@ -192,7 +193,7 @@ describe APP::Stubs do
             /Not a valid date string/
           )
         end
-        it "returns empty string if 2001-01-01 given" do
+        it "returns empty string if 2000-01-01 given" do
           flickr.interestingness.getList(:date => '2000-01-01').should == fixtures.empty_photos
         end
         it "returns photo details fixture when option given" do
@@ -211,47 +212,26 @@ describe APP::Stubs do
       end
     end
 
-    context "Api stubs" do
+    context "Api" do
+      specify{api_stubs.should respond_to(:all)}
+      context "all" do
+        before(:each) do
+          api_stubs.all
+        end
+        it_behaves_like "stub for Api.photo"
+        it_behaves_like "stub for Api.photos"
+        it_behaves_like "stub for Api.photo_details"
+        it_behaves_like "stub for Api.photo_sizes"
+        it_behaves_like "stub for Api.interesting_photos"
+        it_behaves_like "stub for Api.commons_institutions"
+      end
+
       specify {api_stubs.should respond_to :photos}
       context "photos" do
         before(:each) do
           api_stubs.photos
         end
-        context "owner_id provided" do
-          it "returns object with same user when owner_id provided" do
-            params = {:owner_id => '1'}
-            api.photos(:owner_id => '1').should ==
-              ::FlickrMocks::PhotoSearch.new(fixtures.photos,api.search_params(params))
-          end
-          it "returns object with same user when owner_id and tags provided" do
-            params = {:owner_id => '1',:search_terms => 'iran'}
-            api.photos(:owner_id => '1').should ==
-              ::FlickrMocks::PhotoSearch.new(fixtures.photos,api.search_params({:owner_id => '1'}))
-          end
-          it "returns object with no entries when owner_id set to  'garbage'" do
-            api.photos(:owner_id => 'garbage').should ==
-              ::FlickrMocks::PhotoSearch.new(fixtures.empty_photos,api.search_params({:owner_id => 'garbage'}))
-          end
-        end
-        context "search_terms provided" do
-          it "returns object with different owner_id values when :search_terms provided" do
-            params = {:search_terms => 'iran'}
-            api.photos(params).should ==
-              ::FlickrMocks::PhotoSearch.new(fixtures.photos,api.search_params(params))
-          end
-          it "returns object with no entries when :search_terms is set to 'garbage'" do
-            params = {:search_terms => 'garbage'}
-            api.photos(params).should ==
-              ::FlickrMocks::PhotoSearch.new(fixtures.empty_photos,api.search_params(params))
-          end
-        end
-
-        context "error conditions" do
-          let(:subject){api}
-          let(:method){:photos}
-          it_behaves_like "object that expects single Hash argument"
-        end
-
+        it_behaves_like "stub for Api.photos"
       end
 
       specify {api_stubs.should respond_to :photo_details}
@@ -259,58 +239,41 @@ describe APP::Stubs do
         before(:each) do
           api_stubs.photo_details
         end
-        it "returns expected object when proper :photo_id provided" do
-          api.photo_details(:photo_id => '1234').should ==
-            ::FlickrMocks::PhotoDetails.new(fixtures.photo_details,fixtures.photo_sizes)
-        end
-
-        context "error conditions" do
-          let(:subject){api}
-          let(:method){:photo_details}
-          it_behaves_like "object that expects single Hash argument"
-          
-          it "raises FlickRaw::FailedResponse when :photo_id not supplied in Hash" do
-            expect {
-              api.photo_details({})
-            }.to raise_error(FlickRaw::FailedResponse)
-          end
-          it "raises FlickRaw::FailedResponse when :photo_id is nil" do
-            expect {
-              api.photo_details({:photo_id => nil})
-            }.to raise_error(FlickRaw::FailedResponse)
-          end
-          it "raises FlickRaw::FailedResponse when :photo_id is garbage" do
-            expect {
-              api.photo_details({:photo_id => 'garbage'})
-            }.to raise_error(FlickRaw::FailedResponse)
-          end
-        end
+        it_behaves_like "stub for Api.photo_details"
       end
 
       specify {api_stubs.should respond_to :photo}
       context "photo" do
-         context "error conditions" do
+        before(:each) do
+          api_stubs.photo
         end
-
+        it_behaves_like "stub for Api.photo"
       end
       
       specify {api_stubs.should respond_to :photo_sizes}
       context "photo_sizes" do
-
+        before(:each) do
+          api_stubs.photo_sizes
+        end
+        it_behaves_like "stub for Api.photo_sizes"
       end
       
       specify {api_stubs.should respond_to :interesting_photos}
       context "interesting_photos" do
-
+        before(:each) do
+          api_stubs.interesting_photos
+        end
+        it_behaves_like "stub for Api.interesting_photos"
       end
       
       specify {api_stubs.should respond_to :commons_institutions}
       context "commons_institutions" do
-        
+        before(:each) do
+          api_stubs.commons_institutions
+        end
+        it_behaves_like "stub for Api.commons_institutions"
       end
-      
-    end
-
-
+    end   
   end
+
 end

data/spec/base/version_spec.rb

@@ -1,12 +1,19 @@
 require 'spec_helper'
 
-describe APP::VERSION do
-  subject{APP::VERSION}
-
+describe APP do
+  subject{APP}
   context "constants" do
     context "VERSION" do
       it "returns non-empty version" do
-        subject.should_not be_empty
+        subject::VERSION.should_not be_empty
+      end
+    end
+  end
+
+  context "class methods" do
+    context "version" do
+      it "returns expected version" do
+         subject.version.should == subject::VERSION
       end
     end
   end

data/spec/models/commons_institution_spec.rb

@@ -1,8 +1,9 @@
 require 'spec_helper'
 
-describe APP::CommonsInstitution do
+describe APP::Models::CommonsInstitution do
   let(:api) {APP::Api}
-  let(:klass) {APP::CommonsInstitution}
+  let(:models){APP::Models}
+  let(:klass) {models::CommonsInstitution}
   let(:fixtures){APP::Fixtures.instance}
   let(:fixture){fixtures.commons_institutions[0]}
   subject {klass.new(fixture)}

data/spec/models/commons_institutions_spec.rb

@@ -1,8 +1,9 @@
 require 'spec_helper'
 
-describe APP::CommonsInstitutions do
+describe APP::Models::CommonsInstitutions do
   let(:api) {APP::Api}
-  let(:klass) {APP::CommonsInstitutions}
+  let(:models){APP::Models}
+  let(:klass) {models::CommonsInstitutions}
   let(:fixtures){APP::Fixtures.instance}
   let(:fixture){fixtures.commons_institutions}
   subject {klass.new(fixture)}
@@ -11,7 +12,7 @@ describe APP::CommonsInstitutions do
   context "class methods" do
     specify { klass.should respond_to(:defaults)}
     it "returns expected set of defaults" do
-      klass.defaults.should == FlickrMocks::Models::Helpers.paging_defaults
+      klass.defaults.should == models::Helpers.paging_defaults
     end
   end
 
@@ -28,6 +29,34 @@ describe APP::CommonsInstitutions do
   end
 
   context "instance methods" do
+    specify {subject.should respond_to(:extract_per_page)}
+    context "#extract_per_page" do
+      let(:method){:extract_per_page}
+      let(:options){{}}
+      it_behaves_like "per page hash option"
+    end
+
+    specify {subject.should respond_to(:extract_current_page)}
+    context "#extract_current_page" do
+      let(:method){:extract_current_page}
+      context ":page option provided" do
+        let(:options){{}}
+        it_behaves_like "page hash option"
+      end
+      context ":current_page option" do
+        it "returns page number when current_page given" do
+          subject.extract_current_page(:current_page => '2').should == '2'
+        end
+        it "prefers :current_page to :page" do
+          subject.extract_current_page(:current_page => '3', :page => '30').should == '3'
+        end
+        it "returns default page when :current_page is set to nil" do
+          subject.extract_current_page(:current_page => nil).should == FlickrMocks::Api.default(:page)
+        end
+      end
+    end
+
+
     specify {subject.should respond_to(:default)}
     context "#default" do
       it "should return default when proper symbol provided" do
@@ -71,14 +100,14 @@ describe APP::CommonsInstitutions do
       context "#per_page" do
         it "returns default per_page when none specified at initialization" do
           klass.new(fixture,:current_page => 1).per_page.should ==
-            FlickrMocks::Models::Helpers.paging_defaults[:per_page]
+            api.default(:per_page).to_i
         end
         it "returns per_page value that was specified during initialization" do
           klass.new(fixture,:per_page => 33, :current_page => 1).per_page.should == 33
         end
         it "returns 1 when per_page is set to 0" do
           klass.new(fixture,:per_page => 0, :current_page => 1).per_page.should ==
-                             FlickrMocks::Models::Helpers.paging_defaults[:per_page]
+                             api.default(:per_page).to_i
         end
       end
 

data/spec/models/helpers_spec.rb

@@ -21,17 +21,18 @@ describe APP::Models::Helpers do
           :medium_640, :large, :original]
       end
     end
-    
+
     specify {klass.should respond_to(:paging_defaults)}
     context "paging_defaults" do
-      it "returns expected hash of paging defaults" do
+      it "returns expected hash containing paging defaults" do
         klass.paging_defaults.should == {
-          :max_entries => 4000,
-          :per_page => 50,
-          :current_page => 1
+          :max_entries => ::FlickrMocks::Api.default(:max_entries).to_i,
+          :per_page => ::FlickrMocks::Api.default(:per_page).to_i,
+          :current_page => ::FlickrMocks::Api.default(:page).to_i
         }
       end
     end
-    
+
   end
 end
+

data/spec/models/photo_details_spec.rb

@@ -1,12 +1,13 @@
 require 'spec_helper'
 
-describe APP::PhotoDetails do  
-  let(:klass){APP::PhotoDetails}
+describe APP::Models::PhotoDetails do
+  let(:klass){APP::Models::PhotoDetails}
   let(:fixtures){APP::Fixtures.instance}
+  let(:models){APP::Models}
 
-  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(:basic_photo) { models::Photo.new fixtures.photo }
+  let(:extended_photo) { models::Photo.new fixtures.photo_details }
+  let(:photo_sizes) { models::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)}
@@ -23,16 +24,16 @@ describe APP::PhotoDetails 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
+      lambda{models::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
+      lambda{models::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
+      lambda{models::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
+      lambda{models::PhotoDetails.new nil,photo_sizes}.should raise_error ArgumentError
     end
   end
 
@@ -118,7 +119,7 @@ describe APP::PhotoDetails do
           end
         end
       it "returns expected result delegated to url helpers for basic photo" do
-          reference = APP::Photo.new(fixtures.photo)
+          reference = models::Photo.new(fixtures.photo)
           FlickrMocks::Models::Helpers.possible_sizes.each do |size|
             subject.send(size).should == reference.send(size)
           end
@@ -133,7 +134,7 @@ describe APP::PhotoDetails do
           end
         end
         it "returns expected result delegated to url helpers for detailed photo" do
-          reference = APP::Photo.new(fixtures.photo_details)
+          reference = models::Photo.new(fixtures.photo_details)
           FlickrMocks::Models::Helpers.possible_sizes.each do |size|
             subject.send(size).should == reference.send(size)
           end

data/spec/models/photo_dimensions_spec.rb

@@ -1,11 +1,12 @@
 require 'spec_helper'
 
-describe APP::PhotoDimensions do
+describe APP::Models::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}
+  let(:models){APP::Models}
+  let(:klass) {models::PhotoDimensions}
 
-  subject { APP::PhotoDimensions.new(dimensions_string) }
+  subject { models::PhotoDimensions.new(dimensions_string) }
 
   context "class methods" do
     specify {klass.should respond_to(:regexp_size)}
@@ -148,7 +149,7 @@ describe APP::PhotoDimensions do
       end
 
       context "partially specified dimensions" do
-        subject {APP::PhotoDimensions.new('square:1x11')}
+        subject {models::PhotoDimensions.new('square:1x11')}
         it "should return object for dimensions that are specified" do
           subject.send(:square).should_not be_nil
         end