Rails 2.1

Update to Rails 2.1 final.

vendor/rails/activerecord/test/cases/active_schema_test_mysql.rb

@@ -40,47 +40,56 @@ class ActiveSchemaTest < ActiveRecord::TestCase
   end
 
   def test_add_timestamps 
-    #we need to actually modify some data, so we make execute to point to the original method
-    ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do      
-      alias_method :execute_with_stub, :execute
-      alias_method :execute, :execute_without_stub
-    end  
-    ActiveRecord::Base.connection.create_table :delete_me do |t|        
-    end
-    ActiveRecord::Base.connection.add_timestamps :delete_me
-    assert_equal ActiveRecord::Base.connection.execute("SHOW FIELDS FROM delete_me where FIELD='updated_at' AND TYPE='datetime'").num_rows, 1
-    assert_equal ActiveRecord::Base.connection.execute("SHOW FIELDS FROM delete_me where FIELD='created_at' AND TYPE='datetime'").num_rows, 1
-  ensure    
-    ActiveRecord::Base.connection.drop_table :delete_me rescue nil  
-    #before finishing, we restore the alias to the mock-up method
-    ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do      
-      alias_method :execute, :execute_with_stub
+    with_real_execute do
+      begin
+        ActiveRecord::Base.connection.create_table :delete_me do |t|
+        end
+        ActiveRecord::Base.connection.add_timestamps :delete_me
+        assert column_present?('delete_me', 'updated_at', 'datetime')
+        assert column_present?('delete_me', 'created_at', 'datetime')
+      ensure
+        ActiveRecord::Base.connection.drop_table :delete_me rescue nil
+      end
     end
   end
   
   def test_remove_timestamps 
-    #we need to actually modify some data, so we make execute to point to the original method
-    ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do      
-      alias_method :execute_with_stub, :execute
-      alias_method :execute, :execute_without_stub
-    end  
-    ActiveRecord::Base.connection.create_table :delete_me do |t|        
-      t.timestamps
-    end
-    ActiveRecord::Base.connection.remove_timestamps :delete_me
-    assert_equal ActiveRecord::Base.connection.execute("SHOW FIELDS FROM delete_me where FIELD='updated_at' AND TYPE='datetime'").num_rows, 0
-    assert_equal ActiveRecord::Base.connection.execute("SHOW FIELDS FROM delete_me where FIELD='created_at' AND TYPE='datetime'").num_rows, 0
-  ensure    
-    ActiveRecord::Base.connection.drop_table :delete_me rescue nil  
-    #before finishing, we restore the alias to the mock-up method
-    ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do      
-      alias_method :execute, :execute_with_stub
+    with_real_execute do
+      begin
+        ActiveRecord::Base.connection.create_table :delete_me do |t|
+          t.timestamps
+        end
+        ActiveRecord::Base.connection.remove_timestamps :delete_me
+        assert !column_present?('delete_me', 'updated_at', 'datetime')
+        assert !column_present?('delete_me', 'created_at', 'datetime')
+      ensure
+        ActiveRecord::Base.connection.drop_table :delete_me rescue nil
+      end
     end
   end
 
-
   private
+    def with_real_execute
+      #we need to actually modify some data, so we make execute point to the original method
+      ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
+        alias_method :execute_with_stub, :execute
+        alias_method :execute, :execute_without_stub
+      end
+      yield
+    ensure
+      #before finishing, we restore the alias to the mock-up method
+      ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
+        alias_method :execute, :execute_with_stub
+      end
+    end
+
+
     def method_missing(method_symbol, *arguments)
       ActiveRecord::Base.connection.send(method_symbol, *arguments)
     end
+
+    def column_present?(table_name, column_name, type)
+      results = ActiveRecord::Base.connection.select_all("SHOW FIELDS FROM #{table_name} LIKE '#{column_name}'")
+      results.first && results.first['Type'] == type
+    end
 end

vendor/rails/activerecord/test/cases/adapter_test.rb

@@ -104,4 +104,24 @@ class AdapterTest < ActiveRecord::TestCase
     end
   end
 
