flickrmocks 0.8.15 → 0.9.0

data/spec/api/api_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 require 'ruby-debug'
 describe APP::Api do
   let(:klass) { APP::Api }
+  let(:models){APP::Models}
 
   let(:fixtures){APP::Fixtures.instance}
   let(:photo){fixtures.photo}
@@ -21,7 +22,11 @@ describe APP::Api do
         klass.defaults = @defaults
       end
       it "returns has with expected set of keys" do
-        klass.defaults.keys.sort.should  == [:per_page,:license,:media,:extras,:tag_mode,:flickr_tag_modes].sort
+        klass.defaults.keys.sort.should  == [:page,:per_page,:license,:media,
+                                                        :max_entries,:extras,:tag_mode,
+                                                        :possible_sizes,:possible_tag_modes].sort
+
+
       end
       it "returns object whose elements can be set similar to a hash" do
         expected = "#{Random.srand}"
@@ -34,13 +39,26 @@ describe APP::Api do
   end
 
   context "class methods" do
+    specify {klass.should respond_to(:default)}
+    context "default" do
+      it "returns key stored in @defaults class instance variable when symbol specified" do
+        klass.default(:per_page).should == klass.defaults[:per_page]
+      end
+      it "returns key stored in @defaults class instance variable when string specified" do
+        klass.default('per_page').should  == klass.defaults[:per_page]
+      end
+      it "returns nil when key that is not in @defaults class instance variable is specified" do
+        klass.default('garbage').should == nil
+      end
+    end
+    
     let(:subject){klass}
     specify {klass.should respond_to(:photo)}
     context "photo" do
       it "returns expected Photo object" do
         flickr.photos.stub(:getInfo).and_return(photo)
         klass.photo({:photo =>photo.id,
-                         :secret => photo.secret}).should == APP::Photo.new(photo)
+            :secret => photo.secret}).should == models::Photo.new(photo)
       end
       context "arguments" do
         let(:method){:photo}
@@ -53,7 +71,7 @@ describe APP::Api do
       it "returns expected PhotoSearch object" do
         flickr.photos.stub(:search).and_return(photos)
         klass.photos({:search_terms => 'iran'}).should ==
-          APP::PhotoSearch.new(photos,{:search_terms => 'iran'})
+          models::PhotoSearch.new(photos,{:search_terms => 'iran'})
       end
       it "raises error when non-hash argument provided" do
         expect {
@@ -69,10 +87,10 @@ describe APP::Api do
     specify {klass.should respond_to(:photo_sizes)}
     context "photo_sizes" do
       it "returns expected PhotoSizes object" do
-        expected = APP::PhotoSizes.new(sizes)
+        expected = models::PhotoSizes.new(sizes)
         flickr.photos.stub(:getSizes).and_return(sizes)
         klass.photo_sizes(:photo => expected.id,
-                                :secret => expected.secret).should ==  expected
+          :secret => expected.secret).should ==  expected
       end
       context "arguments" do
         let(:method){:photos}
@@ -86,7 +104,7 @@ describe APP::Api do
         flickr.photos.stub(:getSizes).and_return(sizes)
         flickr.photos.stub(:getInfo).and_return(photo)
         klass.photo_details(:photo => photo.id,
-                                  :secret => photo.secret).should  == APP::PhotoDetails.new(photo,sizes)
+          :secret => photo.secret).should  == models::PhotoDetails.new(photo,sizes)
       end
       context "arguments" do
         let(:method){:photo_details}
@@ -100,7 +118,7 @@ describe APP::Api do
       it "returns expected PhotoSearch object" do
         flickr.interestingness.stub(:getList).and_return(interesting_photos)
         klass.interesting_photos({:date => '2010-01-01'}).should ==
-                  APP::PhotoSearch.new(interesting_photos,{:date => '2010-01-01'})
+          models::PhotoSearch.new(interesting_photos,{:date => '2010-01-01'})
       end
       context "arguments" do
         let(:method){:interesting_photos}
@@ -113,7 +131,7 @@ describe APP::Api do
       it "returns expected CommonsInstitutions object" do
         flickr.commons.stub(:getInstitutions).and_return(commons_institutions)
         klass.commons_institutions({}).should ==
