datamapper 0.2.3 → 0.2.4

data/spec/base_spec.rb

@@ -25,6 +25,13 @@ describe DataMapper::Base do
     x.should be_dirty
   end
   
+  it "should be dirty when set to nil" do
+    x = Person.create(:name => 'a')
+    x.should_not be_dirty
+    x.name = "asdfasfd"
+    x.should be_dirty    
+  end
+  
   it "should return a diff" do
     x = Person.new(:name => 'Sam', :age => 30, :occupation => 'Programmer')
     y = Person.new(:name => 'Amy', :age => 21, :occupation => 'Programmer')
@@ -46,6 +53,30 @@ describe DataMapper::Base do
     x.should_not be_dirty
   end 
   
+  it "should return the table for a given model" do
+    Person.table.should be_a_kind_of(DataMapper::Adapters::Sql::Mappings::Table)
+  end
+  
+  it "should support boolean accessors" do
+    dolphin = Animal.first(:name => 'Dolphin')
+    dolphin.should be_nice
+  end
+
+  it "should be comparable" do
+    p1 = Person.create(:name => 'Sam')
+    p2 = Person[p1.id]
+
+    p1.should == p2
+  end
+
+  it "should not be equal if attributes have changed" do
+    p1 = Person.create(:name => 'Sam')
+    p2 = Person[p1.id]
+    p2.name = "Paul"
+
+    p1.should_not == p2
+  end
+
 end
 
 describe 'A new record' do
@@ -71,4 +102,161 @@ describe 'A new record' do
     @bob.id.should == nil
   end
   
