activerecord 1.10.1 → 1.11.0

data/test/lifecycle_test.rb

@@ -1,6 +1,7 @@
 require 'abstract_unit'
 require 'fixtures/topic'
 require 'fixtures/developer'
+require 'fixtures/reply'
 
 class Topic; def after_find() end end
 class Developer; def after_find() end end
@@ -54,9 +55,7 @@ class MultiObserver < ActiveRecord::Observer
 end
 
 class LifecycleTest < Test::Unit::TestCase
-  def setup
-    @topics, @developers = create_fixtures("topics", "developers")
-  end
+  fixtures :topics, :developers
 
   def test_before_destroy
     assert_equal 2, Topic.count
@@ -106,4 +105,4 @@ class LifecycleTest < Test::Unit::TestCase
     developer = Developer.find(1)    
     assert_equal multi_observer.record.name, developer.name
   end
-end
+end

data/test/locking_test.rb

@@ -2,9 +2,7 @@ require 'abstract_unit'
 require 'fixtures/person'
 
 class LockingTest < Test::Unit::TestCase
-  def setup
-    @people = create_fixtures('people')
-  end
+  fixtures :people
 
   def test_lock_existing
     p1 = Person.find(1)
@@ -31,4 +29,4 @@ class LockingTest < Test::Unit::TestCase
       p2.save
     }
   end 
-end
+end

data/test/migration_test.rb

