flickrmocks 0.8.5

data/lib/flickr_mocks/models/photos.rb

@@ -0,0 +1,133 @@
+module FlickrMocks
+  class Photos
+    attr_reader :current_page,:per_page,:total_entries,:total_pages,:photos
+    alias :perpage :per_page
+
+    @defaults =  {
+      :max_entries => 4000,
+      :per_page => 50
+    }
+
+
+    class << self
+      attr_accessor :defaults
+    end
+
+    def initialize(data)
+      raise ArgumentError, 'Expecting class of FlickRaw::ResponseList' unless data.class == FlickRaw::ResponseList
+      self.current_page= data.page
+      self.per_page= data.perpage
+      self.total_entries= data.total
+      self.total_pages = data.pages
+      self.photos =  data.photo
+    end
+
+    def default(value)
+      Photos.defaults[value.to_s.to_sym]
+    end
+
+    def capped_entries
+      total_entries > max_entries ? max_entries : total_entries
+    end
+
+    def capped?
+      max_entries < total_entries ? true : false
+    end
+
+    def max_entries
+      default(:max_entries)
+    end
+
+    def pages
+      max_pages = default(:max_entries)/perpage
+      total_pages > max_pages ? max_pages : total_pages
+    end
+
+    def usable_photos
+      photos.clone.keep_if(&:usable?)
+    end
+
+    def collection(usable=nil)
+      case usable
+      when true
+        usable_photos = photos.clone.keep_if(&:usable?)
+        ::WillPaginate::Collection.create(1, per_page, usable_photos.length) do |obj|
+          obj.replace(usable_photos)
+        end
+      else
+        ::WillPaginate::Collection.create(current_page, per_page, capped_entries) do |obj|
+          obj.replace(photos)
+        end
+      end
+    end
+
+
+    def ==(other)
+      return false unless other.class == Photos
+      return false unless [:current_page,:per_page,:total_entries,:total_pages].inject(true) do |state,method|
+        state && (self.send(method) == other.send(method))
+      end
+      other.respond_to?(:photos) ? photos == other.photos : false
+    end
+
+
+    # metaprogramming methods
+    def method_missing(id,*args,&block)
+      return photos.send(id,*args,&block) if  delegated_instance_methods.include?(id)
+      super
+    end
+
+    alias :old_respond_to? :respond_to?
+    def respond_to?(method)
+      old_respond_to?(method) || delegated_instance_methods.include?(method)
+    end
+
+    alias :old_methods :methods
+    def methods
+      delegated_instance_methods + old_methods
+    end
+
+    def delegated_instance_methods
+      FlickrMocks::Models::Helpers.array_accessor_methods
+    end
+
+    # custom cloning methods
+    def initialize_copy(orig)
+      super
+      @photos = @photos.map do |photo|
+        photo.clone
+      end
+    end
+    
+    private
+    def current_page=(value)
+      raise ArgumentError,"Expected Fixnum but was #{value.class}" unless value.is_a?(Fixnum) or value.is_a?(String)
+      @current_page=value.to_i
+    end
+
+    def per_page=(value)
+      raise ArgumentError,"Expected Fixnum but was #{value.class}" unless value.is_a?(Fixnum) or value.is_a?(String)
+      @per_page=value.to_i
+    end
+
+    def total_entries=(value)
+      raise ArgumentError,"Expected Fixnum but was #{value.class}"  unless value.is_a?(Fixnum) or value.is_a?(String)
+      @total_entries=value.to_i
+    end
+
+    def total_pages=(value)
+      raise ArgumentError,"Expected Fixnum but was #{value.class}" unless value.is_a?(Fixnum) or value.is_a?(String)
+      @total_pages=value.to_i
+    end
+
+    def photos=(photos)
+      raise ArgumentError,"Expected argument that responds to :each but got class #{photos.class}" unless photos.respond_to?(:each)
+      results = []
+      photos.each do |photo|
+        raise ArgumentError,"Expected FlickRaw::Response but was #{value.class}" unless photo.is_a?(FlickRaw::Response)
+        results.push(Photo.new(photo))
+      end
+      @photos=results
+    end
+  end
+end

data/lib/flickr_mocks/stubs.rb

