datamapper 0.2.4 → 0.2.5

data/spec/attributes_spec.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + "/spec_helper"
 
-describe DataMapper::Base do
+describe DataMapper::Persistence do
     
   it 'should allow mass-assignment of attributes' do
     zoo = Zoo.new(:name => 'MassAssignment', :notes => 'This is a test.')

data/spec/base_spec.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + "/spec_helper"
 
-describe DataMapper::Base do
+describe DataMapper::Persistence do
   
   it "attributes method should load all lazy-loaded values" do
     Animal.first(:name => 'Cup').attributes[:notes].should == 'I am a Cup!'
@@ -137,7 +137,7 @@ describe 'A new record' do
   
   it "should have original values when loaded from the database" do
     Person.create(:name => 'a')
-    x = Person[:name => 'a']
+    x = Person.first(:name => 'a')
     x.original_values.should_not be_empty
     x.original_values.keys.should include(:name)
     x.original_values[:name].should == "a"
@@ -165,7 +165,9 @@ end
 describe 'Properties' do
 
   it 'should default to public method visibility' do
-    class SoftwareEngineer < DataMapper::Base
+    class SoftwareEngineer
+      include DataMapper::Persistence
+      
       set_table_name 'people'
       property :name, :string
     end
@@ -175,7 +177,9 @@ describe 'Properties' do
   end
 
   it 'should respect protected property options' do
-    class SanitationEngineer < DataMapper::Base
+    class SanitationEngineer
+      include DataMapper::Persistence
+
       set_table_name 'people'
       property :name, :string, :reader => :protected
       property :age, :integer, :writer => :protected
@@ -186,7 +190,9 @@ describe 'Properties' do
   end
 
   it 'should respect private property options' do
-    class ElectricalEngineer < DataMapper::Base
+    class ElectricalEngineer
+      include DataMapper::Persistence
+
       set_table_name 'people'
       property :name, :string, :reader => :private
       property :age, :integer, :writer => :private
@@ -197,7 +203,9 @@ describe 'Properties' do
   end
 
   it 'should set both reader and writer visibiliy when accessor option is passed' do
-    class TrainEngineer < DataMapper::Base
+    class TrainEngineer
+      include DataMapper::Persistence
+
       property :name, :string, :accessor => :private
     end
 
@@ -206,32 +214,38 @@ describe 'Properties' do
   end
 
   it 'should only be listed in attributes if they have public getters' do
-    class SalesEngineer < DataMapper::Base
+    class SalesEngineer
+      include DataMapper::Persistence
+
       set_table_name 'people'
       property :name, :string
       property :age, :integer, :reader => :private
     end
 
-    @sam = SalesEngineer[:name => 'Sam']
+    @sam = SalesEngineer.first(:name => 'Sam')
     # note: id default key gets a public reader by default (but writer is protected)
     @sam.attributes.should == {:id => @sam.id, :name => @sam.name}
   end
 
   it 'should not allow mass assignment if private or protected' do
-    class ChemicalEngineer < DataMapper::Base
+    class ChemicalEngineer
+      include DataMapper::Persistence
+
       set_table_name 'people'
       property :name, :string, :writer => :private
       property :age, :integer
     end
 
-    @sam = ChemicalEngineer[:name => 'Sam']
+    @sam = ChemicalEngineer.first(:name => 'Sam')
     @sam.attributes = {:name => 'frank', :age => 101}
     @sam.age.should == 101
     @sam.name.should == 'Sam'
   end
 
   it 'should allow :protected to be passed as an alias for a public reader, protected writer' do
-    class CivilEngineer < DataMapper::Base
+    class CivilEngineer
+      include DataMapper::Persistence
+
       set_table_name 'people'
       property :name, :string, :protected => true
     end
@@ -241,7 +255,9 @@ describe 'Properties' do
   end
 
   it 'should allow :private to be passed as an alias for a public reader, private writer' do
-    class AudioEngineer < DataMapper::Base
+    class AudioEngineer
+      include DataMapper::Persistence
+
       set_table_name 'people'
       property :name, :string, :private => true
     end
@@ -252,11 +268,23 @@ describe 'Properties' do
   
   it 'should raise an error when invalid options are passsed' do
     lambda do
