dupe 1.0.1 → 1.1.0.rc1

data/spec/lib_specs/dupe_spec.rb

@@ -4,7 +4,7 @@ describe Dupe do
   before do
     Dupe.reset
   end
-  
+
   describe "#sequences" do 
     it "should be empty on initialization" do
       Dupe.sequences.should == {}
@@ -44,7 +44,7 @@ describe Dupe do
       Dupe.next(:email).should == "email-2@address.com"
     end
   end
-  
+
   describe "reset" do
     it "should call reset_models, reset_database, and reset_network" do
       Dupe.should_receive(:reset_models).once
@@ -66,7 +66,7 @@ describe Dupe do
       Dupe.sequences.should == {}
     end
   end
-  
+
   describe "reset_models" do
     it "should reset @models to an empty hash" do
       Dupe.models.length.should == 0
@@ -79,7 +79,7 @@ describe Dupe do
       Dupe.models.should == {}
     end
   end
-  
+
   describe "reset_database" do
     it "should clear out the database" do
       Dupe.define :book
@@ -89,7 +89,7 @@ describe Dupe do
       Dupe.database.tables.should be_empty
     end    
   end
-  
+
   describe "reset_network" do
     it "should clear out the network" do
       Dupe.create :book
@@ -99,156 +99,13 @@ describe Dupe do
       Dupe.network.mocks.values.inject(false) {|b,v| b || !v.empty?}.should == false
     end    
   end
-  
-  describe "define" do
-  
-    # Dupe.define :model_name
-    it "should accept a single symbol parameter" do
-      proc {
-        Dupe.define :book
-      }.should_not raise_error
-    end
-  
-    # Dupe.define :model_name do |attrs|
-    #   attrs.attr1 'Default Value'
-    #   attrs.attr2 do |value|
-    #     'transformed value'
-    #   end
-    # end
-    it "should accept a symbol plus a block (that accepts a single parameter)" do
-      proc {
-        Dupe.define :book do
-        end
-      }.should raise_error(
-        ArgumentError,
-        "Unknown Dupe.define parameter format. Please consult the API" + 
-        " for information on how to use Dupe.define"
-      )
-    
-      proc {
-        Dupe.define :book do |attrs|
-          attrs.author 'Anon'
-          attrs.title 'Untitled'
-        end
-      }.should_not raise_error
-    end
-    
-    it "should create a model and a schema with the desired definition" do
-      Dupe.define :book do |attrs|
-        attrs.author 'Anon'
-        attrs.genre do
-          'Unknown' + rand(2).to_s
-        end
-        attrs.title 'Untitled' do |value|
-          "transformed #{value}"
-        end
-      end
-      
-      Dupe.models.length.should == 1
-      Dupe.models[:book].schema.attribute_templates[:author].name.should == :author
-      Dupe.models[:book].schema.attribute_templates[:author].default.should == 'Anon'
-      Dupe.models[:book].schema.attribute_templates[:title].name.should == :title
-      Dupe.models[:book].schema.attribute_templates[:title].default.should == 'Untitled'
-      Dupe.models[:book].schema.attribute_templates[:title].transformer.should be_kind_of(Proc)
-      Dupe.models[:book].schema.attribute_templates[:title].transformer.call('value').should == 'transformed value'
-      Dupe.models[:book].schema.attribute_templates[:genre].name.should == :genre
-      Dupe.models[:book].schema.attribute_templates[:genre].transformer.should be_nil
-      Dupe.models[:book].schema.attribute_templates[:genre].default.should be_kind_of(Proc)
-      Dupe.models[:book].schema.attribute_templates[:genre].default.call.should match(/^Unknown\d$/)
-    end
-    
-    it "should add a table to the database" do
-      Dupe.database.tables.length.should == 0
-      Dupe.database.tables[:book].should be_nil
-      Dupe.define :book
-      Dupe.database.tables.length.should == 1
-      Dupe.database.tables[:book].should_not be_nil
-      Dupe.database.tables[:book].should == []
-    end
-    
-    it "should add find(:all) and find(<id>) mocks to the network" do
-      Dupe.network.mocks[:get].should be_empty
-      Dupe.create :book
-      Dupe.network.mocks[:get].should_not be_empty
-      Dupe.network.mocks[:get].length.should == 2
-      
-      find_all_mock = Dupe.network.mocks[:get].first
-      find_all_mock.class.should == Dupe::Network::GetMock
-      find_all_mock.url_pattern.should == %r{^/books\.xml$}
-      find_all_mock.mocked_response('/books.xml').should == Dupe.find(:books).to_xml(:root => 'books')
-      
-      find_one_mock = Dupe.network.mocks[:get].last
-      find_one_mock.class.should == Dupe::Network::GetMock
-      find_one_mock.url_pattern.should == %r{^/books/(\d+)\.xml$}
-      find_one_mock.mocked_response('/books/1.xml').should == Dupe.find(:book).to_xml(:root => 'book')
-    end
 
