dupe 1.0.1 → 1.1.0.rc1

data/spec/lib_specs/mock_definitions_spec.rb

@@ -1,58 +1,119 @@
 require 'spec_helper'
 
 describe "Mock Definition Methods" do
-  before do
-    Dupe.reset
-  end
-  
-  describe "Get" do    
-    it "should require a url pattern that is a regex" do
-      proc { Get() }.should raise_error(ArgumentError)
-      proc { Get 'not a regexp' }.should raise_error(ArgumentError)
-      proc { Get %r{/some_url} }.should_not raise_error
+  describe "using xml" do
+    before do
+      Dupe.format = ActiveResource::Formats::XmlFormat
+      Dupe.reset
     end
     
-    it "should create and return a Dupe::Network::Mock of type :get" do
-      Dupe.network.mocks[:get].should be_empty
-      @book = Dupe.create :book, :label => 'rooby'
-      Dupe.network.mocks[:get].should_not be_empty
-      Dupe.network.mocks[:get].length.should == 2
+    describe "Get" do    
+      it "should require a url pattern that is a regex" do
+        proc { Get() }.should raise_error(ArgumentError)
+        proc { Get 'not a regexp' }.should raise_error(ArgumentError)
+        proc { Get %r{/some_url} }.should_not raise_error
+      end
       
-      mock = Get %r{/books/([^&]+)\.xml} do |label|
-        Dupe.find(:book) {|b| b.label == label}
+      it "should create and return a Dupe::Network::Mock of type :get" do
+        Dupe.network.mocks[:get].should be_empty
+        @book = Dupe.create :book, :label => 'rooby'
+        Dupe.network.mocks[:get].should_not be_empty
+        Dupe.network.mocks[:get].length.should == 2
+        
+        mock = Get %r{/books/([^&]+)\.xml} do |label|
+          Dupe.find(:book) {|b| b.label == label}
+        end
+        
+        Dupe.network.mocks[:get].length.should == 3
+        Dupe.network.mocks[:get].last.should == mock
+        Dupe.network.mocks[:get].last.url_pattern.should == %r{/books/([^&]+)\.xml}
+        book = Dupe.find(:book)
+        Dupe.network.request(:get, '/books/rooby.xml').should == book.make_safe.to_xml(: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
       
-      Dupe.network.mocks[:get].length.should == 3
-      Dupe.network.mocks[:get].last.should == mock
-      Dupe.network.mocks[:get].last.url_pattern.should == %r{/books/([^&]+)\.xml}
-      book = Dupe.find(:book)
-      Dupe.network.request(:get, '/books/rooby.xml').should == book.to_xml_safe(:root => 'book')
+      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}.make_safe.to_xml(:root => 'book'), "/books/4.xml"]
+      end
     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
+
+  describe "using json" do
+    before do
+      Dupe.format = ActiveResource::Formats::JsonFormat
+      Dupe.reset
     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
+    describe "Get" do    
+      it "should require a url pattern that is a regex" do
+        proc { Get() }.should raise_error(ArgumentError)
+        proc { Get 'not a regexp' }.should raise_error(ArgumentError)
+        proc { Get %r{/some_url} }.should_not raise_error
+      end
       
-      mock = Post %r{/books\.xml} do |post_data|
-        Dupe.create(:book, post_data)
+      it "should create and return a Dupe::Network::Mock of type :get" do
+        Dupe.network.mocks[:get].should be_empty
+        @book = Dupe.create :book, :label => 'rooby'
+        Dupe.network.mocks[:get].should_not be_empty
+        Dupe.network.mocks[:get].length.should == 2
+        
+        mock = Get %r{/books/([^&]+)\.json} do |label|
+          Dupe.find(:book) {|b| b.label == label}
+        end
+        
+        Dupe.network.mocks[:get].length.should == 3
+        Dupe.network.mocks[:get].last.should == mock
+        Dupe.network.mocks[:get].last.url_pattern.should == %r{/books/([^&]+)\.json}
+        book = Dupe.find(:book)
+        Dupe.network.request(:get, '/books/rooby.json').should == book.make_safe.to_json(: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
       
-      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"]
+      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\.json} 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\.json}
+        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.json', book_post).should == [Dupe.find(:book) {|b| b.id == 4}.make_safe.to_json(:root => 'book'), "/books/4.json"]
+      end
     end
   end
 end

data/spec/lib_specs/mock_spec.rb

@@ -34,160 +34,336 @@ describe Dupe::Network::Mock do
 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