-      class JumpyCow < DataMapper::Base
+      class JumpyCow
+        include DataMapper::Persistence
+
         set_table_name 'animals'
         property :name, :string, :laze => true
       end
     end.should raise_error(ArgumentError)
   end
 
+  it 'should raise an error when the first argument to index isnt an array' do
+    lambda do
+      class JumpyCow
+        include DataMapper::Persistence
+
+        set_table_name 'animals'
+        index :name, :parent
+      end
+    end.should raise_error(ArgumentError)
+  end
 end

data/spec/callbacks_spec.rb

@@ -44,4 +44,36 @@ describe DataMapper::Callbacks do
     
   end
   
+  it "should execute before_save regardless of dirty state" do
+    
+    Post.before_save do |post|
+      post.instance_variable_set("@one", 'moo')
+    end
+    
+    Post.before_save do |post|
+      post.instance_variable_set("@two", 'cow')
+    end
+    
+    Post.before_save :red_cow
+    
+    class Post
+      def red_cow
+        @three = "blue_cow"
+      end
+    end
+    
+    post = Post.new(:title => 'bob')
+    post.save
+    
+    post = Post.first(:title => 'bob')
+    post.instance_variable_get("@one").should be_nil
+    post.instance_variable_get("@two").should be_nil
+    post.instance_variable_get("@three").should be_nil
+
+    post.save
+    post.instance_variable_get("@one").should eql('moo')
+    post.instance_variable_get("@two").should eql('cow')
+    post.instance_variable_get("@three").should eql('blue_cow')
+  end
+  
 end

data/spec/coersion_spec.rb

@@ -18,7 +18,7 @@ describe DataMapper::Adapters::Sql::Coersion do
     dob = Date::today
     bob = Person.create(:name => 'DateCoersionTest', :date_of_birth => dob)
     
-    bob2 = Person[:name => 'DateCoersionTest']
+    bob2 = Person.first(:name => 'DateCoersionTest')
     
     bob.date_of_birth.should eql(dob)
     bob2.date_of_birth.should eql(dob)

data/spec/column_spec.rb

@@ -3,8 +3,13 @@ require File.dirname(__FILE__) + "/spec_helper"
 describe DataMapper::Adapters::Sql::Mappings::Column do
   
   before(:all) do
+    @mappings = DataMapper::Adapters::Sql::Mappings
     fixtures(:zoos)
   end
+  
+  def table
+  	@table ||= @mappings::Table.new(database(:mock).adapter, "Cow")
+  end
 
   it "should only lazy loading text columns by default" do
     table = database.table(Zoo)
@@ -18,21 +23,17 @@ describe DataMapper::Adapters::Sql::Mappings::Column do
   end
   
   it "should be unique within a set" do
-    
-    mappings = DataMapper::Adapters::Sql::Mappings
-    
     columns = SortedSet.new
     
-    table = mappings::Table.new(database(:mock).adapter, "Cow")
-    columns << mappings::Column.new(database(:mock).adapter, table, :one, :string, 1)
-    columns << mappings::Column.new(database(:mock).adapter, table, :two, :string, 2)
-    columns << mappings::Column.new(database(:mock).adapter, table, :three, :string, 3)
+    columns << @mappings::Column.new(database(:mock).adapter, table, :one, :string, 1)
+    columns << @mappings::Column.new(database(:mock).adapter, table, :two, :string, 2)
+    columns << @mappings::Column.new(database(:mock).adapter, table, :three, :string, 3)
     columns.should have(3).entries
     
-    columns << mappings::Column.new(database(:mock).adapter, table, :two, :integer, 3)
+    columns << @mappings::Column.new(database(:mock).adapter, table, :two, :integer, 3)
     columns.should have(3).entries
     
-    columns << mappings::Column.new(database(:mock).adapter, table, :id, :integer, -1)
+    columns << @mappings::Column.new(database(:mock).adapter, table, :id, :integer, -1)
     columns.should have(4).entries
   end
   
@@ -92,10 +93,19 @@ describe DataMapper::Adapters::Sql::Mappings::Column do
   end
   
   it "should default the size of an integer column to 11" do
