dupe 0.3.7 → 0.4.0

data/spec/lib_specs/attribute_template_spec.rb

@@ -0,0 +1,173 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Dupe::Model::Schema::AttributeTemplate do 
+  describe "new" do
+    it "should require a name" do
+      proc {
+        Dupe::Model::Schema::AttributeTemplate.new
+      }.should raise_error(ArgumentError)
+    end
+    
+    it "should set the name if one is passed to it" do
+      attribute = Dupe::Model::Schema::AttributeTemplate.new(:title)
+      attribute.name.should == :title
+    end
+    
+    it "should set a default value if one is passed to it" do
+      attribute = 
+        Dupe::Model::Schema::AttributeTemplate.new(
+          :title, 
+          :default => 'Untitled'
+        )
+      attribute.default.should == 'Untitled'
+    end
+    
+    it "should verify that the transformer is a proc" do
+      proc {
+        attribute = 
+          Dupe::Model::Schema::AttributeTemplate.new(
+            :title, 
+            :default => nil, 
+            :transformer => 'not a proc'
+          )
+      }.should raise_error(
+        ArgumentError,
+        "Your transformer must be a kind of proc."
+      )
+    end
+    
+    it "should verify that the transformer requires a single parameter" do
+      proc {
+        attribute = Dupe::Model::Schema::AttributeTemplate.new(
+          :title, 
+          :default => nil, 
+          :transformer => proc {'test'}
+        )
+      }.should raise_error(
+        ArgumentError,
+        "Your transformer must accept a parameter."
+      )
+    end
+    
+    it "should set the transformer if one is passed" do
+      transformer = proc {|dont_care| }
+      attribute = Dupe::Model::Schema::AttributeTemplate.new(
+        :title, 
+        :default => nil, 
+        :transformer => transformer
+      )
+      attribute.transformer.should == transformer
+    end
+  end
+  
+  describe "generate" do
+    describe "on an attribute without a default value and without a transformer" do
+      before do
+        @attribute = Dupe::Model::Schema::AttributeTemplate.new(:title)
+      end
+
+      it "should generate a key with the name of the attribute" do
+        key, value = @attribute.generate
+        key.should == @attribute.name
+      end
+      
+      describe "when passed nothing" do     
+        it "should generate a nil value" do
+          key, value = @attribute.generate
+          value.should == nil
+        end
+      end
+      
+      describe "when passed a value" do
+        it "should generate a value equal to the value passed in" do
+          key, value = @attribute.generate('test')
+          value.should == 'test'
+        end
+      end
+    end
+    
+    describe "on an attribute with a default value but without a transformer" do
+      before do
+        @attribute = Dupe::Model::Schema::AttributeTemplate.new(:title, :default => 'Untitled')
+      end
+
+      it "should generate a key with the name of the attribute" do
+        key, value = @attribute.generate
+        key.should == @attribute.name
+      end   
+      
+      describe "when passed nothing" do
+        it "should generate a value equal to the default value" do
+          key, value = @attribute.generate
+          value.should == @attribute.default
+        end
+      end
+      
+      describe "when passed a value" do
+        it "should generate a value equal to the value passed in" do
+          title = '2001: A Space Odyssey'
+          key, value = @attribute.generate title
+          value.should == title
+        end
+      end
+    end
+    
+    describe "on an attribute with a default value that is a proc" do
+      before do
+        @default_value = proc { 'knock' * 3 }
+        @attribute = Dupe::Model::Schema::AttributeTemplate.new(:title, :default => @default_value)
+      end
+
+      it "should generate a key with the name of the attribute" do
+        key, value = @attribute.generate
+        key.should == @attribute.name
+      end   
+      
+      describe "when passed nothing" do
+        it "should return the value of the default_value proc" do
+          key, value = @attribute.generate
+          value.should == @default_value.call
+        end
+      end
+      
+      describe "when passed a value" do
+        it "should generate a value equal to the value passed in" do
+          title = 'Rooby'
+          key, value = @attribute.generate title
+          value.should == title
+        end
+      end
+      
+    end
+    
+    describe "on an attribute with a transformer" do
+      before do
+        @transformer = proc {|dont_care| 'test'}
+        @attribute = Dupe::Model::Schema::AttributeTemplate.new(
+          :title, 
+          :default => nil, 
+          :transformer => @transformer
+        )
+      end
+      
+      it "should generate a key with the name of the attribute" do
+        key, value = @attribute.generate
+        key.should == @attribute.name
+      end
+      
+      describe "when passed nothing" do
+        it "should generate a value equal to the default" do
+          key, value = @attribute.generate
+          value.should == @attribute.default
+        end
+      end
+      
+      describe "when passed a value" do
+        it "should generate a value equal to the value returned by the transformer" do
+          key, value = @attribute.generate 'blah'
+          value.should == @transformer.call('blah')
+        end
+      end
+    end
+  end
+end