-    it "should add a POST (create resource) mock to the network" do
-      Dupe.network.mocks[:post].should be_empty
-      Dupe.define :book
-      Dupe.network.mocks[:post].should_not be_empty
-      Dupe.network.mocks[:post].length.should == 1
-
-      post_mock = Dupe.network.mocks[:post].first
-      post_mock.class.should == Dupe::Network::PostMock
-      post_mock.url_pattern.should == %r{^/books\.xml$}
-      resp, url = post_mock.mocked_response('/books.xml', {:title => "Rooby"})
-      Hash.from_xml(resp).should == Hash.from_xml(Dupe.find(:book).to_xml(:root => 'book'))
-      url.should == "/books/1.xml"
-    end
-
-    it "should add a PUT (update resource) mock to the network" do
-      Dupe.network.mocks[:put].should be_empty
-      book = Dupe.create :book, :title => 'Rooby!'
-      Dupe.network.mocks[:put].should_not be_empty
-      Dupe.network.mocks[:put].length.should == 1
-
-      put_mock = Dupe.network.mocks[:put].first
-      put_mock.class.should == Dupe::Network::PutMock
-      put_mock.url_pattern.should == %r{^/books/(\d+)\.xml$}
-      resp, url = put_mock.mocked_response('/books/1.xml', {:title => "Rails!"})
-      resp.should == nil
-      url.should == "/books/1.xml"
-      book.title.should == "Rails!"
-    end
-
-    it "should add a DELETE mock to the network" do
-      Dupe.network.mocks[:delete].should be_empty
-      book = Dupe.create :book, :title => 'Rooby!'
-      Dupe.network.mocks[:delete].should_not be_empty
-      Dupe.network.mocks[:delete].length.should == 1
-
-      delete_mock = Dupe.network.mocks[:delete].first
-      delete_mock.class.should == Dupe::Network::DeleteMock
-      delete_mock.url_pattern.should == %r{^/books/(\d+)\.xml$}
-    end
-
-    
-    it "should honor ActiveResource site prefix's for the find(:all) and find(<id>) mocks" do
-      Dupe.network.mocks[:get].should be_empty
-      class Author < ActiveResource::Base; self.site='http://somewhere.com/book_services'; end
-      Dupe.create :author
-      Dupe.network.mocks[:get].should_not be_empty
-      Dupe.network.mocks[:get].length.should == 2
-      
-      find_all_mock = Dupe.network.mocks[:get].first
-      find_all_mock.class.should == Dupe::Network::GetMock
-      find_all_mock.url_pattern.should == %r{^/book_services/authors\.xml$}
-      find_all_mock.mocked_response('/book_services/authors.xml').should == Dupe.find(:authors).to_xml(:root => 'authors')
-      
-      find_one_mock = Dupe.network.mocks[:get].last
-      find_one_mock.class.should == Dupe::Network::GetMock
-      find_one_mock.url_pattern.should == %r{^/book_services/authors/(\d+)\.xml$}
-      find_one_mock.mocked_response('/book_services/authors/1.xml').should == Dupe.find(:author).to_xml(:root => 'author')
-    end    
-  end
-  
   describe "create" do
     it "should require a model name parameter" do
       proc {Dupe.create}.should raise_error(ArgumentError)
       proc {Dupe.create :book}.should_not raise_error(ArgumentError)
     end