+  def test_add_limit_offset_should_sanitize_sql_injection_for_limit_without_comas
+    sql_inject = "1 select * from schema"
+      assert_equal " LIMIT 1", @connection.add_limit_offset!("", :limit=>sql_inject)
+    if current_adapter?(:MysqlAdapter)
+      assert_equal " LIMIT 7, 1", @connection.add_limit_offset!("", :limit=>sql_inject, :offset=>7)
+    else
+      assert_equal " LIMIT 1 OFFSET 7", @connection.add_limit_offset!("", :limit=>sql_inject, :offset=>7)
+    end
+  end
+
+  def test_add_limit_offset_should_sanitize_sql_injection_for_limit_with_comas
+    sql_inject = "1, 7 procedure help()"
+    if current_adapter?(:MysqlAdapter)
+      assert_equal " LIMIT 1,7", @connection.add_limit_offset!("", :limit=>sql_inject)
+      assert_equal " LIMIT 7, 1", @connection.add_limit_offset!("", :limit=>sql_inject, :offset=>7)
+    else
+      assert_equal " LIMIT 1,7", @connection.add_limit_offset!("", :limit=>sql_inject)
+      assert_equal " LIMIT 1,7 OFFSET 7", @connection.add_limit_offset!("", :limit=>sql_inject, :offset=>7)
+    end
+  end
 end

vendor/rails/activerecord/test/cases/associations/belongs_to_associations_test.rb

@@ -12,6 +12,8 @@ require 'models/author'
 require 'models/tag'
 require 'models/tagging'
 require 'models/comment'
+require 'models/sponsor'
+require 'models/member'
 
 class BelongsToAssociationsTest < ActiveRecord::TestCase
   fixtures :accounts, :companies, :developers, :projects, :topics,
@@ -54,8 +56,8 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     original_proxy = citibank.firm
     citibank.firm = another_firm
 
-    assert_equal first_firm.object_id, original_proxy.object_id
-    assert_equal another_firm.object_id, citibank.firm.object_id
+    assert_equal first_firm.object_id, original_proxy.target.object_id
+    assert_equal another_firm.object_id, citibank.firm.target.object_id
   end
 
   def test_creating_the_belonging_object
@@ -92,6 +94,11 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_not_nil Company.find(3).firm_with_condition, "Microsoft should have a firm"
   end
 
+  def test_with_select
+    assert_equal Company.find(2).firm_with_select.attributes.size, 1
+    assert_equal Company.find(2, :include => :firm_with_select ).firm_with_select.attributes.size, 1
+  end
+
   def test_belongs_to_counter
     debate = Topic.create("title" => "debate")
     assert_equal 0, debate.send(:read_attribute, "replies_count"), "No replies yet"
@@ -376,5 +383,30 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_raise(ActiveRecord::ReadOnlyRecord) { companies(:first_client).readonly_firm.save! }
     assert companies(:first_client).readonly_firm.readonly?
   end
-
+  
+  def test_polymorphic_assignment_foreign_type_field_updating
+    # should update when assigning a saved record
+    sponsor = Sponsor.new
+    member = Member.create
+    sponsor.sponsorable = member
+    assert_equal "Member", sponsor.sponsorable_type
+    
+    # should update when assigning a new record
+    sponsor = Sponsor.new
+    member = Member.new
+    sponsor.sponsorable = member
+    assert_equal "Member", sponsor.sponsorable_type
+  end
+  
+  def test_polymorphic_assignment_updates_foreign_id_field_for_new_and_saved_records
+    sponsor = Sponsor.new
+    saved_member = Member.create
+    new_member = Member.new
+    
+    sponsor.sponsorable = saved_member
+    assert_equal saved_member.id, sponsor.sponsorable_id
+    
+    sponsor.sponsorable = new_member
+    assert_equal nil, sponsor.sponsorable_id
+  end
 end

vendor/rails/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb

@@ -401,6 +401,8 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
 
   def test_include_uses_array_include_after_loaded
     project = projects(:active_record)
+    project.developers.class # force load target
+
     developer = project.developers.first
     
     assert_no_queries do

vendor/rails/activerecord/test/cases/associations/has_many_associations_test.rb

@@ -32,6 +32,10 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal 2, Firm.find(:first).plain_clients.count
   end
 
