superdupe 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,163 @@
+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 "delete" do
+    before do 
+      Dupe.stub 10, :books
+    end
+
+    it "should delete the first record found if the resource name is singular and there is no conditions proc" do
+      Dupe.find(:books).length.should == 10
+      Dupe.database.delete :book
+      Dupe.find(:books).length.should == 9
+    end
+
+    it "should delete all records if the resource name is plural and there is no conditions proc" do
+      Dupe.find(:books).length.should == 10
+      Dupe.database.delete :books
+      Dupe.find(:books).length.should == 0
+    end
+
+    it "should delete all matching records if there is a conditions proc and the resource name is singular" do
+      Dupe.find(:books).length.should == 10
+      Dupe.database.delete :book, proc {|b| b.id < 3}
+      Dupe.find(:books).length.should == 8
+    end
+
+    it "should delete all matching records if there is a conditions proc and the resource name is plural" do
+      Dupe.find(:books).length.should == 10
+      Dupe.database.delete :books, proc {|b| b.id < 3}
+      Dupe.find(:books).length.should == 8
+    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