datamapper 0.1.1 → 0.2.0

data/spec/attributes_spec.rb

@@ -0,0 +1,15 @@
+describe DataMapper::Base do
+    
+  it 'should allow mass-assignment of attributes' do
+    zoo = Zoo.new(:name => 'MassAssignment', :notes => 'This is a test.')
+    
+    zoo.name.should eql('MassAssignment')
+    zoo.notes.should eql('This is a test.')
+    
+    zoo.attributes = { :name => 'ThroughAttributesEqual', :notes => 'This is another test.' }
+    
+    zoo.name.should eql('ThroughAttributesEqual')
+    zoo.notes.should eql('This is another test.')
+  end
+  
+end

data/spec/base_spec.rb

@@ -0,0 +1,44 @@
+describe DataMapper::Base do
+  
+  it "attributes method should load all lazy-loaded values" do
+    Animal.first(:name => 'Cup').attributes[:notes].should == 'I am a Cup!'
+  end
+  
+  it "mass assignment should call methods" do
+    class Animal
+      attr_reader :test
+      def test=(value)
+        @test = value + '!'
+      end
+    end
+    
+    a = Animal.new(:test => 'testing')
+    a.test.should == 'testing!'
+  end
+  
+end
+
+describe 'A new record' do
+  
+  before(:each) do
+    @bob = Person.new(:name => 'Bob', :age => 30, :occupation => 'Sales')
+  end
+  
+  it 'should be dirty' do
+    @bob.dirty?.should == true
+  end
+  
+  it 'set attributes should be dirty' do
+    attributes = @bob.attributes.dup.reject { |k,v| k == :id }
+    @bob.dirty_attributes.should == { :name => 'Bob', :age => 30, :occupation => 'Sales' }
+  end
+  
+  it 'should be marked as new' do
+    @bob.new_record?.should == true
+  end
+  
+  it 'should have a nil id' do
+    @bob.id.should == nil
+  end
+  
+end

data/spec/callbacks_spec.rb

@@ -0,0 +1,45 @@
+describe DataMapper::Callbacks do
+  
+  it "should allow for a callback to be set, then called" do
+    
+    example = Class.new do
+      include DataMapper::CallbacksHelper
+      
+      attr_accessor :name
+      
+      def initialize(name)
+        @name = name
+      end
+      
+      before_save 'name = "bob"'
+      before_validation { |instance| instance.name = 'Barry White Returns!' }
+
+    end.new('Barry White')
+    
+    example.class::callbacks.execute(:before_save, example)
+    example.name.should == 'Barry White'
+    
+    example.class::callbacks.execute(:before_validation, example)
+    example.name.should == 'Barry White Returns!'
+  end
+  
+  it "should allow method delegation by passing symbols to the callback definitions" do
+    
+    example = Class.new do
+      include DataMapper::CallbacksHelper
+      
+      attr_accessor :name
+      
+      before_save :test
+      
+      def test
+        @name = 'Walter'
+      end
+    end.new
+    
+    example.class::callbacks.execute(:before_save, example)
+    example.name.should == 'Walter'
+    
+  end
+  
+end

data/spec/can_has_sphinx.rb

@@ -0,0 +1,6 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+
+describe DataMapper::Plugins::CanHasSphinx do
+  
+end

data/spec/coersion_spec.rb

@@ -0,0 +1,34 @@
+describe DataMapper::Adapters::Sql::Coersion do
+  
+  before(:all) do
+    @coersive = Class.new do
+      include DataMapper::Adapters::Sql::Coersion
+    end.new
+  end
+  
+  it 'should cast to a BigDecimal' do
+    target = BigDecimal.new('7.2')
+    @coersive.type_cast_decimal('7.2').should == target
+    @coersive.type_cast_decimal(7.2).should == target
+  end
+  
+  it 'should store and load a date' do
+    dob = Date::today
+    bob = Person.create(:name => 'DateCoersionTest', :date_of_birth => dob)
+    
+    bob2 = Person[:name => 'DateCoersionTest']
+    
+    bob.date_of_birth.should eql(dob)
+    bob.date_of_birth.should eql(bob2.date_of_birth)
+  end
+  
+  it 'should cast to a Date' do
+    target = Date.civil(2001, 1, 1)
+    
+    @coersive.type_cast_date('2001-1-1').should eql(target)
+    @coersive.type_cast_date(target.dup).should eql(target)
+    @coersive.type_cast_date(DateTime::parse('2001-1-1')).should eql(target)
+    @coersive.type_cast_date(Time::parse('2001-1-1')).should eql(target)
+  end
+  
+end

data/spec/conditions_spec.rb