+  def test_counting_with_empty_hash_conditions
+    assert_equal 2, Firm.find(:first).plain_clients.count(:conditions => {})
+  end
+
   def test_counting_with_single_conditions
     assert_equal 2, Firm.find(:first).plain_clients.count(:conditions => '1=1')
   end
@@ -346,6 +350,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal "Another Client", new_client.name
     assert new_client.new_record?
     assert_equal new_client, company.clients_of_firm.last
+    company.name += '-changed'
     assert_queries(2) { assert company.save }
     assert !new_client.new_record?
     assert_equal 2, company.clients_of_firm(true).size
@@ -356,6 +361,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     new_clients = assert_no_queries { company.clients_of_firm.build([{"name" => "Another Client"}, {"name" => "Another Client II"}]) }
     
     assert_equal 2, new_clients.size
+    company.name += '-changed'
     assert_queries(3) { assert company.save }
     assert_equal 3, company.clients_of_firm(true).size
   end
@@ -818,6 +824,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_include_uses_array_include_after_loaded
     firm = companies(:first_firm)
+    firm.clients.class # force load target
+
     client = firm.clients.first
 
     assert_no_queries do
@@ -857,4 +865,68 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert ! firm.clients.include?(client)
   end
 
+  def test_calling_first_or_last_on_association_should_not_load_association
+    firm = companies(:first_firm)
+    firm.clients.first
+    firm.clients.last
+    assert !firm.clients.loaded?
+  end
+
+  def test_calling_first_or_last_on_loaded_association_should_not_fetch_with_query
+    firm = companies(:first_firm)
+    firm.clients.class # force load target
+    assert firm.clients.loaded?
+
+    assert_no_queries do
+      firm.clients.first
+      assert_equal 2, firm.clients.first(2).size
+      firm.clients.last
+      assert_equal 2, firm.clients.last(2).size
+    end
+  end
+
+  def test_calling_first_or_last_on_existing_record_with_build_should_load_association
+    firm = companies(:first_firm)
+    firm.clients.build(:name => 'Foo')
+    assert !firm.clients.loaded?
+
+    assert_queries 1 do
+      firm.clients.first
+      firm.clients.last
+    end
+
+    assert firm.clients.loaded?
+  end
+
+  def test_calling_first_or_last_on_new_record_should_not_run_queries
+    firm = Firm.new
+
+    assert_no_queries do
+      firm.clients.first
+      firm.clients.last
+    end
+  end
+
+  def test_calling_first_or_last_with_find_options_on_loaded_association_should_fetch_with_query
+    firm = companies(:first_firm)
+    firm.clients.class # force load target
+
+    assert_queries 2 do
+      assert firm.clients.loaded?
+      firm.clients.first(:order => 'name')
+      firm.clients.last(:order => 'name')
+    end
+  end
+
+  def test_calling_first_or_last_with_integer_on_association_should_load_association
+    firm = companies(:first_firm)
+
+    assert_queries 1 do
+      firm.clients.first(2)
+      firm.clients.last(2)
+    end
+
+    assert firm.clients.loaded?
+  end
+
 end

vendor/rails/activerecord/test/cases/associations/has_many_through_associations_test.rb

@@ -59,6 +59,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     #    * 2 new records = 4
     # + 1 query to save the actual post = 5
     assert_queries(5) do
+      posts(:thinking).body += '-changed'
       posts(:thinking).save
     end
     

vendor/rails/activerecord/test/cases/associations/has_one_associations_test.rb

@@ -24,6 +24,11 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
     assert_queries(0) { firms.each(&:account) }
   end
 
+  def test_with_select
+    assert_equal Firm.find(1).account_with_select.attributes.size, 2
+    assert_equal Firm.find(1, :include => :account_with_select).account_with_select.attributes.size, 2
+  end
+
   def test_can_marshal_has_one_association_with_nil_target
     firm = Firm.new
     assert_nothing_raised do

vendor/rails/activerecord/test/cases/associations/join_model_test.rb

@@ -664,6 +664,8 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_has_many_through_include_uses_array_include_after_loaded
     david = authors(:david)
+    david.categories.class # force load target
+
     category = david.categories.first
 
     assert_no_queries do

