flickrmocks 0.8.15 → 0.9.0

data/lib/flickr_mocks/models/photo_sizes.rb

@@ -1,93 +1,94 @@
 module FlickrMocks
-  class PhotoSizes
-
-    def initialize(object)
-      self.delegated_to_object= object
-    end
+  module Models
+    class PhotoSizes
+      def initialize(object)
+        self.delegated_to_object= object
+      end
 
-    def id
-      @delegated_to_object.first.id
-    end
+      def id
+        @delegated_to_object.first.id
+      end
 
-    def secret
-      @delegated_to_object.first.secret
-    end
+      def secret
+        @delegated_to_object.first.secret
+      end
 
-    def sizes
-      @delegated_to_object
-    end
+      def sizes
+        @delegated_to_object
+      end
 
-    def available_sizes
-      @available_sizes ||= sizes.map do |size|
-        size.size.to_sym
+      def available_sizes
+        @available_sizes ||= sizes.map do |size|
+          size.size.to_sym
+        end
+        @available_sizes
       end
-      @available_sizes
-    end
 
-    def collection
-      @collection ||= ::WillPaginate::Collection.create(1, sizes.length, sizes.length) do |obj|
-        obj.replace(sizes)
+      def collection
+        @collection ||= ::WillPaginate::Collection.create(1, sizes.length, sizes.length) do |obj|
+          obj.replace(sizes)
+        end
+        @collection
       end
-      @collection
-    end
 
 
-    def to_s
-      PhotoDimensions.new(@delegated_to_object.map do |size|
-          "#{size.size}:#{size.width}x#{size.height}"
-        end.join(',')).to_s
-    end
+      def to_s
+        PhotoDimensions.new(@delegated_to_object.map do |size|
+            "#{size.size}:#{size.width}x#{size.height}"
+          end.join(',')).to_s
+      end
 
-    def ==(other)
-      return false unless self.class == other.class
-      @delegated_to_object == other.instance_eval('@delegated_to_object')
-    end
+      def ==(other)
+        return false unless self.class == other.class
+        @delegated_to_object == other.instance_eval('@delegated_to_object')
+      end
 
-    def possible_sizes
-      Models::Helpers.possible_sizes
-    end
+      def possible_sizes
+        Models::Helpers.possible_sizes
+      end
 
-    # metaprogramming methods
-    alias :old_methods :methods
-    def methods
-      delegated_instance_methods + old_methods
-    end
+      # metaprogramming methods
+      alias :old_methods :methods
+      def methods
+        delegated_instance_methods + old_methods
+      end
 
-    def method_missing(id,*args,&block)
-      return @delegated_to_object.send(id,*args,&block) if  delegated_instance_methods.include?(id)
-      return nil if possible_sizes.include?(name)
-      super
-    end
+      def method_missing(id,*args,&block)
+        return @delegated_to_object.send(id,*args,&block) if  delegated_instance_methods.include?(id)
+        return nil if possible_sizes.include?(name)
+        super
+      end
 
-    alias :old_respond_to? :respond_to?
-    def respond_to?(method)
-      old_respond_to?(method) || delegated_instance_methods.include?(method)
-    end
+      alias :old_respond_to? :respond_to?
+      def respond_to?(method)
+        old_respond_to?(method) || delegated_instance_methods.include?(method)
+      end
 
-    def delegated_instance_methods
-      possible_sizes + FlickrMocks::Models::Helpers.array_accessor_methods
-    end
+      def delegated_instance_methods
+        possible_sizes + FlickrMocks::Models::Helpers.array_accessor_methods
+      end
 
-    # cloning methods
-    def initialize_copy(orig)
-      super
-      @delegated_to_object = @delegated_to_object.map do |data|
-        data.clone
+      # cloning methods
+      def initialize_copy(orig)
+        super
+        @delegated_to_object = @delegated_to_object.map do |data|
+          data.clone
+        end
       end
-    end
 
 
-    private
+      private
 
-    def delegated_to_object=(data)
-      raise ArgumentError, 'FlickRaw::Response expected' unless data.class == FlickRaw::ResponseList
-      @delegated_to_object = []
-      data.each do |datum|
-        @delegated_to_object.push PhotoSize.new datum
+      def delegated_to_object=(data)
+        raise ArgumentError, 'FlickRaw::Response expected' unless data.class == FlickRaw::ResponseList
+        @delegated_to_object = []
+        data.each do |datum|
+          @delegated_to_object.push PhotoSize.new datum
+        end
       end