@@ -0,0 +1,103 @@
+module FlickrMocks
+  module Stubs
+
+    def self.stub_flickr
+      [:stub_search,:stub_getInfo,:stub_getSizes,:stub_interestingness].each do |method|
+        self.send(method)
+      end
+    end
+
+
+    def self.stub_search
+      fixtures = Fixtures.new
+      Proc.new { flickr.photos.stub(:search) do |params|
+          if !params.is_a?(Hash)
+            raise FlickRaw::FailedResponse.new('Parameterless searches have been disabled. Please use flickr.photos.getRecent instead.',
+              'code','flickr.photos.search'
+            )
+          elsif(params[:tags] == 'garbage' || params[:user_id] == 'garbage')
+            fixtures.empty_photos
+          elsif(params[:tags] && params[:user_id])
+            fixtures.author_photos
+          elsif params.has_key?(:tags)
+            fixtures.photos
+          elsif params.has_key?(:user_id)
+            fixtures.author_photos
+          else
+            raise FlickRaw::FailedResponse.new('Parameterless searches have been disabled. Please use flickr.photos.getRecent instead.',
+              'code','flickr.photos.search'
+            )    
+          end
+        end
+      }.call
+    end
+
+    def self.stub_getInfo
+      Proc.new { 
+        flickr.photos.stub(:getInfo) do |params|
+          if !params.is_a?(Hash)
+            raise FlickRaw::FailedResponse.new('Photo not found',
+                                             'code', 'flickr.photos.getInfo')
+          elsif !params.has_key?(:photo_id)
+            raise FlickRaw::FailedResponse.new('Photo not found',
+                                             'code', 'flickr.photos.getInfo')
+          elsif params[:photo_id] == 'garbage'
+            raise FlickRaw::FailedResponse.new('Photo "%s" not found (invalid ID)' % params[:photo_id],
+            'code','flickr.photos.getInfo')
+          else
+            Fixtures.new.photo_details
+          end
+        end
+      }.call
+    end
+
+    def self.stub_getSizes
+      Proc.new {
+        flickr.photos.stub(:getSizes) do |params|
+          if !params.is_a?(Hash)
+            raise FlickRaw::FailedResponse.new('Photo not found',
+              'code', 'flickr.photos.getSizes')
+          elsif !params.has_key?(:photo_id)
+            raise FlickRaw::FailedResponse.new('Photo not found',
+              'code', 'flickr.photos.getSizes')
+          elsif params[:photo_id] == 'garbage'
+            raise FlickRaw::FailedResponse.new('Photo not found',
+              'code','flickr.photos.getSizes')
+          else
+            Fixtures.new.photo_sizes
+          end
+        end
+      }.call
+    end
+
+    def self.stub_interestingness
+      Proc.new { 
+        flickr.interestingness.stub(:getList) do |params|
+          if !params.is_a?(Hash)
+            Fixtures.new.interesting_photos
+          elsif !params.has_key?(:date)
+            Fixtures.new.interesting_photos
+          elsif params[:date] == 'garbage'
+            raise FlickRaw::FailedResponse.new('Not a valid date string',
+            'code','flickr.interestingness.getList'
+            )
+          elsif params[:date] == '2000-01-01'
+            Fixtures.new.empty_photos
+          else
+            Fixtures.new.interesting_photos
+          end
+        end
+      }.call
+    end
+
+  end
+end
+
+
+
+
+
+
+
+
+

data/lib/flickr_mocks/version.rb

@@ -0,0 +1,4 @@
+
+module FlickrMocks
+  VERSION = File.read(File.expand_path("../../../VERSION", __FILE__)).strip
+end

data/lib/flickrmocks.rb

@@ -0,0 +1,27 @@
+require 'chronic'
+
+require 'find'
+require 'delegate'
+require 'cgi'
+
+require 'will_paginate/collection'
+
+# Use user specified FlickRaw definition, if not defined use flickraw-cached if
+#   available
+begin
+  require 'flickraw-cached' unless defined?(FlickRaw)
+rescue LoadError
+  require 'flickraw'
+end
+
+  
+
+  flickrmocks_path = File.expand_path('../flickr_mocks/', __FILE__)
+
+
+# include all ruby files in the library path
+ Find.find(flickrmocks_path) do |file|
+  if File.file?(file)
+    require file if File.extname(file) == '.rb'
+  end
+ end

data/spec/api/api_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+require 'ruby-debug'
+describe APP::Api do
+  let(:klass) { APP::Api }
+
+  let(:fixtures) { APP::Fixtures.new }
+  let(:photo)  {fixtures.photo}
+  let(:photos) {fixtures.photos}
+  let(:sizes) {fixtures.photo_sizes}
+  let(:photo_details) {fixtures.photo_details}
+  let(:interesting_photos) {fixtures.interesting_photos}
+
+
+  context "class instance variables" do
+    context "@defaults" do
+      before(:each) do
+        @defaults = klass.defaults.clone
+      end
+      after(:each) 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
+      end
+      it "returns object whose elements can be set similar to a hash" do
+        expected = "#{Random.srand}"
+        klass.defaults.keys.each do |k|
+          klass.defaults[k] = expected
+          klass.defaults[k].should == expected
+        end
+      end
+    end
+  end
+
+  context "class methods" do
+    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)
+      end
+    end
+
+    specify {klass.should respond_to(:photos)}
+    context "photos" 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'})
+      end
+    end
+
+    specify {klass.should respond_to(:photo_sizes)}
+    describe "photo_sizes" do
+      it "returns expected PhotoSizes object" do
+        expected = APP::PhotoSizes.new(sizes)
+        flickr.photos.stub(:getSizes).and_return(sizes)
+        klass.photo_sizes(:photo => expected.id,
+                                :secret => expected.secret).should ==  expected
+      end
+    end
+    
+    specify {klass.should respond_to(:photo_details)}
+    describe "photo_details" do
+      it "returns expected PhotoDetails object" 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)
+      end
+    end
+
+    specify {klass.should respond_to(:interesting_photos)}
+    describe "interesting_photos" 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'})
+      end
+    end
+
+  end
+end

