datamapper 0.2.5 → 0.3.0

data/spec/load_command_spec.rb

@@ -1,5 +1,53 @@
 require File.dirname(__FILE__) + "/spec_helper"
 
+describe DataMapper::Adapters::Sql::Commands::LoadCommand do
+  
+  def conditions_for(klass, options = {})
+    database_context = database(:mock)
+    DataMapper::Adapters::Sql::Commands::LoadCommand.new(
+      database_context.adapter, database_context, klass, options
+    ).conditions
+  end
+  
+  it 'empty? should be false if conditions are present' do
+    conditions_for(Zoo, :name => 'Galveston').should_not be_empty
+  end
+  
+  it 'should map implicit option names to field names' do
+    conditions_for(Zoo, :name => 'Galveston').should eql([["`name` = ?", 'Galveston']])
+  end
+  
+  it 'should qualify with table name when using a join' do
+    conditions_for(Zoo, :name => 'Galveston', :include => :exhibits).should eql([["`zoos`.`name` = ?", 'Galveston']])
+  end
+  
+  it 'should use Symbol::Operator to determine operator' do
+    conditions_for(Person, :age.gt => 28).should eql([["`age` > ?", 28]])
+    conditions_for(Person, :age.gte => 28).should eql([["`age` >= ?", 28]])
+    
+    conditions_for(Person, :age.lt => 28).should eql([["`age` < ?", 28]])
+    conditions_for(Person, :age.lte => 28).should eql([["`age` <= ?", 28]])
+    
+    conditions_for(Person, :age.not => 28).should eql([["`age` <> ?", 28]])
+    conditions_for(Person, :age.eql => 28).should eql([["`age` = ?", 28]])
+    
+    conditions_for(Person, :name.like => 'S%').should eql([["`name` LIKE ?", 'S%']])
+    
+    conditions_for(Person, :age.in => [ 28, 29 ]).should eql([["`age` IN ?", [ 28, 29 ]]])
+  end
+  
+  it 'should use an IN clause for an Array' do
+    conditions_for(Person, :age => [ 28, 29 ]).should eql([["`age` IN ?", [ 28, 29 ]]])
+  end
+  
+  it 'should use "not" for not-equal operations' do
+    conditions_for(Person, :name.not => 'Bob').should eql([["`name` <> ?", 'Bob']])
+    conditions_for(Person, :name.not => nil).should eql([["`name` IS NOT ?", nil]])
+    conditions_for(Person, :name.not => ['Sam', 'Bob']).should eql([["`name` NOT IN ?", ['Sam', 'Bob']]])
+  end
+
+end
+
 describe DataMapper::Adapters::Sql::Commands::LoadCommand do
   
   before(:all) do
@@ -202,14 +250,20 @@ describe DataMapper::Adapters::Sql::Commands::LoadCommand do
      end
   end
    
-   it "should return in order" do
-     fixtures(:posts)
-          
-     one = Post.first
-     one.title.should eql('One')
-     two = one.next
-     two.title.should eql('Two')
-     one.next.next.previous.previous.next.previous.next.next.title.should eql('Three')
+   # it "should return in order" do
+   #   pending("This spec is silly, and nothing but trouble since it depends on the table's clustered index. :-p")
+   #   fixtures(:posts)
+   #        
+   #   one = Post.first
+   #   one.title.should eql('One')
+   #   two = one.next
+   #   two.title.should eql('Two')
+   #   one.next.next.previous.previous.next.previous.next.next.title.should eql('Three')
+   # end
+   
+   it "should allow both implicit :conditions and explicit in the same finder" do
+     cup = Animal.first(:name => 'Cup', :conditions => ['name <> ?', 'Frog'])
+     cup.should == Animal[cup.key]
    end
    
    it "should iterate in batches" do
@@ -221,7 +275,15 @@ describe DataMapper::Adapters::Sql::Commands::LoadCommand do
        count += 1
      end
      
-     count.should == total     
+     count.should == total
+     
+     count = 0
+     
+     Animal.each(:order => "id asc", :conditions => ["id > ? AND id < ?", 0, 9985], :limit => 2) do |animal|
+       count += 1
+     end
+     
+     count.should == total
    end
    
    it "should get the right object back" do

data/spec/magic_columns_spec.rb

@@ -1,11 +1,26 @@
 require File.dirname(__FILE__) + "/spec_helper"
 
 describe "Magic Columns" do
-  
+
   it "should update updated_at on save" do
     zoo = Zoo.new(:name => 'Mary')
     zoo.save
     zoo.updated_at.should be_a_kind_of(Time)
   end
-  
+
+  it "should not update created_at when updating a model" do
+    section = Section.create(:title => "Mars")
+    old_created_at = section.created_at
+    section.update_attributes(:title => "Mars2!")
+    section.created_at.should eql(old_created_at)
+  end
+
+  it "should not set the created_at/on fields if already set on creation" do
+    section = Section.new(:title => "Mars")
+    fixed_created_at = Time::now - 2600
+    section.created_at = fixed_created_at
+    section.save
+    section.created_at.should eql(fixed_created_at)
+  end
+
 end