-          APP::CommonsInstitutions.new(commons_institutions)
+          models::CommonsInstitutions.new(commons_institutions)
       end
       context "arguments" do
         let(:method){:commons_institutions}

data/spec/api/flickr_spec.rb

@@ -1,54 +1,54 @@
 require 'spec_helper'
 
-describe APP::Api do
-  let(:klass){APP::Api}
+describe APP::Api::Flickr do
+  let(:klass){APP::Api::Flickr}
   let(:fixtures){APP::Fixtures.instance}
   
   context "class methods" do
-    specify {klass.should respond_to(:flickr_photos)}
-    context "flickr_photos" do
+    specify {klass.should respond_to(:photos)}
+    context "photos" do
       it "returns list of photos" do
         flickr.photos.stub(:search).and_return(fixtures.photos)
-        klass.flickr_photos({}).should == fixtures.photos
+        klass.photos({}).should == fixtures.photos
       end
     end
 
-    specify {klass.should respond_to(:flickr_photo)}
-    context "flickr_photos" do
+    specify {klass.should respond_to(:photo)}
+    context "photos" do
       it "returns photo" do
         flickr.photos.stub(:getInfo).and_return(fixtures.photo)
-        klass.flickr_photo({}).should == fixtures.photo
+        klass.photo({}).should == fixtures.photo
       end
     end
 
-    specify {klass.should respond_to(:flickr_photo_sizes)}
-    context "flickr_photo_sizes" do
+    specify {klass.should respond_to(:photo_sizes)}
+    context "photo_sizes" do
       it "returns list sizes for a photo" do
         flickr.photos.stub(:getSizes).and_return(fixtures.photo_sizes)
-        klass.flickr_photo_sizes({}).should == fixtures.photo_sizes
+        klass.photo_sizes({}).should == fixtures.photo_sizes
       end
     end
 
-    specify {klass.should respond_to(:flickr_interestingness)}
-    context "flickr_interestingness" do
+    specify {klass.should respond_to(:interestingness)}
+    context "interestingness" do
       it "returns list of interesting photos" do
         flickr.interestingness.stub(:getList).and_return(fixtures.interesting_photos)
-        klass.flickr_interestingness({}).should == fixtures.interesting_photos
+        klass.interestingness({}).should == fixtures.interesting_photos
       end
     end
     
-    specify {klass.should respond_to(:flickr_author)}
-    context "flickr_author" do
+    specify {klass.should respond_to(:author)}
+    context "author" do
       it "returns list of photos for an author" do
         flickr.photos.stub(:search).and_return(fixtures.author_photos)
-        klass.flickr_author({}).should == fixtures.author_photos
+        klass.author({}).should == fixtures.author_photos
       end
     end
 
-    specify {klass.should respond_to(:flickr_commons_institutions)}
+    specify {klass.should respond_to(:commons_institutions)}
     it "retuns list of commons institutions" do
       flickr.commons.stub(:getInstitutions).and_return(fixtures.commons_institutions)
-      klass.flickr_commons_institutions.should == fixtures.commons_institutions
+      klass.commons_institutions.should == fixtures.commons_institutions
     end
   end
 end

data/spec/api/helper_spec.rb

@@ -1,37 +1,37 @@
 require 'spec_helper'
 
-describe APP::Api do
+describe APP::Api::Helpers do
   
-  let(:klass) {APP::Api}  
+  let(:klass) {APP::Api::Helpers}
   context "class methods" do
-    specify {klass.should respond_to(:default)}
-    context "default" do
-      it "returns key stored in @defaults class instance variable when symbol specified" do
-        klass.default(:per_page).should == klass.defaults[:per_page]
-      end
-      it "returns key stored in @defaults class instance variable when string specified" do
-        klass.default('per_page').should  == klass.defaults[:per_page]
-      end
-      it "returns nil when key that is not in @defaults class instance variable is specified" do
-        klass.default('garbage').should == nil
-      end
-    end
-
-    specify {klass.should respond_to(:time)}
-    context "time" do
+    specify {klass.should respond_to(:date)}
+    context "date" do
       it "returns yesterday when no time is specified" do
         expected = Chronic.parse('yesterday').strftime('%Y-%m-%d')
-        klass.time.should == expected
+        klass.date.should == expected
       end
 
       it "returns user specified date when proper date given" do
         expected = '2010-12-25'