data/spec/lib_specs/database_spec.rb

@@ -0,0 +1,133 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Dupe::Database do
+  before do
+    Dupe.reset
+  end
+  
+  describe "new" do
+    before do
+      @database = Dupe::Database.new
+    end
+    
+    it "should initialize an empty table set" do
+      @database.tables.should be_kind_of(Hash)
+      @database.tables.should be_empty
+    end
+  end
+  
+  describe "insert" do
+    before do
+      Dupe.define :book
+      @book = Dupe.models[:book].create :title => 'test'
+      @database = Dupe::Database.new
+    end
+    
+    it "should require a record" do
+      proc {@database.insert}.should raise_error(ArgumentError)
+      proc {
+        @database.insert 'not a Dupe::Database::Record object'
+      }.should raise_error(
+        ArgumentError,
+        "You may only insert well-defined Dupe::Database::Record objects"
+      )
+      proc {
+        @database.insert Dupe::Database::Record.new
+      }.should raise_error(
+        ArgumentError,
+        "You may only insert well-defined Dupe::Database::Record objects"
+      )
+      proc {@database.insert @book}.should_not raise_error
+    end
+    
+    it "should create a new table if one does not already exist upon insert" do
+      @database.tables.should be_empty
+      @database.insert @book
+      @database.tables[:book].should_not be_nil
+      @database.tables[:book].should be_kind_of(Array)
+      @database.tables[:book].should_not be_empty
+      @database.tables[:book].first.should_not be_nil
+      @database.tables[:book].first.should == @book
+    end
+  end
+  
+  describe "select" do
+    before do
+      Dupe.define :book
+      @book = Dupe.models[:book].create :title => 'test'
+      @database = Dupe::Database.new
+      @database.insert @book
+    end
+    
+    it "should require a valid model name" do
+      proc { @database.select }.should raise_error(ArgumentError)
+      proc { @database.select :undefined_model }.should raise_error(
+        Dupe::Database::TableDoesNotExistError,
+        "The table ':undefined_model' does not exist."
+      )
+      proc { @database.select :book }.should_not raise_error
+    end
+    
+    it "should accept a conditions proc" do
+      proc { @database.select :book, proc {|c| true} }.should_not raise_error
+    end
+    
+    it "should verify that the conditions proc accepts a single parameter" do
+      proc { @database.select :book, proc {true} }.should raise_error(
+        Dupe::Database::InvalidQueryError,
+        "There was a problem with your select conditions. Please consult the API."
+      )
+    end
+    
+    it "should find the requested items and return an array" do
+      results = @database.select :book, proc {|b| b.title == 'test' }
+      results.should be_kind_of(Array)
+      results.should_not be_empty
+      results.first.__model__.should == Dupe.models[:book]
+      results.first.__model__.name.should == :book
+      results.first.title.should == 'test'
+      results.first.id.should == 1
+    end
+  end
+  
+  describe "create_table" do
+    it "should create a database table if one doesn't already exist" do
+      @database = Dupe::Database.new
+      @database.tables.length.should == 0
+      @database.tables[:book].should be_nil
+      @database.create_table 'book'
+      @database.tables[:book].should_not be_nil
+      @database.tables.length.should == 1
+      @database.tables[:book].should == []
+      
+      # make sure it doesn't overwrite a table that already exists
+      m = Dupe::Model.new :book
+      record = m.create
+      @database.insert record
+      @database.tables[:book].length.should == 1
+      @database.tables[:book].first.should == record
+      @database.create_table :book
+      @database.tables[:book].length.should == 1
+      @database.tables[:book].first.should == record
+    end
+  end
+  
+  describe "truncate_tables" do
+    it "should remove all records from all tables" do
+      Dupe.create :book
+      Dupe.create :author
+      Dupe.create :publisher
+      Dupe.database.tables.length.should == 3
+      Dupe.database.tables[:book].length.should == 1
+      Dupe.database.tables[:author].length.should == 1
+      Dupe.database.tables[:publisher].length.should == 1
+      Dupe.database.truncate_tables
+      Dupe.database.tables.length.should == 3
+      Dupe.database.tables[:book].length.should == 0
+      Dupe.database.tables[:author].length.should == 0
+      Dupe.database.tables[:publisher].length.should == 0
+    end
+  end
+  
+
+end