-    end
     
 
+    end
   end
-end
 
+end

data/lib/flickr_mocks/models/photos.rb

@@ -1,130 +1,135 @@
 module FlickrMocks
-  class Photos
-    attr_reader :current_page,:per_page,:total_entries,:total_pages,:photos
-    alias :perpage :per_page
-
-    @defaults =  FlickrMocks::Models::Helpers.paging_defaults.clone
+  module Models
+    class Photos
+      attr_reader :current_page,:per_page,:total_entries,:total_pages,:photos
+      alias :perpage :per_page
 
+    
 
-    class << self
-      attr_accessor :defaults
-    end
+      class << self
+        attr_writer :defaults
+        def defaults
+          @defaults ||= FlickrMocks::Models::Helpers.paging_defaults().clone
+          @defaults
+        end
+      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 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 default(value)
+        Photos.defaults[value.to_s.to_sym]
+      end
 
-    def capped_entries
-      total_entries > max_entries ? max_entries : total_entries
-    end
+      def capped_entries
+        total_entries > max_entries ? max_entries : total_entries
+      end
 
-    def capped?
-      max_entries < total_entries ? true : false
-    end
+      def capped?
+        max_entries < total_entries ? true : false
+      end
 
-    def max_entries
-      default(:max_entries)
-    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 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 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)
+      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
-    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))
+      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
-      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
+      # 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_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
+      alias :old_methods :methods
+      def methods
+        delegated_instance_methods + old_methods
+      end
 
-    def delegated_instance_methods
-      FlickrMocks::Models::Helpers.array_accessor_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
+      # custom cloning methods
+      def initialize_copy(orig)
+        super
+        @photos = @photos.map do |photo|
+          photo.clone
+        end
       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
+      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 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 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_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 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 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))
+      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(Models::Photo.new(photo))
+        end
+        @photos=results
       end
-      @photos=results
     end
   end
 end

data/lib/flickr_mocks/stubs.rb

@@ -1,50 +1,166 @@
 module FlickrMocks
+  # wrapper for methods that are used for Stubbing FlickRaw queries and Api calls that
+  # access the Flickr API. These methods are useful for stubbing the Flickr API for
+  # your Rspec 2.0 tests.
   module Stubs
     module Api
+      # Once this method is called all subsequent calls to the following calls are stubbed:
+      #
+      #  Api.photos
+      #  Api.photo_details
+      #  Api.photo
+      #  Api.photo_sizes
+      #  Api.interesting_photos
+      #  Api.commons_institutions
       def self.all
+        # [:VERSION, :Stubs, :Helpers, :Fixtures, :Models, :Api, :CustomClone, :CustomCompare, :CustomMarshal]
         [:photos,:photo_details,:photo,:photo_sizes,
           :interesting_photos,:commons_institutions].each do |method|
           self.send(method)
         end
       end
 
+
+      # Once this method is called, all subsequent calls to Api.photos are stubbed.
+      # The stub returns an object of class Flickr::PhotoSearch.
+      # The return value for Api.photos hash depends on the
+      # the options hash:
+      #
+      #   :search_terms => 'garbage' (returns empy list of photos)
+      #   :owner_id => 'garbage' (returns empty list of photos)
+      #   :owner_id => '<valid_id>' (returns list of photos that contain same author photos; valid_id is any string other than garbage)
+      #   :search_terms => '<valid_tag>' (returns list of photos with different author photos (if :owner_id must be nil); valid_tag is any string other than 'garbage')
+      #   :search_terms => nil and :owner_id => nil (raises FlickRaw::FailedResponse error)
       def self.photos
         lambda {::FlickrMocks::Api.stub(:photos) do |params|
             ::FlickrMocks::Stubs::Flickr.search
             case params
             when Hash then
-              PhotoSearch.new flickr.photos.search(::FlickrMocks::Api.search_options(params)),::FlickrMocks::Api.search_params(params)
+              Models::PhotoSearch.new flickr.photos.search(::FlickrMocks::Api::Options.search(params)),params
             else
               raise ArgumentError
             end
         end}.call
       end
 