vendor/rails/activerecord/test/cases/associations_test.rb

@@ -99,12 +99,12 @@ class AssociationProxyTest < ActiveRecord::TestCase
     david = authors(:david)
     assert_equal  david, david.posts.proxy_owner
     assert_equal  david.class.reflect_on_association(:posts), david.posts.proxy_reflection
-    david.posts.first   # force load target
+    david.posts.class   # force load target
     assert_equal  david.posts, david.posts.proxy_target
 
     assert_equal  david, david.posts_with_extension.testing_proxy_owner
     assert_equal  david.class.reflect_on_association(:posts_with_extension), david.posts_with_extension.testing_proxy_reflection
-    david.posts_with_extension.first   # force load target
+    david.posts_with_extension.class   # force load target
     assert_equal  david.posts_with_extension, david.posts_with_extension.testing_proxy_target
   end
 
@@ -160,6 +160,18 @@ class AssociationProxyTest < ActiveRecord::TestCase
     assert_equal 1, developer.reload.audit_logs.size
   end
 
+  def test_create_via_association_with_block
+    post = authors(:david).posts.create(:title => "New on Edge") {|p| p.body = "More cool stuff!"}
+    assert_equal post.title, "New on Edge"
+    assert_equal post.body, "More cool stuff!"
+  end
+
+  def test_create_with_bang_via_association_with_block
+    post = authors(:david).posts.create!(:title => "New on Edge") {|p| p.body = "More cool stuff!"}
+    assert_equal post.title, "New on Edge"
+    assert_equal post.body, "More cool stuff!"
+  end
+
   def test_failed_reload_returns_nil
     p = setup_dangling_association
     assert_nil p.author.reload

vendor/rails/activerecord/test/cases/datatype_test_postgresql.rb

@@ -30,8 +30,8 @@ class PostgresqlDataTypeTest < ActiveRecord::TestCase
     @connection.execute("INSERT INTO postgresql_arrays (commission_by_quarter, nicknames) VALUES ( '{35000,21000,18000,17000}', '{foo,bar,baz}' )")
     @first_array = PostgresqlArray.find(1)
 
-    @connection.execute("INSERT INTO postgresql_moneys (wealth) VALUES ('$567.89')")
-    @connection.execute("INSERT INTO postgresql_moneys (wealth) VALUES ('-$567.89')")
+    @connection.execute("INSERT INTO postgresql_moneys (wealth) VALUES ('567.89'::money)")
+    @connection.execute("INSERT INTO postgresql_moneys (wealth) VALUES ('-567.89'::money)")
     @first_money = PostgresqlMoney.find(1)
     @second_money = PostgresqlMoney.find(2)
 
@@ -143,11 +143,11 @@ class PostgresqlDataTypeTest < ActiveRecord::TestCase
   end
 
   def test_update_money
-    new_value = 123.45
+    new_value = BigDecimal.new('123.45')
     assert @first_money.wealth = new_value
     assert @first_money.save
     assert @first_money.reload
-    assert_equal @first_money.wealth, new_value
+    assert_equal new_value, @first_money.wealth
   end
 
   def test_update_number

vendor/rails/activerecord/test/cases/defaults_test.rb

@@ -5,7 +5,7 @@ require 'models/entrant'
 class DefaultTest < ActiveRecord::TestCase
   def test_nil_defaults_for_not_null_columns
     column_defaults =
-      if current_adapter?(:MysqlAdapter)
+      if current_adapter?(:MysqlAdapter) && Mysql.client_version < 50051
         { 'id' => nil, 'name' => '',  'course_id' => nil }
       else
         { 'id' => nil, 'name' => nil, 'course_id' => nil }

vendor/rails/activerecord/test/cases/dirty_test.rb

@@ -44,6 +44,16 @@ class DirtyTest < ActiveRecord::TestCase
     assert_nil pirate.catchphrase_change
   end
 
+  def test_nullable_integer_not_marked_as_changed_if_new_value_is_blank
+    pirate = Pirate.new
+
+    ["", nil].each do |value|
+      pirate.parrot_id = value
+      assert !pirate.parrot_id_changed?
+      assert_nil pirate.parrot_id_change
+    end
+  end
+
   def test_object_should_be_changed_if_any_attribute_is_changed
     pirate = Pirate.new
     assert !pirate.changed?