@@ -0,0 +1,186 @@
+require 'abstract_unit'
+require 'fixtures/person'
+require File.dirname(__FILE__) + '/fixtures/migrations/1_people_have_last_names'
+require File.dirname(__FILE__) + '/fixtures/migrations/2_we_need_reminders'
+
+if ActiveRecord::Base.connection.supports_migrations? 
+
+  class Reminder < ActiveRecord::Base; end
+
+  class MigrationTest < Test::Unit::TestCase
+    def setup
+    end
+
+    def teardown
+      ActiveRecord::Base.connection.initialize_schema_information
+      ActiveRecord::Base.connection.update "UPDATE schema_info SET version = 0"
+
+      Reminder.connection.drop_table("reminders") rescue nil
+      Reminder.connection.drop_table("people_reminders") rescue nil
+      Reminder.reset_column_information
+
+      Person.connection.remove_column("people", "last_name") rescue nil
+      Person.connection.remove_column("people", "bio") rescue nil
+      Person.connection.remove_column("people", "age") rescue nil
+      Person.connection.remove_column("people", "height") rescue nil
+      Person.connection.remove_column("people", "birthday") rescue nil
+      Person.connection.remove_column("people", "favorite_day") rescue nil
+      Person.connection.remove_column("people", "male") rescue nil
+      Person.connection.remove_column("people", "administrator") rescue nil
+      Person.reset_column_information
+    end
+    
+    def test_add_index
+      Person.connection.add_column "people", "last_name", :string        
+      
+      assert_nothing_raised { Person.connection.add_index("people", "last_name") }
+      assert_nothing_raised { Person.connection.remove_index("people", "last_name") }
+
+      assert_nothing_raised { Person.connection.add_index("people", ["last_name", "first_name"]) }
+      assert_nothing_raised { Person.connection.remove_index("people", "last_name") }
+    end
+  
+    def test_native_types
+      Person.delete_all
+      Person.connection.add_column "people", "last_name", :string
+      Person.connection.add_column "people", "bio", :text
+      Person.connection.add_column "people", "age", :integer
+      Person.connection.add_column "people", "height", :float
+      Person.connection.add_column "people", "birthday", :datetime
+      Person.connection.add_column "people", "favorite_day", :date
+      Person.connection.add_column "people", "male", :boolean
+      assert_nothing_raised { Person.create :first_name => 'bob', :last_name => 'bobsen', :bio => "I was born ....", :age => 18, :height => 1.78, :birthday => 18.years.ago, :favorite_day => 10.days.ago, :male => true }
+      bob = Person.find(:first)
+        
+      assert_equal bob.first_name, 'bob'
+      assert_equal bob.last_name, 'bobsen'
+      assert_equal bob.bio, "I was born ...."
+      assert_equal bob.age, 18
+      assert_equal bob.male?, true
+    
+      assert_equal String, bob.first_name.class
+      assert_equal String, bob.last_name.class
+      assert_equal String, bob.bio.class
+      assert_equal Fixnum, bob.age.class
+      assert_equal Time, bob.birthday.class
+      assert_equal Date, bob.favorite_day.class
+      assert_equal TrueClass, bob.male?.class
+    end
+
+    def test_add_remove_single_field
+      assert !Person.column_methods_hash.include?(:last_name)
+
+      PeopleHaveLastNames.up
+
+      Person.reset_column_information
+      assert Person.column_methods_hash.include?(:last_name)
+    
+      PeopleHaveLastNames.down
+
+      Person.reset_column_information
+      assert !Person.column_methods_hash.include?(:last_name)
+    end
+    
+    def test_add_rename
+      Person.delete_all
+            
+      Person.connection.add_column "people", "girlfriend", :string      
+      Person.create :girlfriend => 'bobette'      
+      
+      begin
+        Person.connection.rename_column "people", "girlfriend", "exgirlfriend"
+      
+        Person.reset_column_information      
+        bob = Person.find(:first)
+      
+        assert_equal "bobette", bob.exgirlfriend
+      ensure
+        Person.connection.remove_column("people", "girlfriend") rescue nil
+        Person.connection.remove_column("people", "exgirlfriend") rescue nil
+      end
+      
+    end
+    
+    def test_change_column
+      Person.connection.add_column "people", "bio", :string
+      assert_nothing_raised { Person.connection.change_column "people", "bio", :text }
+    end    
+
+    def test_change_column_with_new_default
+      Person.connection.add_column "people", "administrator", :boolean, :default => 1
+      Person.reset_column_information            
+      assert Person.new.administrator?
+      
+      assert_nothing_raised { Person.connection.change_column "people", "administrator", :boolean, :default => 0 }
+      Person.reset_column_information            
+      assert !Person.new.administrator?
+    end    
+
+    def test_add_table
+      assert_raises(ActiveRecord::StatementInvalid) { Reminder.column_methods_hash }
+    
+      WeNeedReminders.up
+    
+      assert Reminder.create("content" => "hello world", "remind_at" => Time.now)
+      assert_equal "hello world", Reminder.find(:first).content
+    
+      WeNeedReminders.down
+      assert_raises(ActiveRecord::StatementInvalid) { Reminder.find(:first) }
+    end
+
+    def test_migrator
+      assert !Person.column_methods_hash.include?(:last_name)
+      assert_raises(ActiveRecord::StatementInvalid) { Reminder.column_methods_hash }
+
+      ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/')
+
+      assert_equal 3, ActiveRecord::Migrator.current_version
+      Person.reset_column_information
+      assert Person.column_methods_hash.include?(:last_name)
+      assert Reminder.create("content" => "hello world", "remind_at" => Time.now)
+      assert_equal "hello world", Reminder.find(:first).content
+
+      ActiveRecord::Migrator.down(File.dirname(__FILE__) + '/fixtures/migrations/')
+
+      assert_equal 0, ActiveRecord::Migrator.current_version
+      Person.reset_column_information
+      assert !Person.column_methods_hash.include?(:last_name)
+      assert_raises(ActiveRecord::StatementInvalid) { Reminder.find(:first) }
+    end
+
+    def test_migrator_one_up
+      assert !Person.column_methods_hash.include?(:last_name)
+      assert_raises(ActiveRecord::StatementInvalid) { Reminder.column_methods_hash }
+
+      ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/', 1)
+
+      Person.reset_column_information
+      assert Person.column_methods_hash.include?(:last_name)
+      assert_raises(ActiveRecord::StatementInvalid) { Reminder.column_methods_hash }
+
+
+      ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/', 2)
+
+      assert Reminder.create("content" => "hello world", "remind_at" => Time.now)
+      assert_equal "hello world", Reminder.find(:first).content
+    end
+  
+    def test_migrator_one_down
+      ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/')
+    
+      ActiveRecord::Migrator.down(File.dirname(__FILE__) + '/fixtures/migrations/', 1)
+
+      Person.reset_column_information
+      assert Person.column_methods_hash.include?(:last_name)
+      assert_raises(ActiveRecord::StatementInvalid) { Reminder.column_methods_hash }
+    end
+  
+    def test_migrator_one_up_one_down
+      ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/', 1)
+      ActiveRecord::Migrator.down(File.dirname(__FILE__) + '/fixtures/migrations/', 0)
+
+      assert !Person.column_methods_hash.include?(:last_name)
+      assert_raises(ActiveRecord::StatementInvalid) { Reminder.column_methods_hash }
+    end
+  end
+end