-    mappings = DataMapper::Adapters::Sql::Mappings
-    table    = mappings::Table.new(database(:mock).adapter, "Zebu")
-    integer  = mappings::Column.new(database(:mock).adapter, table, :age, :integer, 1)
+    integer  = @mappings::Column.new(database(:mock).adapter, table, :age, :integer, 1)
     integer.size.should == 11    
   end
   
+  it "should be able to create a column with unique index" do
+    column = table.add_column("name", :string, :index => :unique)
+    column.unique?.should be_true
+    table.to_create_sql.should match(/UNIQUE/)
+  end
+  
+  it "should be able to create an indexed column" do
+    column = table.add_column("age", :integer, :index => true)
+    column.index?.should be_true
+    table.to_create_index_sql[0].should match(/CREATE INDEX cow_age_index/)
+  end
 end

data/spec/dependency_spec.rb

@@ -1,18 +1,20 @@
 require File.dirname(__FILE__) + "/spec_helper"
 
-describe DataMapper::Base do
+describe DataMapper::Persistence do
   
   it "should be able to add a dependency for a class not yet defined" do
     
     $happy_cow_defined = false
     
-    DataMapper::Base.dependencies.add('HappyCow') do |klass|
+    DataMapper::Persistence.dependencies.add('HappyCow') do |klass|
       klass.should eql(Object.const_get('HappyCow'))
       database.table(klass).key.name.should eql(:name)
       $happy_cow_defined = true
     end
     
-    class HappyCow < DataMapper::Base
+    class HappyCow 
+      include DataMapper::Persistence
+      
       property :name, :string, :key => true
     end
     

data/spec/embedded_value_spec.rb

@@ -3,7 +3,7 @@ require File.dirname(__FILE__) + "/spec_helper"
 describe DataMapper::EmbeddedValue do
     
   before(:all) do
-    @bob = Person[:name => 'Bob']
+    @bob = Person.first(:name => 'Bob')
   end
   
   it 'should proxy getting values for you' do
@@ -19,7 +19,9 @@ describe DataMapper::EmbeddedValue do
   end
   
   it 'should not require prefix' do
-    class PointyHeadedBoss < DataMapper::Base
+    class PointyHeadedBoss
+      include DataMapper::Persistence
+
       set_table_name 'people'
       property :name, :string
 
@@ -31,12 +33,14 @@ describe DataMapper::EmbeddedValue do
       end
     end
 
-    @sam = PointyHeadedBoss[:name => 'Sam']
+    @sam = PointyHeadedBoss.first(:name => 'Sam')
     @sam.address.address_street.should == '1337 Duck Way'
   end
 
   it 'should add convenience methods to the non-embedded base' do
-    class Employee < DataMapper::Base
+    class Employee
+      include DataMapper::Persistence
+
       set_table_name 'people'
       property :name, :string
 
@@ -46,12 +50,14 @@ describe DataMapper::EmbeddedValue do
       end
     end
 
-    @sam = Employee[:name => 'Sam']
+    @sam = Employee.first(:name => 'Sam')
     @sam.address_street.should == '1337 Duck Way'
   end
 
   it 'should support lazy loading of embedded properties' do
-    class Human < DataMapper::Base
+    class Human
+      include DataMapper::Persistence
+
       set_table_name 'people'
       property :name, :string
 
@@ -61,12 +67,14 @@ describe DataMapper::EmbeddedValue do
       end
     end
 
-    @sam = Human[:name => 'Sam']
+    @sam = Human.first(:name => 'Sam')
     @sam.address.street.should == '1337 Duck Way'
   end
 
   it 'should default to public method visibility for all' do
-    class SoftwareEngineer < DataMapper::Base
+    class SoftwareEngineer
+      include DataMapper::Persistence
+
       set_table_name 'people'
       property :name, :string
 
@@ -75,13 +83,15 @@ describe DataMapper::EmbeddedValue do
       end
     end
 
-    @sam = SoftwareEngineer[:name => 'Sam']
+    @sam = SoftwareEngineer.first(:name => 'Sam')
     public_properties = @sam.address.class.public_instance_methods.select { |m| ["city", "city="].include?(m) }
     public_properties.length.should == 2
   end
 
   it 'should respect protected property options for all' do
