dupe 0.4.9 → 0.5.0

data/README.rdoc

@@ -374,6 +374,10 @@ Similarly:
 
 Dupe knew how to handle simple find by id and find :all lookups from ActiveResource. But what about other requests we might potentially make? 
 
+===GET requests
+
+In this section, you'll learn how to mock custom GET requests.
+
   irb# Dupe.create :author, :name => 'Monkey', :published => true
     ==> <#Duped::Author name="Monkey" published=true id=1>
 
@@ -384,14 +388,7 @@ Dupe knew how to handle simple find by id and find :all lookups from ActiveResou
     ==> ""
 
   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
+    ==> Dupe::Network::RequestNotFoundError: No mocked service response found for '/authors/published.xml'
 
 Obviously, Dupe had no way of anticipating this possibility. However, you can create your own custom intercept mock for this: 
 
@@ -472,7 +469,66 @@ We can mock this with the following:
           </author>
         </authors>
 
+===POST requests
+
+Out of the box you get a POST intercept mock:
+
+  irb# Dupe.define :author
+
+  irb# class Author < ActiveResource::Base; self.site = ''; end
+    ==> ""
+
+  irb# Author.create :name => "CS Lewis"
+    ==> #<Author:0x1a4ca58 @attributes={"name"=>"CS Lewis", "id"=>1}, @prefix_options={}>
+  
+Author.create sent a network POST to /authors.xml and Dupe responded by creating the resource with the requested parameters:
+
+  irb# Dupe.find :authors
+    ==> [<#Duped::Author name="CS Lewis" id=1>]
+    
+You can also overwrite the default POST intercept mock for your resource by using the Post method:
+
+  irb# Post %r{/authors\.xml} do |post_data|
+         raise Dupe::UnprocessableEntity.new(:name => " must be present.") unless post_data["name"]
+         Dupe.create :author, post_data
+       end
+    ==> #<Dupe::Network::PostMock:0x1a1afe4 @url_pattern=/\/authors\.xml/, @response=#<Proc:0x01a1b084@(irb):13>, @verb=:post>
+  
+Now, when you try to create an Author without a name, it will respond with the appropriate mocked errors.
+  
+  irb# Dupe.find(:authors)
+    ==> []
+  
+  irb# a = Author.create
+    ==> a = #<Author:0x1a19fb8 @attributes={}, @errors=#<ActiveResource::Errors:0x1a10bc0 @errors={"base"=>["name must be present."]}, @base=#<Author:0x1a19fb8 ...>>, @prefix_options={}>
+  
+  irb# a = a.valid?
+    ==> false
+  
+  irb# a = a.new?
+    ==> true
+    
+Because the resource would invalidate, the Dupe object is not created.
+  
+  irb# Dupe.find(:authors)
+    ==> []
+    
+When we create the Author with the required attributes, it will now be considered valid.
+    
+  irb# a = Author.create :name => "CS Lewis"
+    ==> #<Author:0x19f1edc @attributes={"name"=>"CS Lewis", "id"=>1}, @prefix_options={}>
+    
+  irb# a.valid?
+    ==> true
+    
+  irb# a.new?
+    ==> false
+    
+Now, Dupe will go ahead and create the resource.
 
+  irb# Dupe.find(:authors)
+    ==> [<#Duped::Author name="CS Lewis" id=1>]
+  
 == More
 
 Consult the API documentation at http://moonmaster9000.github.com/dupe/api/

data/lib/dupe/active_resource_extensions.rb

@@ -14,12 +14,41 @@ module ActiveResource #:nodoc:
       rescue
         mocked_response = Dupe.network.request(:get, path)
         ActiveResource::HttpMock.respond_to do |mock|
-          mock.get path, {}, mocked_response
+          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 = {}) #:nodoc:
+      begin
+        response = request(:post, path, body.to_s, build_request_headers(headers, :post))
+        
+      # if the request threw an exception
+      rescue
+        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
   end
 end

data/lib/dupe/custom_mocks.rb

@@ -97,6 +97,12 @@
 #             <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

data/lib/dupe/dupe.rb

@@ -178,7 +178,12 @@ class Dupe
             :get, 
             %r{^#{model_name.to_s.titleize.constantize.prefix rescue '/'}#{model_name.to_s.pluralize}/(\\d+)\\.xml$}, 
             proc {|id| Dupe.find(:#{model_name}) {|resource| resource.id == id.to_i}}
-          )  
+          )
+          network.define_service_mock(
+            :post, 
+            %r{^#{model_name.to_s.titleize.constantize.prefix rescue '/'}#{model_name.to_s.pluralize}\\.xml$}, 
+            proc { |post_body| Dupe.create(:#{model_name.to_s}, post_body) }
+          )
         }
         eval(mocks)
       end
@@ -509,3 +514,7 @@ class Dupe
     end
   end
 end
+
+class Dupe
+  class UnprocessableEntity < StandardError; end
+end

data/lib/dupe/mock.rb

@@ -26,33 +26,64 @@ class Dupe
         url_pattern =~ url ? true : false
       end
     
-      def mocked_response(url)
+      def mocked_response(url, body = nil)
         raise(
           StandardError, 
           "Tried to mock a response to a non-matched url! This should never occur. My pattern: #{@url_pattern}. Url: #{url}"
         ) unless match?(url)
       
         grouped_results = url_pattern.match(url)[1..-1]
+        grouped_results << body if body
         resp = @response.call *grouped_results
+        process_response(resp, url)
+      end
       
+      def process_response(resp, url)
+        raise NotImplementedError, "Need to specify the appropriate mock class: GetMock, PostMock, PutMock or DeleteMock"
+      end
+    end
+  end
+end
+
+class Dupe
+  class Network
+    class GetMock < Mock #:nodoc:
+      def process_response(resp, url)
         case resp
-          when NilClass
-            raise ResourceNotFoundError, "Failed with 404: the request '#{url}' returned nil." 
-          when Dupe::Database::Record
-            resp = resp.to_xml_safe(:root => resp.__model__.name.to_s)
-          when Array
-            if resp.empty?
-              resp = [].to_xml :root => 'results'
-            else
-              resp = resp.map {|r| HashPruner.prune(r)}.to_xml(:root => resp.first.__model__.name.to_s.pluralize)
-            end
+        when NilClass
+          raise ResourceNotFoundError, "Failed with 404: the request '#{url}' returned nil." 
+        when Dupe::Database::Record
+          resp = resp.to_xml_safe(:root => resp.__model__.name.to_s)
+        when Array
+          if resp.empty?
+            resp = [].to_xml :root => 'results'
+          else
+            resp = resp.map {|r| HashPruner.prune(r)}.to_xml(:root => resp.first.__model__.name.to_s.pluralize)
+          end
         end
-        
         Dupe.network.log.add_request @verb, url, resp
-        
         resp
       end
-    
     end
   end
 end
+
+class Dupe
+  class Network
+    class PostMock < Mock #:nodoc:
+      def process_response(resp, url)
+        case resp
+        when NilClass
+          raise ResourceNotFoundError, "Failed with 404: the request '#{url}' returned nil." 
+        when Dupe::Database::Record
+          new_path = "/#{resp.__model__.name.to_s.pluralize}/#{resp.id}.xml"
+          resp = resp.to_xml_safe(:root => resp.__model__.name.to_s)
+          Dupe.network.log.add_request @verb, url, resp
+          return resp, new_path
+        else
+          raise StandardError, "Unknown PostMock Response. Your Post intercept mocks must return a Duped resource object or nil"
+        end
+      end
+    end
+  end
+end

data/lib/dupe/network.rb

@@ -12,14 +12,24 @@ class Dupe
       VERBS.each { |verb| @mocks[verb] = [] }
     end
         
-    def request(verb, url)
+    def request(verb, url, body=nil)
       validate_request_type verb
-      match(verb, url).mocked_response(url)
+      match(verb, url).mocked_response(url, body)
     end
     
     def define_service_mock(verb, url_pattern, response_proc=nil)
-      Mock.new(verb, url_pattern, response_proc).tap do |mock|
-        @mocks[verb] << mock
+      validate_request_type verb
+      case verb
+      when :get
+        GetMock.new(verb, url_pattern, response_proc).tap do |mock|
+          @mocks[verb] << mock
+        end
+      when :post
+        PostMock.new(verb, url_pattern, response_proc).tap do |mock|
+          @mocks[verb].unshift mock
+        end
+      else
+        raise StandardError, "Dupe does not (yet) support mocking #{verb.to_s.upcase} requests."
       end
     end
     

data/spec/lib_specs/active_resource_extensions_spec.rb

@@ -26,4 +26,40 @@ describe ActiveResource::Connection do
       books.first.label.should == 'rooby'
     end
   end
+  
+  describe "#post" do
+    before do
+      @book = Dupe.create :book, :label => 'rooby', :title => 'Rooby'
+      @book.delete(:id)
+      class Book < ActiveResource::Base
+        self.site = ''
+      end
+    end
+    
+    it "should pass a request off to the Dupe network if the original request failed" do
+      Dupe.network.should_receive(:request).with(:post, '/books.xml', Hash.from_xml(@book.to_xml(:root => 'book'))["book"] ).once
+      book = Book.create({:label => 'rooby', :title => 'Rooby'})
+    end
+    
+    it "should parse the xml and turn the result into active resource objects" do
+      book = Book.create({:label => 'rooby', :title => 'Rooby'})
+      book.id.should == 2
+      book.title.should == 'Rooby'
+      book.label.should == 'rooby'
+    end
+    
+    it "should make ActiveResource throw an unprocessable entity exception if our Post mock throws a Dupe::UnprocessableEntity exception" do
+      Post %r{/books\.xml} do |post_data|
+        raise Dupe::UnprocessableEntity.new(:title => "must be present.") unless post_data["title"]
+        Dupe.create :book, post_data
+      end
+      
+      b = Book.create
+      b.new?.should be_true
+      b.errors.errors.should_not be_empty
+      b = Book.create(:title => "hello")
+      b.new?.should be_false
+      b.errors.should be_empty
+    end
+  end
 end

data/spec/lib_specs/mock_definitions_spec.rb

@@ -29,4 +29,30 @@ describe "Mock Definition Methods" do
       Dupe.network.request(:get, '/books/rooby.xml').should == book.to_xml_safe(:root => 'book')
     end
   end
+  
+  describe "Post" do    
+    it "should require a url pattern that is a regex" do
+      proc { Post() }.should raise_error(ArgumentError)
+      proc { Post 'not a regexp' }.should raise_error(ArgumentError)
+      proc { Post %r{/some_url} }.should_not raise_error
+    end
+    
+    it "should create and return a Dupe::Network::Mock of type :post" do
+      @book = Dupe.create :book, :label => 'rooby'
+      Dupe.network.mocks[:post].should_not be_empty
+      Dupe.network.mocks[:post].length.should == 1
+      
+      mock = Post %r{/books\.xml} do |post_data|
+        Dupe.create(:book, post_data)
+      end
+      
+      Dupe.network.mocks[:post].length.should == 2
+      Dupe.network.mocks[:post].first.should == mock
+      Dupe.network.mocks[:post].first.url_pattern.should == %r{/books\.xml}
+      book_post = Dupe.create(:book, {:title => "Rooby", :label => "rooby"})
+      book_post.delete(:id)
+      book_response = Dupe.create(:book, {:title => "Rooby", :label => "rooby"})
+      Dupe.network.request(:post, '/books.xml', book_post).should == [Dupe.find(:book) {|b| b.id == 4}.to_xml_safe(:root => 'book'), "/books/4.xml"]
+    end
+  end
 end

data/spec/lib_specs/mock_spec.rb

@@ -40,6 +40,12 @@ describe Dupe::Network::Mock do
       mock.match?('/bogs/1.xml').should == false
     end
   end
+end
+
+describe Dupe::Network::GetMock do
+  before do
+    Dupe.reset
+  end
   
   describe "mocked_response" do
     describe "on a mock object whose response returns a Dupe.find with actual results" do
@@ -47,13 +53,13 @@ describe Dupe::Network::Mock do
         url_pattern = %r{/books/(\d+)\.xml}
         response = proc {|id| Dupe.find(:book) {|b| b.id == id.to_i}}
         book = Dupe.create :book
-        mock = Dupe::Network::Mock.new :get, url_pattern, response
+        mock = Dupe::Network::GetMock.new :get, url_pattern, response
         mock.mocked_response('/books/1.xml').should == book.to_xml(:root => 'book')
         
-        proc { mock.mocked_response('/books/2.xml') }.should raise_error(Dupe::Network::Mock::ResourceNotFoundError)
+        proc { mock.mocked_response('/books/2.xml') }.should raise_error(Dupe::Network::GetMock::ResourceNotFoundError)
         
         Dupe.define :author
-        mock = Dupe::Network::Mock.new :get, %r{/authors\.xml$}, proc {Dupe.find :authors}
+        mock = Dupe::Network::GetMock.new :get, %r{/authors\.xml$}, proc {Dupe.find :authors}
         mock.mocked_response('/authors.xml').should == [].to_xml(:root => 'results')
       end
       
@@ -61,7 +67,7 @@ describe Dupe::Network::Mock do
         url_pattern = %r{/books/([a-zA-Z0-9-]+)\.xml}
         response = proc {|label| Dupe.find(:book) {|b| b.label == label}}
         book = Dupe.create :book, :label => 'rooby'
-        mock = Dupe::Network::Mock.new :get, url_pattern, response
+        mock = Dupe::Network::GetMock.new :get, url_pattern, response
         Dupe.network.log.requests.length.should == 0
         mock.mocked_response('/books/rooby.xml')
         Dupe.network.log.requests.length.should == 1
@@ -73,21 +79,21 @@ describe Dupe::Network::Mock do
         url_pattern = %r{/authors/(\d+)\.xml}
         response = proc { |id| Dupe.find(:author) {|a| a.id == id.to_i}}
         Dupe.define :author
-        mock = Dupe::Network::Mock.new :get, url_pattern, response
-        proc {mock.mocked_response('/authors/1.xml')}.should raise_error(Dupe::Network::Mock::ResourceNotFoundError)
+        mock = Dupe::Network::GetMock.new :get, url_pattern, response
+        proc {mock.mocked_response('/authors/1.xml')}.should raise_error(Dupe::Network::GetMock::ResourceNotFoundError)
       end
     end
     
     describe "on a mock object whose response returns an empty array" do
       it "should convert the empty array to an xml array record set with root 'results'" do        
         Dupe.define :author
-        mock = Dupe::Network::Mock.new :get, %r{/authors\.xml$}, proc {Dupe.find :authors}
+        mock = Dupe::Network::GetMock.new :get, %r{/authors\.xml$}, proc {Dupe.find :authors}
         mock.mocked_response('/authors.xml').should == [].to_xml(:root => 'results')
       end
       
       it "should add a request to the Dupe::Network#log" do
         Dupe.define :author
-        mock = Dupe::Network::Mock.new :get, %r{/authors\.xml$}, proc {Dupe.find :authors}
+        mock = Dupe::Network::GetMock.new :get, %r{/authors\.xml$}, proc {Dupe.find :authors}
         Dupe.network.log.requests.length.should == 0
         mock.mocked_response('/authors.xml')
         Dupe.network.log.requests.length.should == 1
@@ -97,19 +103,43 @@ describe Dupe::Network::Mock do
     describe "on a mock object whose response returns an array of duped records" do
       it "should convert the array to xml" do        
         Dupe.create :author  
-        mock = Dupe::Network::Mock.new :get, %r{/authors\.xml$}, proc {Dupe.find :authors}
+        mock = Dupe::Network::GetMock.new :get, %r{/authors\.xml$}, proc {Dupe.find :authors}
         mock.mocked_response('/authors.xml').should == Dupe.find(:authors).to_xml(:root => 'authors')
       end
       
       it "should add a request to the Dupe::Network#log" do
         Dupe.create :author
-        mock = Dupe::Network::Mock.new :get, %r{/authors\.xml$}, proc {Dupe.find :authors}
+        mock = Dupe::Network::GetMock.new :get, %r{/authors\.xml$}, proc {Dupe.find :authors}
         Dupe.network.log.requests.length.should == 0
         mock.mocked_response('/authors.xml')
         Dupe.network.log.requests.length.should == 1
       end
-    end 
+    end
   end
-  
-  
 end
+
+describe Dupe::Network::PostMock do
+  before do
+    Dupe.reset
+  end
+  
+  describe "mocked_response" do
+    describe "on a mock object whose response returns a location of a new record" do
+      it "should convert the new post to xml" do        
+        Dupe.define :author  
+        mock = Dupe::Network::PostMock.new :post, %r{/authors\.xml$}, proc {|post_data| Dupe.create(:author, post_data)}
+        resp, url = mock.mocked_response('/authors.xml', {:name => "Rachel"})
+        resp.should == Dupe.find(:authors).first.to_xml_safe(:root => 'author')
+        url.should == "/authors/1.xml"
+      end
+      
+      it "should add a request to the Dupe::Network#log" do
+        Dupe.define :author
+        mock = Dupe::Network::PostMock.new :post, %r{/authors\.xml$}, proc {|post_data| Dupe.create(:author, post_data)}
+        Dupe.network.log.requests.length.should == 0
+        mock.mocked_response('/authors.xml', {:name => "Rachel"})
+        Dupe.network.log.requests.length.should == 1
+      end
+    end
+  end
+end

data/spec/lib_specs/network_spec.rb

@@ -27,20 +27,34 @@ describe Dupe::Network do
       proc { @network.request }.should raise_error
       proc { @network.request :invalid_rest_verb, '/some_url' }.should raise_error(Dupe::Network::UnknownRestVerbError)
       proc { @network.request :get, '/some_url' }.should_not raise_error(Dupe::Network::UnknownRestVerbError)
+      proc { @network.request :post, '/some_url', 'some body' }.should_not raise_error(Dupe::Network::UnknownRestVerbError)
+      proc { @network.request :put, '/some_url' }.should_not raise_error(Dupe::Network::UnknownRestVerbError)
+      proc { @network.request :delete, '/some_url' }.should_not raise_error(Dupe::Network::UnknownRestVerbError)
     end
     
     it "should require a URL" do
       proc { @network.request :get }.should raise_error(ArgumentError)
       proc { @network.request :get, 'some_url'}.should_not raise_error(ArgumentError)
+      proc { @network.request :post, 'some_url', 'some body'}.should_not raise_error(ArgumentError)
+      proc { @network.request :put, 'some_url'}.should_not raise_error(ArgumentError)
+      proc { @network.request :delete, 'some_url'}.should_not raise_error(ArgumentError)
     end
     
     it "should raise an exception if the network has no mocks that match the url" do
       proc { @network.request(:get, '/some_url')}.should raise_error(Dupe::Network::RequestNotFoundError)
+      proc { @network.request(:post, '/some_url', 'some body')}.should raise_error(Dupe::Network::RequestNotFoundError)
+      proc { @network.request(:put, '/some_url')}.should raise_error(Dupe::Network::RequestNotFoundError)
+      proc { @network.request(:delete, '/some_url')}.should raise_error(Dupe::Network::RequestNotFoundError)
     end
     
     it "should return the appropriate mock response if a mock matches the url" do
       @network.define_service_mock :get, %r{/greeting$}, proc { "hello" }
       @network.request(:get, '/greeting').should == 'hello'
+      
+      @network.define_service_mock :post, %r{/greeting$}, proc { |post_data| Dupe.create(:greeting, post_data) }
+      resp, url = @network.request(:post, '/greeting', {} )
+      resp.should == Dupe.find(:greeting).to_xml_safe(:root => 'greeting')
+      url.should == "/greetings/1.xml"
     end
   end
   
@@ -53,24 +67,42 @@ describe Dupe::Network do
       proc { @network.define_service_mock }.should raise_error
       proc { @network.define_service_mock :invalid_rest_verb, // }.should raise_error(Dupe::Network::UnknownRestVerbError)
       proc { @network.define_service_mock :get, // }.should_not raise_error(Dupe::Network::UnknownRestVerbError)
+      proc { @network.define_service_mock :post, // }.should_not raise_error(Dupe::Network::UnknownRestVerbError)
+
     end
     
     it "should require a valid Regexp url pattern" do
       proc { @network.define_service_mock :get, 'not a regular expression' }.should raise_error(ArgumentError)
+      proc { @network.define_service_mock :post, 'not a regular expression' }.should raise_error(ArgumentError)
       proc { @network.define_service_mock :get, // }.should_not raise_error
+      proc { @network.define_service_mock :post, // }.should_not raise_error
+
     end
     
-    it "should create and return a new service mock when given valid parameters" do
+    it "should create and return a new get service mock when given valid parameters" do
       verb = :get
       pattern = //
       response = proc { 'test' }
       @network.mocks[:get].should be_empty
       mock = @network.define_service_mock verb, pattern, response
       @network.mocks[:get].should_not be_empty
+      @network.mocks[:post].first.class == "GetMock"
       @network.mocks[:get].length.should == 1
       @network.mocks[:get].first.should == mock
     end
     
+    it "should create and return a new post service mock when given valid parameters" do
+      verb = :post
+      pattern = //
+      response = proc { 'test' }
+      @network.mocks[:post].should be_empty
+      mock = @network.define_service_mock verb, pattern, response
+      @network.mocks[:post].should_not be_empty
+      @network.mocks[:post].first.class == "PostMock"
+      @network.mocks[:post].length.should == 1
+      @network.mocks[:post].first.should == mock
+    end
+
     
   end
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dupe
 version: !ruby/object:Gem::Version 
-  version: 0.4.9
+  version: 0.5.0
 platform: ruby
 authors: 
 - Matt Parker
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-12 00:00:00 -05:00
+date: 2010-03-12 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -91,7 +91,7 @@ test_files:
 - spec/lib_specs/attribute_template_spec.rb
 - spec/lib_specs/database_spec.rb
 - spec/lib_specs/dupe_spec.rb
-- spec/lib_specs/hash_pruner.rb
+- spec/lib_specs/hash_pruner_spec.rb
 - spec/lib_specs/log_spec.rb
 - spec/lib_specs/logged_request_spec.rb
 - spec/lib_specs/mock_definitions_spec.rb