superdupe 0.4.0

data/README.markdown

@@ -0,0 +1,10 @@
+## SuperDupe
+SuperDupe provides two things:
+
+ * Mock ActiveResource objects like the originally gem dupe
+ * Superdupe send no requests to external services registerd by the ARes. It has an extra parameter to send explicitly extrnal requests.
+
+SuperDupe is a fork of the originally gem dupe 0.5.1 (Matt Parker). At first, the gem try to use only the available mocked resources. If you have the requirement to send external requests without mocking, take an extra parameter for this situation.
+
+# Install the gem
+    gem install superdupe

data/lib/superdupe/active_resource_extensions.rb

@@ -0,0 +1,161 @@
+ActiveResource::HttpMock.instance_eval do #:nodoc:
+  def delete_mock(http_method, path) #:nodoc:
+    responses.reject! {|r| r[0].path == path && r[0].method == http_method}
+  end
+end
+
+module ActiveResource #:nodoc:
+  class Base
+    class << self
+      
+      # Overwrite the configuration of ActiveResource authentication (self.user). Don't need it for mocking.
+      def user=(user)
+      end
+      
+      # Overwrite the configuration of ActiveResource authentication (self.password). Don't need it for mocking.
+      def password=(password)
+      end
+      
+      def find(*arguments)      
+        scope = arguments.slice!(0)
+        options = arguments.slice!(0) || {}
+
+        case scope
+          when :all then find_every(options)
+          when :first then find_every(options).first
+          when :last then find_every(options).last
+          when :one then find_one(options)
+          else find_single(scope, options)
+        end
+      end
+      
+      private
+      def find_every(options)
+        external_request = options[:external_request] if options.has_key?(:external_request)
+        
+        case from = options[:from]
+        when Symbol
+          instantiate_collection(get(from, options[:params]))
+        when String
+          path = "#{from}#{query_string(options[:params])}"
+          instantiate_collection(connection.get(path, headers, external_request) || [])
+        else
+          prefix_options, query_options = split_options(options[:params])
+          path = collection_path(prefix_options, query_options)
+          instantiate_collection( (connection.get(path, headers, external_request) || []), prefix_options )
+        end
+      end
+
+      def find_one(options)
+        external_request = options[:external_request] if options.has_key?(:external_request)
+        
+        case from = options[:from]
+        when Symbol
+          instantiate_record(get(from, options[:params]))
+        when String
+          path = "#{from}#{query_string(options[:params])}"
+          instantiate_record(connection.get(path, headers, external_request))
+        end
+      end
+
+      def find_single(scope, options)
+        external_request = options[:external_request] if options.has_key?(:external_request)
+                
+        prefix_options, query_options = split_options(options[:params])
+        path = element_path(scope, prefix_options, query_options)
+        instantiate_record(connection.get(path, headers, external_request), prefix_options)
+      end
+    end
+  end
+    
+  class Connection #:nodoc:
+    def get(path, headers = {}, external_request = false) #:nodoc:
+      if external_request
+        # Without mocking - standard ActiveResource
+        response = request(:get, path, build_request_headers(headers, :get))
+      else
+        mocked_response = Dupe.network.request(:get, path)
+        ActiveResource::HttpMock.respond_to do |mock|
+          mock.get(path, {}, mocked_response)
+        end
+        response = request(:get, path, build_request_headers(headers, :get))
+        ActiveResource::HttpMock.delete_mock(:get, path)
+      end
+      format.decode(response.body)
+    end
+
+    
+    def post(path, body = '', headers = {}, external_request = false) #:nodoc:
+      if external_request
+        # external request - standard ActiveResource
+        response = request(:post, path, body.to_s, build_request_headers(headers, :post))
+      else
+        resource_hash = Hash.from_xml(body)
+        resource_hash = resource_hash[resource_hash.keys.first]
+        resource_hash = {} unless resource_hash.kind_of?(Hash)
+        begin
+          mocked_response, new_path = Dupe.network.request(:post, path, resource_hash)
+          error = false
+        rescue Dupe::UnprocessableEntity => e
+          mocked_response = {:error => e.message.to_s}.to_xml(:root => 'errors')
+          error = true
+        end
+        ActiveResource::HttpMock.respond_to do |mock|
+          if error
+            mock.post(path, {}, mocked_response, 422, "Content-Type" => 'application/xml')
+          else
+            mock.post(path, {}, mocked_response, 201, "Location" => new_path)
+          end
+        end
+        response = request(:post, path, body.to_s, build_request_headers(headers, :post))
+        ActiveResource::HttpMock.delete_mock(:post, path)
+      end
+      response
+    end
+    
+    
+    def put(path, body = '', headers = {}, external_request = false) #:nodoc:
+      if external_request
+        response = request(:put, path, body.to_s, build_request_headers(headers, :put))        
+      else
+        resource_hash = Hash.from_xml(body)
+        resource_hash = resource_hash[resource_hash.keys.first]
+        resource_hash = {} unless resource_hash.kind_of?(Hash)
+        resource_hash.symbolize_keys!
+      
+        begin
+          error = false
+          mocked_response, path = Dupe.network.request(:put, path, resource_hash)
+        rescue Dupe::UnprocessableEntity => e
+          mocked_response = {:error => e.message.to_s}.to_xml(:root => 'errors')
+          error = true
+        end
+        ActiveResource::HttpMock.respond_to do |mock|
+          if error
+            mock.put(path, {}, mocked_response, 422, "Content-Type" => 'application/xml')
+          else
+            mock.put(path, {}, mocked_response, 204)
+          end
+        end
+        response = request(:put, path, body.to_s, build_request_headers(headers, :put))
+        ActiveResource::HttpMock.delete_mock(:put, path)
+      end
+
+      response
+    end
+
+
+    def delete(path, headers = {}, external_request = false)
+      # External requests are not allowed!      
+      Dupe.network.request(:delete, path)
+
+      ActiveResource::HttpMock.respond_to do |mock|
+        mock.delete(path, {}, nil, 200)
+      end
+      response = request(:delete, path, build_request_headers(headers, :delete))
+      
+      ActiveResource::HttpMock.delete_mock(:delete, path)
+      response
+    end
+  end
+end