@@ -78,7 +88,7 @@ class DirtyTest < ActiveRecord::TestCase
   end
 
   def test_association_assignment_changes_foreign_key
-    pirate = Pirate.create!
+    pirate = Pirate.create!(:catchphrase => 'jarl')
     pirate.parrot = Parrot.create!
     assert pirate.changed?
     assert_equal %w(parrot_id), pirate.changed
@@ -115,6 +125,26 @@ class DirtyTest < ActiveRecord::TestCase
     end
   end
 
+  def test_changed_attributes_should_be_preserved_if_save_failure
+    pirate = Pirate.new
+    pirate.parrot_id = 1
+    assert !pirate.save
+    check_pirate_after_save_failure(pirate)
+
+    pirate = Pirate.new
+    pirate.parrot_id = 1
+    assert_raises(ActiveRecord::RecordInvalid) { pirate.save! }
+    check_pirate_after_save_failure(pirate)
+  end
+
+  def test_reload_should_clear_changed_attributes
+    pirate = Pirate.create!(:catchphrase => "shiver me timbers")
+    pirate.catchphrase = "*hic*"
+    assert pirate.changed?
+    pirate.reload
+    assert !pirate.changed?
+  end
+
   private
     def with_partial_updates(klass, on = true)
       old = klass.partial_updates?
@@ -123,4 +153,11 @@ class DirtyTest < ActiveRecord::TestCase
     ensure
       klass.partial_updates = old
     end
+
+    def check_pirate_after_save_failure(pirate)
+      assert pirate.changed?
+      assert pirate.parrot_id_changed?
+      assert_equal %w(parrot_id), pirate.changed
+      assert_nil pirate.parrot_id_was
+    end
 end

vendor/rails/activerecord/test/cases/finder_test.rb

@@ -9,6 +9,7 @@ require 'models/developer'
 require 'models/post'
 require 'models/customer'
 require 'models/job'
+require 'models/categorization'
 
 class FinderTest < ActiveRecord::TestCase
   fixtures :companies, :topics, :entrants, :developers, :developers_projects, :posts, :comments, :accounts, :authors, :customers
@@ -859,12 +860,17 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_with_order_on_included_associations_with_construct_finder_sql_for_association_limiting_and_is_distinct
-    assert_equal 2, Post.find(:all,:include=>{:authors=>:author_address},:order=>' author_addresses.id DESC ', :limit=>2).size
+    assert_equal 2, Post.find(:all, :include => { :authors => :author_address }, :order => ' author_addresses.id DESC ', :limit => 2).size
 
-    assert_equal 3, Post.find(:all,:include=>{:author=>:author_address,:authors=>:author_address},
-                              :order=>' author_addresses_authors.id DESC ', :limit=>3).size
+    assert_equal 3, Post.find(:all, :include => { :author => :author_address, :authors => :author_address},
+                              :order => ' author_addresses_authors.id DESC ', :limit => 3).size
   end
 
+  def test_with_limiting_with_custom_select
+    posts = Post.find(:all, :include => :author, :select => ' posts.*, authors.id as "author_id"', :limit => 3, :order => 'posts.id')
+    assert_equal 3, posts.size
+    assert_equal [0, 1, 1], posts.map(&:author_id).sort
+  end
 
   protected
     def bind(statement, *vars)

vendor/rails/activerecord/test/cases/fixtures_test.rb

@@ -610,15 +610,17 @@ class ActiveSupportSubclassWithFixturesTest < ActiveRecord::TestCase
 end
 
 class FixtureLoadingTest < ActiveRecord::TestCase
-  def test_logs_message_for_failed_dependency_load
-    Test::Unit::TestCase.expects(:require_dependency).with(:does_not_exist).raises(LoadError)
-    ActiveRecord::Base.logger.expects(:warn)
-    Test::Unit::TestCase.try_to_load_dependency(:does_not_exist)
-  end
+  uses_mocha 'reloading_fixtures_through_accessor_methods' do
+    def test_logs_message_for_failed_dependency_load
+      Test::Unit::TestCase.expects(:require_dependency).with(:does_not_exist).raises(LoadError)
+      ActiveRecord::Base.logger.expects(:warn)
+      Test::Unit::TestCase.try_to_load_dependency(:does_not_exist)
+    end
 