@@ -0,0 +1,49 @@
+describe DataMapper::Adapters::Sql::Commands::Conditions do
+  
+  def conditions_for(klass, options = {})
+    session = database(:mock)
+    DataMapper::Adapters::Sql::Commands::LoadCommand.new(
+      session.adapter, session, klass, options
+    ).conditions
+  end
+  
+  it 'empty? should be false if conditions are present' do
+    conditions_for(Zoo, :name => 'Galveston').empty?.should == false
+  end
+  
+  it 'should map implicit option names to field names' do
+    conditions_for(Zoo, :name => 'Galveston').to_parameterized_sql.should == ["(`name` = ?)", 'Galveston']
+  end
+  
+  it 'should qualify with table name when using a join' do
+    conditions = conditions_for(Zoo, :name => 'Galveston', :include => :exhibits)
+    conditions.to_parameterized_sql.should == ["(`zoos`.`name` = ?)", 'Galveston']
+  end
+  
+  it 'should use Symbol::Operator to determine operator' do
+    conditions_for(Person, :age.gt => 28).to_parameterized_sql.should == ["(`age` > ?)", 28]
+    conditions_for(Person, :age.gte => 28).to_parameterized_sql.should == ["(`age` >= ?)", 28]
+    
+    conditions_for(Person, :age.lt => 28).to_parameterized_sql.should == ["(`age` < ?)", 28]
+    conditions_for(Person, :age.lte => 28).to_parameterized_sql.should == ["(`age` <= ?)", 28]
+    
+    conditions_for(Person, :age.not => 28).to_parameterized_sql.should == ["(`age` <> ?)", 28]
+    conditions_for(Person, :age.eql => 28).to_parameterized_sql.should == ["(`age` = ?)", 28]
+    
+    conditions_for(Person, :name.like => 'S%').to_parameterized_sql.should == ["(`name` LIKE ?)", 'S%']
+    
+    conditions_for(Person, :age.in => [ 28, 29 ]).to_parameterized_sql.should == ["(`age` IN ?)", [ 28, 29 ]]
+  end
+  
+  it 'should use an IN clause for an Array' do
+    conditions = conditions_for(Person, :age => [ 28, 29 ])
+    conditions.to_parameterized_sql.should == ["(`age` IN ?)", [ 28, 29 ]]
+  end
+  
+  it 'should use "not" for not-equal operations' do
+    conditions_for(Person, :name.not => 'Bob').to_parameterized_sql.should == ["(`name` <> ?)", 'Bob']
+    conditions_for(Person, :name.not => nil).to_parameterized_sql.should == ["(`name` IS NOT ?)", nil]
+    conditions_for(Person, :name.not => ['Sam', 'Bob']).to_parameterized_sql.should == ["(`name` NOT IN ?)", ['Sam', 'Bob']]
+  end
+
+end

data/spec/conversions_to_yaml_spec.rb

@@ -0,0 +1,17 @@
+describe "Conversion to YAML" do
+  # check each model to see if the conversion *.to_yaml works.
+  Dir[File.dirname(__FILE__) + "/fixtures/*.yaml"].each do |path|
+
+    name = File::basename(path).sub(/\.yaml$/, '')
+    klass = Kernel::const_get(Inflector.classify(Inflector.singularize(name)))
+    
+    it "the first #{klass} converted to YAML should match the YAML in the fixture" do
+
+      YAML::load(klass.first.to_yaml).to_a.reject do |pair|
+        pair.first == "updated_at" || pair.first == "id"
+      end.sort.should == YAML::load_file("./spec/fixtures/#{name}.yaml")[0].to_a.sort
+      
+    end
+    
+  end
+end

data/spec/count_command_spec.rb

@@ -0,0 +1,11 @@
+describe DataMapper::Adapters::AbstractAdapter do
+    
+  before(:all) do
+    fixtures(:zoos)
+  end
+
+  it "should return a count of the selected table" do
+    Zoo.count.should be_a_kind_of(Integer)
+    Zoo.count.should == Zoo.all.size
+  end
+end

data/spec/delete_command_spec.rb

@@ -1,4 +1,4 @@
-describe DataMapper::Adapters::Sql::Commands::DeleteCommand do
+describe "Delete Command" do
   
   it "should drop and create the table" do
     database.schema[Zoo].drop!.should == true

data/spec/embedded_value_spec.rb

@@ -0,0 +1,23 @@
+describe DataMapper::EmbeddedValue do
+    
+  before(:all) do
+    @bob = Person[:name => 'Bob']
+  end
+  
+  it 'should proxy getting values for you' do
+    @bob.address.street.should == '123 Happy Ln.'
+  end
+  
+  it 'should return a sub-class of the containing class' do
+    @bob.address.class.should be(Person::Address)
+  end
+  
+  it 'should allow definition of instance methods' 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'
+  end
+  
+end