data/lib/superdupe/attribute_template.rb

@@ -0,0 +1,71 @@
+class Dupe
+  class Model #:nodoc:
+    class Schema #:nodoc:
+      # This class represents an attribute template.
+      # An attribute template consists of an attribute name (a symbol),
+      # a potential default value (nil if not specified), 
+      # and a potential transformer proc. 
+      class AttributeTemplate #:nodoc:
+        
+        class NilValue; end
+        
+        attr_reader :name
+        attr_reader :transformer
+        attr_reader :default
+        
+        def initialize(name, options={})
+          default = options[:default]
+          transformer = options[:transformer]
+          
+          if transformer
+            raise ArgumentError, "Your transformer must be a kind of proc." if !transformer.kind_of?(Proc)
+            raise ArgumentError, "Your transformer must accept a parameter." if transformer.arity != 1
+          end
+          
+          @name = name
+          @default = default
+          @transformer = transformer
+        end
+        
+        # Suppose we have the following attribute template:
+        #
+        #   console> a = Dupe::Model::Schema::AttributeTemplate.new(:title)
+        #   
+        # If we call generate with no parameter, we'll get back the following:
+        #  
+        #   console> a.generate
+        #     ===> :title, nil
+        #
+        # If we call generate with a parameter, we'll get back the following:
+        # 
+        #   console> a.generate 'my value'
+        #     ===> :title, 'my value'
+        #
+        # If we setup an attribute template with a transformer:
+        #   
+        #   console> a = 
+        #             Dupe::Model::Schema::AttributeTemplate.new(
+        #               :title, 
+        #               :default => 'default value', 
+        #               :transformer => proc {|dont_care| 'test'}
+        #             )
+        # Then we'll get back the following when we call generate:
+        #
+        #   console> a.generate
+        #     ===> :title, 'default value'
+        #
+        #   console> a.generate 'my value'
+        #     ===> :title, 'test'
+        def generate(value=NilValue)
+          if value == NilValue
+            v = @default.respond_to?(:call) ? @default.call : (@default.dup rescue @default)
+          else
+            v = (@transformer ? @transformer.call(value) : value)
+          end
+          
+          return @name, v
+        end
+      end
+    end
+  end
+end

data/lib/superdupe/cucumber_hooks.rb

@@ -0,0 +1,16 @@
+begin
+  After do |scenario|
+    # print the requests logged during the scenario if in Dupe debug mode
+    if Dupe.debug
+      log = Dupe.network.log.pretty_print
+      puts "\n\n" + log.indent(4) + "\n\n" if log
+    end
+    
+    # remove any data created during the scenario from the dupe database
+    Dupe.database.truncate_tables
+    
+    # clear out the network log
+    Dupe.network.log.reset
+  end
+rescue
+end