-  def test_does_not_logs_message_for_successful_dependency_load
-    Test::Unit::TestCase.expects(:require_dependency).with(:works_out_fine)
-    ActiveRecord::Base.logger.expects(:warn).never
-    Test::Unit::TestCase.try_to_load_dependency(:works_out_fine)
+    def test_does_not_logs_message_for_successful_dependency_load
+      Test::Unit::TestCase.expects(:require_dependency).with(:works_out_fine)
+      ActiveRecord::Base.logger.expects(:warn).never
+      Test::Unit::TestCase.try_to_load_dependency(:works_out_fine)
+    end
   end
 end

vendor/rails/activerecord/test/cases/inheritance_test.rb

@@ -6,6 +6,50 @@ require 'models/subscriber'
 class InheritanceTest < ActiveRecord::TestCase
   fixtures :companies, :projects, :subscribers, :accounts
 
+  def test_class_with_store_full_sti_class_returns_full_name
+    old = ActiveRecord::Base.store_full_sti_class
+    ActiveRecord::Base.store_full_sti_class = true
+    assert_equal 'Namespaced::Company', Namespaced::Company.sti_name
+  ensure
+    ActiveRecord::Base.store_full_sti_class = old
+  end
+
+  def test_class_without_store_full_sti_class_returns_demodulized_name
+    old = ActiveRecord::Base.store_full_sti_class
+    ActiveRecord::Base.store_full_sti_class = false
+    assert_equal 'Company', Namespaced::Company.sti_name
+  ensure
+    ActiveRecord::Base.store_full_sti_class = old
+  end
+
+  def test_should_store_demodulized_class_name_with_store_full_sti_class_option_disabled
+    old = ActiveRecord::Base.store_full_sti_class
+    ActiveRecord::Base.store_full_sti_class = false
+    item = Namespaced::Company.new
+    assert_equal 'Company', item[:type]
+  ensure
+    ActiveRecord::Base.store_full_sti_class = old
+  end
+  
+  def test_should_store_full_class_name_with_store_full_sti_class_option_enabled
+    old = ActiveRecord::Base.store_full_sti_class
+    ActiveRecord::Base.store_full_sti_class = true
+    item = Namespaced::Company.new
+    assert_equal 'Namespaced::Company', item[:type]
+  ensure
+    ActiveRecord::Base.store_full_sti_class = old
+  end
+  
+  def test_different_namespace_subclass_should_load_correctly_with_store_full_sti_class_option
+    old = ActiveRecord::Base.store_full_sti_class
+    ActiveRecord::Base.store_full_sti_class = true
+    item = Namespaced::Company.create :name => "Wolverine 2"
+    assert_not_nil Company.find(item.id)
+    assert_not_nil Namespaced::Company.find(item.id)
+  ensure
+    ActiveRecord::Base.store_full_sti_class = old
+  end
+
   def test_company_descends_from_active_record
     assert_raise(NoMethodError) { ActiveRecord::Base.descends_from_active_record? }
     assert AbstractCompany.descends_from_active_record?, 'AbstractCompany should descend from ActiveRecord::Base'

vendor/rails/activerecord/test/cases/method_scoping_test.rb

@@ -50,6 +50,22 @@ class MethodScopingTest < ActiveRecord::TestCase
     end
   end
 
+  def test_scoped_find_select
+    Developer.with_scope(:find => { :select => "id, name" }) do
+      developer = Developer.find(:first, :conditions => "name = 'David'")
+      assert_equal "David", developer.name
+      assert !developer.has_attribute?(:salary)
+    end
+  end
+
+  def test_options_select_replaces_scope_select
+    Developer.with_scope(:find => { :select => "id, name" }) do
+      developer = Developer.find(:first, :select => 'id, salary', :conditions => "name = 'David'")
+      assert_equal 80000, developer.salary
+      assert !developer.has_attribute?(:name)
+    end
+  end
+
   def test_scoped_count
     Developer.with_scope(:find => { :conditions => "name = 'David'" }) do
       assert_equal 1, Developer.count