-end
+  it "should not have dirty attributes when not dirty" do
+    x = Person.create(:name => 'a')
+    x.should_not be_dirty
+    x.dirty_attributes.should be_empty
+  end
+  
+  it "should only list attributes that have changed in the dirty attributes hash" do
+    x = Person.create(:name => 'a')
+    x.name = "asdfr"
+    x.should be_dirty
+    x.dirty_attributes.keys.should == [:name]
+  end
+  
+  it "should not have original_values when a new record" do
+    x = Person.new(:name => 'a')
+    x.original_values.should be_empty
+  end
+  
+  it "should have original_values after saved" do
+    x = Person.new(:name => 'a')
+    x.save
+    x.original_values.should_not be_empty
+    x.original_values.keys.should include(:name)
+    x.original_values[:name].should == 'a'
+  end
+  
+  it "should have original values when created" do
+    x = Person.create(:name => 'a')
+    x.original_values.should_not be_empty
+    x.original_values.keys.should include(:name)
+    x.original_values[:name].should == "a"
+  end
+  
+  it "should have original values when loaded from the database" do
+    Person.create(:name => 'a')
+    x = Person[:name => 'a']
+    x.original_values.should_not be_empty
+    x.original_values.keys.should include(:name)
+    x.original_values[:name].should == "a"
+  end
+  
+  it "should reset the original values when not new, changed then saved" do
+    x = Person.create(:name => 'a')
+    x.should_not be_new_record
+    x.original_values[:name].should == "a"
+    x.name = "b"
+    x.save
+    x.original_values[:name].should == "b"
+  end
+  
+  it "should allow a value to be set to nil" do
+    x = Person.create(:name => 'a')
+    x.name = nil
+    x.save
+    x.reload!
+    x.name.should be_nil    
+  end
+
+end
+
+describe 'Properties' do
+
+  it 'should default to public method visibility' do
+    class SoftwareEngineer < DataMapper::Base
+      set_table_name 'people'
+      property :name, :string
+    end
+
+    public_properties = SoftwareEngineer.public_instance_methods.select { |m| ["name", "name="].include?(m) }
+    public_properties.length.should == 2
+  end
+
+  it 'should respect protected property options' do
+    class SanitationEngineer < DataMapper::Base
+      set_table_name 'people'
+      property :name, :string, :reader => :protected
+      property :age, :integer, :writer => :protected
+    end
+
+    protected_properties = SanitationEngineer.protected_instance_methods.select { |m| ["name", "age="].include?(m) }
+    protected_properties.length.should == 2
+  end
+
+  it 'should respect private property options' do
+    class ElectricalEngineer < DataMapper::Base
+      set_table_name 'people'
+      property :name, :string, :reader => :private
+      property :age, :integer, :writer => :private
+    end
+
+    private_properties = ElectricalEngineer.private_instance_methods.select { |m| ["name", "age="].include?(m) }
+    private_properties.length.should == 2
+  end
+
+  it 'should set both reader and writer visibiliy when accessor option is passed' do
+    class TrainEngineer < DataMapper::Base
+      property :name, :string, :accessor => :private
+    end
+
+    private_properties = TrainEngineer.private_instance_methods.select { |m| ["name", "name="].include?(m) }
+    private_properties.length.should == 2
+  end
+
+  it 'should only be listed in attributes if they have public getters' do
+    class SalesEngineer < DataMapper::Base
+      set_table_name 'people'
+      property :name, :string
+      property :age, :integer, :reader => :private
+    end
+
+    @sam = SalesEngineer[: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
+      set_table_name 'people'
+      property :name, :string, :writer => :private
+      property :age, :integer
+    end
+
+    @sam = ChemicalEngineer[: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
+      set_table_name 'people'
+      property :name, :string, :protected => true
+    end
+
+    CivilEngineer.public_instance_methods.should include("name")
+    CivilEngineer.protected_instance_methods.should include("name=")
+  end
+
+  it 'should allow :private to be passed as an alias for a public reader, private writer' do
+    class AudioEngineer < DataMapper::Base
+      set_table_name 'people'
+      property :name, :string, :private => true
+    end
+
+    AudioEngineer.public_instance_methods.should include("name")
+    AudioEngineer.private_instance_methods.should include("name=")
+  end
+  
+  it 'should raise an error when invalid options are passsed' do
+    lambda do
+      class JumpyCow < DataMapper::Base
+        set_table_name 'animals'
+        property :name, :string, :laze => true
+      end
+    end.should raise_error(ArgumentError)
+  end
+
+end

data/spec/column_spec.rb

@@ -2,22 +2,100 @@ require File.dirname(__FILE__) + "/spec_helper"
 
 describe DataMapper::Adapters::Sql::Mappings::Column do
   
+  before(:all) do
+    fixtures(:zoos)
+  end
+
+  it "should only lazy loading text columns by default" do
+    table = database.table(Zoo)
+    table.columns.each do  |column|
+      if column.type == :text
+        column.should be_lazy
+      else
+        column.should_not be_lazy
+      end
+    end
+  end
+  
   it "should be unique within a set" do
     
     mappings = DataMapper::Adapters::Sql::Mappings
     
     columns = SortedSet.new
-
-    columns << mappings::Column.new(database(:mock).adapter, nil, :one, :string, 1)
-    columns << mappings::Column.new(database(:mock).adapter, nil, :two, :string, 2)
-    columns << mappings::Column.new(database(:mock).adapter, nil, :three, :string, 3)
+    
+    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.should have(3).entries
     
-    columns << mappings::Column.new(database(:mock).adapter, nil, :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, nil, :id, :integer, -1)
+    columns << mappings::Column.new(database(:mock).adapter, table, :id, :integer, -1)
     columns.should have(4).entries
   end
   
-end
+  it "should get its meta data from the database"
+  
+  it "should be able to rename" do
+    table = database.table(Zoo)
+    name_column = table[:name]
+    
+    lambda { database.query("SELECT name FROM zoos") }.should_not raise_error
+    lambda { database.query("SELECT moo FROM zoos") }.should raise_error
+    
+    name_column.rename!(:moo).should eql(true)
+    name_column.name.should eql(:moo)
+    
+    lambda { database.query("SELECT name FROM zoos") }.should raise_error
+    lambda { database.query("SELECT moo FROM zoos") }.should_not raise_error
+    
+    name_column.rename!(:name)
+    name_column.name.should eql(:name)
+    
+    lambda { database.query("SELECT name FROM zoos") }.should_not raise_error
+    lambda { database.query("SELECT moo FROM zoos") }.should raise_error
+  end
+  
+  it "should create, alter and drop a column" do
+    lambda { database.query("SELECT moo FROM zoos") }.should raise_error
+    
+    database.logger.debug { 'MOO' * 10 }
+    
+    table = database.table(Zoo)
+    Zoo.property(:moo, :string)
+    moo = table[:moo]
+    moo.create!
+    
+    lambda { database.query("SELECT moo FROM zoos") }.should_not raise_error
+    
+    zoo = Zoo.create(:name => 'columns', :moo => 'AAA')
+    zoo.moo.should eql('AAA')
+    
+    zoo.moo = 4
+    zoo.save
+    zoo.reload!
+    zoo.moo.should eql('4')
+    
+    moo.type = :integer
+    moo.alter!
+    zoo.reload!
+    zoo.moo.should eql(4)
+    
+    moo.drop!
+    
+    Zoo.send(:undef_method, :moo)
+    Zoo.send(:undef_method, :moo=)
+    
+    lambda { database.query("SELECT moo FROM zoos") }.should raise_error
+  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.size.should == 11    
+  end
+  
+end

data/spec/conditions_spec.rb

@@ -3,9 +3,9 @@ require File.dirname(__FILE__) + "/spec_helper"
 describe DataMapper::Adapters::Sql::Commands::LoadCommand do
   
   def conditions_for(klass, options = {})
-    session = database(:mock)
+    database_context = database(:mock)
     DataMapper::Adapters::Sql::Commands::LoadCommand.new(
-      session.adapter, session, klass, options
+      database_context.adapter, database_context, klass, options
     ).conditions
   end
   

data/spec/dependency_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe DataMapper::Base 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|
+      klass.should eql(Object.const_get('HappyCow'))
+      database.table(klass).key.name.should eql(:name)
+      $happy_cow_defined = true
+    end
+    
+    class HappyCow < DataMapper::Base
+      property :name, :string, :key => true
+    end
+    
+    # Dependencies are not resolved until you try to access the key for a table...
+    database.table(HappyCow).key
+    
+    raise 'Dependency not called for HappyCow :-(' unless $happy_cow_defined
+  end
+  
+end

data/spec/embedded_value_spec.rb

@@ -18,8 +18,128 @@ describe DataMapper::EmbeddedValue do
     @bob.address.city_state_zip_code.should == 'Dallas, TX 75000'
   end
   
-  it 'should allow you to use your own classes as well as long as they inherit from EmbeddedValue' do
-    @bob.location.to_s.should == 'Dallas, TX'
+  it 'should not require prefix' do
+    class PointyHeadedBoss < DataMapper::Base
+      set_table_name 'people'
+      property :name, :string
+
+      embed :address do
+        # don't provide a prefix option to embed
+        # so the column names of these properties gets nothing auto-prepended
+        property :address_street, :string
+        property :address_city, :string
+      end
+    end
+
+    @sam = PointyHeadedBoss[: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
+      set_table_name 'people'
+      property :name, :string
+
+      embed :address, :prefix => true do
+        property :street, :string
+        property :city, :string
+      end
+    end
+
+    @sam = Employee[:name => 'Sam']
+    @sam.address_street.should == '1337 Duck Way'
   end
+
+  it 'should support lazy loading of embedded properties' do
+    class Human < DataMapper::Base
+      set_table_name 'people'
+      property :name, :string
+
+      embed :address, :lazy => true, :prefix => true do
+        property :street, :string
+        property :city, :string
+      end
+    end
+
+    @sam = Human[:name => 'Sam']
+    @sam.address.street.should == '1337 Duck Way'
+  end
+
+  it 'should default to public method visibility for all' do
+    class SoftwareEngineer < DataMapper::Base
+      set_table_name 'people'
+      property :name, :string
+
+      embed :address, :prefix => true do
+        property :city, :string
+      end
+    end
+
+    @sam = SoftwareEngineer[: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
+      set_table_name 'people'
+      property :name, :string
+
+      embed :address, :reader => :protected, :prefix => true do
+        property :city, :string
+        property :street, :string
+      end
+    end
+
+    @sam = SanitationEngineer[: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
+      set_table_name 'people'
+      property :name, :string, :reader => :private
+
+      embed :address, :writer => :private, :prefix => true do
+        property :city, :string
+        property :street, :string
+      end
+    end
+
+    @sam = ElectricalEngineer[: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
+      set_table_name 'people'
+      property :name, :string, :reader => :private
   
-end
+      embed :address, :accessor => :private, :prefix => true do
+        property :city, :string
+      end
+    end
+
+    @sam = TrainEngineer[: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
+      set_table_name 'people'
+      property :name, :string
+
+      embed :address, :accessor => :private, :prefix => true do
+        property :city, :string
+        property :street, :string, :accessor => :public
+      end
+    end
+
+    @sam = ChemicalEngineer[:name => 'Sam']
+    public_properties = @sam.address.class.public_instance_methods.select { |m| ["street", "street="].include?(m) }
+    public_properties.length.should == 2
+  end
+end

data/spec/fixtures/animals.yaml

@@ -22,6 +22,7 @@
   notes: I am a Whale!
 - name: Dolphin
   notes: I am a Dolphin!
+  nice: true
 - name: Mouse
   notes: I am a Mouse!
 - name: Rat

data/spec/fixtures/careers.yaml

@@ -0,0 +1,5 @@
+---
+- name: Programmer
+- name: Business Analyst Manager
+- name: Peon
+- name: Supervisor

data/spec/fixtures/comments.yaml

@@ -0,0 +1 @@
+--- []

data/spec/fixtures/people.yaml

@@ -2,31 +2,36 @@
   age: 29
   occupation: Programmer
   type: Person
-  street: 1337 Duck Way
-  city: Galveston
-  state: TX
-  zip_code: "75000"
+  address_street: 1337 Duck Way
+  address_city: Galveston
+  adresss_state: TX
+  address_zip_code: "75000"
   notes: 
   date_of_birth: 2007-10-24
+  career_name: Programmer
 - name: Amy
   age: 28
   occupation: Business Analyst Manager
   type: Person
+  career_name: Business Analyst Manager
 - name: Scott
   age: 25
   occupation: Programmer
   type: SalesPerson
   commission: 172
+  career_name: Programmer
 - name: Josh
   age: 23
   occupation: Supervisor
   type:
+  career_name: Supervisor
 - name: Bob
   age: 29
   occupation: Peon
-  street: 123 Happy Ln.
-  city: Dallas
-  state: TX
-  zip_code: 75000
+  address_street: 123 Happy Ln.
+  address_city: Dallas
+  address_state: TX
+  address_zip_code: 75000
   type: SalesPerson
-  commission: 40
+  commission: 40
+  career_name: Peon

data/spec/fixtures/projects.yaml

@@ -0,0 +1,4 @@
+--- 
+- id: 1
+  title: Test
+  description: 

data/spec/fixtures/sections.yaml

@@ -0,0 +1,5 @@
+--- 
+- id: 1
+  title: Main
+  created_at: 2007-12-08T11:31:08-06:00
+  project_id: 1

data/spec/fixtures/serializers.yaml

@@ -0,0 +1,6 @@
+--- 
+- id: 1
+  content: 
+    :second: dos
+    :first: 1
+    :third: 3.0

data/spec/fixtures/users.yaml

@@ -0,0 +1 @@
+--- []

data/spec/load_command_spec.rb

@@ -4,11 +4,12 @@ describe DataMapper::Adapters::Sql::Commands::LoadCommand do
   
   before(:all) do
     fixtures(:zoos)
+    fixtures(:animals)
   end
   
   def loader_for(klass, options = {})
-    session = database(:mock)
-    DataMapper::Adapters::Sql::Commands::LoadCommand.new(session.adapter, session, klass, options)
+    database_context = database(:mock)
+    DataMapper::Adapters::Sql::Commands::LoadCommand.new(database_context.adapter, database_context, klass, options)
   end
   
   it "should return a Struct for custom queries" do
@@ -41,7 +42,7 @@ describe DataMapper::Adapters::Sql::Commands::LoadCommand do
 
   it "should join has and belongs to many associtions in the statement" do
     loader_for(Animal, :include => :exhibits).to_parameterized_sql.first.should == <<-EOS.compress_lines
-      SELECT `animals`.`id`, `animals`.`name`,
+      SELECT `animals`.`id`, `animals`.`name`, `animals`.`nice`,
         `exhibits`.`id`, `exhibits`.`name`, `exhibits`.`zoo_id`,
         `animals_exhibits`.`animal_id`, `animals_exhibits`.`exhibit_id`
       FROM `animals`
@@ -52,7 +53,7 @@ describe DataMapper::Adapters::Sql::Commands::LoadCommand do
   
   it "should shallow-join unmapped tables for has-and-belongs-to-many in the statement" do
     loader_for(Animal, :shallow_include => :exhibits).to_parameterized_sql.first.should == <<-EOS.compress_lines
-      SELECT `animals`.`id`, `animals`.`name`,
+      SELECT `animals`.`id`, `animals`.`name`, `animals`.`nice`,
         `animals_exhibits`.`animal_id`, `animals_exhibits`.`exhibit_id`
       FROM `animals`
       JOIN `animals_exhibits` ON `animals_exhibits`.`animal_id` = `animals`.`id`

data/spec/mock_adapter.rb

@@ -7,10 +7,10 @@ class MockAdapter < DataMapper::Adapters::DataObjectAdapter
   def delete(instance_or_klass, options = nil)
   end
   
-  def save(session, instance)
+  def save(database_context, instance)
   end
   
-  def load(session, klass, options)
+  def load(database_context, klass, options)
   end
   
   def table_exists?(name)

data/spec/models/animal.rb

@@ -1,6 +1,7 @@
 class Animal < DataMapper::Base
-  property :name, :string
+  property :name, :string, :default => "No Name"
   property :notes, :text
+  property :nice, :boolean
   
   has_one :favourite_fruit, :class => 'Fruit', :foreign_key => 'devourer_id'
   has_and_belongs_to_many :exhibits

data/spec/models/animals_exhibit.rb

@@ -1,6 +1,6 @@
 # This is just here to get around the fact I use a Class to load
 # fixtures right now.
 class AnimalsExhibit < DataMapper::Base
-  property :animal_id, :integer, :key => true, :serial => false
-  property :exhibit_id, :integer
+  property :animal_id, :integer, :key => true
+  property :exhibit_id, :integer, :key => true
 end

data/spec/models/career.rb

@@ -0,0 +1,6 @@
+class Career < DataMapper::Base
+  
+  property :name, :string, :key => true
+  
+  has_many :followers, :class => 'Person'
+end

data/spec/models/comment.rb

@@ -0,0 +1,4 @@
+class Comment < DataMapper::Base
+  property   :comment, :text, :lazy => false
+  belongs_to :author, :class => 'User', :foreign_key => 'user_id'
+end

data/spec/models/exhibit.rb

@@ -1,7 +1,11 @@
 class Exhibit < DataMapper::Base
   property :name, :string
   
+  begin
   validates_presence_of :name
+  rescue ArgumentError => e
+    throw e unless e.message =~ /specify a unique key/
+  end
   
   belongs_to :zoo
   has_and_belongs_to_many :animals