dupe 0.3.5

data/README.rdoc

@@ -0,0 +1,188 @@
+= Dupe 
+
+There are lots of great tools out there to ease the burden of prototyping ActiveRecord objects while cuking your application (e.g., thoughtbot's {"Factory Girl"}[http://www.thoughtbot.com/projects/factory_girl]).
+But what about prototyping ActiveResource records? That's where Dupe steps in.  
+
+
+== Motivation 
+
+Dupe is ideally suited for cuking the client side of a service-oriented (ActiveResource) application where the backend service does not yet exist.
+
+Why would anyone want to do that, you might ask? Dupe arose in the midst of a site migration project. Essentially, the site being replaced 
+had a complicated, denormalized, and chaotic backend datastore that made ordinary data migration a complex nightmare. So the developers involved
+decided to rebuild the frontend of the site first, and connect it to the existing backend via services. 
+
+Using Dupe, they were able to cuke the new frontend, mocking
+the backend services they needed, and then the developers for the old site were able to use the mocked XML output of Dupe to determine exactly what
+services they needed to expose on the backend (along with the XML format of those services). Once those services existed, the new frontend was launched,
+and the developers then created a new backend, migrated data from the old backend (over the services), and pointed the new frontend to the new backend services.
+The resulting site had a nicely decoupled, service-oriented architecture. 
+
+
+== Installation
+
+Add this to your cucumber.rb environment (config/environments/cucumber.rb)
+  
+  config.gem 'dupe', :lib => 'dupe', :version => '>=0.3.5' :source => 'http://gemcutter.org'
+
+Then run this rake task to install the gem: 
+
+  # rake gems:install RAILS_ENV=cucumber
+
+Lastly, from your rails project root, run:
+
+  # script/generate dupe
+
+
+== Example
+
+Let's suppose your cuking a book search application for a library that consumes a RESTFUL book datastore service via ActiveResource.
+You might start by writing the following feature in <em>RAILS_ROOT/features/library/find_book.feature</em>:
+
+  Feature: find a book
+    As a reader
+    I want to search for books
+    so that I can check them out and read them. 
+
+  Scenario: search by author
+    Given an author "Arthur C. Clarke"
+    And a book "2001: A Space Odyssey" by "Arthur C. Clarke"
+    When I search for "Arthur C. Clarke"
+    I should see "2001: A Space Odyssey"
+
+To get this to pass, you might first create ActiveResource[http://api.rubyonrails.org/classes/ActiveResource/Base.html] models for Books and Authors that connect to the Library service:
+
+  class Book < ActiveResource::Base
+    self.site = 'http://bookservice.domain'
+  end
+
+  class Author < ActiveResource::Base
+    self.site = 'http://bookservice.domain'
+  end
+
+Then you might create the following resource definition via Dupe.define (put it in a file with a .rb extension and place it in RAILS_ROOT/features/support/):
+  
+  Dupe.define :book do |book|
+    book.author do |author_name|
+      Dupe.find(:author) {|a| a.name == author_name}
+    end
+  end
+
+and the following cucumber step definitions (utilizing Dupe.create):
+  
+  Given /^an author "([^\"]*)"$/ do |author|
+    Dupe.create :author, :name => author
+  end
+
+  Given /^a book "([^\"]*)" by "([^\"]*)"$/ do |book, author|
+    Dupe.create :book, :title => book, :author => author 
+  end
+
+Dupe.create will in turn mock two service responses for each resource. For example,
+for the Book resource, it will mock:
+
+  # Book.find(:all) --> GET /books.xml
+  <?xml version="1.0" encoding="UTF-8"?>
+  <books type="array">
+    <book>
+      <id type="integer">1</id>
+      <title>2001: A Space Odyssey</title>
+      <author>
+        <id type="integer">1</id>
+        <name>Arthur C. Clarke</name>
+      </author>
+    </book>
+  </books>
+
+  # Book.find(1) --> GET /books/1.xml
+  <?xml version="1.0" encoding="UTF-8"?>
+  <book>
+    <id type="integer">1</id>
+    <title>2001: A Space Odyssey</title>
+    <author>
+      <id type="integer">1</id>
+      <name>Arthur C. Clarke</name>
+    </author>
+  </book>
+
+From here, you could start scaffolding your controllers, with the assumption that Dupe will mock the responses to Book.find(<id or :all>) and Author.find(<id or :all>).
+
+However, what happens when one of your controllers uses an ActiveResource object in such a way that it sends off a request that Dupe has not yet mocked? For example, suppose 
+you had the following in one of your controllers:
+
+  Book.find :all, :params => {:author_id => 1}
+
+This would send off a request like "/books.xml?author_id=1". If this happened during the context of a cucumber scenario, then Dupe would throw an exception with a message like:
+
+  There is no custom service mapping for "/books.xml?author_id=1". 
+  Now go to features/support/custom_mocks.rb and add it. (StandardError)
+
+When you ran "script/generate dupe" during dupe installation, it created a file features/support/custom_mocks.rb that should look something like this:
+
+  module CustomMocks
+    # Maps a service request url to a Dupe find. By default, Dupe will only
+    # mock simple requests like SomeResource.find(some_id) or SomeResource.find(:all)
+    #
+    # For example, suppose you have a Book < ActiveResource::Base class, and
+    # somewhere your code does:
+    #
+    #   Book.find :all, :params => {:limit => 10, :offset => 20}
+    #
+    # That in turn will send off a request to a url like:
+    #
+    #   /books.xml?limit=10&offset=20
+    #
+    # In this file, you could add a "when" statement like:
+    #
+    #   when %r{/books.xml\?limit=(\d+)&offset=(\d+)$}
+    #     start = $2.to_i
+    #     finish = start + $1.to_i - 1
+    #     Dupe.find(:books)[start..finish]
+    def custom_service(url)
+      case url
+
+        # remove this and replace it with a real custom mock
+        when %r{/bogus_url}
+          ''
+
+        else
+          raise StandardError.new(
+            "There is no custom service mapping for \"#{url}\"." +
+            "Now go to features/support/custom_mocks.rb and add it."
+          )
+      end
+    end
+  end
+
+
+Now remove the "when %r{/bogus_url}" statement and add a custom mock for your service:
+
+    def custom_service(url)
+      case url
+
+        when %r{books.xml\?author_id=(\d+)$}
+          Dupe.find(:books) {|b| b.author.id == $1}
+
+        else
+          raise StandardError.new(
+            "There is no custom service mapping for \"#{url}\"." +
+            "Now go to features/support/custom_mocks.rb and add it."
+          )
+
+      end
+    end
+
+Dupe will take the result of the Dupe.find(:books)... code (a Hash), and convert it to XML. 
+You could have alternatively given a string of XML (or a string of anything), and Dupe would have taken it as-is. 
+
+
+== More
+
+Dupe supports attribute defaults, attribute transformations, stubbing, resource associations, custom resource mocks, and more. 
+Want to learn more? Consult the API documentation at http://moonmaster9000.github.com/dupe/api/
+
+
+== TODO List
+
+* Thus far, Dupe has only been used for consuming a service via GET requests. There are no facilities yet for mocking responses to PUT, POST, and DELETE requests. 
+* We need a rake task that will run your scenarios and create service documentation based on the dupe log output (i.e., example requests and example responses) that the programmers implementing the service can use as a reference. 

data/lib/dupe/active_resource.rb

@@ -0,0 +1,135 @@
+# this allows us to control when we flush out the HttpMock requests / responses
+ActiveResource::HttpMock.instance_eval do #:nodoc:
+  def reset! #:nodoc:
+  end
+
+  def reset_from_dupe! #:nodoc:
+    requests.clear
+    responses.clear
+  end
+
+  def delete_mock(http_method, path)
+    responses.reject! {|r| r[0].path == path && r[0].method == http_method}
+  end
+end
+
+# makes it possible to override existing request/response definitions
+module ActiveResource #:nodoc:
+  class HttpMock      #:nodoc:
+    class Responder   #:nodoc:
+      for method in [ :post, :put, :get, :delete, :head ]
+        module_eval <<-EOE, __FILE__, __LINE__
+          def #{method}(path, request_headers = {}, body = nil, status = 200, response_headers = {})
+            @responses.reject! {|r| r[0].path == path && r[0].method == :#{method}}
+            @responses << [Request.new(:#{method}, path, nil, request_headers), Response.new(body || "", status, response_headers)]
+          end
+        EOE
+      end 
+    end
+  end
+end
+
+module CustomMocks
+  class NotImplementedError < StandardError
+  end
+  
+  def custom_service(url)
+    raise NotImplementedError.new("you must implement the CustomMocks::custom_service method.")
+  end
+end
+
+module ActiveResource
+  class Connection #:nodoc:
+    
+    include CustomMocks
+
+    class << self
+      attr_reader :request_log
+
+      def log_request(method, path, headers, response)
+        @request_log ||= []
+        @request_log << {
+          :method   => method,
+          :path     => path,
+          :headers  => headers,
+          :response => response
+        }
+      end
+
+      def flush_request_log
+        @request_log = []
+      end
+      
+      def print_request_log
+        @request_log ||= []
+        if @request_log.empty?
+          puts("\n  -----No request attempts logged for this scenario")  
+          return
+        end
+        puts "\n    Request attempts logged for this scenario:\n    --------------------------------------------\n\n"
+        @request_log.each do |request|
+          puts "    Request: #{request[:method].to_s.upcase} #{request[:path]}"
+          puts "    Headers: #{request[:headers].inspect}"
+          puts "    Response Body:\n#{request[:response].body.split("\n").map {|s| (" "*6) + s}.join("\n")}"
+          puts "    Response Code: #{request[:response].code}"
+          puts "    Response Headers: #{request[:response].headers}"
+          puts "    Response Message: #{request[:response].message}"
+          puts "\n\n"
+        end
+      end
+    end
+    
+    # Execute a GET request.
+    # Used to get (find) resources.
+    def get(path, headers = {})
+      begin
+        response = request(:get, path, build_request_headers(headers, :get))
+
+      # if the request threw an exception
+      rescue
+        # make sure that it's not a custom service that should be handled on the fly
+        response_body = custom_service(path)
+        response_body = response_body.to_xml(:root => path.match(/^\/([^\/\.]+)/)[1]) if response_body.is_a?(Hash) || response_body.is_a?(Array)
+        ActiveResource::HttpMock.respond_to do |mock|
+          mock.get path, {}, response_body
+        end
+        response = request(:get, path, build_request_headers(headers, :get))
+        ActiveResource::HttpMock.delete_mock(:get, path)
+      end
+      ActiveResource::Connection.log_request(:get, path, build_request_headers(headers, :get), response)
+      format.decode(response.body)
+    end
+
+    # Execute a DELETE request (see HTTP protocol documentation if unfamiliar).
+    # Used to delete resources.
+    def delete(path, headers = {})
+      response = request(:delete, path, build_request_headers(headers, :delete))
+      ActiveResource::Connection.log_request(:delete, path, build_request_headers(headers, :delete), response)
+      response
+    end
+
+    # Execute a PUT request (see HTTP protocol documentation if unfamiliar).
+    # Used to update resources.
+    def put(path, body = '', headers = {})
+      response = request(:put, path, body.to_s, build_request_headers(headers, :put))
+      ActiveResource::Connection.log_request(:put, path, build_request_headers(headers, :put), response)
+      response
+    end
+
+    # Execute a POST request.
+    # Used to create new resources.
+    def post(path, body = '', headers = {})
+      response = request(:post, path, body.to_s, build_request_headers(headers, :post))
+      ActiveResource::Connection.log_request(:post, path, build_request_headers(headers, :post), response) 
+      response
+    end
+
+    # Execute a HEAD request.
+    # Used to obtain meta-information about resources, such as whether they exist and their size (via response headers).
+    def head(path, headers = {})
+      response = request(:head, path, build_request_headers(headers))
+      ActiveResource::Connection.log_request(:head, path, build_request_headers(headers), response)
+      response
+    end
+  end
+end

data/lib/dupe/attribute.rb

@@ -0,0 +1,17 @@
+class Dupe 
+  class Attribute #:nodoc:
+    def initialize(name, value=nil, prock=nil)
+      @name, @value, @prock = name.to_sym, value, prock
+    end
+
+    def value(v=nil)
+      v = @value.dup if @value and !v
+      @prock && v ? @prock.call(v) : v 
+    end
+
+    def to_hash
+      {@name => value} 
+    end
+
+  end
+end

data/lib/dupe/configuration.rb

@@ -0,0 +1,20 @@
+class Dupe 
+  class Configuration #:nodoc:
+    attr_reader :config
+    
+    def initialize
+      @config ||= {}
+      @config[:record_identifiers] = [:id]
+    end
+
+    def method_missing(method_name, *args, &block)
+      set_config_option(method_name.to_sym, method_name.to_s.plural? ? args : args.first)
+    end
+
+
+    private
+    def set_config_option(key, value)
+      @config[key] = value
+    end
+  end
+end

data/lib/dupe/cucumber_hooks.rb

@@ -0,0 +1,8 @@
+After do |scenario| #:nodoc:
+  if Dupe.global_configuration.config[:debug] == true
+    ActiveResource::Connection.print_request_log 
+    ActiveResource::Connection.flush_request_log
+  end
+
+  Dupe.flush
+end

data/lib/dupe/dupe.rb

@@ -0,0 +1,477 @@
+# Author::    Matt Parker  (mailto:moonmaster9000@gmail.com)
+# License::   Distributes under the same terms as Ruby
+
+class Dupe
+  attr_reader :factory_name   #:nodoc:
+  attr_reader :configuration  #:nodoc:
+  attr_reader :attributes     #:nodoc:
+  attr_reader :config         #:nodoc:
+  attr_reader :mocker         #:nodoc:
+  attr_reader :records        #:nodoc:
+
+  class << self
+    attr_accessor :factories            #:nodoc:
+    attr_accessor :global_configuration #:nodoc:
+    
+    # Create data definitions for your resources. This allows you to setup default values for columns
+    # and even provide data transformations.
+    #
+    # For example, suppose you had the following cucumber scenario: 
+    #
+    #   # RAILS_ROOT/features/library/find_book.feature
+    #   Feature: Find a book
+    #     As a reader
+    #     I want to find books in my library
+    #     So that I can read them
+    #
+    #   Scenario: Browsing books
+    #     Given the following author: 
+    #     | name             | date_of_birth |
+    #     | Arthur C. Clarke | 1917-12-16    |
+    #
+    #     And the following book:
+    #     | name                  | author            |
+    #     | 2001: A Space Odyssey | Arthur C. Clarke  |
+    #
+    #     When....
+    #
+    #
+    # We can use Dupe.define to
+    # * Transform data (e.g., turn the string '1917-12-16' into a Date object)
+    # * Provide default values for attributes (e.g., give all author's a default biography)
+    # * Associate records (e.g., given an author name, return the author record associated with that name)
+    #
+    # To accomplish the afore mentioned definitions:
+    #
+    #   # RAILS_ROOT/features/dupe_definitions/book.rb
+    #
+    #   Dupe.define :author do |define|
+    #     define.bio 'Lorem ipsum delor.'
+    #     define.date_of_birth do |d|
+    #       Date.parse(t)
+    #     end
+    #   end
+    #   
+    #   Dupe.define :book do |define|
+    #     define.author do |author_name|
+    #       Dupe.find(:author) {|a| a.name == author_name}
+    #     end
+    #   end
+    #
+    #   -----------------------------------------------------------------------------------------------------------------
+    #
+    #   # RAILS_ROOT/features/step_definitions/library/find_book_steps.rb
+    #
+    #   Given /^the following author:$/ do |author_table|
+    #     Dupe.create(:author, author_table.hashes)
+    #   end
+    #
+    #   Given /^the following book:$/ do |book_table|
+    #     Dupe.create(:book, book_table.hashes)
+    #   end
+    #
+    # When cucumber encounters the "Given the following author:" line, the corresponding step definition
+    # will ask Dupe to mock ActiveResource responses to find(:all) and find(:id) with the data
+    # specified in the cucumber hash table immediately following the "Given the following author:" line. 
+    # Since we didn't specify a 'bio' value in our cucumber hash table, Dupe will give it the 
+    # default value 'Lorem ipsum delor.'. Also, it will transform the 'date_of_birth' value we provided in the hash 
+    # table into a time object.
+    #
+    # Similarly, for the :book cucumber hash table, Dupe will transform the author name we provided
+    # into the author object we had already specified in the :author table. 
+    #
+    # In terms of mocked responses, we could expect something like: 
+    #
+    #   # Author.find(1) --> GET /authors/1.xml
+    #   <?xml version="1.0" encoding="UTF-8"?>
+    #   <author>
+    #     <id type="integer">1</id>
+    #     <name>Arthur C. Clarke</name>
+    #     <bio>Lorem ipsum delor.</bio>
+    #     <date_of_birth>1917-12-16T00:00:00Z</date_of_birth>
+    #   </author>
+    #
+    #   # Book.find(1) --> GET /books/1.xml
+    #   <?xml version="1.0" encoding="UTF-8"?>
+    #   <book>
+    #     <id type="integer">1</id>
+    #     <name>2001: A Space Odyssey</name>
+    #     <author>
+    #       <id type="integer">1</id>
+    #       <name>Arthur C. Clarke</name>
+    #       <bio>Lorem ipsum delor.</bio>
+    #       <date_of_birth>1917-12-16T00:00:00Z</date_of_birth>
+    #     </author>
+    #   </book>
+    def define(factory) # yield: define
+      setup_factory(factory)
+      yield @factories[factory]
+    end
+   
+    # This method will cause Dupe to mock resources for the record(s) provided. 
+    # The "records" value may be either a hash or an array of hashes. 
+    # For example, suppose you'd like to mock a single author ActiveResource object: 
+    #
+    #   Dupe.create :author, :name => 'Arthur C. Clarke'
+    #
+    # This will translate into the following two mocked resource calls:
+    #
+    #   # Author.find(:all) --> GET /authors.xml
+    #   <?xml version="1.0" encoding="UTF-8"?>
+    #   <authors>
+    #     <author>
+    #       <id type="integer">1</id>
+    #       <name>Arthur C. Clarke</name>
+    #     </author>
+    #   </authors>
+    #   
+    #   # Author.find(1) --> GET /authors/1.xml
+    #   <?xml version="1.0" encoding="UTF-8"?>
+    #   <author>
+    #     <id type="integer">1</id>
+    #     <name>Arthur C. Clarke</name>
+    #   </author>
+    #
+    # However, suppose you wanted to mock two or more authors. 
+    #
+    #   Dupe.create :author, [{:name => 'Arthur C. Clarke'}, {:name => 'Robert Heinlein'}]
+    #
+    # This will translate into the following three mocked resource calls: 
+    #
+    #   # Author.find(:all) --> GET /authors.xml 
+    #   <?xml version="1.0" encoding="UTF-8"?>
+    #   <authors>
+    #     <author>
+    #       <id type="integer">1</id>
+    #       <name>Arthur C. Clarke</name>
+    #     </author>
+    #     <author>
+    #       <id type="integer">2</id>
+    #       <name>Robert Heinlein</name>
+    #     </author>
+    #   </authors>
+    #   
+    #   # Author.find(1) --> GET /authors/1.xml
+    #   <?xml version="1.0" encoding="UTF-8"?>
+    #   <author>
+    #     <id type="integer">1</id>
+    #     <name>Arthur C. Clarke</name>
+    #   </author>
+    #
+    #   # Author.find(2) --> GET /authors/2.xml
+    #   <?xml version="1.0" encoding="UTF-8"?>
+    #   <author>
+    #     <id type="integer">2</id>
+    #     <name>Robert Heinlein</name>
+    #   </author>
+    def create(factory, records={})
+      setup_factory(factory)
+      raise Exception, "unknown records type" if !records.nil? and !records.is_a?(Array) and !records.is_a?(Hash)
+      records = [records] if records.is_a?(Hash)
+      @factories[factory].generate_services_for(records)
+    end
+
+    # You can use this method to quickly stub out a large number of resources. For example: 
+    #
+    #   Dupe.stub 20, :authors
+    #
+    #
+    # Assuming you had an :author resource definition like: 
+    #
+    #   Dupe.define :author {|author| author.name('default')}
+    #
+    #
+    # then stub would have generated 20 author records like: 
+    #
+    #   {:name => 'default', :id => 1}
+    #   ....
+    #   {:name => 'default', :id => 20}
+    #
+    # and it would also have mocked find(id) and find(:all) responses for these records (along with any other custom mocks you've
+    # setup via Dupe.define_mocks). (Had you not defined an author resource, then the stub would have generated 20 author records
+    # where the only attribute is the id). 
+    #
+    # Of course, it's more likely that you wanted to dupe 20 <em>different</em> authors. You can accomplish this by simply doing: 
+    #   
+    #   Dupe.stub 20, :authors, :like => {:name => proc {|n| "author #{n}"}}
+    #
+    # which would generate 20 author records like: 
+    #
+    #   {:name => 'author 1',   :id => 1}
+    #   ....
+    #   {:name => 'author 20',  :id => 20}
+    #
+    # You may also override the sequence starting value:
+    #
+    #   Dupe.stub 20, :authors, :like => {:name => proc {|n| "author #{n}"}}, :starting_with => 150
+    #
+    # This would generate 20 author records like:  
+    #
+    #   {:name => 'author 150',   :id => 1}
+    #   ....
+    #   {:name => 'author 169',  :id => 20}
+    #
+    # Naturally, stub will consult the Dupe.define definitions for anything it's attempting to stub
+    # and will honor those definitions (default values, transformations) as you would expect. 
+    def stub(count, factory, options={})
+      factory = factory.to_s.singularize.to_sym
+      setup_factory(factory)
+      @factories[factory].stub_services_with((options[:like] || {}), count.to_i, (options[:starting_with] || 1))
+    end
+
+    # === Global Configuration
+    #
+    # On a global level, configure supports the following options (expect this list to grow as the app grows):
+    #   debug: list the attempted requests and mocked responses that happened during the course of a scenario
+    #
+    # To turn on debugging, simply do:
+    #   Dupe.configure do |global_config|
+    #     global_config.debug true
+    #   end
+    #
+    # === Factory Configuration 
+    #
+    # On a factory level, configure support the following options (expect this list to grow as the app grows):
+    #   record_identifiers: a list of attributes that are unique to each record in that resource factory.
+    #   
+    # The "record_identifiers" configuration option allows you to override the array record identifiers for your resources ([:id], by default)
+    # 
+    # For example, suppose the RESTful application your trying to consume supports lookups by both a textual 'label' 
+    # and a numeric 'id', and that it contains an author service where the author with id '1' has the label 'arthur-c-clarke'.
+    # Your application should expect the same response whether or not you call <tt>Author.find(1)</tt> or <tt>Author.find('arthur-c-clarke')</tt>.
+    # 
+    # Thus, to ensure that Dupe mocks both, do the following:
+    #   Dupe.configure :author do |configure|
+    #     configure.record_identifiers :id, :label
+    #   end
+    #
+    # With this configuration, a <tt>Dupe.create :author, :name => 'Arthur C. Clarke', :label => 'arthur-c-clarke'</tt>
+    # will result in the following mocked service calls: 
+    #
+    # <tt>Author.find(1) --> (GET /authors/1.xml)</tt>
+    #
+    #   <?xml version="1.0" encoding="UTF-8"?>
+    #   <author>
+    #     <id type="integer">1</id>
+    #     <name>Arthur C. Clarke</name>
+    #     <label>arthur-c-clarke</label>
+    #   </author>
+    #
+    #
+    # <tt>Author.find('arthur-c-clarke') --> (GET /authors/arthur-c-clarke.xml)</tt>
+    #
+    #   <?xml version="1.0" encoding="UTF-8"?>
+    #   <author>
+    #     <id type="integer">1</id>
+    #     <name>Arthur C. Clarke</name>
+    #     <label>arthur-c-clarke</label>
+    #   </author>
+    def configure(factory=nil) # yield: configure
+      yield global_configuration and return unless factory
+      setup_factory(factory)
+      yield @factories[factory].config
+    end
+    
+    # By default, Dupe will mock responses to ActiveResource <tt>find(:all)</tt> and <tt>find(id)</tt>. 
+    # However, it's likely that your cucumber scenarios will eventually fire off an ActiveResource request that's
+    # something other than these basic lookups.
+    #
+    # Dupe.define_mocks allows you to add new resource mocks and override the built-in resource mocks. 
+    #
+    # For example, suppose you had a Book ActiveResource model, and you want to use it to get the :count of all 
+    # Books in the back end system your consuming. <tt>Book.get(:count)</tt> would fire off an HTTP request to the 
+    # backend service like <tt>"GET /books/count.xml"</tt>, and assuming the service is set up to respond to that
+    # request, you might expect to get something back like: 
+    #
+    #   <?xml version="1.0" encoding="UTF-8"?>
+    #   <hash>
+    #     <count type="integer">3</count>
+    #   </hash>
+    #
+    # To mock this for the purposes of cuking, you could do the following:
+    # 
+    #   Dupe.define_mocks :book do |define|
+    #     define.count do |mock, records|
+    #       mock.get "/books/count.xml", {}, {:count => records.size}.to_xml 
+    #     end
+    #   end
+    #
+    # The <tt>mock</tt> object is the ActiveResource::HttpMock object. Please see the documentation for that
+    # if you would like to know more about what's possible with it. 
+    def define_mocks(factory) # yield: define
+      setup_factory(factory)
+      yield @factories[factory].mocker
+    end
+    
+
+    # Search for a resource. This works a bit differently from both ActiveRecord's find and ActiveResource's find. 
+    # This is most often used for defining associations between objects (Dupe.define). 
+    # It will return a hash representation of the resource (or an array of hashes if we asked for multiple records).
+    #
+    # For example, suppose we have an author resource, and a book resource with a nested author attribute (in ActiveRecord
+    # parlance, Book belongs_to Author, Author has_many Book). 
+    #
+    # Now suppose we've created the following cucumber scenario:
+    #
+    #   Scenario: Browsing books
+    #     Given the following author: 
+    #     | name             | date_of_birth |
+    #     | Arthur C. Clarke | 1917-12-16    |
+    #
+    #     And the following books:
+    #     | name                  | author           | published | genre    |
+    #     | 2001: A Space Odyssey | Arthur C. Clarke | 1968      | sci-fi   |
+    #     | A Fall of Moondust    | Arthur C. Clarke | 1961      | fantasy  |
+    #     | Rendezvous with Rama  | Arthur C. Clarke | 1972      | sci-fi   |
+    #
+    #     When....
+    #
+    # To link up the book and author, we could create the following book definition
+    #   
+    #   Dupe.define :book do |book|
+    #     book.author {|name| Dupe.find(:author) {|a| a.name == name}}
+    #   end
+    # 
+    # The line <tt>Dupe.find(:author) {|a| a.name == name}</tt> could be translated as 
+    # "find the first author record where the author's name equals `name`". 
+    #
+    # Dupe decided to return only a single record because we specified <tt>find(:author)</tt>. 
+    # Had we instead specified <tt>find(:authors)</tt>, resource factory would have instead returned an array of results. 
+    #
+    # More examples: 
+    #   
+    #   # find all books written in the 1960's
+    #   Dupe.find(:books) {|b| b.published >= 1960 and b.published <= 1969}
+    #
+    #   # return the first book found that was written by Arthur C. Clarke (nested resources example)
+    #   Dupe.find(:book) {|b| b.author.name == 'Arthur C. Clarke'}
+    #
+    #   # find all sci-fi and fantasy books
+    #   Dupe.find(:books) {|b| b.genre == 'sci-fi' or b.genre == 'fantasy'}
+    #
+    #   # find all books written by people named 'Arthur'
+    #   Dupe.find(:books) {|b| b.author.name.match /Arthur/}
+    #
+    # Also, if you have the need to explicitly specify :all or :first instead of relying on specifying the singular v. plural 
+    # version of your resource name (perhaps the singular and plural version of your resource are exactly the same):
+    # 
+    #   Dupe.find(:all, :deer) {|d| d.type == 'doe'}
+    #   Dupe.find(:first, :deer) {|d| d.name == 'Bambi'}
+    def find(*args, &block) # yield: record
+      all_or_first, factory_name = args[-2], args[-1]
+      match         = block ? block : proc {true}
+      all_or_first  = ((factory_name.to_s.plural?) ? :all : :first) unless all_or_first
+      factory_name  = factory_name.to_s.singularize.to_sym
+      verify_factory_exists factory_name
+      result        = factories[factory_name].find_records_like match
+      all_or_first  == :all ? result : result.first
+    end
+
+    def get_factory(factory) #:nodoc:
+      setup_factory(factory)
+      @factories[factory]
+    end
+
+    def flush(factory=nil, destroy_definitions=false) #:nodoc:
+      if factory and factories[factory]
+        factories[factory].flush(destroy_definitions)
+      else
+        factories.each {|factory_name, factory| factory.flush(destroy_definitions)}
+      end
+    end
+
+    def factories #:nodoc:
+      @factories ||= {}
+    end
+
+    def global_configuration #:nodoc:
+      @global_configuration ||= Configuration.new
+    end
+
+    private
+    
+    def setup_factory(factory)
+      factories[factory] = Dupe.new(factory) unless factories[factory]
+    end
+
+    def reset(factory)
+      factories[factory].flush if factories[factory]
+    end
+
+    def verify_factory_exists(factory_name)
+      raise "Dupe doesn't know about the '#{factory_name}' resource" unless factories[factory_name]
+    end
+  end
+
+  def flush(destroy_definitions=false) #:nodoc:
+    @records = []
+    @sequence = Sequence.new
+    @attributes = {} if destroy_definitions
+    ActiveResource::HttpMock.reset_from_dupe!
+  end
+  
+  def stub_services_with(record_template, count=1, starting_value=1) #:nodoc: 
+    records = stub_records(record_template, count, starting_value)
+    generate_services_for(records, true)
+  end
+  
+  def initialize(factory) #:nodoc:
+    @factory_name = factory
+    @attributes   = {}
+    @config       = Configuration.new
+    @mocker       = MockServiceResponse.new(@factory_name)
+    @records      = []
+  end
+
+  def method_missing(method_name, *args, &block) #:nodoc:
+    args = [nil] if args.empty?
+    args << block
+    define_attribute(method_name.to_sym, *args)
+  end
+
+  def generate_services_for(records, records_already_processed=false) #:nodoc:
+    records = process_records records unless records_already_processed
+    @mocker.run_mocks(@records, @config.config[:record_identifiers])
+  end
+  
+  def find_records_like(match) #:nodoc:
+    @records.select {|r| match.call Record.new(r)}
+  end
+
+  private
+  def define_attribute(name, default_value=nil, prock=nil) 
+    @attributes[name] = Attribute.new(name, default_value, prock)
+  end
+
+  def process_records(records)
+    records.map {|r| generate_record({:id => sequence}.merge(r))}
+  end
+
+  def generate_record(overrides={})
+    define_missing_attributes(overrides.keys)
+    record = {}
+    @attributes.each do |attr_key, attr_class|
+      override_default_value = overrides[attr_key] || overrides[attr_key.to_s]
+      record[attr_key] = attr_class.value(override_default_value)
+    end
+    @records << record
+    record
+  end
+
+  def sequence
+    (@sequence ||= Sequence.new).next
+  end
+
+  def define_missing_attributes(keys)
+    keys.each {|k| define_attribute(k.to_sym) unless @attributes[k.to_sym]}
+  end
+
+  def stub_records(record_template, count, stub_number)
+    overrides = record_template.merge({})
+    overrides.keys.each {|k| overrides[k] = overrides[k].call(stub_number) if overrides[k].respond_to?(:call)}
+    overrides = {:id => sequence}.merge(overrides) unless overrides[:id]
+    return [generate_record(overrides)] if count <= 1
+    [generate_record(overrides)] + stub_records(record_template, count-1, stub_number+1)
+  end
+
+end

data/lib/dupe/mock_service_response.rb

@@ -0,0 +1,55 @@
+class Dupe 
+  class MockServiceResponse #:nodoc:
+    attr_reader :mocks
+    attr_reader :resource_name
+    attr_reader :format
+
+    def initialize(resource_name, format=:xml)
+      @mocks = []
+      @resource_name = resource_name
+      @to_format = "to_#{format}"
+    end
+    
+    def define_mock(prock)
+      @mocks << prock
+    end
+
+    def method_missing(method_name, *args, &block)
+      @mocks << block
+    end
+
+    def run_mocks(records, identifiers)
+      ActiveResource::HttpMock.respond_to do |mock|
+        @mocks.each do |a_mock|
+          a_mock.call mock, records
+        end
+      end
+      find_all(records)
+      records.each {|r| find_one(r, identifiers)}
+    end
+    
+    private
+    def find_all(records)
+      ActiveResource::HttpMock.respond_to do |mock|
+        mock.get "#{prefix}#{@resource_name.to_s.pluralize}.xml",  {}, format_for_service_response(records)
+      end
+    end
+    
+    def find_one(record, identifiers)
+      ActiveResource::HttpMock.respond_to do |mock|
+        identifiers.each do |identifier|
+          mock.get "#{prefix}#{@resource_name.to_s.pluralize}/#{record[identifier]}.xml", {}, format_for_service_response(record)
+        end
+      end
+    end
+
+    def format_for_service_response(records)
+      root = (records.is_a? Array) ? @resource_name.to_s.pluralize : @resource_name.to_s
+      @format == :json ? records.to_json({:root => root}): records.to_xml({:root => root})
+    end
+
+    def prefix
+      @resource_name.to_s.camelize.constantize.prefix.gsub(/\/+/, '/') rescue "/" 
+    end
+  end
+end

data/lib/dupe/record.rb

@@ -0,0 +1,19 @@
+class Dupe
+  class Record #:nodoc:
+    def initialize(hash)
+      @attributes = hash.merge(hash) do |k,v| 
+        if v.is_a?(Hash) 
+          Record.new(v)
+        elsif v.is_a?(Array)
+          v.map {|r| Record.new(r)}
+        else
+          v
+        end
+      end
+    end
+
+    def method_missing(method_name, *args, &block)
+      @attributes[method_name.to_sym]
+    end
+  end
+end

data/lib/dupe/sequence.rb

@@ -0,0 +1,11 @@
+class Dupe
+  class Sequence  #:nodoc:
+    def initialize(start=0)
+      @sequence_value = start
+    end
+
+    def next
+      @sequence_value += 1
+    end
+  end
+end

data/lib/dupe/string.rb

@@ -0,0 +1,9 @@
+class String
+  def plural?
+    self.to_s == pluralize
+  end
+
+  def singular?
+    self.to_s == singularize
+  end
+end

data/lib/dupe.rb

@@ -0,0 +1,18 @@
+require 'active_resource'
+require 'active_resource/http_mock'
+require 'dupe/string'
+require 'dupe/dupe'
+require 'dupe/sequence'
+require 'dupe/mock_service_response'
+require 'dupe/configuration'
+require 'dupe/attribute'
+require 'dupe/active_resource'
+require 'dupe/cucumber_hooks'
+require 'dupe/record'
+
+path = defined?(RAILS_ROOT) ? RAILS_ROOT + '/features/dupe_definitions' : '../features/dupe_definitions'
+if File.directory? path
+  Dir[File.join(path, '*.rb')].each do |file|
+    require file
+  end
+end

data/rails_generators/dupe/dupe_generator.rb

@@ -0,0 +1,14 @@
+class DupeGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      # make sure the features and features/support directories exist
+      m.directory 'features/support'
+
+      # copy the custom_mocks.rb example file into features/support
+      m.template 'custom_mocks.rb', 'features/support/custom_mocks.rb'
+
+      # copy the dupe_setup.rb example file into features/support
+      m.template 'dupe_setup.rb', 'features/support/dupe_setup.rb'
+    end
+  end
+end

data/rails_generators/dupe/templates/custom_mocks.rb

@@ -0,0 +1,34 @@
+module CustomMocks
+  # Maps a service request url to a Dupe find. By default, Dupe will only
+  # mock simple requests like SomeResource.find(some_id) or SomeResource.find(:all)
+  #
+  # For example, suppose you have a Book < ActiveResource::Base class, and
+  # somewhere your code does:
+  #
+  #   Book.find :all, :params => {:limit => 10, :offset => 20}
+  #
+  # That in turn will send off a request to a url like:
+  #
+  #   /books.xml?limit=10&offset=20
+  #
+  # In this file, you could add a "when" statement like:
+  #
+  #   when %r{/books.xml\?limit=(\d+)&offset=(\d+)$}
+  #     start = $2.to_i
+  #     finish = start + $1.to_i - 1
+  #     Dupe.find(:books)[start..finish]
+  def custom_service(url)
+    case url
+
+      # remove this and replace it with a real custom mock
+      when %r{/bogus_url}
+        ''
+
+      else
+        raise StandardError.new(
+          "There is no custom service mapping for \"#{url}\"." +
+          "Now go to features/support/custom_mocks.rb and add it."
+        )
+    end
+  end
+end

data/rails_generators/dupe/templates/dupe_setup.rb

@@ -0,0 +1,23 @@
+Dupe.configure do |global_config|
+  # set this to false if you don't want to see the mocked
+  # xml output after each scenario
+  global_config.debug true
+end
+
+# You can also place your resource definitions in this file. 
+=begin
+  # Example resource definition
+  Dupe.define :books do |book|
+    book.name 'default name'
+
+    # supporting Dupe.create :book, :genre => 'Sci-fi'
+    book.genre do |genre_name|
+      Dupe.find(:genre) {|g| g.name == genre_name}
+    end
+
+    # supporting Dupe.create :book, :authors => 'Arthur C. Clarke, Gentry Lee'
+    book.authors do |author_names|
+      Dupe.find(:authors) {|a| author_names.split(/,\ */).include?(a.name)}
+    end
+  end
+=end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: dupe
+version: !ruby/object:Gem::Version 
+  version: 0.3.5
+platform: ruby
+authors: 
+- Matt Parker
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-28 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activeresource
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.3
+    version: 
+description: |-
+  Dupe rides on top of ActiveResource to allow you to cuke the client side of 
+                             a service-oriented app without having to worry about whether or not the service 
+                             is live or available while cuking.
+email: moonmaster9000@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- lib/dupe.rb
+- lib/dupe/active_resource.rb
+- lib/dupe/attribute.rb
+- lib/dupe/configuration.rb
+- lib/dupe/cucumber_hooks.rb
+- lib/dupe/dupe.rb
+- lib/dupe/mock_service_response.rb
+- lib/dupe/record.rb
+- lib/dupe/sequence.rb
+- lib/dupe/string.rb
+- rails_generators/dupe/dupe_generator.rb
+- rails_generators/dupe/templates/custom_mocks.rb
+- rails_generators/dupe/templates/dupe_setup.rb
+has_rdoc: true
+homepage: http://github.com/moonmaster9000/dupe
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A tool that helps you mock services while cuking.
+test_files: []
+