data/test/mixin_nested_set_test.rb

@@ -143,41 +143,41 @@ class MixinNestedSetTest < Test::Unit::TestCase
   def test_deleting_root
     NestedSetWithStringScope.find(4001).destroy
     
-    assert( NestedSetWithStringScope.find_all.length == 0 )
+    assert( NestedSetWithStringScope.count == 0 )
   end            
                                
   def test_common_usage
-    @set_1.add_child( @set_2 )
-    assert_equal( 1, @set_1.direct_children.length )
+    mixins(:set_1).add_child( mixins(:set_2) )
+    assert_equal( 1, mixins(:set_1).direct_children.length )
 
-    @set_2.add_child( @set_3 )                      
-    assert_equal( 1, @set_1.direct_children.length )     
+    mixins(:set_2).add_child( mixins(:set_3) )                      
+    assert_equal( 1, mixins(:set_1).direct_children.length )     
     
     # Local cache is now out of date!
     # Problem: the update_alls update all objects up the tree
-    @set_1.reload
-    assert_equal( 2, @set_1.all_children.length )              
-    
-    assert_equal( 1, @set_1.lft )
-    assert_equal( 2, @set_2.lft )
-    assert_equal( 3, @set_3.lft )
-    assert_equal( 4, @set_3.rgt )
-    assert_equal( 5, @set_2.rgt )
-    assert_equal( 6, @set_1.rgt )
+    mixins(:set_1).reload
+    assert_equal( 2, mixins(:set_1).all_children.length )              
+    
+    assert_equal( 1, mixins(:set_1).lft )
+    assert_equal( 2, mixins(:set_2).lft )
+    assert_equal( 3, mixins(:set_3).lft )
+    assert_equal( 4, mixins(:set_3).rgt )
+    assert_equal( 5, mixins(:set_2).rgt )
+    assert_equal( 6, mixins(:set_1).rgt )
           
-    assert( @set_1.root? )
+    assert( mixins(:set_1).root? )
                   
     begin
-      @set_4.add_child( @set_1 )
+      mixins(:set_4).add_child( mixins(:set_1) )
       fail
     rescue
     end
     
-    assert_equal( 2, @set_1.all_children.length )
+    assert_equal( 2, mixins(:set_1).all_children.length )
     
-    @set_1.add_child @set_4
+    mixins(:set_1).add_child mixins(:set_4)
 
-    assert_equal( 3, @set_1.all_children.length )
+    assert_equal( 3, mixins(:set_1).all_children.length )
 
 
   end

data/test/mixin_test.rb

@@ -9,68 +9,68 @@ class ListTest < Test::Unit::TestCase
  
   def test_reordering
     
-    assert_equal [@mixins['list_1'].find, 
-                  @mixins['list_2'].find, 
-                  @mixins['list_3'].find, 
-                  @mixins['list_4'].find], 
-                  ListMixin.find_all("parent_id=5", "pos")
+    assert_equal [mixins(:list_1), 
+                  mixins(:list_2), 
+                  mixins(:list_3), 
+                  mixins(:list_4)], 
+                  ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos')
                   
-    @mixins['list_2'].find.move_lower
+    mixins(:list_2).move_lower
                   
-    assert_equal [@mixins['list_1'].find, 
-                  @mixins['list_3'].find, 
-                  @mixins['list_2'].find, 
-                  @mixins['list_4'].find], 
-                  ListMixin.find_all("parent_id=5", "pos")                      
+    assert_equal [mixins(:list_1), 
+                  mixins(:list_3), 
+                  mixins(:list_2), 
+                  mixins(:list_4)], 
+                  ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos')
                   
-    @mixins['list_2'].find.move_higher
+    mixins(:list_2).move_higher
 
