activerecord 1.10.1 → 1.11.0

data/test/base_test.rb

@@ -2,6 +2,7 @@ require 'abstract_unit'
 require 'fixtures/topic'
 require 'fixtures/reply'
 require 'fixtures/company'
+require 'fixtures/developer'
 require 'fixtures/project'
 require 'fixtures/default'
 require 'fixtures/auto_id'
@@ -11,23 +12,33 @@ class Category < ActiveRecord::Base; end
 class Smarts < ActiveRecord::Base; end
 class CreditCard < ActiveRecord::Base; end
 class MasterCreditCard < ActiveRecord::Base; end
+class Post < ActiveRecord::Base; end
+class Computer < ActiveRecord::Base; end
 
 class LoosePerson < ActiveRecord::Base
   attr_protected :credit_rating, :administrator
 end
 
+class LooseDescendant < LoosePerson
+  attr_protected :phone_number
+end
+
 class TightPerson < ActiveRecord::Base
   attr_accessible :name, :address
 end
 
-class TightDescendent < TightPerson
+class TightDescendant < TightPerson
   attr_accessible :phone_number
 end
 
 class Booleantest < ActiveRecord::Base; end
 
+class Task < ActiveRecord::Base
+  attr_protected :starting
+end
+
 class BasicsTest < Test::Unit::TestCase
-  fixtures :topics, :companies, :projects
+  fixtures :topics, :companies, :developers, :projects, :computers
 
   def test_set_attributes
     topic = Topic.find(1)
@@ -35,7 +46,7 @@ class BasicsTest < Test::Unit::TestCase
     topic.save
     assert_equal("Budget", topic.title)
     assert_equal("Jason", topic.author_name)
-    assert_equal(@topics["first"]["author_email_address"], Topic.find(1).author_email_address)
+    assert_equal(topics(:first).author_email_address, Topic.find(1).author_email_address)
   end
   
   def test_integers_as_nil
@@ -103,7 +114,7 @@ class BasicsTest < Test::Unit::TestCase
   end
  
   def test_attributes_hash
-    assert_equal @projects['active_record'].to_hash, Project.find_first.attributes
+    assert_equal @loaded_fixtures['computers']['workstation'].to_hash, Computer.find(:first).attributes
   end
 
   def test_create
@@ -159,6 +170,21 @@ class BasicsTest < Test::Unit::TestCase
     topicReloaded.send :write_attribute, 'does_not_exist', 'test'
     assert_nothing_raised { topicReloaded.save }
   end
+  
+  def test_write_attribute
+    topic = Topic.new
+    topic.send(:write_attribute, :title, "Still another topic")
+    assert_equal "Still another topic", topic.title
+
+    topic.send(:write_attribute, "title", "Still another topic: part 2")
+    assert_equal "Still another topic: part 2", topic.title
+  end
+
+  def test_read_attribute_when_false
+    topic = topics(:first)
+    topic.approved = false
+    assert_equal 0, topic.approved, "approved should be 0"
+  end
 
   def test_preserving_date_objects
     # SQL Server doesn't have a separate column type just for dates, so all are returned as time
@@ -194,7 +220,6 @@ class BasicsTest < Test::Unit::TestCase
     topic.written_on = "2003-12-12 23:23:00"
     topic.save
     topic.destroy
-    assert_raise(TypeError) { topic.save }
     assert_raise(ActiveRecord::RecordNotFound) { Topic.find(topic.id) }
   end
   
@@ -221,16 +246,16 @@ class BasicsTest < Test::Unit::TestCase
   end
   
   def test_load
-    topics = Topic.find_all nil, "id"    
+    topics = Topic.find(:all, :order => 'id')    
     assert_equal(2, topics.size)
-    assert_equal(@topics["first"]["title"], topics.first.title)
+    assert_equal(topics(:first).title, topics.first.title)
   end
   
   def test_load_with_condition
-    topics = Topic.find_all "author_name = 'Mary'"
+    topics = Topic.find(:all, :conditions => "author_name = 'Mary'")
     
     assert_equal(1, topics.size)
-    assert_equal(@topics["second"]["title"], topics.first.title)
+    assert_equal(topics(:second).title, topics.first.title)
   end
 
   def test_table_name_guesses
@@ -270,15 +295,16 @@ class BasicsTest < Test::Unit::TestCase
   end
   
   def test_destroy_all
-    assert_equal 2, Topic.find_all.size
+    assert_equal 2, Topic.count
 
     Topic.destroy_all "author_name = 'Mary'"