data/lib/superdupe/custom_mocks.rb

@@ -0,0 +1,116 @@
+# Dupe knows how to handle simple find by id and find :all lookups from ActiveResource. But what about other requests we might potentially make? 
+# 
+#   irb# Dupe.create :author, :name => 'Monkey', :published => true
+#     ==> <#Duped::Author name="Monkey" published=true id=1>
+# 
+#   irb# Dupe.create :author, :name => 'Tiger', :published => false
+#     ==> <#Duped::Author name="Tiger" published=false id=2>
+# 
+#   irb# class Author < ActiveResource::Base; self.site = ''; end
+#     ==> ""
+# 
+#   irb# Author.find :all, :from => :published
+#   Dupe::Network::RequestNotFoundError: No mocked service response found for '/authors/published.xml'
+#     from /Library/Ruby/Gems/1.8/gems/dupe-0.4.0/lib/dupe/network.rb:32:in `match'
+#     from /Library/Ruby/Gems/1.8/gems/dupe-0.4.0/lib/dupe/network.rb:17:in `request'
+#     from /Library/Ruby/Gems/1.8/gems/dupe-0.4.0/lib/dupe/active_resource_extensions.rb:15:in `get'
+#     from /Library/Ruby/Gems/1.8/gems/activeresource-2.3.5/lib/active_resource/custom_methods.rb:57:in `get'
+#     from /Library/Ruby/Gems/1.8/gems/activeresource-2.3.5/lib/active_resource/base.rb:632:in `find_every'
+#     from /Library/Ruby/Gems/1.8/gems/activeresource-2.3.5/lib/active_resource/base.rb:582:in `find'
+#     from (irb):12
+# 
+# Obviously, Dupe had no way of anticipating this possibility. However, you can create your own custom intercept mock for this: 
+# 
+#   irb# Get %r{/authors/published.xml} do
+#    --#   Dupe.find(:authors) {|a| a.published == true}
+#    --# end
+#     ==> #<Dupe::Network::Mock:0x1833e88 @url_pattern=/\/authors\/published.xml/, @verb=:get, @response=#<Proc:0x01833f14@(irb):13>
+# 
+#   irb# Author.find :all, :from => :published
+#     ==> [#<Author:0x1821d3c @attributes={"name"=>"Monkey", "published"=>true, "id"=>1}, prefix_options{}]
+# 
+#   irb# puts Dupe.network.log.pretty_print
+# 
+#     Logged Requests:
+#       Request: GET /authors/published.xml
+#       Response:
+#         <?xml version="1.0" encoding="UTF-8"?>
+#         <authors type="array">
+#           <author>
+#             <name>Monkey</name>
+#             <published type="boolean">true</published>
+#             <id type="integer">1</id>
+#           </author>
+#         </authors>
+# 
+# 
+# The "Get" method requires a url pattern and a block. In most cases, your block will return a Dupe.find result. Internally, Dupe will transform that into XML. However, if your "Get" block returns a string, Dupe will use that as the response body and not attempt to do any transformations on it. 
+# 
+# Suppose instead the service expected us to pass published as a query string parameter:
+# 
+#   irb# Author.find :all, :params => {:published => true}
+#   Dupe::Network::RequestNotFoundError: No mocked service response found for '/authors.xml?published=true'
+#     from /Library/Ruby/Gems/1.8/gems/dupe-0.4.0/lib/dupe/network.rb:32:in `match'
+#     from /Library/Ruby/Gems/1.8/gems/dupe-0.4.0/lib/dupe/network.rb:17:in `request'
+#     from /Library/Ruby/Gems/1.8/gems/dupe-0.4.0/lib/dupe/active_resource_extensions.rb:15:in `get'
+#     from /Library/Ruby/Gems/1.8/gems/activeresource-2.3.5/lib/active_resource/base.rb:639:in `find_every'
+#     from /Library/Ruby/Gems/1.8/gems/activeresource-2.3.5/lib/active_resource/base.rb:582:in `find'
+#     from (irb):18
+# 
+# We can mock this with the following:
+# 
+#   irb# Get %r{/authors\.xml\?published=(true|false)$} do |published|
+#    --#   if published == 'true'
+#    --#     Dupe.find(:authors) {|a| a.published == true}
+#    --#   else
+#    --#     Dupe.find(:authors) {|a| a.published == false}
+#    --#   end
+#    --# end
+# 
+#   irb# Author.find :all, :params => {:published => true}
+#     ==> [#<Author:0x17db094 @attributes={"name"=>"Monkey", "published"=>true, "id"=>1}, prefix_options{}]
+# 
+#   irb# Author.find :all, :params => {:published => false}
+#     ==> [#<Author:0x17c68c4 @attributes={"name"=>"Tiger", "published"=>false, "id"=>2}, prefix_options{}]
+# 
+#   irb# puts Dupe.network.log.pretty_print
+#   
+#     Logged Requests:
+#       Request: GET /authors.xml?published=true
+#       Response:
+#         <?xml version="1.0" encoding="UTF-8"?>
+#         <authors type="array">
+#           <author>
+#             <name>Monkey</name>
+#             <published type="boolean">true</published>
+#             <id type="integer">1</id>
+#           </author>
+#         </authors>
+# 
+#       Request: GET /authors.xml?published=false
+#       Response:
+#         <?xml version="1.0" encoding="UTF-8"?>
+#         <authors type="array">
+#           <author>
+#             <name>Tiger</name>
+#             <published type="boolean">false</published>
+#             <id type="integer">2</id>
+#           </author>
+#         </authors>
+
+
+def Get(url_pattern, &block)
+  Dupe.network.define_service_mock :get, url_pattern, block
+end
+
+def Post(url_pattern, &block)
+  Dupe.network.define_service_mock :post, url_pattern, block
+end
+
+def Put(url_pattern, &block)
+  Dupe.network.define_service_mock :put, url_pattern, block
+end
+
+def Delete(url_pattern, &block)
+  Dupe.network.define_service_mock :delete, url_pattern, block
+end

