superdupe 0.4.0 → 0.5.0

data/spec/lib_specs/hash_pruner_spec.rb

@@ -1,73 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe HashPruner do
-  describe "#prune" do
-    it "should nil out any repeated hashes" do
-      clarke = {:name => "Arthur C. Clarke"}
-      heinlein = {:name => "Robert Heinlein"}
-      sci_fi = {:name => "Science Fiction", :authors => [clarke, heinlein]}
-      clarke[:genre] = sci_fi
-      odyssey = {:name => "2001", :genre => sci_fi, :author => clarke}
-      hoag = {:name => "the unpleasant profession", :genre => sci_fi, :author => heinlein}
-      clarke[:books] = [odyssey]
-      heinlein[:books] = [hoag]
-
-      HashPruner.prune(clarke).should == 
-        { 
-          :name=>"Arthur C. Clarke", 
-          :genre => {
-            :name => "Science Fiction",
-            :authors => [
-              {
-                :name=>"Arthur C. Clarke"
-              },
-              {
-                :name=>"Robert Heinlein", 
-                :books=> [
-                  {
-                    :name => "the unpleasant profession",
-                    :genre => {
-                      :name => "Science Fiction"
-                    }, 
-                    :author => {
-                      :name => "Robert Heinlein"
-                    }
-                  }
-                ]
-              }
-            ]
-          },
-          :books=> [
-            { 
-              :name => "2001",
-              :genre => {
-                :name => "Science Fiction",
-                :authors => [
-                  {
-                    :name => "Arthur C. Clarke"                    
-                  },
-                  {
-                    :name=>"Robert Heinlein", 
-                    :books=> [
-                      {
-                        :name => "the unpleasant profession",
-                        :genre => {
-                          :name => "Science Fiction"
-                        }, 
-                        :author => {
-                          :name => "Robert Heinlein"
-                        }
-                      }
-                    ]
-                  }
-                ]
-              },
-              :author => {
-                :name => "Arthur C. Clarke"
-              } 
-            }
-          ]
-        }
-    end
-  end
-end

data/spec/lib_specs/log_spec.rb

@@ -1,78 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Dupe::Network::Log do
-  before do
-    Dupe.reset
-  end
-  
-  describe "##new" do
-    it "should initialize the request entries to an empty array" do
-      log = Dupe::Network::Log.new
-      log.requests.should == []
-    end
-  end
-  
-  describe "#add_request" do
-    before do
-      @log = Dupe::Network::Log.new
-    end
-    
-    it "should require a valid HTTP verb" do
-      proc { 
-        @log.add_request :invalid_http_verb, '/some_url' 
-      }.should raise_error(Dupe::Network::UnknownRestVerbError)
-      proc {
-        Dupe::Network::VERBS.each do |verb|
-          @log.add_request verb, '/some_url'
-        end
-      }.should_not raise_error
-    end
-    
-    it "should require a url" do
-      proc {
-        @log.add_request :get
-      }.should raise_error(ArgumentError)
-      proc {
-        @log.add_request :get, '/a_url'
-      }.should_not raise_error
-    end
-    
-    it "should add a Dupe::Network::Log::MockedRequest to requests" do
-      @log.requests.should be_empty
-      path = '/translate?q=hola&from=spanish&to=english'
-      response_body = 'hello'
-      @log.add_request :get, path, response_body
-      @log.requests.should_not be_empty
-      @log.requests.length.should == 1
-      logged_request = @log.requests.first
-      logged_request.should be_kind_of(Dupe::Network::Log::Request)
-      logged_request.verb.should == :get
-      logged_request.path.should == path
-      logged_request.response_body.should == response_body
-    end
-  end
-  
-  describe "#pretty_print" do
-    before do
-      @log = Dupe::Network::Log.new
-      @log.add_request :get, '/knock-knock', "who's there?"
-    end
-    it "should return a formatted list of mocked requests" do
-      @log.pretty_print.should == 
-       "Logged Requests:\n" +
-       "  Request: GET /knock-knock\n" +
-       "  Response:\n" +
-       "    who's there?\n\n"
-    end
-  end
-  
-  describe "#reset" do
-    it "should clear out all logged requests" do
-      @log = Dupe::Network::Log.new
-      @log.add_request :get, '/knock-knock', "who's there?"
-      @log.requests.should_not be_empty
-      @log.reset
-      @log.requests.should be_empty
-    end
-  end
-end

data/spec/lib_specs/logged_request_spec.rb

@@ -1,22 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Dupe::Network::Log::Request do
-  describe "##new" do
-    it "should set the verb, url, and response_body" do
-      r = Dupe::Network::Log::Request.new :get, "/knock-knock", "who's there?"
-      r.verb.should == :get
-      r.path.should == "/knock-knock"
-      r.response_body.should == "who's there?"
-    end
-  end
-  
-  describe "#pretty_print" do
-    it "should show the request type, request path, and request response" do
-      r = Dupe::Network::Log::Request.new :get, "/knock-knock", "who's there?"
-      r.pretty_print.should ==
-        "Request: GET /knock-knock\n" +
-        "Response:\n" +
-        "  who's there?"
-    end
-  end
-end

data/spec/lib_specs/mock_definitions_spec.rb

@@ -1,58 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../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
-    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
-      
-      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.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