-    assert_equal [@mixins['list_1'].find, 
-                  @mixins['list_2'].find, 
-                  @mixins['list_3'].find, 
-                  @mixins['list_4'].find], 
-                  ListMixin.find_all("parent_id=5", "pos")
+    assert_equal [mixins(:list_1), 
+                  mixins(:list_2), 
+                  mixins(:list_3), 
+                  mixins(:list_4)], 
+                  ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos')
     
-    @mixins['list_1'].find.move_to_bottom
+    mixins(:list_1).move_to_bottom
 
-    assert_equal [@mixins['list_2'].find, 
-                  @mixins['list_3'].find, 
-                  @mixins['list_4'].find, 
-                  @mixins['list_1'].find], 
-                  ListMixin.find_all("parent_id=5", "pos")
+    assert_equal [mixins(:list_2), 
+                  mixins(:list_3), 
+                  mixins(:list_4), 
+                  mixins(:list_1)], 
+                  ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos')
 
-    @mixins['list_1'].find.move_to_top
+    mixins(:list_1).move_to_top
 
-    assert_equal [@mixins['list_1'].find, 
-                  @mixins['list_2'].find, 
-                  @mixins['list_3'].find, 
-                  @mixins['list_4'].find],
-                  ListMixin.find_all("parent_id=5", "pos")
+    assert_equal [mixins(:list_1), 
+                  mixins(:list_2), 
+                  mixins(:list_3), 
+                  mixins(:list_4)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos')
                   
                   
-    @mixins['list_2'].find.move_to_bottom
+    mixins(:list_2).move_to_bottom
   
-    assert_equal [@mixins['list_1'].find, 
-                  @mixins['list_3'].find, 
-                  @mixins['list_4'].find, 
-                  @mixins['list_2'].find],
-                  ListMixin.find_all("parent_id=5", "pos")                  
-
-    @mixins['list_4'].find.move_to_top
-
-    assert_equal [@mixins['list_4'].find, 
-                  @mixins['list_1'].find, 
-                  @mixins['list_3'].find, 
-                  @mixins['list_2'].find],
-                  ListMixin.find_all("parent_id=5", "pos")                  
+    assert_equal [mixins(:list_1), 
+                  mixins(:list_3), 
+                  mixins(:list_4), 
+                  mixins(:list_2)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos')
+
+    mixins(:list_4).move_to_top
+
+    assert_equal [mixins(:list_4), 
+                  mixins(:list_1), 
+                  mixins(:list_3), 
+                  mixins(:list_2)],
+                  ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos')
         
   end
   
   def test_next_prev
-    assert_equal @list_2, @list_1.lower_item
-    assert_nil @list_1.higher_item
-    assert_equal @list_3, @list_4.higher_item
-    assert_nil @list_4.lower_item
+    assert_equal mixins(:list_2), mixins(:list_1).lower_item
+    assert_nil mixins(:list_1).higher_item
+    assert_equal mixins(:list_3), mixins(:list_4).higher_item
+    assert_nil mixins(:list_4).lower_item
   end
   
   
@@ -130,31 +130,31 @@ class ListTest < Test::Unit::TestCase
   
   def test_delete_middle
     
-    assert_equal [@mixins['list_1'].find, 
-                  @mixins['list_2'].find, 
-                  @mixins['list_3'].find, 
-                  @mixins['list_4'].find], 
-                  ListMixin.find_all("parent_id=5", "pos")
+    assert_equal [mixins(:list_1), 
+                  mixins(:list_2), 
+                  mixins(:list_3), 
+                  mixins(:list_4)], 
+                  ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos')
               
-    @mixins['list_2'].find.destroy
+    mixins(:list_2).destroy
     
-    assert_equal [@mixins['list_1'].find, 
-                  @mixins['list_3'].find, 
-                  @mixins['list_4'].find], 
-                  ListMixin.find_all("parent_id=5", "pos")
+    assert_equal [mixins(:list_1, :reload), 
+                  mixins(:list_3, :reload), 
+                  mixins(:list_4, :reload)], 
+                  ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos')
                   
-    assert_equal 1, @mixins['list_1'].find.pos
-    assert_equal 2, @mixins['list_3'].find.pos
-    assert_equal 3, @mixins['list_4'].find.pos
+    assert_equal 1, mixins(:list_1).pos
+    assert_equal 2, mixins(:list_3).pos
+    assert_equal 3, mixins(:list_4).pos
 
-    @mixins['list_1'].find.destroy
+    mixins(:list_1).destroy
 
-    assert_equal [@mixins['list_3'].find, 
-                  @mixins['list_4'].find], 
-                  ListMixin.find_all("parent_id=5", "pos")
+    assert_equal [mixins(:list_3, :reload), 
+                  mixins(:list_4, :reload)], 
+                  ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos')
                   
-    assert_equal 1, @mixins['list_3'].find.pos
-    assert_equal 2, @mixins['list_4'].find.pos
+    assert_equal 1, mixins(:list_3).pos
+    assert_equal 2, mixins(:list_4).pos
     
   end  
 
@@ -168,7 +168,7 @@ class ListTest < Test::Unit::TestCase
   def test_nil_scope
     new1, new2, new3 = ListMixin.create, ListMixin.create, ListMixin.create
     new2.move_higher
-    assert_equal [new2, new1, new3], ListMixin.find_all("parent_id IS NULL", "pos")
+    assert_equal [new2, new1, new3], ListMixin.find(:all, :conditions => 'parent_id IS NULL', :order => 'pos')
   end
 end
 
@@ -176,42 +176,42 @@ class TreeTest < Test::Unit::TestCase
   fixtures :mixins
   
   def test_has_child
-    assert_equal true, @tree_1.has_children?
-    assert_equal true, @tree_2.has_children?
-    assert_equal false, @tree_3.has_children?
-    assert_equal false, @tree_4.has_children?
+    assert_equal true, mixins(:tree_1).has_children?
+    assert_equal true, mixins(:tree_2).has_children?
+    assert_equal false, mixins(:tree_3).has_children?
+    assert_equal false, mixins(:tree_4).has_children?
   end
 
   def test_children
-    assert_equal @tree_1.children, [@tree_2, @tree_4]
-    assert_equal @tree_2.children, [@tree_3]
-    assert_equal @tree_3.children, []
-    assert_equal @tree_4.children, []
+    assert_equal mixins(:tree_1).children, [mixins(:tree_2), mixins(:tree_4)]
+    assert_equal mixins(:tree_2).children, [mixins(:tree_3)]
+    assert_equal mixins(:tree_3).children, []
+    assert_equal mixins(:tree_4).children, []
   end
 
   def test_parent
-    assert_equal @tree_2.parent, @tree_1
-    assert_equal @tree_2.parent, @tree_4.parent
-    assert_nil @tree_1.parent
+    assert_equal mixins(:tree_2).parent, mixins(:tree_1)
+    assert_equal mixins(:tree_2).parent, mixins(:tree_4).parent
+    assert_nil mixins(:tree_1).parent
   end
   
   def test_delete
     assert_equal 4, TreeMixin.count
-    @tree_1.destroy
+    mixins(:tree_1).destroy
     assert_equal 0, TreeMixin.count
   end
   
   def test_insert
-    @extra = @tree_1.children.create
+    @extra = mixins(:tree_1).children.create
     
     assert @extra
     
-    assert_equal @extra.parent, @tree_1
+    assert_equal @extra.parent, mixins(:tree_1)
 
-    assert_equal 3, @tree_1.children.size
-    assert @tree_1.children.include?(@extra)
-    assert @tree_1.children.include?(@tree_2)
-    assert @tree_1.children.include?(@tree_4)
+    assert_equal 3, mixins(:tree_1).children.size
+    assert mixins(:tree_1).children.include?(@extra)
+    assert mixins(:tree_1).children.include?(mixins(:tree_2))
+    assert mixins(:tree_1).children.include?(mixins(:tree_4))
   end
 
 end
@@ -258,9 +258,9 @@ class TouchTest < Test::Unit::TestCase
   def test_create_turned_off
     Mixin.record_timestamps = false
 
-    assert_nil @tree_1.updated_at
-    @tree_1.save
-    assert_nil @tree_1.updated_at
+    assert_nil mixins(:tree_1).updated_at
+    mixins(:tree_1).save
+    assert_nil mixins(:tree_1).updated_at
 
     Mixin.record_timestamps = true
   end