-    class SanitationEngineer < DataMapper::Base
+    class SanitationEngineer
+      include DataMapper::Persistence
+
       set_table_name 'people'
       property :name, :string
 
@@ -91,13 +101,15 @@ describe DataMapper::EmbeddedValue do
       end
     end
 
-    @sam = SanitationEngineer[:name => 'Sam']
+    @sam = SanitationEngineer.first(:name => 'Sam')
     protected_properties = @sam.address.class.protected_instance_methods.select { |m| ["city", "street"].include?(m) }
     protected_properties.length.should == 2
   end
 
   it 'should respect private property options for all' do
-    class ElectricalEngineer < DataMapper::Base
+    class ElectricalEngineer
+      include DataMapper::Persistence
+
       set_table_name 'people'
       property :name, :string, :reader => :private
 
@@ -107,13 +119,15 @@ describe DataMapper::EmbeddedValue do
       end
     end
 
-    @sam = ElectricalEngineer[:name => 'Sam']
+    @sam = ElectricalEngineer.first(:name => 'Sam')
     private_properties = @sam.address.class.private_instance_methods.select { |m| ["city=", "street="].include?(m) }
     private_properties.length.should == 2
   end
 
   it 'should set both reader and writer visibiliy for all when accessor option is passed' do
-    class TrainEngineer < DataMapper::Base
+    class TrainEngineer
+      include DataMapper::Persistence
+
       set_table_name 'people'
       property :name, :string, :reader => :private
   
@@ -122,13 +136,15 @@ describe DataMapper::EmbeddedValue do
       end
     end
 
-    @sam = TrainEngineer[:name => 'Sam']
+    @sam = TrainEngineer.first(:name => 'Sam')
     private_properties = @sam.address.class.private_instance_methods.select { |m| ["city", "city="].include?(m) }
     private_properties.length.should == 2
   end
 
   it 'should allow individual properties to override method visibility options passed on the block' do
-    class ChemicalEngineer < DataMapper::Base
+    class ChemicalEngineer
+      include DataMapper::Persistence
+
       set_table_name 'people'
       property :name, :string
 
@@ -138,7 +154,7 @@ describe DataMapper::EmbeddedValue do
       end
     end
 
-    @sam = ChemicalEngineer[:name => 'Sam']
+    @sam = ChemicalEngineer.first(:name => 'Sam')
     public_properties = @sam.address.class.public_instance_methods.select { |m| ["street", "street="].include?(m) }
     public_properties.length.should == 2
   end

data/spec/has_many_association_spec.rb