data/spec/fixtures/animals_exhibits.yaml

@@ -0,0 +1,2 @@
+- animal_id: 1
+  exhibit_id: 5

data/spec/fixtures/people.yaml

@@ -1,15 +1,32 @@
 - name: Sam
   age: 29
   occupation: Programmer
+  type: Person
+  street: 1337 Duck Way
+  city: Galveston
+  state: TX
+  zip_code: "75000"
+  notes: 
+  date_of_birth: 2007-10-24T22:48:51-05:00
 - name: Amy
   age: 28
   occupation: Business Analyst Manager
+  type: Person
 - name: Scott
   age: 25
   occupation: Programmer
+  type: SalesPerson
+  commission: 172
 - name: Josh
   age: 23
   occupation: Supervisor
+  type:
 - name: Bob
   age: 29
-  occupation: Peon
+  occupation: Peon
+  street: 123 Happy Ln.
+  city: Dallas
+  state: TX
+  zip_code: 75000
+  type: SalesPerson
+  commission: 40

data/spec/{legacy.rb → legacy_spec.rb}

@@ -1,10 +1,10 @@
-context 'Legacy Database' do
+describe 'Legacy mappings' do
   
-  specify('should allow models to map with custom attribute names') do
+  it('should allow models to map with custom attribute names') do
     Fruit.first.name.should == 'Kiwi'
   end
   
-  specify('should allow custom foreign-key mappings') do
+  it('should allow custom foreign-key mappings') do
     database do
       Fruit[:name => 'Watermelon'].devourer_of_souls.should == Animal[:name => 'Cup']
       Animal[:name => 'Cup'].favourite_fruit.should == Fruit[:name => 'Watermelon']

data/spec/load_command_spec.rb

@@ -4,41 +4,178 @@ describe DataMapper::Adapters::Sql::Commands::LoadCommand do
     fixtures(:zoos)
   end
   
+  def loader_for(klass, options = {})
+    session = database(:mock)
+    DataMapper::Adapters::Sql::Commands::LoadCommand.new(session.adapter, session, klass, options)
+  end
+  
   it "should return a Struct for custom queries" do
     results = database.query("SELECT * FROM zoos WHERE name = ?", 'Galveston')
     zoo = results.first
-    zoo.class.superclass.should == DataMapper::Support::Struct
+    zoo.class.superclass.should == Struct
     zoo.name.should == "Galveston"
   end
-  
-end
 
-describe DataMapper::Adapters::Sql::Commands::AdvancedLoadCommand do
-  
-  def loader_for(klass, options = {})
-    session = database
-    DataMapper::Adapters::Sql::Commands::AdvancedLoadCommand.new(session.adapter, session, klass, options)
-  end
-  
   it "should return a simple select statement for a given class" do
-    loader_for(Zoo).to_sql.should == 'SELECT `id`, `name` FROM `zoos`'
+    loader_for(Zoo).to_parameterized_sql.first.should == 'SELECT `id`, `name`, `updated_at` FROM `zoos`'
   end
-  
+
   it "should include only the columns specified in the statement" do
-    loader_for(Zoo, :select => [:name]).to_sql.should == 'SELECT `name` FROM `zoos`'
+    loader_for(Zoo, :select => [:name]).to_parameterized_sql.first.should == 'SELECT `name` FROM `zoos`'
   end
-  
+
   it "should optionally include lazy-loaded columns in the statement" do
-    loader_for(Zoo, :include => :notes).to_sql.should == 'SELECT `id`, `name`, `notes` FROM `zoos`'
+    loader_for(Zoo, :include => :notes).to_parameterized_sql.first.should == 'SELECT `id`, `name`, `updated_at`, `notes` FROM `zoos`'
   end
-  
+
   it "should join associations in the statement" do
-    loader_for(Zoo, :include => :exhibits2).to_sql.should == <<-EOS.compress_lines
-      SELECT `zoos`.`id`, `zoos`.`name`,
+    loader_for(Zoo, :include => :exhibits).to_parameterized_sql.first.should == <<-EOS.compress_lines
+      SELECT `zoos`.`id`, `zoos`.`name`, `zoos`.`updated_at`,
         `exhibits`.`id`, `exhibits`.`name`, `exhibits`.`zoo_id`
       FROM `zoos`
-      JOIN `exhibits` ON `exhibits`.`cow_id` = `zoos`.`id`
+      JOIN `exhibits` ON `exhibits`.`zoo_id` = `zoos`.`id`
     EOS
   end