data/spec/migration_spec.rb

@@ -0,0 +1,267 @@
+require File.dirname(__FILE__) + "/spec_helper"
+require File.dirname(__FILE__) + "/../lib/data_mapper/migration"
+
+class MigrationUser
+  include DataMapper::Persistence
+  
+  property :name, :string
+  property :login, :string
+  
+end
+
+def check_schema
+  case ENV['ADAPTER']
+  when 'postgresql'
+    result = database.query("
+    SELECT table_name, column_name FROM information_schema.columns WHERE table_name = 'migration_users'
+    ").join(", ")
+    result.blank? ? nil : result
+  when 'mysql'
+    begin
+      database.query("SHOW CREATE TABLE migration_users")[0]["create table"]
+    rescue Exception => e
+      raise e unless e.message.match(/Table.*doesn\'t exist/)
+    end
+  else
+    database.query("
+    SELECT sql FROM
+       (SELECT * FROM sqlite_master UNION ALL
+        SELECT * FROM sqlite_temp_master)
+    WHERE name = 'migration_users'
+    ORDER BY substr(type,2,1), name
+    ")[0]
+  end
+end
+
+describe DataMapper::Migration do
+  
+  class AddUsers < DataMapper::Migration
+    def self.up
+      table :migration_users do # sees that the users table does not exist and so creates the table
+        add :name, :string
+        add :login, :string
+      end
+    end
+
+    def self.down
+      table.drop :migration_users
+    end
+  end
+
+  class AddPasswordToUsers < DataMapper::Migration
+    def self.up
+      table :migration_users do
+        add :password, :string
+      end
+    end
+
+    def self.down
+      table :migration_users do
+        remove :password
+      end
+    end
+  end
+
+  class RenameLoginOnUsers < DataMapper::Migration
+    def self.up
+      table :migration_users do
+        rename :login, :username
+      end
+    end
+
+    def self.down
+      table :migration_users do
+        rename :username, :login
+      end
+    end
+  end
+  
+  class AlterLoginOnUsers < DataMapper::Migration
+    def self.up
+      table :migration_users do
+        alter :login, :text, :nullable => false, :default => "username"
+      end
+    end
+    
+    def self.down
+      table :migration_users do
+        alter :login, :string
+      end
+    end
+  end
+  
+  it "should migrate up creating a table with its columns" do
+    AddUsers.migrate(:up)
+    database.table_exists?(MigrationUser).should be_true
+    check_schema.should match(/migration_users/)
+    check_schema.should match(/name|login/)
+    user = MigrationUser.new(:name => "test", :login => "username")
+    user.save.should be_true
+    MigrationUser.first.should == user
+  end
+  
+  it "should migrate down deleting the created table" do
+    AddUsers.migrate(:down)
+    check_schema.should be_nil
+    database.table_exists?(MigrationUser).should == false
+  end
+  
+  it "should migrate up altering a table to add a column" do
+    AddUsers.migrate(:up)
+    AddPasswordToUsers.migrate(:up)
+    table = database.table(MigrationUser)
+    table[:password].should_not be_nil
+  end
+  
+  it "should migrate down altering a table to remove a column" do
+    check_schema.should match(/password/)
+    AddPasswordToUsers.migrate(:down)
+    check_schema.should_not match(/password/)
+    table = database.table(MigrationUser)
+    table[:password].should be_nil
+    AddUsers.migrate(:down)
+  end
+  
+  it "should migrate up renaming a column" do
+    AddUsers.migrate(:up)
+    user = MigrationUser.create(:name => "Sam", :login => "sammy")
+    RenameLoginOnUsers.migrate(:up)
+    class MigrationUser
+      property :username, :string
+    end
+    check_schema.should match(/username/)
+    check_schema.should_not match(/login/)
+    MigrationUser.first.username.should == user.login
+  end
+  
+  it "should migrate down renaming a column" do
+    user = MigrationUser.first
+    RenameLoginOnUsers.migrate(:down)
+    check_schema.should_not match(/username/)
+    check_schema.should match(/login/)
+    MigrationUser.first.login.should == user.username
+    AddUsers.migrate(:down)
+  end
+  
+  it "should migrate up altering a column" do
+    AddUsers.migrate(:up)
+    AlterLoginOnUsers.migrate(:up)
+    column = database.table(MigrationUser)[:login]
+    column.type.should == :text
+    column.nullable?.should be_false
+    column.default.should == "username"
+  end
+  
+  it "should migrate down altering a column" do
+    AlterLoginOnUsers.migrate(:down)
+    column = database.table(MigrationUser)[:login]
+    column.type.should == :string
+    column.nullable?.should be_true
+    column.default.should be_nil
+    AddUsers.migrate(:down)
+  end
+end
+
+describe "DataMapper::Migration [RAILS]" do
+  class RailsAddUsers < DataMapper::Migration
+    def self.up
+      create_table :migration_users do |t|
+        t.column :name, :string
+        t.column :login, :string
+      end
+    end
+  
+    def self.down
+      drop_table :migration_users
+    end
+  end
+
+  class RailsAddPasswordToUsers < DataMapper::Migration
+    def self.up
+      add_column :migration_users, :password, :string
+    end
+  
+    def self.down
+      remove_column :migration_users, :password
+    end
+  end
+  
+  class RailsRenameLoginOnUsers < DataMapper::Migration
+    def self.up
+      rename_column :migration_users, :login, :username
+    end
+
+    def self.down
+      rename_column :migration_users, :username, :login
+    end
+  end
+  
+  class RailsAlterLoginOnUsers < DataMapper::Migration
+    def self.up
+      change_column :migration_users, :login, :text, :nullable => false, :default => "username"
+    end
+    
+    def self.down
+      change_column :migration_users, :login, :string
+    end
+  end
+  
+  it "should migrate up creating a table with its columns" do
+    RailsAddUsers.migrate(:up)
+    database.table_exists?(MigrationUser).should be_true
+    check_schema.should match(/migration_users/)
+    check_schema.should match(/name|login/)
+  end
+  
+  it "should migrate down deleting the created table" do
+    RailsAddUsers.migrate(:down)
+    database.table_exists?(MigrationUser).should be_false
+    check_schema.should be_nil
+  end
+  
+  it "should migrate up altering a table to add a column" do
+    RailsAddUsers.migrate(:up)
+    RailsAddPasswordToUsers.migrate(:up)
+    check_schema.should match(/password/)
+  end
+  
+  it "should migrate down altering a table to remove a column" do
+    RailsAddPasswordToUsers.migrate(:down)
+    check_schema.should_not match(/password/)
+    table = database.table(MigrationUser)
+    table[:password].should be_nil
+    RailsAddUsers.migrate(:down)
+  end
+  
+  it "should migrate up renaming a column" do
+    RailsAddUsers.migrate(:up)
+    RailsRenameLoginOnUsers.migrate(:up)
+    check_schema.should match(/username/)
+    check_schema.should_not match(/login/)
+  end
+  
+  it "should migrate down renaming a column" do
+    RailsRenameLoginOnUsers.migrate(:down)
+    check_schema.should match(/login/)
+    check_schema.should_not match(/username/)
+    RailsAddUsers.migrate(:down)
+  end
+  
+  it "should migrate up altering a column" do
+    AddUsers.migrate(:up)
+    RailsAlterLoginOnUsers.migrate(:up)
+    column = database.table(MigrationUser)[:login]
+    column.type.should == :text
+    column.nullable?.should be_false
+    column.default.should == "username"
+  end
+  
+  it "should migrate down altering a column" do
+    RailsAlterLoginOnUsers.migrate(:down)
+    column = database.table(MigrationUser)[:login]
+    column.type.should == :string
+    column.nullable?.should be_true
+    column.default.should be_nil
+    AddUsers.migrate(:down)
+  end
+end

data/spec/models/animal.rb

@@ -1,4 +1,4 @@
-class Animal #< DataMapper::Base
+class Animal #< DataMapper::Base # please do not remove this
   include DataMapper::Persistence
 
   property :name, :string, :default => "No Name", :index => :unique

data/spec/models/candidate.rb

@@ -0,0 +1,8 @@
+class Candidate #< DataMapper::Base # please do not remove this
+  include DataMapper::Persistence
+
+  property :name, :string
+
+  belongs_to :job
+  has_and_belongs_to_many :applications, :class => 'Job', :join_table => "applications_candidates"
+end

data/spec/models/career.rb

@@ -1,4 +1,4 @@
-class Career #< DataMapper::Base
+class Career #< DataMapper::Base # please do not remove this
   include DataMapper::Persistence
   
   property :name, :string, :key => true

data/spec/models/chain.rb

@@ -0,0 +1,8 @@
+class Chain #< DataMapper::Base # please do not remove this
+  include DataMapper::Persistence
+
+  property :name, :string
+
+  belongs_to :fence
+  #has_and_belongs_to_many :chains   # do not remove this
+end

data/spec/models/comment.rb

@@ -1,4 +1,4 @@
-class Comment #< DataMapper::Base
+class Comment #< DataMapper::Base # please do not remove this
   include DataMapper::Persistence
   
   property   :comment, :text, :lazy => false

data/spec/models/exhibit.rb

@@ -1,4 +1,4 @@
-class Exhibit #< DataMapper::Base
+class Exhibit #< DataMapper::Base # please do not remove this
   include DataMapper::Persistence
   
   property :name, :string

data/spec/models/fence.rb

@@ -0,0 +1,7 @@
+class Fence #< DataMapper::Base # please do not remove this
+  include DataMapper::Persistence
+
+  property :name, :string
+
+  #has_many :chains    # do not remove
+end