-        klass.time(expected).should == expected
+        klass.date(expected).should == expected
       end
 
       it "returns yesterday when garbage date given" do
-        klass.time('garbage').should == Chronic.parse('yesterday').strftime('%Y-%m-%d')
+        klass.date('garbage').should == Chronic.parse('yesterday').strftime('%Y-%m-%d')
       end
     end
   end
+
+  specify {klass.should respond_to(:valid_date?)}
+  context "valid_date?" do
+    it "returns true when valid string of Format 'YYYY-MM-DD' provided" do
+      klass.valid_date?('2001-10-10').should be_true
+    end
+    it "returns false when integer provided string of format provided" do
+      klass.valid_date?(1).should be_false
+    end
+    it "returns false when ambiguous date provided" do
+      klass.valid_date?('2000').should be_false
+    end
+  end
 end

data/spec/api/options_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 describe APP::Api do
-  let(:api) {APP::Api}
-  let(:subject) {APP::Api}
+  let(:api) {APP::Api::Options}
+  let(:subject) {APP::Api::Options}
   let(:extras){
     { :license => '4,5,6,7',
       :media => 'photos',
@@ -23,159 +23,205 @@ describe APP::Api do
     }.merge(extras.clone)
   }
   
-
-  context "search_options" do
+  specify {subject.should respond_to(:search)}
+  context "search" do
+    let(:method){:search}
     it "should give correct options when all options are specified except :author_id" do
-      subject.search_options(options.clone.merge(:per_page =>'400')).should == expected
+      subject.search(options.clone.merge(:per_page =>'400')).should == expected
     end
     it "should return options when fully specified" do
-      subject.search_options(:per_page => '400',:owner_id => 'authorid',:page => '2').should ==
+      subject.search(:per_page => '400',:owner_id => 'authorid',:page => '2').should ==
         expected.clone.merge(:user_id => 'authorid',:tags => nil)
       
     end
-    it "should give correct values when :perpage given in lieu of :per_page" do
-      subject.search_options(options.clone.merge({:perpage => '400'})).should == expected
-    end
-    it "should give correct value when no :perpage is specified" do
-      subject.search_options(options).should == expected.clone.merge({:per_page => '200'})
-    end
-    it "should give preference to :per_page to :perpage" do
-      subject.search_options(options.clone.merge({:per_page => '500', :perpage => '444'})).should ==
-        expected.clone.merge(:per_page => '500')
-    end
-    it "should be able to set :tag_mode" do
-      subject.search_options(options.clone.merge(:per_page => '500', :tag_mode=>'all' )).should ==
-        expected.clone.merge({:per_page => '500',:tag_mode => 'all'}
-      )
-    end
-    it "should give default tag_mode when not specified" do
-      subject.search_options(options.clone.merge(:per_page => '500')).should ==
-        expected.clone.merge({:per_page => '500'}
-      )
-    end
-    it "should give default tag_mode when junk given for tag_mode" do
-      subject.search_options(options.clone.merge(:per_page => '500', :tag_mode => 'junk')).should ==
-        expected.clone.merge({:per_page => '500'}
-      )
+    context "tag_mode option" do
+      let(:options){
+        extras.clone.merge({
+            :search_terms => 'france',
+            :owner_id =>  '1234',
+            :page =>  '1',
+            :per_page => '50'
+          })
+      }
+      let(:expected){
+        extras.clone.merge({
+            :tags => options[:search_terms],
+            :user_id =>  options[:owner_id],
+            :page =>  options[:page],
+            :per_page => options[:per_page]
+          })
+      }
+      it_behaves_like "tag mode hash option"
+    end
+    context "per page option" do
+      let(:options){
+        extras.clone.merge({
+            :search_terms => 'france',
+            :owner_id =>  '1234',
+            :page =>  '1',
+          })
+      }
+      let(:expected){
+        extras.clone.merge({
+            :tags => options[:search_terms],
+            :user_id =>  options[:owner_id],
+            :page =>  options[:page],
+          })
+      }
+      it_behaves_like "per page hash option"
+    end
+    context "page option" do
+      let(:options){
+        extras.clone.merge({
+            :search_terms => 'france',
+            :owner_id =>  '1234',
+            :per_page =>  '50',
+          })
+      }
+      let(:expected){
+        extras.clone.merge({
+            :tags => options[:search_terms],
+            :user_id =>  options[:owner_id],
+            :per_page =>  options[:per_page],
+          })
+      }
+      it_behaves_like "page hash option"      
     end
   end
 