+      # Once this method is called, subsequent calls to Api.photo_details are stubbed.
+      # The stub returns an object of class Models::PhotoDetails.
+      # The return value for Api.photo_details stub depends on the
+      # state of the supplied options hash:
+      #
+      #   :photo_id or :id => 'garbage' (raises FlickRaw::FailedResponse error)
+      #   :photo_id or :id => nil (raises FlickRaw::FailedResponse error)
+      #   :photo_id or :id => <valid_id> (returns a photo fixture with detailed information; valid_id can be any string other than 'garbage' )
       def self.photo_details
         lambda {::FlickrMocks::Api.stub(:photo_details) do |params|
             ::FlickrMocks::Stubs::Flickr.getInfo
             ::FlickrMocks::Stubs::Flickr.getSizes
             case params
             when Hash then
-              PhotoDetails.new(flickr.photos.getInfo(::FlickrMocks::Api.photo_options(params)),
-                flickr.photos.getSizes(::FlickrMocks::Api.photo_options(params)))
+              Models::PhotoDetails.new(flickr.photos.getInfo(::FlickrMocks::Api::Options.photo(params)),
+                flickr.photos.getSizes(::FlickrMocks::Api::Options.photo(params)))
             else
               raise ArgumentError
             end
           end}.call
       end
 
-    end
+      # Once this method is called, all subsequent calls to Api.photo are stubbed.
+      # The stub returns an object of class Models::Photo. The return value for the Api.photo
+      # stub depends on the supplied options:
+      #
+      #   :photo_id or :id => 'garbage' (raises Invaid ID error)
+      #   :photo_id or :id => nil (raises invalid ID error)
+      #   :photo_id or :id => <valid_id> (returns a photo fixture with detailed information; valid_id is any string other than 'garbage')
+      def self.photo
+        lambda{::FlickrMocks::Api.stub(:photo) do |params|
+            ::FlickrMocks::Stubs::Flickr.getInfo
+            case params
+            when Hash then
+              Models::Photo.new(::FlickrMocks::Api::Flickr.photo(params))
+            else
+              raise ArgumentError
+            end
+        end}.call
+      end
 
+      # Once this method is called, all subsequent calls to Api.photo_sizes are stubbed.
+      # The stub returns an object of class Models::PhotoSizes.
+      # The return value of Api.photo_sizes stub depends on the supplied options:
+      #
+      #   :photo_id or :id => 'garbage' (raises FlickRaw::FailedResponse error)
+      #   :photo_id or :id => nil (raises FlickRaw::FailedResponse error)
+      #   :photo_id or :id => <valid_id> (returns list of photo sizes; valid_id is any string other than 'garbage')
+      def self.photo_sizes  
+         lambda {::FlickrMocks::Api.stub(:photo_sizes) do |params|
+            ::FlickrMocks::Stubs::Flickr.getSizes
+            case params
+            when Hash then
+              Models::PhotoSizes.new(flickr.photos.getSizes(::FlickrMocks::Api::Options.photo(params)))
+            else
+              raise ArgumentError
+            end
+          end}.call
+      end
 
+      # Once this method is called, all subsequent calls to Api.interesting_photos
+      # are stubbed. The stub returns an object of class Models::PhotoSearch.
+      # The return value for Api.interesting_photos stub depends on the supplied
+      # options hash:
+      # 
+      #  :date => '2000-01-01' (returns empy list of photos)
+      #  :date => 'garbage' (raises an error)
+      #  :date => <valid_id> (returns interesting list of photos; date is any string other than 'garbage' and '2001-01-01')
+      def self.interesting_photos
+         lambda {::FlickrMocks::Api.stub(:interesting_photos) do |params|
+            ::FlickrMocks::Stubs::Flickr.interestingness
+            case params
+            when Hash then
+              Models::PhotoSearch.new(flickr.interestingness.getList(params),params)
+            else
+              raise ArgumentError
+            end
+          end}.call
+      end
+
+      # Once method is called all subsequent calls to Api.commons_institutions
+      # are stubbed.
+      def self.commons_institutions
+        lambda {::FlickrMocks::Api.stub(:commons_institutions) do |params|
+            ::FlickrMocks::Stubs::Flickr.commons_institutions
+            case params
+            when Hash then
+              CommonsInstitutions.new(::FlickrMocks::Api.flickr_commons_institutions,params)
+            else
+              raise ArgumentError
+            end
+          end}.call
+      end
+
+    end
+
+    # stubs low level FlickRaw Api calls to Flickr
     module Flickr