@@ -1,194 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Dupe::Network::Mock do
-  before do
-    Dupe.reset
-  end
-  
-  describe "new" do
-    it "should require the url be a kind of regular expression" do
-      proc { Dupe::Network::Mock.new '', proc {} }.should raise_error(
-        ArgumentError,
-        "The URL pattern parameter must be a type of regular expression."
-      )
-    end
-    
-    it "should set the, @url, and @response parameters accordingly" do
-      url_pattern = /\//
-      response = proc {}
-      mock = Dupe::Network::Mock.new url_pattern, response
-      mock.url_pattern.should == url_pattern
-      mock.response.should == response
-    end
-  end
-  
-  describe "match?" do
-    it "should determine if a given string matches the mock's url pattern" do
-      url = %r{/blogs/(\d+).xml}
-      response = proc {}
-      mock = Dupe::Network::Mock.new url, response
-      mock.match?('/blogs/1.xml').should == true
-      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
-      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
-    
-    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
-    
-    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
-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"
-      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
-  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
-
-      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 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
-  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
-
-      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
-  end
-end

data/spec/lib_specs/model_spec.rb

@@ -1,95 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Dupe::Model do
-  describe "new" do
-    it "should require a model name" do
-      proc { Dupe::Model.new }.should raise_error(ArgumentError)
-    end
-    
-    it "should set the model name to what was passed in during initialization" do
-      m = Dupe::Model.new :book
-      m.name.should == :book
-    end
-    
-    it "should initialize an empty schema" do
-      m = Dupe::Model.new :book
-      m.schema.should be_kind_of(Dupe::Model::Schema)
-    end
-    
-    it "should setup an id_sequence initialized to 0" do
-      m = Dupe::Model.new :book
-      m.id_sequence.current_value.should == 1
-    end
-  end
-  
-  describe "define" do
-    describe "when passed a proc" do
-      before do
-        @model = Dupe::Model.new :book
-        @definition = proc { |attrs|
-          attrs.author('Anonymous') do |dont_care|
-            'Flying Spaghetti Monster'
-          end
-        }
-      end
-      
-      it "should pass that proc off to it's schema" do
-        @model.schema.should_receive(:method_missing).once
-        @model.define @definition
-      end
-      
-      it "should result in a schema with the desired attribute templates" do
-        @model.define @definition
-        @model.schema.attribute_templates[:author].name.should == :author
-        @model.schema.attribute_templates[:author].default.should == 'Anonymous'
-        @model.schema.attribute_templates[:author].transformer.call(
-          'dont care'
-        ).should == 'Flying Spaghetti Monster'
-      end
-    end
-  end
-  
-  describe "create" do
-    before do 
-      Dupe.define :book do |attrs|
-        attrs.title 'Untitled'
-        attrs.author 'Anon' do |author|
-          "Author: #{author}"
-        end
-        attrs.after_create do |book|
-          book.label = book.title.downcase.gsub(/\ +/, '-')
-        end
-      end
-      
-      @book_model = Dupe.models[:book]
-    end
-    
-    it "shouldn't require any parameters" do
-      proc {
-        @book_model.create
-      }.should_not raise_error
-    end
-    
-    it "should return a Dupe::Database::Record instance with the desired parameters" do
-      book = @book_model.create
-      book.should be_kind_of(Dupe::Database::Record)
-      book.__model__.name.should == :book
-      book.id.should == 1
-      book.title.should == 'Untitled'
-      book.author.should == 'Anon'
-      
-      # the callback shouldn't get run until the database record is inserted into the duped 'database'
-      book.label.should == nil
-      
-      book = @book_model.create :title => 'Rooby On Rails', :author => 'Matt Parker'
-      book.__model__.name.should == :book
-      book.id.should == 2
-      book.title.should == 'Rooby On Rails'
-      
-      # the callback shouldn't get run until the database record is inserted into the duped 'database'
-      book.label.should == nil
-      
-      book.author.should == 'Author: Matt Parker'
-    end
-  end
-end

data/spec/lib_specs/network_spec.rb

@@ -1,130 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Dupe::Network do
-  
-  describe "new" do
-    before do
-      @network = Dupe::Network.new
-    end
-    
-    it "should initialize @mocks to a hash of empty arrays keyed with valid REST verbs" do
-      Dupe::Network::VERBS.each do |verb|
-        @network.mocks[verb].should == []
-      end
-    end
-    
-    it "should initialize @log to a new Dupe::Network::Log" do
-      @network.log.should be_kind_of(Dupe::Network::Log)
-    end
-  end
-  
-  describe "request" do
-    before do
-      @network = Dupe::Network.new
-    end
-    
-    it "should require a valid REST verb" 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
-  
-  describe "define_service_mock" do
-    before do
-      @network = Dupe::Network.new
-    end
-    
-    it "should require a valid REST verb" 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)
-      proc { @network.define_service_mock :put, // }.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 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[:get].first.class.should == Dupe::Network::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.should == Dupe::Network::PostMock
-      @network.mocks[:post].length.should == 1
-      @network.mocks[:post].first.should == mock
-    end
-    
-    it "should create and return a new put service mock when given valid parameters" do
-      verb = :put
-      pattern = //
-      response = proc { 'test' }
-      @network.mocks[:put].should be_empty
-      mock = @network.define_service_mock verb, pattern, response
-      @network.mocks[:put].should_not be_empty
-      @network.mocks[:put].first.class.should == Dupe::Network::PutMock
-      @network.mocks[:put].length.should == 1
-      @network.mocks[:put].first.should == mock
-    end
-    
-    it "should create and return a new delete service mock when given valid parameters" do
-      verb = :delete
-      pattern = //
-      response = proc { 'test' }
-      @network.mocks[:delete].should be_empty
-      mock = @network.define_service_mock verb, pattern, response
-      @network.mocks[:delete].should_not be_empty
-      @network.mocks[:delete].first.class.should == Dupe::Network::DeleteMock
-      @network.mocks[:delete].length.should == 1
-      @network.mocks[:delete].first.should == mock
-    end
-  end
-  
-end