-  context "interesting_options" do
-    let(:expected){
-      { :date => '2010-02-14',
-        :per_page => '2',
-        :page => '2'
-      }
-    }
-    it "should return proper date with default options" do
-      subject.interesting_options(expected).should == expected.clone.merge(:extras => 'license')
+  specify {subject.should respond_to(:interesting)}
+  context "interesting" do
+    let(:method){:interesting}
+    context "date option" do
+      let(:options){{
+          :per_page => '2',
+          :page => '2',
+          :extras => 'license'
+        }}
+      let(:expected){options}
+      it_behaves_like "date hash option"
     end
-    it "should return proper date when no page given" do
-      subject.interesting_options(:date => '2010-02-14', :per_page => '2').should ==
-        expected.clone.merge(:page => '1', :extras => 'license')
-      
-    end
-    it "should return proper date when not specified" do
-      date = Chronic.parse('yesterday').strftime('%Y-%m-%d')
-      subject.interesting_options({:date => date})[:date].should == date
+    
+    context "page option" do
+      let(:options){
+        {   :date => '2010-10-10',
+          :per_page =>  '50',
+          :extras => FlickrMocks::Api.default(:extras)
+        }}
+      let(:expected){options}
+      it_behaves_like "page hash option"
+    end
+    context "per page option" do
+      let(:options){
+        { :date => '2010-10-10',
+          :page =>  '1',
+          :extras => FlickrMocks::Api.default(:extras)
+        }}
+      let(:expected){options}
+      it_behaves_like "per page hash option"
     end
   end
 
-  context "photo_options" do
+  specify{subject.should respond_to(:photo)}
+  context "photo" do
     let(:expected) {
       {:photo_id => '20030', :secret => 'abcdef'}
     }
-
-    it "should extract :photo_id and :secret" do
-      subject.photo_options(expected).should == expected
+    it "returns :photo_id and :secret when provided" do
+      subject.photo(expected).should == expected
     end
-    it "should return photo id when present" do
-      subject.photo_options(:id => '20030',:secret => 'abcdef').should == expected
+    it "returns :photo_id when :id provided" do
+      subject.photo(:id => '20030',:secret => 'abcdef').should == expected
     end
-    it "should give preference to :photo_id over :id" do
-      subject.photo_options(expected.clone.merge(:id => 'not correct')).should == expected
+    it "should prefer :photo_id over :id" do
+      subject.photo(expected.clone.merge(:id => 'not correct')).should == expected
     end
-    it "should give preference to :photo_secret over :secret" do
-      subject.photo_options(:photo_secret => 'abcdef', :secret => 'not correct', :id => '20030').should ==
-        expected
-      
+    it "should prefer :photo_secret over :secret" do
+      subject.photo(:photo_secret => 'abcdef', :secret => 'not correct', :id => '20030').should ==
+        expected   
     end
-  end
-
-  context "search_params" do
-    let(:expected){
-      {
-        :search_terms => 'iran,shiraz',
-        :owner_id => 'authorid',
-        :base_url => 'http://www.happyboy.com/'
-      }
-    }
-    let(:base_url) {'http://www.example.com/'}
-    
-    it "should return properly when all options specified" do
-      subject.search_params(expected).should == expected
+    it "returns nil for :photo_id when no id given" do
+      subject.photo({:secret => '22'}).should ==
+        {:secret => '22', :photo_id => nil}
     end
-    it "should filter non-required options" do
-      subject.search_params(expected.clone.merge(:date => '2010-10-02',:per_page => '2')).should ==
-        expected
-      
+    it "returns nil for :secret when no :secret given" do
+      subject.photo({:photo_id => '1234'}).should ==
+        {:secret => nil, :photo_id => '1234'}
     end
-    it "should properly extract :base_url" do
-      subject.search_params(expected.clone.merge(:base_url => base_url)).should ==
-        expected.clone.merge(:base_url => base_url)
+    it "returns nil for :secret and :photo_id when nil provided" do
+      subject.photo({:photo_id => nil, :secret => nil}).should ==
+        {:secret => nil, :photo_id => nil}
     end
   end
 
