activerecord 1.11.1 → 1.12.1

data/test/lifecycle_test.rb

@@ -5,6 +5,7 @@ require 'fixtures/reply'
 
 class Topic; def after_find() end end
 class Developer; def after_find() end end
+class SpecialDeveloper < Developer; end
 
 class TopicManualObserver
   include Singleton
@@ -64,22 +65,22 @@ class LifecycleTest < Test::Unit::TestCase
   end
   
   def test_after_save
-    topic_observer = TopicManualObserver.instance
+    ActiveRecord::Base.observers = :topic_manual_observer
 
     topic = Topic.find(1)
     topic.title = "hello"
     topic.save
     
-    assert topic_observer.has_been_notified?
-    assert_equal :after_save, topic_observer.callbacks.last["callback_method"]
+    assert TopicManualObserver.instance.has_been_notified?
+    assert_equal :after_save, TopicManualObserver.instance.callbacks.last["callback_method"]
   end
   
   def test_observer_update_on_save
-    topic_observer = TopicManualObserver.instance
+    ActiveRecord::Base.observers = TopicManualObserver
 
     topic = Topic.find(1)    
-    assert topic_observer.has_been_notified?
-    assert_equal :after_find, topic_observer.callbacks.first["callback_method"]
+    assert TopicManualObserver.instance.has_been_notified?
+    assert_equal :after_find, TopicManualObserver.instance.callbacks.first["callback_method"]
   end
   
   def test_auto_observer
@@ -105,4 +106,11 @@ class LifecycleTest < Test::Unit::TestCase
     developer = Developer.find(1)    
     assert_equal multi_observer.record.name, developer.name
   end
+  
+  def test_observing_subclasses
+    multi_observer = MultiObserver.instance
+
+    developer = SpecialDeveloper.find(1)
+    assert_equal multi_observer.record.name, developer.name
+  end
 end

data/test/migration_test.rb

@@ -8,12 +8,14 @@ if ActiveRecord::Base.connection.supports_migrations?
   class Reminder < ActiveRecord::Base; end
 
   class MigrationTest < Test::Unit::TestCase
+    self.use_transactional_fixtures = false
+
     def setup
     end
 
     def teardown
       ActiveRecord::Base.connection.initialize_schema_information
-      ActiveRecord::Base.connection.update "UPDATE schema_info SET version = 0"
+      ActiveRecord::Base.connection.update "UPDATE #{ActiveRecord::Migrator.schema_info_table_name} SET version = 0"
 
       Reminder.connection.drop_table("reminders") rescue nil
       Reminder.connection.drop_table("people_reminders") rescue nil
@@ -32,12 +34,75 @@ if ActiveRecord::Base.connection.supports_migrations?
     
     def test_add_index
       Person.connection.add_column "people", "last_name", :string        
+      Person.connection.add_column "people", "administrator", :boolean
       
       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") }
+
+      assert_nothing_raised { Person.connection.add_index("people", %w(last_name first_name administrator), :name => "named_admin") }
+      assert_nothing_raised { Person.connection.remove_index("people", :name => "named_admin") }
+    end
+
+    def test_create_table_adds_id
+      Person.connection.create_table :testings do |t|
+        t.column :foo, :string
+      end
+
+      assert_equal %w(foo id),
+        Person.connection.columns(:testings).map { |c| c.name }.sort
+    ensure
+      Person.connection.drop_table :testings rescue nil
+    end
+
+    def test_create_table_with_not_null_column
+      Person.connection.create_table :testings do |t|
+        t.column :foo, :string, :null => false
+      end
+
+      assert_raises(ActiveRecord::StatementInvalid) do
+        Person.connection.execute "insert into testings (foo) values (NULL)"
+      end
+    ensure
+      Person.connection.drop_table :testings rescue nil
+    end
+
+    def test_create_table_with_defaults
+      Person.connection.create_table :testings do |t|
+        t.column :one, :string, :default => "hello"
+        t.column :two, :boolean, :default => true
+        t.column :three, :boolean, :default => false
+        t.column :four, :integer, :default => 1
+      end
+
+      columns = Person.connection.columns(:testings)
+      one = columns.detect { |c| c.name == "one" }
+      two = columns.detect { |c| c.name == "two" }
+      three = columns.detect { |c| c.name == "three" }
+      four = columns.detect { |c| c.name == "four" }
+
+      assert_equal "hello", one.default
+      assert_equal true, two.default
+      assert_equal false, three.default
+      assert_equal 1, four.default
+
+    ensure
+      Person.connection.drop_table :testings rescue nil
+    end
+  
+    def test_add_column_not_null
+      Person.connection.create_table :testings do |t|
+        t.column :foo, :string
+      end
+      Person.connection.add_column :testings, :bar, :string, :null => false
+
+      assert_raises(ActiveRecord::StatementInvalid) do
+        Person.connection.execute "insert into testings (foo, bar) values ('hello', NULL)"
+      end
+    ensure
+      Person.connection.drop_table :testings rescue nil
     end
   
     def test_native_types