-    
+
     it "should create a model if one doesn't already exist" do
       Dupe.models.should be_empty
       Dupe.create :book
@@ -256,7 +113,7 @@ describe Dupe do
       Dupe.models[:book].should_not be_nil
       Dupe.models[:book].name.should == :book
     end
-    
+
     it "should be smart enough to singularize the model name before lookup/create" do
       Dupe.define :book
       Dupe.models.should_not be_empty
@@ -272,7 +129,7 @@ describe Dupe do
       Dupe.models[:author].name.should == :author
       Dupe.models[:authors].should be_nil
     end
-    
+
     it "should create (and return) a database record if passed a single hash" do
       Dupe.define :book
       Dupe.database.tables[:book].should be_empty
@@ -281,7 +138,7 @@ describe Dupe do
       Dupe.database.tables[:book].length.should == 1
       Dupe.database.tables[:book].first.should == @book
     end
-    
+
     it "should create several records if passed an array of hashes (and return an array of the records created)" do
       Dupe.define :book
       Dupe.database.tables[:book].should be_empty
@@ -291,13 +148,13 @@ describe Dupe do
       Dupe.database.tables[:book].first.should == @books.first
       Dupe.database.tables[:book].last.should == @books.last      
     end
-    
+
     it "should symbolize hash keys to keep from duplicating column names" do 
       b = Dupe.create :book, 'title' => 'War And Peace', :title => 'War And Peace'
       b.title.should == 'War And Peace'
       b[:title].should == 'War And Peace'
       b['title'].should == nil
-      
+
       bs = Dupe.create :books, [{:test => 2, 'test' => 2}, {:test => 4, 'test' => 4}]
       bs.first.test.should == 2
       bs.first[:test].should == 2
@@ -328,18 +185,18 @@ describe Dupe do
       b.isbn.should == 1
     end
   end
-  
+
   describe "create resources that have an after_create callback" do
     before do
       Dupe.define :book do |book|
         book.uniquify :title, :author, :genre
-      
+        
         book.after_create do |b|
           b.label = b.title.downcase.gsub(/\ +/, '-') unless b.label
         end
       end
     end
-    
+
     it "should create a label based on the title if a label is passed in during the create call" do
       b = Dupe.create :book, :title => 'Testing Testing'
       b.label.should == 'testing-testing'
@@ -347,21 +204,21 @@ describe Dupe do
       b.label.should == 'testbook'
     end
   end
-  
+
   describe "find" do
     before do
       Dupe.define :book
       @book = Dupe.create :book
     end
-    
+
     it "should require a model name parameter" do
       proc { Dupe.find }.should raise_error(ArgumentError)
     end
-    
+
     it "should require the model to exist" do
       proc { Dupe.find :unknown_models }.should raise_error(Dupe::Database::TableDoesNotExistError)
     end
-    
+
     it "should return an array if you ask for a plural model (e.g., Dupe.find :books)" do
       result = Dupe.find :books
       result.should be_kind_of(Array)
@@ -369,27 +226,27 @@ describe Dupe do
       result.length.should == 1
       result.first.should == @book
     end
-    
+
     it "should return a single record (or nil) if you ask for a singular model (e.g., Dupe.find :book)" do
       result = Dupe.find :book
       result.should be_kind_of(Dupe::Database::Record)
       result.should == @book