-    assert_equal 1, Topic.find_all.size
+    assert_equal 1, Topic.count
   end
 
   def test_destroy_many
+    assert_equal 3, Client.count
     Client.destroy([2, 3])
-    assert_equal 0, Client.count
+    assert_equal 1, Client.count
   end
 
   def test_delete_many
@@ -308,6 +334,10 @@ class BasicsTest < Test::Unit::TestCase
   end
   
   def test_update_all
+    # The ADO library doesn't support the number of affected rows
+    if ActiveRecord::ConnectionAdapters.const_defined? :SQLServerAdapter
+      return true if ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters::SQLServerAdapter)
+    end
     assert_equal 2, Topic.update_all("content = 'bulk updated!'")
     assert_equal "bulk updated!", Topic.find(1).content
     assert_equal "bulk updated!", Topic.find(2).content
@@ -326,6 +356,10 @@ class BasicsTest < Test::Unit::TestCase
   end
 
   def test_delete_all
+    # The ADO library doesn't support the number of affected rows
+    if ActiveRecord::ConnectionAdapters.const_defined? :SQLServerAdapter
+      return true if ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters::SQLServerAdapter)
+    end
     assert_equal 2, Topic.delete_all
   end
 
@@ -428,6 +462,14 @@ class BasicsTest < Test::Unit::TestCase
     assert client.frozen?
   end
   
+  def test_destroy_record_with_associations
+    client = Client.find(3)
+    client.destroy
+    assert client.frozen?
+    assert_kind_of Firm, client.firm
+    assert_raises(TypeError) { client.name = "something else" }
+  end
+  
   def test_update_attribute
     assert !Topic.find(1).approved?
     Topic.find(1).update_attribute("approved", true)
@@ -463,8 +505,17 @@ class BasicsTest < Test::Unit::TestCase
   end
   
   def test_mass_assignment_protection_inheritance
+    assert_nil LoosePerson.accessible_attributes
     assert_equal [ :credit_rating, :administrator ], LoosePerson.protected_attributes
+
+    assert_nil LooseDescendant.accessible_attributes
+    assert_equal [ :credit_rating, :administrator, :phone_number  ], LooseDescendant.protected_attributes
+
     assert_nil TightPerson.protected_attributes
+    assert_equal [ :name, :address ], TightPerson.accessible_attributes
+
+    assert_nil TightDescendant.protected_attributes
+    assert_equal [ :name, :address, :phone_number  ], TightDescendant.accessible_attributes
   end
 
   def test_multiparameter_attributes_on_date
@@ -518,6 +569,15 @@ class BasicsTest < Test::Unit::TestCase
     assert_equal Time.local(2004, 6, 24, 16, 24, 0), topic.written_on
   end
 
+  def test_multiparameter_mass_assignment_protector
+    task = Task.new
+    time = Time.mktime(0)
+    task.starting = time 
+    attributes = { "starting(1i)" => "2004", "starting(2i)" => "6", "starting(3i)" => "24" }
+    task.attributes = attributes
+    assert_equal time, task.starting
+  end
+
   def test_attributes_on_dummy_time
     # Oracle does not have a TIME datatype.
     if ActiveRecord::ConnectionAdapters.const_defined? :OracleAdapter
@@ -546,7 +606,8 @@ class BasicsTest < Test::Unit::TestCase
   
   def test_clone
     topic = Topic.find(1)
-    cloned_topic = topic.clone
+    cloned_topic = nil
+    assert_nothing_raised { cloned_topic = topic.clone }
     assert_equal topic.title, cloned_topic.title
     assert cloned_topic.new_record?
 
@@ -566,7 +627,33 @@ class BasicsTest < Test::Unit::TestCase
     assert !cloned_topic.new_record?
     assert cloned_topic.id != topic.id
   end
-  
+
+  def test_clone_with_aggregate_of_same_name_as_attribute
+    dev = DeveloperWithAggregate.find(1)
+    assert_kind_of DeveloperSalary, dev.salary
+
+    clone = nil
+    assert_nothing_raised { clone = dev.clone }
+    assert_kind_of DeveloperSalary, clone.salary
+    assert_equal dev.salary.amount, clone.salary.amount
+    assert clone.new_record?
+
+    # test if the attributes have been cloned
+    original_amount = clone.salary.amount
+    dev.salary.amount = 1
+    assert_equal original_amount, clone.salary.amount
+
+    assert clone.save
+    assert !clone.new_record?
+    assert clone.id != dev.id
+  end
+
+  def test_clone_preserves_subtype
+    clone = nil
+    assert_nothing_raised { clone = Company.find(3).clone }
+    assert_kind_of Client, clone
+  end
+
   def test_bignum
     company = Company.find(1)
     company.rating = 2147483647