-  context "interesting_params" do
-    let(:expected) {
-      {
-        :date => 'iran,shiraz',
-        :base_url => 'http://www.happyboy.com/'
-      }
+
+
+  specify {subject.should respond_to(:author)}
+  context "author" do
+    let(:method){:author}
+    let(:expected){
+      { :per_page => '400',
+        :user_id => nil,
+        :page => '2'}.merge(extras.clone)
     }
-    it "should return correct options when all are specified" do
-      subject.interesting_params(expected).should == expected
-    end
-    it "should filter non-required options" do
-      subject.interesting_params(expected.clone.merge(:search_terms => 'iran,shiraz',
-          :owner_id => 'authorid')).should == expected
-    end
-    it "should extract base_url options" do
-      subject.interesting_params(expected.clone.merge(:base_url => expected[:base_url])).should ==
-        expected.clone.merge(:base_url => expected[:base_url])
+    it "should give correct options when all options are specified except :author_id" do
+      subject.author(options.clone.merge(:per_page =>'400')).should == expected
     end
-  end
+    it "should return options when fully specified" do
+      subject.author(:per_page => '400',:owner_id => 'authorid',:page => '2').should ==
+        expected.clone.merge(:user_id => 'authorid')
 
-  context "institution_params" do
-    it "returns :per_page and :current_page if specified" do
-      expected = {:per_page => 2, :current_page => 3}
-      subject.commons_institutions_params(expected).should == expected
-    end
-    it "returns :per_page is prefereed over :perpage is specified" do
-      expected = {:per_page => 2, :current_page => 1}
-      subject.commons_institutions_params(:per_page => 3, :perpage => 20, :current_page => 1).should ==
-        {:per_page => 3, :current_page => 1}
-    end
-    it "returns :perpage if :per_page is not specified" do
-      expected = {:perpage => 3}
-      subject.commons_institutions_params(:perpage => 20, :current_page => 1).should ==
-        {:per_page => 20, :current_page => 1}
     end
-    it "returns :current_page of 1 if not specified" do
-      subject.commons_institutions_params(:per_page => 20).should ==
-        {:per_page => 20, :current_page => 1}
-    end
-    it "returns :current_page in preference to :page" do
-      subject.commons_institutions_params(:per_page=>20,:page=>2,:current_page=>3).should ==
-        {:per_page => 20, :current_page => 3}
-    end
-    it "returns :page when :current_page is not specified" do
-      subject.commons_institutions_params(:per_page=>20,:page=>3).should ==
-        {:per_page => 20, :current_page => 3}
+    context "tag_mode option" do
+      it "should be able to set :tag_mode" do
+        subject.author(options.clone.merge(:per_page => '500', :tag_mode=>'all' )).should ==
+          expected.clone.merge({:per_page => '500',:tag_mode => 'all'}
+        )
+      end
+      it "should give default tag_mode when not specified" do
+        subject.author(options.clone.merge(:per_page => '500')).should ==
+          expected.clone.merge({:per_page => '500'}
+        )
+      end
+      it "should give default tag_mode when junk given for tag_mode" do
+        subject.author(options.clone.merge(:per_page => '500', :tag_mode => 'junk')).should ==
+          expected.clone.merge({:per_page => '500'}
+        )
+      end
+    end
+    context "per page option" do
+      let(:options){
+        extras.clone.merge({
+            :search_terms => 'france',
+            :owner_id =>  '1234',
+            :page =>  '1',
+          })
+      }
+      let(:expected){
+        extras.clone.merge({
+            :user_id =>  options[:owner_id],
+            :page =>  options[:page],
+          })
+      }
+      it_behaves_like "per page hash option"
+    end
+    context "page option" do
+      let(:options){
+        extras.clone.merge({
+            :search_terms => 'france',
+            :owner_id =>  '1234',
+            :per_page =>  '50',
+          })
+      }
+      let(:expected){
+        extras.clone.merge({
+            :user_id =>  options[:owner_id],
+            :per_page =>  options[:per_page],
+          })
+      }
+      it_behaves_like "page hash option"
     end
   end
-  
-  
 end