vendor/rails/activerecord/test/cases/migration_test.rb

@@ -281,7 +281,7 @@ if ActiveRecord::Base.connection.supports_migrations?
       # Do a manual insertion
       if current_adapter?(:OracleAdapter)
         Person.connection.execute "insert into people (id, wealth) values (people_seq.nextval, 12345678901234567890.0123456789)"
-      elsif current_adapter?(:OpenBaseAdapter)
+      elsif current_adapter?(:OpenBaseAdapter) || (current_adapter?(:MysqlAdapter) && Mysql.client_version < 50003) #before mysql 5.0.3 decimals stored as strings
         Person.connection.execute "insert into people (wealth) values ('12345678901234567890.0123456789')"
       else
         Person.connection.execute "insert into people (wealth) values (12345678901234567890.0123456789)"
@@ -384,7 +384,7 @@ if ActiveRecord::Base.connection.supports_migrations?
           assert_not_equal "Z", bob.moment_of_truth.zone
           # US/Eastern is -5 hours from GMT
           assert_equal Rational(-5, 24), bob.moment_of_truth.offset
-          assert_equal "-05:00", bob.moment_of_truth.zone
+          assert_match /\A-05:?00\Z/, bob.moment_of_truth.zone #ruby 1.8.6 uses HH:MM, prior versions use HHMM
           assert_equal DateTime::ITALY, bob.moment_of_truth.start
         end
       end

vendor/rails/activerecord/test/cases/named_scope_test.rb

@@ -6,7 +6,7 @@ require 'models/reply'
 require 'models/author'
 
 class NamedScopeTest < ActiveRecord::TestCase
-  fixtures :posts, :authors, :topics
+  fixtures :posts, :authors, :topics, :comments
 
   def test_implements_enumerable
     assert !Topic.find(:all).empty?
@@ -95,7 +95,7 @@ class NamedScopeTest < ActiveRecord::TestCase
   end
 
   def test_has_many_through_associations_have_access_to_named_scopes
-    assert_not_equal Comment.containing_the_letter_e, authors(:david).posts
+    assert_not_equal Comment.containing_the_letter_e, authors(:david).comments
     assert !Comment.containing_the_letter_e.empty?
 
     assert_equal authors(:david).comments & Comment.containing_the_letter_e, authors(:david).comments.containing_the_letter_e
@@ -118,4 +118,40 @@ class NamedScopeTest < ActiveRecord::TestCase
     assert_equal expected_proxy_options, Topic.approved.proxy_options
   end
 
+  def test_first_and_last_should_support_find_options
+    assert_equal Topic.base.first(:order => 'title'), Topic.base.find(:first, :order => 'title')
+    assert_equal Topic.base.last(:order => 'title'), Topic.base.find(:last, :order => 'title')
+  end
+
+  def test_first_and_last_should_allow_integers_for_limit
+    assert_equal Topic.base.first(2), Topic.base.to_a.first(2)
+    assert_equal Topic.base.last(2), Topic.base.to_a.last(2)
+  end
+
+  def test_first_and_last_should_not_use_query_when_results_are_loaded
+    topics = Topic.base
+    topics.reload # force load
+    assert_no_queries do
+      topics.first
+      topics.last
+    end
+  end
+
+  def test_first_and_last_find_options_should_use_query_when_results_are_loaded
+    topics = Topic.base
+    topics.reload # force load
+    assert_queries(2) do
+      topics.first(:order => 'title')
+      topics.last(:order => 'title')
+    end
+  end
+
+  def test_empty_should_not_load_results
+    topics = Topic.base
+    assert_queries(2) do
+      topics.empty?  # use count query
+      topics.collect # force load
+      topics.empty?  # use loaded (no query)
+    end
+  end
 end

vendor/rails/activerecord/test/cases/reflection_test.rb

@@ -159,9 +159,10 @@ class ReflectionTest < ActiveRecord::TestCase
   end
 
   def test_reflection_of_all_associations