-      it "should convert the response result to xml" 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::GetMock.new 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::GetMock::ResourceNotFoundError)
-        
-        Dupe.define :author
-        mock = Dupe::Network::GetMock.new %r{/authors\.xml$}, proc {Dupe.find :authors}
-        mock.mocked_response('/authors.xml').should == [].to_xml(:root => 'results')
+  describe "using xml" do
+    before do
+      Dupe.reset
+      Dupe.format = ActiveResource::Formats::XmlFormat
+    end
+
+    describe "mocked_response" do
+      describe "on a mock object whose response returns a Dupe.find with actual results" do
+        it "should convert the response result to xml" 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::GetMock.new 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::GetMock::ResourceNotFoundError)
+
+          Dupe.define :author
+          mock = Dupe::Network::GetMock.new %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
+          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::GetMock.new url_pattern, response
+          Dupe.network.log.requests.length.should == 0
+          mock.mocked_response('/books/rooby.xml')
+          Dupe.network.log.requests.length.should == 1
+        end
       end
-      
-      it "should add a request to the Dupe::Network#log" 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::GetMock.new url_pattern, response
-        Dupe.network.log.requests.length.should == 0
-        mock.mocked_response('/books/rooby.xml')
-        Dupe.network.log.requests.length.should == 1
+
+      describe "on a mock object whose response returns nil" do
+        it "should raise an error" 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::GetMock.new url_pattern, response
+          proc {mock.mocked_response('/authors/1.xml')}.should raise_error(Dupe::Network::GetMock::ResourceNotFoundError)
+        end
       end
-    end
-    
-    describe "on a mock object whose response returns nil" do
-      it "should raise an error" 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::GetMock.new url_pattern, response
-        proc {mock.mocked_response('/authors/1.xml')}.should raise_error(Dupe::Network::GetMock::ResourceNotFoundError)
+
+      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::GetMock.new %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::GetMock.new %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
+
+      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::GetMock.new %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::GetMock.new %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
-    
-    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::GetMock.new %r{/authors\.xml$}, proc {Dupe.find :authors}
-        mock.mocked_response('/authors.xml').should == [].to_xml(:root => 'results')
+  end
+
+  describe "using json" do
+    before do
+      Dupe.reset
+      Dupe.format = ActiveResource::Formats::JsonFormat
+    end
+
+    describe "mocked_response" do
+      describe "on a mock object whose response returns a Dupe.find with actual results" do
+        it "should convert the response result to json" do
+          url_pattern = %r{/books/(\d+)\.json}
+          response = proc {|id| Dupe.find(:book) {|b| b.id == id.to_i}}
+          book = Dupe.create :book
+          mock = Dupe::Network::GetMock.new url_pattern, response
+          mock.mocked_response('/books/1.json').should == book.to_json(:root => 'book')
+
+          proc { mock.mocked_response('/books/2.json') }.should raise_error(Dupe::Network::GetMock::ResourceNotFoundError)
+
+          Dupe.define :author
+          mock = Dupe::Network::GetMock.new %r{/authors\.json$}, proc {Dupe.find :authors}
+          mock.mocked_response('/authors.json').should == [].to_json(:root => 'results')
+        end
+
+        it "should add a request to the Dupe::Network#log" do
+          url_pattern = %r{/books/([a-zA-Z0-9-]+)\.json}
+          response = proc {|label| Dupe.find(:book) {|b| b.label == label}}
+          book = Dupe.create :book, :label => 'rooby'
+          mock = Dupe::Network::GetMock.new url_pattern, response
+          Dupe.network.log.requests.length.should == 0
+          mock.mocked_response('/books/rooby.json')
+          Dupe.network.log.requests.length.should == 1
+        end
       end
-      
-      it "should add a request to the Dupe::Network#log" do
-        Dupe.define :author
-        mock = Dupe::Network::GetMock.new %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
+
+      describe "on a mock object whose response returns nil" do
+        it "should raise an error" do
+          url_pattern = %r{/authors/(\d+)\.json}
+          response = proc { |id| Dupe.find(:author) {|a| a.id == id.to_i}}
+          Dupe.define :author
+          mock = Dupe::Network::GetMock.new url_pattern, response
+          proc {mock.mocked_response('/authors/1.json')}.should raise_error(Dupe::Network::GetMock::ResourceNotFoundError)
+        end
       end