-      
+
       result = Dupe.find(:book) {|b| false}
       result.should be_nil
     end
   end
-  
+
   describe "debug" do
     it "should default to false" do
       Dupe.debug.should == false
     end
-    
+
     it "should allow you to set it to true" do
       Dupe.debug = true
       Dupe.debug.should == true
     end
-    
+
     it "should persist across a Dupe.reset" do
       Dupe.debug = true
       Dupe.debug.should == true
@@ -397,7 +254,7 @@ describe Dupe do
       Dupe.debug.should == true
     end
   end
-  
+
   describe "stub" do
     it ": when called with only a count and a model_name, it should generate that many blank (id-only) records" do
       Dupe.database.tables[:author].should be_nil
@@ -406,17 +263,17 @@ describe Dupe do
       Dupe.database.tables[:author].length.should == 20
       authors.collect(&:id).should == (1..20).to_a
     end
-    
+
     it "should accept procs on stubs" do
       Dupe.database.tables[:author].should be_nil
       authors = 
-        Dupe.stub(
-          2, 
-          :authors, 
-          :like => {
-            :name => proc {|n| "Author #{n}"},
-            :bio => proc {|n| "Author #{n}'s bio"}
-          }
+      Dupe.stub(
+        2, 
+        :authors, 
+        :like => {
+          :name => proc {|n| "Author #{n}"},
+          :bio => proc {|n| "Author #{n}'s bio"}
+        }
         )
       authors.first.name.should == "Author 1"
       authors.first.bio.should == "Author 1's bio"
@@ -424,7 +281,7 @@ describe Dupe do
       authors.last.bio.should == "Author 2's bio"
       Dupe.database.tables[:author].length.should == 2
     end
-    
+
     it "shouldn't care if the model_name is singular or plural" do
       Dupe.database.tables.should be_empty
       Dupe.stub 5, :author
@@ -436,35 +293,35 @@ describe Dupe do
       Dupe.database.tables.length.should == 1
     end
   end
-  
+
   describe "find_or_create" do
     it "should require a model name" do
       proc { Dupe.find_or_create }.should raise_error(ArgumentError)
     end
-    
+
     it "should find a result if one exists" do
       b = Dupe.create :book, :title => 'Rooby', :serial_number => 21345
       found_book = Dupe.find_or_create :book, :title => 'Rooby', :serial_number => 21345
       b.should === found_book
-      
+
       g = Dupe.create :genre, :name => 'Science Fiction', :label => 'sci-fi'
       found_genre = Dupe.find_or_create :genre, :name => 'Science Fiction', :label => 'sci-fi'
       g.should === found_genre
     end
-    
+
     it "should create a result if one does not exist" do
       Dupe.database.tables.should be_empty
       author = Dupe.find_or_create :author, :name => 'Matt Parker', :age => 27, :label => 'matt-parker'
       Dupe.database.tables.should_not be_empty
       author.should === (Dupe.find(:author) {|a| a.label == 'matt-parker' && a.age == 27})
     end
-    
+
     it "should return an array of results if passed a plural model name" do
       books = Dupe.stub 20, :books, :like => { :title => proc {|n| "book ##{n} title"} }
       bs = Dupe.find_or_create :books
       books.should == bs
     end
-    
+
     it "should create and return an array of results if passed a plural model name for which no matching records exist" do
       Dupe.database.tables.should be_empty
       books = Dupe.find_or_create :books, :author => 'test'
@@ -472,9 +329,9 @@ describe Dupe do
       books.should be_kind_of(Array)
       books.should == Dupe.find(:books)
     end
-    
+
   end
-  
+
   describe "creating resources should not change definitions (regression test)" do
     before do
       Dupe.define :book do |book|
@@ -484,7 +341,7 @@ describe Dupe do
         end
       end
     end
-    
+
     it "should not add a record to the definition when the default value is an array" do
       b = Dupe.create :book
       a = Dupe.create :author
@@ -493,7 +350,7 @@ describe Dupe do
       b2 = Dupe.create :book
       b2.authors.should be_empty
     end
-    
+
     it "should not dupe the value returned by a lazy attribute" do
       b = Dupe.create :book
       b2 = Dupe.create :book
@@ -519,4 +376,234 @@ describe Dupe do
       Dupe.find(:authors).first.name.should == 'Frank Herbert'
     end
   end
+
+  describe "define" do
+    # Dupe.define :model_name
+    it "should accept a single symbol parameter" do
+      proc {
+        Dupe.define :book
+      }.should_not raise_error
+    end
+  
+    # Dupe.define :model_name do |attrs|
+    #   attrs.attr1 'Default Value'
+    #   attrs.attr2 do |value|
+    #     'transformed value'
+    #   end
+    # end
+    it "should accept a symbol plus a block (that accepts a single parameter)" do
+      proc {
+        Dupe.define :book do
+        end
+      }.should raise_error(
+        ArgumentError,
+        "Unknown Dupe.define parameter format. Please consult the API" + 
+        " for information on how to use Dupe.define"
+      )
+    
+      proc {
+        Dupe.define :book do |attrs|
+          attrs.author 'Anon'
+          attrs.title 'Untitled'
+        end
+      }.should_not raise_error
+    end
+    
+    it "should create a model and a schema with the desired definition" do
+      Dupe.define :book do |attrs|
+        attrs.author 'Anon'
+        attrs.genre do
+          'Unknown' + rand(2).to_s
+        end
+        attrs.title 'Untitled' do |value|
+          "transformed #{value}"
+        end
+      end
+      
+      Dupe.models.length.should == 1
+      Dupe.models[:book].schema.attribute_templates[:author].name.should == :author
+      Dupe.models[:book].schema.attribute_templates[:author].default.should == 'Anon'
+      Dupe.models[:book].schema.attribute_templates[:title].name.should == :title
+      Dupe.models[:book].schema.attribute_templates[:title].default.should == 'Untitled'
+      Dupe.models[:book].schema.attribute_templates[:title].transformer.should be_kind_of(Proc)
+      Dupe.models[:book].schema.attribute_templates[:title].transformer.call('value').should == 'transformed value'
+      Dupe.models[:book].schema.attribute_templates[:genre].name.should == :genre
+      Dupe.models[:book].schema.attribute_templates[:genre].transformer.should be_nil
+      Dupe.models[:book].schema.attribute_templates[:genre].default.should be_kind_of(Proc)
+      Dupe.models[:book].schema.attribute_templates[:genre].default.call.should match(/^Unknown\d$/)
+    end
+    
+    it "should add a table to the database" do
+      Dupe.database.tables.length.should == 0
+      Dupe.database.tables[:book].should be_nil
+      Dupe.define :book
+      Dupe.database.tables.length.should == 1
+      Dupe.database.tables[:book].should_not be_nil
+      Dupe.database.tables[:book].should == []
+    end
+    
+    describe "using xml" do 
+      before do
+        Dupe.format = ActiveResource::Formats::XmlFormat
+      end
+
+      it "should add find(:all) and find(<id>) mocks to the network" do
+        Dupe.network.mocks[:get].should be_empty
+        Dupe.create :book
+        Dupe.network.mocks[:get].should_not be_empty
+        Dupe.network.mocks[:get].length.should == 2
+        
+        find_all_mock = Dupe.network.mocks[:get].first
+        find_all_mock.class.should == Dupe::Network::GetMock
+        find_all_mock.url_pattern.should == %r{^/books\.(?:xml|json)$}
+        find_all_mock.mocked_response('/books.xml').should == Dupe.find(:books).to_xml(:root => 'books')
+        
+        find_one_mock = Dupe.network.mocks[:get].last
+        find_one_mock.class.should == Dupe::Network::GetMock
+        find_one_mock.url_pattern.should == %r{^/books/(\d+)\.(?:xml|json)$}
+        find_one_mock.mocked_response('/books/1.xml').should == Dupe.find(:book).to_xml(:root => 'book')
+      end
+
+      it "should add a POST (create resource) mock to the network" do
+        Dupe.network.mocks[:post].should be_empty
+        Dupe.define :book
+        Dupe.network.mocks[:post].should_not be_empty
+        Dupe.network.mocks[:post].length.should == 1
+
+        post_mock = Dupe.network.mocks[:post].first
+        post_mock.class.should == Dupe::Network::PostMock
+        post_mock.url_pattern.should == %r{^/books\.(?:xml|json)$}
+        resp, url = post_mock.mocked_response('/books.xml', {:title => "Rooby"})
+        Hash.from_xml(resp).should == Hash.from_xml(Dupe.find(:book).to_xml(:root => 'book'))
+        url.should == "/books/1.xml"
+      end
+
+      it "should add a PUT (update resource) mock to the network" do
+        Dupe.network.mocks[:put].should be_empty
+        book = Dupe.create :book, :title => 'Rooby!'
+        Dupe.network.mocks[:put].should_not be_empty
+        Dupe.network.mocks[:put].length.should == 1
+
+        put_mock = Dupe.network.mocks[:put].first
+        put_mock.class.should == Dupe::Network::PutMock
+        put_mock.url_pattern.should == %r{^/books/(\d+)\.(?:xml|json)$}
+        resp, url = put_mock.mocked_response('/books/1.xml', {:title => "Rails!"})
+        resp.should == nil
+        url.should == "/books/1.xml"
+        book.title.should == "Rails!"
+      end
+
+      it "should add a DELETE mock to the network" do
+        Dupe.network.mocks[:delete].should be_empty
+        book = Dupe.create :book, :title => 'Rooby!'
+        Dupe.network.mocks[:delete].should_not be_empty
+        Dupe.network.mocks[:delete].length.should == 1
+
+        delete_mock = Dupe.network.mocks[:delete].first
+        delete_mock.class.should == Dupe::Network::DeleteMock
+        delete_mock.url_pattern.should == %r{^/books/(\d+)\.(?:xml|json)$}
+      end
+
+      
+      it "should honor ActiveResource site prefix's for the find(:all) and find(<id>) mocks" do
+        Dupe.network.mocks[:get].should be_empty
+        class Author < ActiveResource::Base; self.site='http://somewhere.com/book_services'; end
+        Dupe.create :author
+        Dupe.network.mocks[:get].should_not be_empty
+        Dupe.network.mocks[:get].length.should == 2
+        
+        find_all_mock = Dupe.network.mocks[:get].first
+        find_all_mock.class.should == Dupe::Network::GetMock
+        find_all_mock.url_pattern.should == %r{^/book_services/authors\.(?:xml|json)$}
+        find_all_mock.mocked_response('/book_services/authors.xml').should == Dupe.find(:authors).to_xml(:root => 'authors')
+        
+        find_one_mock = Dupe.network.mocks[:get].last
+        find_one_mock.class.should == Dupe::Network::GetMock
+        find_one_mock.url_pattern.should == %r{^/book_services/authors/(\d+)\.(?:xml|json)$}
+        find_one_mock.mocked_response('/book_services/authors/1.xml').should == Dupe.find(:author).to_xml(:root => 'author')
+      end    
+    end
+
+    describe "using json" do
+      before do
+        Dupe.format = ActiveResource::Formats::JsonFormat
+      end
+      
+      it "should add find(:all) and find(<id>) mocks to the network" do
+        Dupe.network.mocks[:get].should be_empty
+        Dupe.create :book
+        Dupe.network.mocks[:get].should_not be_empty
+        Dupe.network.mocks[:get].length.should == 2
+        
+        find_all_mock = Dupe.network.mocks[:get].first
+        find_all_mock.class.should == Dupe::Network::GetMock
+        find_all_mock.url_pattern.should == %r{^/books\.(?:xml|json)$}
+        find_all_mock.mocked_response('/books.json').should == Dupe.find(:books).to_json(:root => 'books')
+        
+        find_one_mock = Dupe.network.mocks[:get].last
+        find_one_mock.class.should == Dupe::Network::GetMock
+        find_one_mock.url_pattern.should == %r{^/books/(\d+)\.(?:xml|json)$}
+        find_one_mock.mocked_response('/books/1.json').should == Dupe.find(:book).to_json(:root => 'book')
+      end
+
+      it "should add a POST (create resource) mock to the network" do
+        Dupe.network.mocks[:post].should be_empty
+        Dupe.define :book
+        Dupe.network.mocks[:post].should_not be_empty
+        Dupe.network.mocks[:post].length.should == 1
+
+        post_mock = Dupe.network.mocks[:post].first
+        post_mock.class.should == Dupe::Network::PostMock
+        post_mock.url_pattern.should == %r{^/books\.(?:xml|json)$}
+        resp, url = post_mock.mocked_response('/books.json', {:title => "Rooby"})
+        Hash.from_json(resp).should == Hash.from_json(Dupe.find(:book).to_json(:root => 'book'))
+        url.should == "/books/1.json"
+      end
+
+      it "should add a PUT (update resource) mock to the network" do
+        Dupe.network.mocks[:put].should be_empty
+        book = Dupe.create :book, :title => 'Rooby!'
+        Dupe.network.mocks[:put].should_not be_empty
+        Dupe.network.mocks[:put].length.should == 1
+
+        put_mock = Dupe.network.mocks[:put].first
+        put_mock.class.should == Dupe::Network::PutMock
+        put_mock.url_pattern.should == %r{^/books/(\d+)\.(?:xml|json)$}
+        resp, url = put_mock.mocked_response('/books/1.json', {:title => "Rails!"})
+        resp.should == nil
+        url.should == "/books/1.json"
+        book.title.should == "Rails!"
+      end
+
+      it "should add a DELETE mock to the network" do
+        Dupe.network.mocks[:delete].should be_empty
+        book = Dupe.create :book, :title => 'Rooby!'
+        Dupe.network.mocks[:delete].should_not be_empty
+        Dupe.network.mocks[:delete].length.should == 1
+
+        delete_mock = Dupe.network.mocks[:delete].first
+        delete_mock.class.should == Dupe::Network::DeleteMock
+        delete_mock.url_pattern.should == %r{^/books/(\d+)\.(?:xml|json)$}
+      end
+
+      
+      it "should honor ActiveResource site prefix's for the find(:all) and find(<id>) mocks" do
+        Dupe.network.mocks[:get].should be_empty
+        class Author < ActiveResource::Base; self.site='http://somewhere.com/book_services'; end
+        Dupe.create :author
+        Dupe.network.mocks[:get].should_not be_empty
+        Dupe.network.mocks[:get].length.should == 2
+        
+        find_all_mock = Dupe.network.mocks[:get].first
+        find_all_mock.class.should == Dupe::Network::GetMock
+        find_all_mock.url_pattern.should == %r{^/book_services/authors\.(?:xml|json)$}
+        find_all_mock.mocked_response('/book_services/authors.json').should == Dupe.find(:authors).to_json(:root => 'authors')
+        
+        find_one_mock = Dupe.network.mocks[:get].last
+        find_one_mock.class.should == Dupe::Network::GetMock
+        find_one_mock.url_pattern.should == %r{^/book_services/authors/(\d+)\.(?:xml|json)$}
+        find_one_mock.mocked_response('/book_services/authors/1.json').should == Dupe.find(:author).to_json(:root => 'author')
+      end    
+    end
+  end
 end