@@ -0,0 +1,173 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe DataMapper::Associations::HasManyAssociation do
+  
+  before(:all) do
+    fixtures(:zoos)
+    fixtures(:exhibits)
+    fixtures(:fruit)
+    fixtures(:animals)
+  end
+
+  after(:all) do
+    fixtures(:fruit)
+    fixtures(:animals)
+  end
+
+  before(:each) do
+    @zoo = Zoo.new(:name => "ZOO")
+    @zoo.save 
+  end
+  
+  after(:each) do
+    @zoo.destroy!
+  end
+  
+  it "should return an empty Enumerable for new objects" do
+    project = Project.new
+    project.sections.should be_a_kind_of(Enumerable)
+    project.sections.should be_empty
+  end
+  
+  it "should display correctly when inspected" do
+    Zoo.first(:name => 'Dallas').exhibits.inspect.should match(/\#\<Exhibit\:0x.{7}/)
+  end
+  
+  it 'should lazily-load the association when Enumerable methods are called' do
+    database do |db|
+      san_diego = Zoo.first(:name => 'San Diego')
+      san_diego.exhibits.size.should == 2
+      san_diego.exhibits.should include(Exhibit.first(:name => 'Monkey Mayhem'))
+    end
+  end
+  
+  it 'should eager-load associations for an entire set' do
+    database do
+      zoos = Zoo.all
+      zoos.each do |zoo|
+        zoo.exhibits.each do |exhibit|
+          exhibit.zoo.should == zoo
+        end
+      end
+    end
+  end
+  
+  it "should be dirty even when clean objects are associated" do
+    zoo = Zoo.first(:name => 'New York')
+    zoo.exhibits << Exhibit.first
+    zoo.should be_dirty
+  end
+  
+  it "should proxy associations on the associated type" do
+    Zoo.first(:name => 'Miami').exhibits.animals.size.should == 1
+  end
+  
+  it "should have a valid zoo setup for testing" do
+    @zoo.should be_valid
+    @zoo.should_not be_a_new_record
+    @zoo.id.should_not be_nil
+  end  
+  
+  it "should generate the SQL for a join statement" do
+    exhibits_association = database(:mock).schema[Zoo].associations.find { |a| a.name == :exhibits }
+  
+    exhibits_association.to_sql.should == <<-EOS.compress_lines
+      JOIN `exhibits` ON `exhibits`.`zoo_id` = `zoos`.`id`
+    EOS
+  end
+
+  it "should add an item to an association" do
+    bear = Exhibit.new( :name => "Bear")
+    @zoo.exhibits << bear
+    @zoo.exhibits.should include(bear)
+  end
+  
+  it "should build a new item" do
+    bear = @zoo.exhibits.build( :name => "Bear" )
+    bear.should be_kind_of(Exhibit)
+    @zoo.exhibits.should include(bear)
+  end
+
+  it "should not save the item when building" do
+    bear = @zoo.exhibits.build( :name => "Bear" )
+    bear.should be_new_record
+  end
+  
+  it "should create a new item" do
+    bear = @zoo.exhibits.create( :name => "Bear" )
+    bear.should be_kind_of(Exhibit)
+    @zoo.exhibits.should include(bear)
+  end
+
+  it "should save the item when creating" do
+    bear = @zoo.exhibits.create( :name => "Bear" )
+    bear.should_not be_new_record
+  end
+
+  it "should set the association to a saved target when added with <<" do    
+    pirahna = Exhibit.new(:name => "Pirahna")
+    pirahna.zoo_id.should be_nil
+    
+    @zoo.exhibits << pirahna
+    pirahna.zoo.should == @zoo
+  end
+  
+  it "should set the association to a non-saved target when added with <<" do
+    zoo = Zoo.new(:name => "My Zoo")
+    kangaroo = Exhibit.new(:name => "Kangaroo")
+    zoo.exhibits << kangaroo
+    kangaroo.zoo.should == zoo
+  end
+  
+  it "should set the id of the exhibit when the associated zoo is saved" do
+    snake = Exhibit.new(:name => "Snake")
+    @zoo.exhibits << snake
+    @zoo.save
+    @zoo.id.should == snake.zoo_id
+  end
+  
+  it "should set the id of an already saved exibit if it's added to a different zoo" do
+    beaver = Exhibit.new(:name => "Beaver")
+    beaver.save
+    beaver.should_not be_a_new_record
+    @zoo.exhibits << beaver
+    @zoo.save
+    beaver.zoo.should == @zoo
+    beaver.zoo_id.should == @zoo.id    
+  end
+  
+  it "should set the size of the assocation" do
+    @zoo.exhibits << Exhibit.new(:name => "anonymous")
+    @zoo.exhibits.size.should == 1
+  end
+  
+  it "should give the association when an inspect is done on it" do
+    whale = Exhibit.new(:name => "Whale")
+    @zoo.exhibits << whale
+    @zoo.exhibits.should_not == "nil"
+    @zoo.exhibits.inspect.should_not be_nil
+  end
+  
+  it "should generate the SQL for a join statement" do
+    fruit_association = database(:mock).schema[Animal].associations.find { |a| a.name == :favourite_fruit }
+  
+    fruit_association.to_sql.should == <<-EOS.compress_lines
+      JOIN `fruit` ON `fruit`.`devourer_id` = `animals`.`id`
+    EOS
+  end
+
+  it "is assigned a devourer_id" do
+    bob = Animal.new(:name => 'bob')
+    fruit = Fruit.first
+    bob.favourite_fruit = fruit
+    
+    bob.save
+    
+    bob.reload!
+    fruit.devourer_id.should eql(bob.id)
+    bob.favourite_fruit.should == fruit
+    
+    fruit.reload!
+    fruit.devourer_of_souls.should == bob
+  end
+end