+      # Once this method is called, the following calls are stubbed: 
+      #  flickr.photos.search
+      #  flickr.photos.getInfo
+      #  flickr.photos.getSizes
+      #  flickr.interestingness.getList
+      #  flickr.commons.getInstitutions
       def self.all
         [:search,:getInfo,:getSizes,:interestingness,:commons_institutions].each do |method|
           self.send(method)
         end
       end
 
-
+      # Once this method are called, all subsequent calls to flickr.photos.search
+      # are stubbed. The return value for the flickr.photos.search depends on
+      # the supplied options hash:
+      #
+      #   :tags => 'garbage' (returns empy list of photos)
+      #   :user_id => 'garbage' (returns empty list of photos)
+      #   :user_id => '<valid_id>' (returns list of photos that contain same author photos)
+      #   :tags => '<valid_tag>' (returns list of photos with different author photos; only if valid author id is not provided)
       def self.search
         fixtures = Fixtures.instance
         lambda { flickr.photos.stub(:search) do |params|
@@ -56,10 +172,10 @@ module FlickrMocks
               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)
+            elsif !params[:user_id].nil?
               fixtures.author_photos
+            elsif !params[:tags].nil?
+              fixtures.photos
             else
               raise FlickRaw::FailedResponse.new('Parameterless searches have been disabled. Please use flickr.photos.getRecent instead.',
                 'code','flickr.photos.search'
@@ -69,19 +185,26 @@ module FlickrMocks
         }.call
       end
 
+      # Once this method is called, all subsequent calls to flickr.photos.getInfo
+      # are stubbed. The return value for the flickr.photos.getInfo stub depends on
+      # the supplied options hash:
+      #
+      #   :photo_id => 'garbage' (raises Invaid ID error)
+      #   :photo_id => nil (raises invalid ID error)
+      #   :photo_id => <valid_id> (returns a photo fixture with detailed information)
       def self.getInfo
         lambda {
           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)
+            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')
-            elsif params[:photo_id] == nil
+            elsif params[:photo_id].nil?
               raise FlickRaw::FailedResponse.new('Photo "nil" not found (invalid ID)',
                 'code','flickr.photos.getInfo')
             else
@@ -91,6 +214,13 @@ module FlickrMocks
         }.call
       end
 
+      # Once this method is called all subsequent calls for flickr.photos.getSizes
+      # are stubbed. The return value for the flickr.photos.getSizes stub depends
+      # on the supplied options hash:
+      #
+      #  :photo_id => nil (raises FlickRaw::FailedResponse error)
+      #  :photo_id => 'garbage' (raises FlickRaw::FailedResponse error)
+      #  :photo_id => '<valid_id>' (returns a list of photo sizes)
       def self.getSizes
         lambda {
           flickr.photos.stub(:getSizes) do |params|
@@ -113,19 +243,24 @@ module FlickrMocks
         }.call
       end
 
+      # Once this method is called, all subsequent calls to flickr.interestingness.getList
+      # are stubbed. The return value for the flickr.interesting.getList stub depends
+      # on the supplied options hash.
+      #
+      #  :date => '2000-01-01' (returns empy list of photos)
+      #  :date => 'garbage' (raises an error)
+      #  :date => <valid_id> (returns interesting list of photos)
       def self.interestingness
         lambda {
           flickr.interestingness.stub(:getList) do |params|
             if !params.is_a?(Hash)
               Fixtures.instance.interesting_photos
-            elsif !params.has_key?(:date)
-              Fixtures.instance.interesting_photos
+            elsif params[:date] == '2000-01-01'
+              Fixtures.instance.empty_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.instance.empty_photos
             else
               Fixtures.instance.interesting_photos
             end
@@ -133,6 +268,8 @@ module FlickrMocks
         }.call
       end
 
+      # Once called, all subsequent calls to flickr.commons.getInstitutions are stubbed.
+      # The flickr.commons.getInstitutions stub simply returns a list of commons institutions.
       def self.commons_institutions
         lambda {
           flickr.commons.stub(:getInstitutions) do

data/lib/flickr_mocks/version.rb

@@ -1,4 +1,10 @@
 
 module FlickrMocks
-  VERSION = '0.8.15'
+  # version for FlickrMocks gem
+  VERSION = '0.9.0'
+
+  # returns the version for FlickrMocks gem
+  def self.version
+    VERSION
+  end
 end