-    end
-    
-    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::GetMock.new %r{/authors\.xml$}, proc {Dupe.find :authors}
-        mock.mocked_response('/authors.xml').should == Dupe.find(:authors).to_xml(:root => 'authors')
+
+      describe "on a mock object whose response returns an empty array" do
+        it "should convert the empty array to an json array record set with root 'results'" do        
+          Dupe.define :author
+          mock = Dupe::Network::GetMock.new %r{/authors\.json$}, proc {Dupe.find :authors}
+          mock.mocked_response('/authors.json').should == [].to_json(:root => 'results')
+        end
+
+        it "should add a request to the Dupe::Network#log" do
+          Dupe.define :author
+          mock = Dupe::Network::GetMock.new %r{/authors\.json$}, proc {Dupe.find :authors}
+          Dupe.network.log.requests.length.should == 0
+          mock.mocked_response('/authors.json')
+          Dupe.network.log.requests.length.should == 1
+        end
       end
-      
-      it "should add a request to the Dupe::Network#log" do
-        Dupe.create :author
-        mock = Dupe::Network::GetMock.new %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
+
+      describe "on a mock object whose response returns an array of duped records" do
+        it "should convert the array to json" do        
+          Dupe.create :author  
+          mock = Dupe::Network::GetMock.new %r{/authors\.json$}, proc {Dupe.find :authors}
+          mock.mocked_response('/authors.json').should == Dupe.find(:authors).to_json(:root => 'authors')
+        end
+
+        it "should add a request to the Dupe::Network#log" do
+          Dupe.create :author
+          mock = Dupe::Network::GetMock.new %r{/authors\.json$}, proc {Dupe.find :authors}
+          Dupe.network.log.requests.length.should == 0
+          mock.mocked_response('/authors.json')
+          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 %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"
+  describe "using xml" do
+    before do
+      Dupe.reset
+      Dupe.format = ActiveResource::Formats::XmlFormat
+    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 %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.make_safe.to_xml(: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 %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
-      
-      it "should add a request to the Dupe::Network#log" do
-        Dupe.define :author
-        mock = Dupe::Network::PostMock.new %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
+
+  describe "using json" do
+    before do
+      Dupe.reset
+      Dupe.format = ActiveResource::Formats::JsonFormat
+    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 json" do        
+          Dupe.define :author  
+          mock = Dupe::Network::PostMock.new %r{/authors\.json$}, proc {|post_data| Dupe.create(:author, post_data)}
+          resp, url = mock.mocked_response('/authors.json', {:name => "Rachel"})
+          resp.should == Dupe.find(:authors).first.make_safe.to_json(:root => 'author')
+          url.should == "/authors/1.json"
+        end
+
+        it "should add a request to the Dupe::Network#log" do
+          Dupe.define :author
+          mock = Dupe::Network::PostMock.new %r{/authors\.json$}, proc {|post_data| Dupe.create(:author, post_data)}
+          Dupe.network.log.requests.length.should == 0
+          mock.mocked_response('/authors.json', {:name => "Rachel"})
+          Dupe.network.log.requests.length.should == 1
+        end
       end
     end
   end
 end
 
 describe Dupe::Network::PutMock 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
-      before do
-        Dupe.define :author  
-        @a = Dupe.create :author, :name => "Matt"
-        @mock = Dupe::Network::PutMock.new %r{/authors/(\d+)\.xml$}, proc {|id, put_data| Dupe.find(:author) {|a| a.id == id.to_i}.merge!(put_data)}
-      end
+  describe "using xml" do
+    before do
+      Dupe.reset
+      Dupe.format = ActiveResource::Formats::XmlFormat
+    end
+
+    describe "mocked_response" do
+      describe "on a mock object whose response returns a location of a new record" do
+        before do
+          Dupe.define :author  
+          @a = Dupe.create :author, :name => "Matt"
+          @mock = Dupe::Network::PutMock.new %r{/authors/(\d+)\.xml$}, proc {|id, put_data| Dupe.find(:author) {|a| a.id == id.to_i}.merge!(put_data)}
+        end
+
+        it "should convert the put to xml" do        
+          resp, url = @mock.mocked_response('/authors/1.xml', {:name => "Rachel"})
+          resp.should == nil
+          @a.name.should == "Rachel"
+          url.should == "/authors/1.xml"
+        end
 
-      it "should convert the put to xml" do        
-        resp, url = @mock.mocked_response('/authors/1.xml', {:name => "Rachel"})
-        resp.should == nil
-        @a.name.should == "Rachel"
-        url.should == "/authors/1.xml"
+        it "should add a request to the Dupe::Network#log" do
+          Dupe.network.log.requests.length.should == 0
+          @mock.mocked_response('/authors/1.xml', {:name => "Rachel"})
+          Dupe.network.log.requests.length.should == 1
+        end
       end
-      
-      it "should add a request to the Dupe::Network#log" do
-        Dupe.network.log.requests.length.should == 0
-        @mock.mocked_response('/authors/1.xml', {:name => "Rachel"})
-        Dupe.network.log.requests.length.should == 1
+    end
+  end
+
+  describe "using json" do
+    before do
+      Dupe.reset
+      Dupe.format = ActiveResource::Formats::JsonFormat
+    end
+
+    describe "mocked_response" do
+      describe "on a mock object whose response returns a location of a new record" do
+        before do
+          Dupe.define :author  
+          @a = Dupe.create :author, :name => "Matt"
+          @mock = Dupe::Network::PutMock.new %r{/authors/(\d+)\.json$}, proc {|id, put_data| Dupe.find(:author) {|a| a.id == id.to_i}.merge!(put_data)}
+        end
+
+        it "should convert the put to json" do        
+          resp, url = @mock.mocked_response('/authors/1.json', {:name => "Rachel"})
+          resp.should == nil
+          @a.name.should == "Rachel"
+          url.should == "/authors/1.json"
+        end
+
+        it "should add a request to the Dupe::Network#log" do
+          Dupe.network.log.requests.length.should == 0
+          @mock.mocked_response('/authors/1.json', {:name => "Rachel"})
+          Dupe.network.log.requests.length.should == 1
+        end
       end
     end
   end
 end
 
 describe Dupe::Network::DeleteMock 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
-      before do
-        Dupe.define :author  
-        @a = Dupe.create :author, :name => "Matt"
-        @mock = Dupe::Network::DeleteMock.new %r{/authors/(\d+)\.xml$}, proc {|id| Dupe.delete(:author) {|a| a.id == id.to_i}}
-      end
+  describe "using xml" do
+    before do
+      Dupe.reset
+      Dupe.format = ActiveResource::Formats::XmlFormat
+    end
 
-      it "should convert the put to xml" do        
-        Dupe.find(:authors).length.should == 1
-        resp = @mock.mocked_response('/authors/1.xml')
-        resp.should == nil
-        Dupe.find(:authors).length.should == 0
+    describe "mocked_response" do
+      describe "on a mock object whose response returns a location of a new record" do
+        before do
+          Dupe.define :author  
+          @a = Dupe.create :author, :name => "Matt"
+          @mock = Dupe::Network::DeleteMock.new %r{/authors/(\d+)\.xml$}, proc {|id| Dupe.delete(:author) {|a| a.id == id.to_i}}
+        end
+
+        it "should convert the put to xml" do        
+          Dupe.find(:authors).length.should == 1
+          resp = @mock.mocked_response('/authors/1.xml')
+          resp.should == nil
+          Dupe.find(:authors).length.should == 0
+        end
+
+        it "should add a request to the Dupe::Network#log" do
+          Dupe.network.log.requests.length.should == 0
+          @mock.mocked_response('/authors/1.xml')
+          Dupe.network.log.requests.length.should == 1
+        end
       end
-      
-      it "should add a request to the Dupe::Network#log" do
-        Dupe.network.log.requests.length.should == 0
-        @mock.mocked_response('/authors/1.xml')
-        Dupe.network.log.requests.length.should == 1
+    end
+  end
+
+  describe "using json" do
+    before do
+      Dupe.reset
+      Dupe.format = ActiveResource::Formats::JsonFormat
+    end
+
+    describe "mocked_response" do
+      describe "on a mock object whose response returns a location of a new record" do
+        before do
+          Dupe.define :author  
+          @a = Dupe.create :author, :name => "Matt"
+          @mock = Dupe::Network::DeleteMock.new %r{/authors/(\d+)\.json$}, proc {|id| Dupe.delete(:author) {|a| a.id == id.to_i}}
+        end
+
+        it "should convert the put to json" do        
+          Dupe.find(:authors).length.should == 1
+          resp = @mock.mocked_response('/authors/1.json')
+          resp.should == nil
+          Dupe.find(:authors).length.should == 0
+        end
+
+        it "should add a request to the Dupe::Network#log" do
+          Dupe.network.log.requests.length.should == 0
+          @mock.mocked_response('/authors/1.json')
+          Dupe.network.log.requests.length.should == 1
+        end
       end
     end
   end