@@ -671,35 +758,35 @@ class BasicsTest < Test::Unit::TestCase
   end
 
   def test_increment_attribute
-    assert_equal 0, @topics["first"].find.replies_count
-    @topics["first"].find.increment! :replies_count
-    assert_equal 1, @topics["first"].find.replies_count
+    assert_equal 0, topics(:first).replies_count
+    topics(:first).increment! :replies_count
+    assert_equal 1, topics(:first, :reload).replies_count
     
-    @topics["first"].find.increment(:replies_count).increment!(:replies_count)
-    assert_equal 3, @topics["first"].find.replies_count
+    topics(:first).increment(:replies_count).increment!(:replies_count)
+    assert_equal 3, topics(:first, :reload).replies_count
   end
   
   def test_increment_nil_attribute
-    assert_nil @topics["first"].find.parent_id
-    @topics["first"].find.increment! :parent_id
-    assert_equal 1, @topics["first"].find.parent_id
+    assert_nil topics(:first).parent_id
+    topics(:first).increment! :parent_id
+    assert_equal 1, topics(:first).parent_id
   end
   
   def test_decrement_attribute
-    @topics["first"].find.increment(:replies_count).increment!(:replies_count)
-    assert_equal 2, @topics["first"].find.replies_count
+    topics(:first).increment(:replies_count).increment!(:replies_count)
+    assert_equal 2, topics(:first).replies_count
     
-    @topics["first"].find.decrement!(:replies_count)
-    assert_equal 1, @topics["first"].find.replies_count
+    topics(:first).decrement!(:replies_count)
+    assert_equal 1, topics(:first, :reload).replies_count
 
-    @topics["first"].find.decrement(:replies_count).decrement!(:replies_count)
-    assert_equal -1, @topics["first"].find.replies_count
+    topics(:first).decrement(:replies_count).decrement!(:replies_count)
+    assert_equal -1, topics(:first, :reload).replies_count
   end
   
   def test_toggle_attribute
-    assert !@topics["first"].find.approved?
-    @topics["first"].find.toggle!(:approved)
-    assert @topics["first"].find.approved?
+    assert !topics(:first).approved?
+    topics(:first).toggle!(:approved)
+    assert topics(:first).approved?
   end
 
   def test_reload
@@ -764,4 +851,36 @@ class BasicsTest < Test::Unit::TestCase
     k.set_inheritance_column { original_inheritance_column + "_id" }
     assert_equal "type_id", k.inheritance_column
   end
+
+  def test_count_with_join
+    res = Post.count_by_sql "SELECT COUNT(*) FROM posts LEFT JOIN comments ON posts.id=comments.post_id WHERE posts.type = 'Post'"
+    res2 = res + 1
+    assert_nothing_raised do
+      res2 = Post.count("posts.type = 'Post'",
+                        "LEFT JOIN comments ON posts.id=comments.post_id")
+    end
+    assert_equal res, res2
+  end
+  
+  def test_clear_association_cache_stored     
+    firm = Firm.find(1)
+    assert_kind_of Firm, firm
+
+    firm.clear_association_cache
+    assert_equal Firm.find(1).clients.collect{ |x| x.name }.sort, firm.clients.collect{ |x| x.name }.sort
+  end
+  
+  def test_clear_association_cache_new_record
+     firm            = Firm.new
+     client_stored   = Client.find(3)
+     client_new      = Client.new
+     client_new.name = "The Joneses"
+     clients         = [ client_stored, client_new ]
+     
+     firm.clients    << clients
+
+     firm.clear_association_cache
+
+     assert_equal    firm.clients.collect{ |x| x.name }.sort, clients.collect{ |x| x.name }.sort
+  end
 end

data/test/binary_test.rb

@@ -7,6 +7,13 @@ class BinaryTest < Test::Unit::TestCase
   end
   
   def test_load_save
+    # Without using prepared statements, it makes no sense to test
+    # BLOB data with SQL Server, because the length of a statement is
+    # limited to 8KB.
+    if ActiveRecord::ConnectionAdapters.const_defined? :SQLServerAdapter
+      return true if ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters::SQLServerAdapter)
+    end
+
     # Without using prepared statements, it makes no sense to test
     # BLOB data with DB2, because the length of a statement is
     # limited to 32KB.

data/test/callbacks_test.rb