-    assert_equal 19, Firm.reflect_on_all_associations.size
+    # FIXME these assertions bust a lot
+    assert_equal 20, Firm.reflect_on_all_associations.size
     assert_equal 16, Firm.reflect_on_all_associations(:has_many).size
-    assert_equal 3, Firm.reflect_on_all_associations(:has_one).size
+    assert_equal 4, Firm.reflect_on_all_associations(:has_one).size
     assert_equal 0, Firm.reflect_on_all_associations(:belongs_to).size
   end
 

vendor/rails/activerecord/test/cases/transactions_test.rb

@@ -179,6 +179,32 @@ class TransactionTest < ActiveRecord::TestCase
     end
   end
 
+  def test_sqlite_add_column_in_transaction_raises_statement_invalid
+    return true unless current_adapter?(:SQLite3Adapter, :SQLiteAdapter)
+
+    # Test first if column creation/deletion works correctly when no
+    # transaction is in place.
+    #
+    # We go back to the connection for the column queries because
+    # Topic.columns is cached and won't report changes to the DB
+    
+    assert_nothing_raised do
+      Topic.reset_column_information
+      Topic.connection.add_column('topics', 'stuff', :string)
+      assert Topic.column_names.include?('stuff')
+      
+      Topic.reset_column_information
+      Topic.connection.remove_column('topics', 'stuff')
+      assert !Topic.column_names.include?('stuff')
+    end
+
+    # Test now inside a transaction: add_column should raise a StatementInvalid
+    Topic.transaction do
+      assert_raises(ActiveRecord::StatementInvalid) { Topic.connection.add_column('topics', 'stuff', :string) }
+      raise ActiveRecord::Rollback
+    end
+  end
+
   private
     def add_exception_raising_after_save_callback_to_topic
       Topic.class_eval { def after_save() raise "Make the transaction rollback" end }

vendor/rails/activerecord/test/cases/validations_test.rb

@@ -583,6 +583,12 @@ class ValidationsTest < ActiveRecord::TestCase
     assert_nil t.errors.on(:title)
   end
 
+  def test_validate_format_with_formatted_message
+    Topic.validates_format_of(:title, :with => /^Valid Title$/, :message => "can't be %s")
+    t = Topic.create(:title => 'Invalid title')
+    assert_equal "can't be Invalid title", t.errors.on(:title)
+  end
+
   def test_validates_inclusion_of
     Topic.validates_inclusion_of( :title, :in => %w( a b c d e f g ) )
 

vendor/rails/activerecord/test/models/company.rb

@@ -15,6 +15,10 @@ class Company < AbstractCompany
   end
 end
 
+module Namespaced
+  class Company < ::Company
+  end
+end
 
 class Firm < Company
   has_many :clients, :order => "id", :dependent => :destroy, :counter_sql =>
@@ -43,6 +47,7 @@ class Firm < Company
   has_many :readonly_clients, :class_name => 'Client', :readonly => true
 
   has_one :account, :foreign_key => "firm_id", :dependent => :destroy
+  has_one :account_with_select, :foreign_key => "firm_id", :select => "id, firm_id", :class_name=>'Account'
   has_one :readonly_account, :foreign_key => "firm_id", :class_name => "Account", :readonly => true
 end
 
@@ -60,6 +65,7 @@ end
 class Client < Company
   belongs_to :firm, :foreign_key => "client_of"
   belongs_to :firm_with_basic_id, :class_name => "Firm", :foreign_key => "firm_id"
+  belongs_to :firm_with_select, :class_name => "Firm", :foreign_key => "firm_id", :select => "id"
   belongs_to :firm_with_other_name, :class_name => "Firm", :foreign_key => "client_of"
   belongs_to :firm_with_condition, :class_name => "Firm", :foreign_key => "client_of", :conditions => ["1 = ?", 1]
   belongs_to :readonly_firm, :class_name => "Firm", :foreign_key => "firm_id", :readonly => true

vendor/rails/activerecord/test/models/pirate.rb

@@ -4,4 +4,6 @@ class Pirate < ActiveRecord::Base
   has_many :treasures, :as => :looter
 
   has_many :treasure_estimates, :through => :treasures, :source => :price_estimates
+
+  validates_presence_of :catchphrase
 end