@@ -67,15 +132,29 @@ if ActiveRecord::Base.connection.supports_migrations?
       assert_equal TrueClass, bob.male?.class
     end
 
-    def test_add_remove_single_field
+    def test_add_remove_single_field_using_string_arguments
       assert !Person.column_methods_hash.include?(:last_name)
 
-      PeopleHaveLastNames.up
+      ActiveRecord::Migration.add_column 'people', 'last_name', :string
 
       Person.reset_column_information
       assert Person.column_methods_hash.include?(:last_name)
     
-      PeopleHaveLastNames.down
+      ActiveRecord::Migration.remove_column 'people', 'last_name'
+
+      Person.reset_column_information
+      assert !Person.column_methods_hash.include?(:last_name)
+    end
+
+    def test_add_remove_single_field_using_symbol_arguments
+      assert !Person.column_methods_hash.include?(:last_name)
+
+      ActiveRecord::Migration.add_column :people, :last_name, :string
+
+      Person.reset_column_information
+      assert Person.column_methods_hash.include?(:last_name)
+
+      ActiveRecord::Migration.remove_column :people, :last_name
 
       Person.reset_column_information
       assert !Person.column_methods_hash.include?(:last_name)
@@ -101,6 +180,25 @@ if ActiveRecord::Base.connection.supports_migrations?
       
     end
     
+    def test_rename_table
+      begin
+        ActiveRecord::Base.connection.create_table :octopuses do |t|
+          t.column :url, :string
+        end          
+        ActiveRecord::Base.connection.rename_table :octopuses, :octopi
+        
+        assert_nothing_raised do
+          ActiveRecord::Base.connection.execute "INSERT INTO octopi (url) VALUES ('http://www.foreverflying.com/octopus-black7.jpg')"
+        end
+
+        assert_equal 'http://www.foreverflying.com/octopus-black7.jpg', ActiveRecord::Base.connection.select_value("SELECT url FROM octopi WHERE id=1")
+      
+      ensure
+        ActiveRecord::Base.connection.drop_table :octopuses rescue nil
+        ActiveRecord::Base.connection.drop_table :octopi 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 }
@@ -197,5 +295,65 @@ if ActiveRecord::Base.connection.supports_migrations?
       assert Reminder.create("content" => "hello world", "remind_at" => Time.now)
       assert_equal "hello world", Reminder.find(:first).content
     end
-  end
-end
+
+    def test_schema_info_table_name
+      ActiveRecord::Base.table_name_prefix = "prefix_"
+      ActiveRecord::Base.table_name_suffix = "_suffix"
+      Reminder.reset_table_name
+      assert_equal "prefix_schema_info_suffix", ActiveRecord::Migrator.schema_info_table_name
+      ActiveRecord::Base.table_name_prefix = ""
+      ActiveRecord::Base.table_name_suffix = ""
+      Reminder.reset_table_name
+      assert_equal "schema_info", ActiveRecord::Migrator.schema_info_table_name
+    end
+  
+    def test_proper_table_name
+      assert_equal "table", ActiveRecord::Migrator.proper_table_name('table')
+      assert_equal "table", ActiveRecord::Migrator.proper_table_name(:table)
+      assert_equal "reminders", ActiveRecord::Migrator.proper_table_name(Reminder)
+      Reminder.reset_table_name
+      assert_equal Reminder.table_name, ActiveRecord::Migrator.proper_table_name(Reminder)
+  
+      # Use the model's own prefix/suffix if a model is given
+      ActiveRecord::Base.table_name_prefix = "ARprefix_"
+      ActiveRecord::Base.table_name_suffix = "_ARsuffix"
+      Reminder.table_name_prefix = 'prefix_'
+      Reminder.table_name_suffix = '_suffix'
+      Reminder.reset_table_name
+      assert_equal "prefix_reminders_suffix", ActiveRecord::Migrator.proper_table_name(Reminder)
+      Reminder.table_name_prefix = ''
+      Reminder.table_name_suffix = ''
+      Reminder.reset_table_name
+      
+      # Use AR::Base's prefix/suffix if string or symbol is given      
+      ActiveRecord::Base.table_name_prefix = "prefix_"
+      ActiveRecord::Base.table_name_suffix = "_suffix"
+      Reminder.reset_table_name
+      assert_equal "prefix_table_suffix", ActiveRecord::Migrator.proper_table_name('table')
+      assert_equal "prefix_table_suffix", ActiveRecord::Migrator.proper_table_name(:table)
+      ActiveRecord::Base.table_name_prefix = ""
+      ActiveRecord::Base.table_name_suffix = ""
+      Reminder.reset_table_name
+    end  
+
+    def test_add_drop_table_with_prefix_and_suffix
+      assert_raises(ActiveRecord::StatementInvalid) { Reminder.column_methods_hash }
+
+      ActiveRecord::Base.table_name_prefix = 'prefix_'
+      ActiveRecord::Base.table_name_suffix = '_suffix'
+      Reminder.reset_table_name
+      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) }
+      ActiveRecord::Base.table_name_prefix = ''
+      ActiveRecord::Base.table_name_suffix = ''
+      Reminder.reset_table_name
+    end
+
+  end  
+  
+end