@@ -1,9 +1,9 @@
 require 'abstract_unit'
 
 class CallbackDeveloper < ActiveRecord::Base
-  class << self
-    def table_name; 'developers' end
+  set_table_name 'developers'
 
+  class << self
     def callback_string(callback_method)
       "history << [#{callback_method.to_sym.inspect}, :string]"
     end
@@ -49,12 +49,31 @@ class CallbackDeveloper < ActiveRecord::Base
   end
 end
 
+class RecursiveCallbackDeveloper < ActiveRecord::Base
+  set_table_name 'developers'
 
-class CallbacksTest < Test::Unit::TestCase
-  def setup
-    @developers = create_fixtures('developers')
+  before_save :on_before_save
+  after_save :on_after_save
+
+  attr_reader :on_before_save_called, :on_after_save_called
+
+  def on_before_save
+    @on_before_save_called ||= 0
+    @on_before_save_called += 1
+    save unless @on_before_save_called > 1
   end
 
+  def on_after_save
+    @on_after_save_called ||= 0
+    @on_after_save_called += 1
+    save unless @on_after_save_called > 1
+  end
+end
+
+
+class CallbacksTest < Test::Unit::TestCase
+  fixtures :developers
+
   def test_initialize
     david = CallbackDeveloper.new
     assert_equal [

data/test/column_alias_test.rb

@@ -8,11 +8,11 @@ class TestColumnAlias < Test::Unit::TestCase
     if ActiveRecord::ConnectionAdapters.const_defined? :OracleAdapter
       if ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters::OracleAdapter)
         records = topic.connection.select_all("SELECT id AS pk FROM topics WHERE ROWNUM < 2")
-        assert_equal(records[0].keys[0], "pk")
+        assert_equal("pk", records[0].keys[0])
       end
     else
       records = topic.connection.select_all("SELECT id AS pk FROM topics")
-      assert_equal(records[0].keys[0], "pk")
+      assert_equal("pk", records[0].keys[0])
     end
   end
   

data/test/connections/native_sqlserver_odbc/connection.rb

@@ -0,0 +1,26 @@
+print "Using native SQLServer via ODBC\n"
+require 'fixtures/course'
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+dsn1 = 'activerecord_unittest'
+dsn2 = 'activerecord_unittest2'
+
+ActiveRecord::Base.establish_connection(
+  :adapter  => "sqlserver",
+  :mode     => "ODBC",
+  :host     => "localhost",
+  :username => "sa",
+  :password => "",
+  :dsn => dsn1
+)
+
+Course.establish_connection(
+  :adapter  => "sqlserver",
+  :mode     => "ODBC",
+  :host     => "localhost",
+  :username => "sa",
+  :password => "",
+  :dsn => dsn2
+)

data/test/deprecated_associations_test.rb

@@ -16,10 +16,8 @@ raise "ActiveRecord should have barked on bad collection keys" unless bad_collec
 
 
 class DeprecatedAssociationsTest < Test::Unit::TestCase
-  def setup
-    create_fixtures "accounts", "companies", "developers", "projects", "developers_projects", "topics"
-    @signals37 = Firm.find(1)
-  end
+  fixtures :accounts, :companies, :developers, :projects, :topics,
+           :developers_projects
 
   def test_has_many_find
     assert_equal 2, Firm.find_first.clients.length
@@ -62,13 +60,14 @@ class DeprecatedAssociationsTest < Test::Unit::TestCase
   end
 
   def test_has_many_dependence
-    assert_equal 2, Client.find_all.length
+    assert_equal 3, Client.find_all.length
     Firm.find_first.destroy
-    assert_equal 0, Client.find_all.length
+    assert_equal 1, Client.find_all.length
   end
 
+  uses_transaction :test_has_many_dependence_with_transaction_support_on_failure
   def test_has_many_dependence_with_transaction_support_on_failure
-    assert_equal 2, Client.find_all.length
+    assert_equal 3, Client.find_all.length
 
     firm = Firm.find_first
     clients = firm.clients
@@ -76,7 +75,7 @@ class DeprecatedAssociationsTest < Test::Unit::TestCase
 
     firm.destroy rescue "do nothing"
 
-    assert_equal 2, Client.find_all.length
+    assert_equal 3, Client.find_all.length
   end
 
   def test_has_one_dependence
@@ -94,7 +93,7 @@ class DeprecatedAssociationsTest < Test::Unit::TestCase
   end
 
   def test_belongs_to