data/spec/api/flickr_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe APP::Api do
+  let(:klass){APP::Api}
+  let(:fixtures){APP::Fixtures.new}
+  
+  context "class methods" do
+    specify {klass.should respond_to(:flickr_photos)}
+    context "flickr_photos" do
+      it "returns list of photos" do
+        flickr.photos.stub(:search).and_return(fixtures.photos)
+        klass.flickr_photos({}).should == fixtures.photos
+      end
+    end
+
+    specify {klass.should respond_to(:flickr_photo)}
+    context "flickr_photos" do
+      it "returns photo" do
+        flickr.photos.stub(:getInfo).and_return(fixtures.photo)
+        klass.flickr_photo({}).should == fixtures.photo
+      end
+    end
+
+    specify {klass.should respond_to(:flickr_photo_sizes)}
+    context "flickr_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
+      end
+    end
+
+    specify {klass.should respond_to(:flickr_interestingness)}
+    context "flickr_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
+      end
+    end
+    
+    specify {klass.should respond_to(:flickr_author)}
+    context "flickr_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
+      end
+    end
+  end
+end

data/spec/api/helper_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe APP::Api do
+  
+  let(:klass) {APP::Api}  
+  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
+      it "returns yesterday when no time is specified" do
+        expected = Chronic.parse('yesterday').strftime('%Y-%m-%d')
+        klass.time.should == expected
+      end
+
+      it "returns user specified date when proper date given" do
+        expected = '2010-12-25'
+        klass.time(expected).should == expected
+      end
+
+      it "returns yesterday when garbage date given" do
+        klass.time('garbage').should == Chronic.parse('yesterday').strftime('%Y-%m-%d')
+      end
+    end
+  end
+end

data/spec/api/options_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+describe APP::Api do
+  let(:api) {APP::Api}
+  let(:subject) {APP::Api}
+  let(:extras){
+    { :license => '4,5,6,7',
+      :media => 'photos',
+      :extras =>  'license',
+      :tag_mode => 'any'}
+  }
+  let(:expected){
+    { :per_page => '400',
+      :user_id => nil,
+      :tags => 'iran,shiraz',
+      :page => '2'}.merge(extras.clone)
+  }
+
+  let(:options){
+    {
+      :search_terms => 'iran,shiraz',
+      :page => '2'
+    }.merge(extras.clone)
+  }
+  
+
+  describe "search_options" do
+    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
+    end
+    it "should return options when fully specified" do
+      subject.search_options(: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'}
+      )
+    end
+  end
+
+  describe "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')
+    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
+    end
+  end
+
+  describe "photo_options" do
+    let(:expected) {
+      {:photo_id => '20030', :secret => 'abcdef'}
+    }
+
+    it "should extract :photo_id and :secret" do
+      subject.photo_options(expected).should == expected
+    end
+    it "should return photo id when present" do
+      subject.photo_options(: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
+    end
+    it "should give preference to :photo_secret over :secret" do
+      subject.photo_options(:photo_secret => 'abcdef', :secret => 'not correct', :id => '20030').should ==
+        expected
+      
+    end
+  end
+
+  describe "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
+    end
+    it "should filter non-required options" do
+      subject.search_params(expected.clone.merge(:date => '2010-10-02',:per_page => '2')).should ==
+        expected
+      
+    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)
+    end
+  end
+
+  describe "interesting_params" do
+    
+    let(:expected) {
+      {
+        :date => 'iran,shiraz',
+        :base_url => 'http://www.happyboy.com/'
+      }
+    }
+    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])
+    end
+  end
+  
+end
+
+ 

data/spec/api/sanitize_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe APP::Api do
+  let(:klass) {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'
+      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'
+      end
+      it "returns default per_page when per_page is not specified" do
+        klass.sanitize_per_page({}).should == klass.default(:per_page)
+      end
+      it "returns expected per_page when perpage specified" do
+        klass.sanitize_per_page(:perpage => '33').should == '33'
+      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'
+      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'
+      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)
+      end
+      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'
+      end
+    end
+
+    specify {klass.should respond_to(:sanitize_time)}
+    context "sanitize_time" do
+      it "returns expected date when format '2010-12-22'" do
+        klass.sanitize_time(: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
+      end
+      it "returns yesterday if no date specified" do
+        date = Chronic.parse('yesterday').strftime('%Y-%m-%d')
+        klass.sanitize_time.should == date
+      end
+    end
+  end
+end