+
+  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`,
+        `exhibits`.`id`, `exhibits`.`name`, `exhibits`.`zoo_id`,
+        `animals_exhibits`.`animal_id`, `animals_exhibits`.`exhibit_id`
+      FROM `animals`
+      JOIN `animals_exhibits` ON `animals_exhibits`.`animal_id` = `animals`.`id`
+      JOIN `exhibits` ON `exhibits`.`id` = `animals_exhibits`.`exhibit_id`
+    EOS
+  end
+  
+  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`,
+        `animals_exhibits`.`animal_id`, `animals_exhibits`.`exhibit_id`
+      FROM `animals`
+      JOIN `animals_exhibits` ON `animals_exhibits`.`animal_id` = `animals`.`id`
+    EOS
+  end
+  
+  it "should allow multiple implicit conditions" do
+    expected_sql = <<-EOS.compress_lines
+      SELECT `id`, `name`, `age`, `occupation`,
+        `type`, `street`, `city`, `state`, `zip_code`
+      FROM `people`
+      WHERE (`name` = ?) AND (`age` = ?)
+    EOS
+    
+    # NOTE: I'm actually not sure how to test this since the order of the parameters isn't gauranteed.
+    # Maybe an ugly OrderedHash passed as the options...
+    # loader_for(Person, :name => 'Sam', :age => 29).to_parameterized_sql.should == [expected_sql, 'Sam', 29]
+  end
+  
+  it "should allow block-interception during load" do
+    result = false
+    Person.first(:intercept_load => lambda { result = true })
+    result.should == true
+  end
   
-end if ENV['ADAPTER'].nil? || ENV['ADAPTER'] == 'mysql'
+  it 'database-specific load should not fail' do
+
+     DataMapper::database do |db|
+       froggy = db.first(Animal, :conditions => ['name = ?', 'Frog'])
+       froggy.name.should == 'Frog'
+     end
+
+   end
+
+   it 'current-database load should not fail' do
+     froggy = DataMapper::database.first(Animal).name.should == 'Frog'
+   end
+
+   it 'load through ActiveRecord impersonation should not fail' do
+     Animal.find(:all).size.should == 16
+   end
+
+   it 'load through Og impersonation should not fail' do
+     Animal.all.size.should == 16
+   end
+
+   it ':conditions option should accept a hash' do
+     Animal.all(:conditions => { :name => 'Frog' }).size.should == 1
+   end
+
+   it 'non-standard options should be considered part of the conditions' do
+     database.log.debug { 'non-standard options should be considered part of the conditions' }
+     zebra = Animal.first(:name => 'Zebra')
+     zebra.name.should == 'Zebra'
+
+     elephant = Animal[:name => 'Elephant']
+     elephant.name.should == 'Elephant'
+
+     aged = Person.all(:age => 29)
+     aged.size.should == 2
+     aged.first.name.should == 'Sam'
+     aged.last.name.should == 'Bob'
+
+     fixtures(:animals)
+   end
+
+   it 'should not find deleted objects' do
+     database do
+       wally = Animal[:name => 'Whale']
+       wally.new_record?.should == false
+       wally.destroy!.should == true
+
+       wallys_evil_twin = Animal[:name => 'Whale']
+       wallys_evil_twin.should == nil
+
+       wally.new_record?.should == true
+       wally.save
+       wally.new_record?.should == false
+
+       Animal[:name => 'Whale'].should == wally
+     end
+   end
+
+   it 'lazy-loads should issue for whole sets' do
+     people = Person.all
+
+     people.each do |person|
+       person.notes
+     end
+   end
+
+   it "should only query once" do
+     database do
+       zoo = Zoo.first
+       same_zoo = Zoo[zoo.id]
+       
+       zoo.should == same_zoo
+     end
+   end
+   
+   it "should return a single object" do
+     Zoo.first.should be_a_kind_of(Zoo)
+     Zoo[1].should be_a_kind_of(Zoo)
+     Zoo.find(1).should be_a_kind_of(Zoo)
+   end
+   
+   it "should be able to search on UTF-8 strings" do
+     Zoo.create(:name => 'Danish Vowels: Smøøt!')
+     Zoo.first(:name.like => '%Smøøt%').should be_a_kind_of(Zoo)
+   end
+end
+
+=begin
+context 'Sub-selection' do
+  
+  specify 'should return a Cup' do
+    Animal[:id.select => { :name => 'cup' }].name.should == 'Cup'
+  end
+  
+  specify 'should return all exhibits for Galveston zoo' do
+    Exhibit.all(:zoo_id.select(Zoo) => { :name => 'Galveston' }).size.should == 3
+  end
+  
+  specify 'should allow a sub-select in the select-list' do
+    Animal[:select => [ :id.count ]]
+  end
+end
+=end