data/test/mixin_test.rb

@@ -65,6 +65,22 @@ class ListTest < Test::Unit::TestCase
                   ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos')
         
   end
+
+  def test_move_to_bottom_with_next_to_last_item
+    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_3).move_to_bottom
+
+    assert_equal [mixins(:list_1), 
+                  mixins(:list_2), 
+                  mixins(:list_4), 
+                  mixins(:list_3)], 
+                  ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos')
+  end
   
   def test_next_prev
     assert_equal mixins(:list_2), mixins(:list_1).lower_item
@@ -126,6 +142,15 @@ class ListTest < Test::Unit::TestCase
 
     new4.reload
     assert_equal 4, new4.pos
+
+    new5 = ListMixin.create("parent_id" => 20)
+    assert_equal 5, new5.pos
+
+    new5.insert_at(1)
+    assert_equal 1, new5.pos
+
+    new4.reload
+    assert_equal 5, new4.pos
   end
   
   def test_delete_middle
@@ -189,6 +214,13 @@ class TreeTest < Test::Unit::TestCase
     assert_equal mixins(:tree_4).children, []
   end
 
+  def test_has_parent
+    assert_equal false, mixins(:tree_1).has_parent?
+    assert_equal true, mixins(:tree_2).has_parent?
+    assert_equal true, mixins(:tree_3).has_parent?
+    assert_equal true, mixins(:tree_4).has_parent?
+  end
+
   def test_parent
     assert_equal mixins(:tree_2).parent, mixins(:tree_1)
     assert_equal mixins(:tree_2).parent, mixins(:tree_4).parent
@@ -196,11 +228,14 @@ class TreeTest < Test::Unit::TestCase
   end
   
   def test_delete
-    assert_equal 4, TreeMixin.count
+    assert_equal 6, TreeMixin.count
     mixins(:tree_1).destroy
+    assert_equal 2, TreeMixin.count
+    mixins(:tree2_1).destroy
+    mixins(:tree3_1).destroy
     assert_equal 0, TreeMixin.count
   end
-  
+
   def test_insert
     @extra = mixins(:tree_1).children.create
     
@@ -214,6 +249,46 @@ class TreeTest < Test::Unit::TestCase
     assert mixins(:tree_1).children.include?(mixins(:tree_4))
   end
 
+  def test_ancestors
+    assert_equal [], mixins(:tree_1).ancestors
+    assert_equal [mixins(:tree_1)], mixins(:tree_2).ancestors
+    assert_equal [mixins(:tree_2), mixins(:tree_1)], mixins(:tree_3).ancestors
+    assert_equal [mixins(:tree_1)], mixins(:tree_4).ancestors
+    assert_equal [], mixins(:tree2_1).ancestors
+    assert_equal [], mixins(:tree3_1).ancestors
+  end
+  
+  def test_root
+    assert_equal mixins(:tree_1), TreeMixin.root
+    assert_equal mixins(:tree_1), mixins(:tree_1).root
+    assert_equal mixins(:tree_1), mixins(:tree_2).root
+    assert_equal mixins(:tree_1), mixins(:tree_3).root
+    assert_equal mixins(:tree_1), mixins(:tree_4).root
+    assert_equal mixins(:tree2_1), mixins(:tree2_1).root
+    assert_equal mixins(:tree3_1), mixins(:tree3_1).root
+  end                                                                  
+
+  def test_roots
+    assert_equal [mixins(:tree_1), mixins(:tree2_1), mixins(:tree3_1)], TreeMixin.roots
+  end
+
+  def test_siblings
+    assert_equal [mixins(:tree2_1), mixins(:tree3_1)], mixins(:tree_1).siblings
+    assert_equal [mixins(:tree_4)], mixins(:tree_2).siblings
+    assert_equal [], mixins(:tree_3).siblings
+    assert_equal [mixins(:tree_2)], mixins(:tree_4).siblings
+    assert_equal [mixins(:tree_1), mixins(:tree3_1)], mixins(:tree2_1).siblings
+    assert_equal [mixins(:tree_1), mixins(:tree2_1)], mixins(:tree3_1).siblings
+  end
+
+  def test_self_and_siblings
+    assert_equal [mixins(:tree_1), mixins(:tree2_1), mixins(:tree3_1)], mixins(:tree_1).self_and_siblings
+    assert_equal [mixins(:tree_2), mixins(:tree_4)], mixins(:tree_2).self_and_siblings
+    assert_equal [mixins(:tree_3)], mixins(:tree_3).self_and_siblings
+    assert_equal [mixins(:tree_2), mixins(:tree_4)], mixins(:tree_4).self_and_siblings
+    assert_equal [mixins(:tree_1), mixins(:tree2_1), mixins(:tree3_1)], mixins(:tree2_1).self_and_siblings
+    assert_equal [mixins(:tree_1), mixins(:tree2_1), mixins(:tree3_1)], mixins(:tree3_1).self_and_siblings
+  end
 end
 
 class TouchTest < Test::Unit::TestCase