data/spec/lib_specs/dupe_spec.rb

@@ -1,4 +1,311 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe Dupe do
+  before do
+    Dupe.reset
+  end
+  
+  describe "reset" do
+    it "should call reset_models, reset_database, and reset_network" do
+      Dupe.should_receive(:reset_models).once
+      Dupe.should_receive(:reset_database).once
+      Dupe.should_receive(:reset_network).once
+      Dupe.reset
+    end
+  end
+  
+  describe "reset_models" do
+    it "should reset @models to an empty hash" do
+      Dupe.models.length.should == 0
+      Dupe.define :book do |attrs|
+        attrs.title
+        attrs.author
+      end
+      Dupe.models.length.should == 1
+      Dupe.reset_models
+      Dupe.models.should == {}
+    end
+  end
+  
+  describe "reset_database" do
+    it "should clear out the database" do
+      Dupe.define :book
+      Dupe.define :author
+      Dupe.database.tables.length.should == 2
+      Dupe.reset_database
+      Dupe.database.tables.should be_empty
+    end    
+  end
+  
+  describe "reset_network" do
+    it "should clear out the network" do
+      Dupe.create :book
+      Dupe.network.mocks.values.inject(false) {|b,v| b || !v.empty?}.should == true
+      Dupe.network.mocks[:get].should_not be_empty
+      Dupe.reset_network
+      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 database" 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.verb.should == :get
+      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.verb.should == :get
+      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
+    
+  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
+      Dupe.models.should_not be_empty
+      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
+      Dupe.models.length.should == 1
+      Dupe.models[:book].should_not be_nil
+      Dupe.create :books
+      Dupe.models.length.should == 1
+      Dupe.models[:books].should be_nil
+      Dupe.models[:book].should_not be_nil
+      Dupe.create :authors
+      Dupe.models.length.should == 2
+      Dupe.models[:author].should_not be_nil
+      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
+      @book = Dupe.create :book, :title => 'test'
+      Dupe.database.tables[:book].should_not be_empty
+      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
+      @books = Dupe.create :books, [{:title => 'Book 1'}, {:title => 'Book 2'}]
+      Dupe.database.tables[:book].should_not be_empty
+      Dupe.database.tables[:book].length.should == 2
+      Dupe.database.tables[:book].first.should == @books.first
+      Dupe.database.tables[:book].last.should == @books.last      
+    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)
+      result.should_not be_empty
+      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
+      Dupe.reset
+      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
+      authors = Dupe.stub 20, :authors
+      authors.length.should == 20
+      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"}
+          }
+        )
+      authors.first.name.should == "Author 1"
+      authors.first.bio.should == "Author 1's bio"
+      authors.last.name.should == "Author 2"
+      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
+      Dupe.database.tables.should_not be_empty
+      Dupe.database.tables.length.should == 1
+      Dupe.database.tables[:author].length.should == 5
+      Dupe.stub 5, :authors
+      Dupe.database.tables[:author].length.should == 10
+      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'
+      Dupe.database.tables.length.should == 1
+      books.should be_kind_of(Array)
+      books.should == Dupe.find(:books)
+    end
+    
+  end
 end

data/spec/lib_specs/log_spec.rb

@@ -0,0 +1,78 @@
+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