data/lib/superdupe/database.rb

@@ -0,0 +1,69 @@
+class Dupe
+  class Database #:nodoc:
+    attr_reader :tables
+    
+    #:nodoc:
+    class TableDoesNotExistError < StandardError; end
+    
+    #:nodoc:
+    class InvalidQueryError < StandardError; end
+    
+    # by default, there are not tables in the database
+    def initialize
+      @tables = {}
+    end
+
+    # database.delete :books # --> would delete all books
+    # database.delete :book # --> would delete the first book record found
+    # database.delete :book, proc {|b| b.id < 10} # --> would delete all books found who's id is less than 10
+    # database.delete :books, proc {|b| b.id < 10} # --> would delete all books found who's id is less than 10
+    def delete(resource_name, conditions=nil)
+      model_name = resource_name.to_s.singularize.to_sym
+      raise StandardError, "Invalid DELETE operation: The resource #{model_name} has not been defined" unless @tables[model_name]
+      
+      if conditions
+        @tables[model_name].reject!(&conditions) 
+      elsif resource_name.singular?
+        @tables[model_name].shift
+      elsif resource_name.plural?
+        @tables[model_name] = []
+      end
+    end
+    
+    # pass in a Dupe::Database::Record object, and this method will store the record
+    # in the appropriate table
+    def insert(record)
+      if !record.kind_of?(Dupe::Database::Record) || !record.__model__ || !record[:id]
+        raise ArgumentError, "You may only insert well-defined Dupe::Database::Record objects" 
+      end
+      @tables[record.__model__.name] ||= []
+      @tables[record.__model__.name] << record
+      record.__model__.run_after_create_callbacks(record)
+    end
+    
+    # pass in a model_name (e.g., :book) and optionally a proc with 
+    # conditions (e.g., {|b| b.genre == 'Science Fiction'})
+    # and recieve a (possibly empty) array of results
+    def select(model_name, conditions=nil)
+      raise TableDoesNotExistError, "The table ':#{model_name}' does not exist." unless @tables[model_name]
+      raise(
+        InvalidQueryError, 
+        "There was a problem with your select conditions. Please consult the API."
+      ) if conditions and (!conditions.kind_of?(Proc) || conditions.arity != 1)
+      
+      return @tables[model_name] if !conditions
+      @tables[model_name].select {|r| conditions.call(r)}
+    end
+    
+    def create_table(model_name)
+      @tables[model_name.to_sym] ||= []
+    end
+    
+    def truncate_tables
+      @tables.each do |table_name, table_records|
+        @tables[table_name] = []
+      end
+    end
+    
+  end
+end