@@ -264,4 +339,5 @@ class TouchTest < Test::Unit::TestCase
 
     Mixin.record_timestamps = true
   end
+
 end

data/test/pk_test.rb

@@ -2,6 +2,7 @@ require 'abstract_unit'
 require 'fixtures/topic'
 require 'fixtures/subscriber'
 require 'fixtures/movie'
+require 'fixtures/keyboard'
 
 class PrimaryKeysTest < Test::Unit::TestCase
   fixtures :topics, :subscribers, :movies
@@ -22,6 +23,26 @@ class PrimaryKeysTest < Test::Unit::TestCase
     assert_equal("New Topic", topicReloaded.title)
   end
 
+  def test_customized_primary_key_auto_assigns_on_save
+    keyboard = Keyboard.new(:name => 'HHKB')
+    assert_nothing_raised { keyboard.save }
+    assert keyboard.id
+    assert_equal keyboard.id, Keyboard.find_by_name('HHKB').id
+  end
+
+  def test_customized_primary_key_can_be_get_before_saving
+    keyboard = Keyboard.new
+    assert_respond_to(keyboard, :key_number)
+    assert_nothing_raised { keyboard.key_number }
+  end
+
+  def test_customized_string_primary_key_settable_before_save
+    subscriber = Subscriber.new
+    assert_nothing_raised { subscriber.id = 'webster123' }
+    assert_equal 'webster123', subscriber.id
+    assert_equal 'webster123', subscriber.nick
+  end
+
   def test_string_key
     subscriber = Subscriber.find(subscribers(:first).nick)
     assert_equal(subscribers(:first).name, subscriber.name)
@@ -32,7 +53,7 @@ class PrimaryKeysTest < Test::Unit::TestCase
     subscriber.id = "jdoe"
     assert_equal("jdoe", subscriber.id)
     subscriber.name = "John Doe"
-    assert_nothing_raised{ subscriber.save }
+    assert_nothing_raised { subscriber.save! }
 
     subscriberReloaded = Subscriber.find("jdoe")
     assert_equal("John Doe", subscriberReloaded.name)
@@ -44,12 +65,15 @@ class PrimaryKeysTest < Test::Unit::TestCase
   
   def test_primary_key_prefix
     ActiveRecord::Base.primary_key_prefix_type = :table_name
+    Topic.reset_primary_key
     assert_equal "topicid", Topic.primary_key
 
     ActiveRecord::Base.primary_key_prefix_type = :table_name_with_underscore
+    Topic.reset_primary_key
     assert_equal "topic_id", Topic.primary_key
 
     ActiveRecord::Base.primary_key_prefix_type = nil
+    Topic.reset_primary_key
     assert_equal "id", Topic.primary_key
   end
 end

data/test/readonly_test.rb

@@ -0,0 +1,31 @@
+require 'abstract_unit'
+require 'fixtures/topic'
+
+class ReadOnlyTest < Test::Unit::TestCase
+  fixtures :topics
+
+  def test_cant_save_readonly_record
+    topic = Topic.find(:first)
+    assert !topic.readonly?
+
+    topic.readonly!
+    assert topic.readonly?
+
+    assert_nothing_raised do
+      topic.content = 'Luscious forbidden fruit.'
+    end
+
+    assert_raise(ActiveRecord::ReadOnlyRecord)  { topic.save  }
+    assert_raise(ActiveRecord::ReadOnlyRecord)  { topic.save! }
+  end
+
+  def test_find_with_readonly_option
+    Topic.find(:all).each { |t| assert !t.readonly? }
+    Topic.find(:all, :readonly => false).each { |t| assert !t.readonly? }
+    Topic.find(:all, :readonly => true).each { |t| assert t.readonly? }
+  end
+
+  def test_find_with_joins_option_implies_readonly
+    Topic.find(:all, :joins => '').each { |t| assert t.readonly? }
+  end
+end