-    assert_equal @signals37.name, Client.find(3).firm.name
+    assert_equal companies(:first_firm).name, Client.find(3).firm.name
     assert Client.find(3).has_firm?, "Microsoft should have a firm"
     # assert !Company.find(1).has_firm?, "37signals shouldn't have a firm"
   end
@@ -115,25 +114,25 @@ class DeprecatedAssociationsTest < Test::Unit::TestCase
   end
 
   def test_has_one
-    assert @signals37.account?(Account.find(1))
-    assert_equal Account.find(1).credit_limit, @signals37.account.credit_limit
-    assert @signals37.has_account?, "37signals should have an account"
-    assert Account.find(1).firm?(@signals37), "37signals account should be able to backtrack"
+    assert companies(:first_firm).account?(Account.find(1))
+    assert_equal Account.find(1).credit_limit, companies(:first_firm).account.credit_limit
+    assert companies(:first_firm).has_account?, "37signals should have an account"
+    assert Account.find(1).firm?(companies(:first_firm)), "37signals account should be able to backtrack"
     assert Account.find(1).has_firm?, "37signals account should be able to backtrack"
 
     assert !Account.find(2).has_firm?, "Unknown isn't linked"
-    assert !Account.find(2).firm?(@signals37), "Unknown isn't linked"
+    assert !Account.find(2).firm?(companies(:first_firm)), "Unknown isn't linked"
   end
 
   def test_has_many_dependence_on_account
     assert_equal 2, Account.find_all.length
-    @signals37.destroy
+    companies(:first_firm).destroy
     assert_equal 1, Account.find_all.length
   end
 
   def test_find_in
-    assert_equal Client.find(2).name, @signals37.find_in_clients(2).name
-    assert_raises(ActiveRecord::RecordNotFound) { @signals37.find_in_clients(6) }
+    assert_equal Client.find(2).name, companies(:first_firm).find_in_clients(2).name
+    assert_raises(ActiveRecord::RecordNotFound) { companies(:first_firm).find_in_clients(6) }
   end
 
   def test_force_reload
@@ -157,21 +156,21 @@ class DeprecatedAssociationsTest < Test::Unit::TestCase
   end
 
   def test_included_in_collection
-    assert @signals37.clients.include?(Client.find(2))
+    assert companies(:first_firm).clients.include?(Client.find(2))
   end
 
   def test_build_to_collection
-    assert_equal 1, @signals37.clients_of_firm_count
-    new_client = @signals37.build_to_clients_of_firm("name" => "Another Client")
+    assert_equal 1, companies(:first_firm).clients_of_firm_count
+    new_client = companies(:first_firm).build_to_clients_of_firm("name" => "Another Client")
     assert_equal "Another Client", new_client.name
     assert new_client.save
 
-    assert new_client.firm?(@signals37)
-    assert_equal 2, @signals37.clients_of_firm_count(true)
+    assert new_client.firm?(companies(:first_firm))
+    assert_equal 2, companies(:first_firm).clients_of_firm_count(true)
   end
 
   def test_create_in_collection
-    assert_equal @signals37.create_in_clients_of_firm("name" => "Another Client"), @signals37.clients_of_firm(true).last
+    assert_equal companies(:first_firm).create_in_clients_of_firm("name" => "Another Client"), companies(:first_firm).clients_of_firm(true).last
   end
 
   def test_has_and_belongs_to_many
@@ -182,7 +181,7 @@ class DeprecatedAssociationsTest < Test::Unit::TestCase
     active_record = Project.find(1)
     assert active_record.has_developers?
     assert_equal 2, active_record.developers_count
-    assert_equal david.name, active_record.developers.first.name
+    assert active_record.developers.include?(david)
   end
 
   def test_has_and_belongs_to_many_removing
@@ -317,13 +316,13 @@ class DeprecatedAssociationsTest < Test::Unit::TestCase
   end
 
   def test_has_one
-    assert @signals37.account?(Account.find(1))
-    assert @signals37.has_account?, "37signals should have an account"
-    assert Account.find(1).firm?(@signals37), "37signals account should be able to backtrack"
+    assert companies(:first_firm).account?(Account.find(1))
+    assert companies(:first_firm).has_account?, "37signals should have an account"
+    assert Account.find(1).firm?(companies(:first_firm)), "37signals account should be able to backtrack"
     assert Account.find(1).has_firm?, "37signals account should be able to backtrack"
 
     assert !Account.find(2).has_firm?, "Unknown isn't linked"
-    assert !Account.find(2).firm?(@signals37), "Unknown isn't linked"
+    assert !Account.find(2).firm?(companies(:first_firm)), "Unknown isn't linked"
   end
 
   def test_has_one_build