ibm_db 5.6.1 → 5.7.0

data/test/cases/multi_db_migrator_test.rb

@@ -4,8 +4,6 @@ require "cases/helper"
 require "cases/migration/helper"
 
 class MultiDbMigratorTest < ActiveRecord::TestCase
-  self.use_transactional_tests = false
-
   # Use this class to sense if migrations have gone
   # up or down.
   class Sensor < ActiveRecord::Migration::Current
@@ -23,22 +21,25 @@ class MultiDbMigratorTest < ActiveRecord::TestCase
 
   def setup
     super
-    @connection_a = ActiveRecord::Base.connection
-    @connection_b = ARUnit2Model.connection
+    @pool_a = ActiveRecord::Base.connection_pool
+    @pool_b = ARUnit2Model.connection_pool
 
-    @connection_a.schema_migration.create_table
-    @connection_b.schema_migration.create_table
+    @pool_a.schema_migration.create_table
+    @pool_b.schema_migration.create_table
 
-    @connection_a.schema_migration.delete_all rescue nil
-    @connection_b.schema_migration.delete_all rescue nil
+    @pool_a.schema_migration.delete_all_versions rescue nil
+    @pool_b.schema_migration.delete_all_versions rescue nil
 
     @path_a = MIGRATIONS_ROOT + "/valid"
     @path_b = MIGRATIONS_ROOT + "/to_copy"
 
-    @schema_migration_a = @connection_a.schema_migration
-    @migrations_a = ActiveRecord::MigrationContext.new(@path_a, @schema_migration_a).migrations
-    @schema_migration_b = @connection_b.schema_migration
-    @migrations_b = ActiveRecord::MigrationContext.new(@path_b, @schema_migration_b).migrations
+    @schema_migration_a = @pool_a.schema_migration
+    @internal_metadata_a = @pool_a.internal_metadata
+    @migrations_a = ActiveRecord::MigrationContext.new(@path_a, @schema_migration_a, @internal_metadata_a).migrations
+
+    @schema_migration_b = @pool_b.schema_migration
+    @internal_metadata_b = @pool_b.internal_metadata
+    @migrations_b = ActiveRecord::MigrationContext.new(@path_b, @schema_migration_b, @internal_metadata_b).migrations
 
     @migrations_a_list = [[1, "ValidPeopleHaveLastNames"], [2, "WeNeedReminders"], [3, "InnocentJointable"]]
     @migrations_b_list = [[1, "PeopleHaveHobbies"], [2, "PeopleHaveDescriptions"]]
@@ -55,8 +56,8 @@ class MultiDbMigratorTest < ActiveRecord::TestCase
   end
 
   teardown do
-    @connection_a.schema_migration.delete_all rescue nil
-    @connection_b.schema_migration.delete_all rescue nil
+    @pool_q.schema_migration.delete_all_versions rescue nil
+    @pool_b.schema_migration.delete_all_versions rescue nil
 
     ActiveRecord::Migration.verbose = @verbose_was
     ActiveRecord::Migration.class_eval do
@@ -67,9 +68,16 @@ class MultiDbMigratorTest < ActiveRecord::TestCase
     end
   end
 
-  def test_schema_migration_class_names
-    assert_equal "ActiveRecord::SchemaMigration", @schema_migration_a.name
-    assert_equal "ARUnit2Model::SchemaMigration", @schema_migration_b.name
+  def test_schema_migration_is_different_for_different_connections
+    assert_not_equal @schema_migration_a, @schema_migration_b
+    assert_not_equal @schema_migration_a.instance_variable_get(:@pool), @schema_migration_b.instance_variable_get(:@pool)
+    if @pool_a.pool_config.respond_to?(:connection_descriptor)
+      assert_equal "ActiveRecord::Base", @pool_a.pool_config.connection_descriptor.name
+      assert_equal "ARUnit2Model", @pool_b.pool_config.connection_descriptor.name
+    else
+      assert_equal "ActiveRecord::Base", @pool_a.pool_config.connection_class.name
+      assert_equal "ARUnit2Model", @pool_b.pool_config.connection_class.name
+    end
   end
 
   def test_finds_migrations
@@ -85,23 +93,23 @@ class MultiDbMigratorTest < ActiveRecord::TestCase
   end
 
   def test_migrations_status
-    @schema_migration_a.create(version: 2)
-    @schema_migration_a.create(version: 10)
+    @schema_migration_a.create_version(2)
+    @schema_migration_a.create_version(10)
 
     assert_equal [
       ["down", "001", "Valid people have last names"],
       ["up",   "002", "We need reminders"],
       ["down", "003", "Innocent jointable"],
       ["up",   "010", "********** NO FILE **********"],
-    ], ActiveRecord::MigrationContext.new(@path_a, @schema_migration_a).migrations_status
+    ], ActiveRecord::MigrationContext.new(@path_a, @schema_migration_a, @internal_metadata_a).migrations_status
 
-    @schema_migration_b.create(version: 4)
+    @schema_migration_b.create_version(4)
 
     assert_equal [
       ["down", "001", "People have hobbies"],
       ["down", "002", "People have descriptions"],
       ["up", "004", "********** NO FILE **********"]
-    ], ActiveRecord::MigrationContext.new(@path_b, @schema_migration_b).migrations_status
+    ], ActiveRecord::MigrationContext.new(@path_b, @schema_migration_b, @internal_metadata_b).migrations_status
   end
 
   def test_get_all_versions
@@ -134,16 +142,16 @@ class MultiDbMigratorTest < ActiveRecord::TestCase
   end
 
   def test_finds_pending_migrations
-    @schema_migration_a.create!(version: "1")
+    @schema_migration_a.create_version("1")
     migration_list_a = [ActiveRecord::Migration.new("foo", 1), ActiveRecord::Migration.new("bar", 3)]
-    migrations_a = ActiveRecord::Migrator.new(:up, migration_list_a, @schema_migration_a).pending_migrations
+    migrations_a = ActiveRecord::Migrator.new(:up, migration_list_a, @schema_migration_a, @internal_metadata_a).pending_migrations
 
     assert_equal 1, migrations_a.size
     assert_equal migration_list_a.last, migrations_a.first
 
-    @schema_migration_b.create!(version: "1")
+    @schema_migration_b.create_version("1")
     migration_list_b = [ActiveRecord::Migration.new("foo", 1), ActiveRecord::Migration.new("bar", 3)]
-    migrations_b = ActiveRecord::Migrator.new(:up, migration_list_b, @schema_migration_b).pending_migrations
+    migrations_b = ActiveRecord::Migrator.new(:up, migration_list_b, @schema_migration_b, @internal_metadata_b).pending_migrations
 
     assert_equal 1, migrations_b.size
     assert_equal migration_list_b.last, migrations_b.first
@@ -151,25 +159,27 @@ class MultiDbMigratorTest < ActiveRecord::TestCase
 
   def test_migrator_db_has_no_schema_migrations_table
     _, migrator = migrator_class(3)
-    migrator = migrator.new(@path_a, @schema_migration_a)
+    migrator = migrator.new(@path_a, @schema_migration_a, @internal_metadata_a)
 
     @schema_migration_a.drop_table
-    assert_not @connection_a.table_exists?("schema_migrations")
+    assert_not @pool_a.lease_connection.table_exists?("schema_migrations")
     migrator.migrate(1)
-    assert @connection_a.table_exists?("schema_migrations")
+    assert @pool_a.lease_connection.table_exists?("schema_migrations")
+    migrator.rollback
 
     _, migrator = migrator_class(3)
-    migrator = migrator.new(@path_b, @schema_migration_b)
+    migrator = migrator.new(@path_b, @schema_migration_b, @internal_metadata_b)
 
     @schema_migration_b.drop_table
-    assert_not @connection_b.table_exists?("schema_migrations")
+    assert_not @pool_b.lease_connection.table_exists?("schema_migrations")
     migrator.migrate(1)
-    assert @connection_b.table_exists?("schema_migrations")
+    assert @pool_b.lease_connection.table_exists?("schema_migrations")
+    migrator.rollback
   end
 
   def test_migrator_forward
     _, migrator = migrator_class(3)
-    migrator = migrator.new(@path_a, @schema_migration_a)
+    migrator = migrator.new(@path_a, @schema_migration_a, @internal_metadata_a)
     migrator.migrate(1)
     assert_equal(1, migrator.current_version)
 
@@ -180,7 +190,7 @@ class MultiDbMigratorTest < ActiveRecord::TestCase
     assert_equal(3, migrator.current_version)
 
     _, migrator_b = migrator_class(3)
-    migrator_b = migrator_b.new(@path_b, @schema_migration_b)
+    migrator_b = migrator_b.new(@path_b, @schema_migration_b, @internal_metadata_b)
     migrator_b.migrate(1)
     assert_equal(1, migrator_b.current_version)
 
@@ -191,6 +201,17 @@ class MultiDbMigratorTest < ActiveRecord::TestCase
     assert_equal(3, migrator_b.current_version)
   end
 
+  def test_internal_metadata_stores_environment
+    current_env     = ActiveRecord::Base.lease_connection.pool.db_config.env_name
+    migrations_path = MIGRATIONS_ROOT + "/valid"
+    migrator = ActiveRecord::MigrationContext.new(migrations_path, @schema_migration_b, @internal_metadata_b)
+
+    migrator.up
+    assert_equal current_env, @internal_metadata_b[:environment]
+  ensure
+    migrator.down if migrator && !current_adapter?(:IBM_DBAdapter)
+  end
+
   private
     def m(name, version)
       x = Sensor.new name, version

data/test/cases/multiparameter_attributes_test.rb

@@ -107,8 +107,8 @@ class MultiParameterAttributeTest < ActiveRecord::TestCase
     }
     topic = Topic.find(1)
     topic.attributes = attributes
-    # testing against to_s(:db) representation because either a Time or a DateTime might be returned, depending on platform
-    assert_equal "1850-06-24 16:24:00", topic.written_on.to_s(:db)
+    # testing against to_fs(:db) representation because either a Time or a DateTime might be returned, depending on platform
+    assert_equal "1850-06-24 16:24:00", topic.written_on.to_fs(:db)
   end
 
   def test_multiparameter_attributes_on_time_will_raise_on_big_time_if_missing_date_parts
@@ -249,36 +249,33 @@ class MultiParameterAttributeTest < ActiveRecord::TestCase
     Topic.reset_column_information
   end
 
-  # Oracle does not have a TIME datatype.
-  unless current_adapter?(:OracleAdapter)
-    def test_multiparameter_attributes_on_time_only_column_with_time_zone_aware_attributes_does_not_do_time_zone_conversion
-      with_timezone_config default: :utc, aware_attributes: true, zone: -28800 do
-        Topic.reset_column_information
-        attributes = {
-          "bonus_time(1i)" => "2000", "bonus_time(2i)" => "1", "bonus_time(3i)" => "1",
-          "bonus_time(4i)" => "16", "bonus_time(5i)" => "24"
-        }
-        topic = Topic.find(1)
-        topic.attributes = attributes
-        assert_equal Time.zone.local(2000, 1, 1, 16, 24, 0), topic.bonus_time
-        assert_not_predicate topic.bonus_time, :utc?
-
-        attributes = {
-          "written_on(1i)" => "2000", "written_on(2i)" => "", "written_on(3i)" => "",
-          "written_on(4i)" => "", "written_on(5i)" => ""
-        }
-        topic.attributes = attributes
-        assert_nil topic.written_on
-      end
-    ensure
+  def test_multiparameter_attributes_on_time_only_column_with_time_zone_aware_attributes_does_not_do_time_zone_conversion
+    with_timezone_config default: :utc, aware_attributes: true, zone: -28800 do
       Topic.reset_column_information
-    end
+      attributes = {
+        "bonus_time(1i)" => "2000", "bonus_time(2i)" => "1", "bonus_time(3i)" => "1",
+        "bonus_time(4i)" => "16", "bonus_time(5i)" => "24"
+      }
+      topic = Topic.find(1)
+      topic.attributes = attributes
+      assert_equal Time.zone.local(2000, 1, 1, 16, 24, 0), topic.bonus_time
+      assert_not_predicate topic.bonus_time, :utc?
 
-    def test_multiparameter_attributes_setting_time_attribute
-      topic = Topic.new("bonus_time(4i)" => "01", "bonus_time(5i)" => "05")
-      assert_equal 1, topic.bonus_time.hour
-      assert_equal 5, topic.bonus_time.min
+      attributes = {
+        "written_on(1i)" => "2000", "written_on(2i)" => "", "written_on(3i)" => "",
+        "written_on(4i)" => "", "written_on(5i)" => ""
+      }
+      topic.attributes = attributes
+      assert_nil topic.written_on
     end
+  ensure
+    Topic.reset_column_information
+  end
+
+  def test_multiparameter_attributes_setting_time_attribute
+    topic = Topic.new("bonus_time(4i)" => "01", "bonus_time(5i)" => "05")
+    assert_equal 1, topic.bonus_time.hour
+    assert_equal 5, topic.bonus_time.min
   end
 
   def test_multiparameter_attributes_on_time_with_empty_seconds

data/test/cases/multiple_db_test.rb

@@ -9,26 +9,26 @@ class MultipleDbTest < ActiveRecord::TestCase
   self.use_transactional_tests = false
 
   def setup
-    @courses  = create_fixtures("courses") { Course.retrieve_connection }
-    @colleges = create_fixtures("colleges") { College.retrieve_connection }
+    @courses  = create_fixtures("courses")
+    @colleges = create_fixtures("colleges")
     @entrants = create_fixtures("entrants")
   end
 
   def test_connected
-    assert_not_nil Entrant.connection
-    assert_not_nil Course.connection
+    assert_not_nil Entrant.lease_connection
+    assert_not_nil Course.lease_connection
   end
 
   def test_proper_connection
-    assert_not_equal(Entrant.connection, Course.connection)
-    assert_equal(Entrant.connection, Entrant.retrieve_connection)
-    assert_equal(Course.connection, Course.retrieve_connection)
-    assert_equal(ActiveRecord::Base.connection, Entrant.connection)
+    assert_not_equal(Entrant.lease_connection, Course.lease_connection)
+    assert_equal(Entrant.lease_connection, Entrant.retrieve_connection)
+    assert_equal(Course.lease_connection, Course.retrieve_connection)
+    assert_equal(ActiveRecord::Base.lease_connection, Entrant.lease_connection)
   end
 
   def test_swapping_the_connection
     old_spec_name, Course.connection_specification_name = Course.connection_specification_name, "ActiveRecord::Base"
-    assert_equal(Entrant.connection, Course.connection)
+    assert_equal(Entrant.lease_connection, Course.lease_connection)
   ensure
     Course.connection_specification_name = old_spec_name
   end
@@ -58,12 +58,12 @@ class MultipleDbTest < ActiveRecord::TestCase
   end
 
   def test_course_connection_should_survive_reloads
-    assert Course.connection
+    assert Course.lease_connection
 
     assert Object.send(:remove_const, :Course)
     assert load("models/course.rb")
 
-    assert Course.connection
+    assert Course.lease_connection
   end
 
   def test_transactions_across_databases
@@ -92,25 +92,48 @@ class MultipleDbTest < ActiveRecord::TestCase
   end
 
   def test_connection
-    assert_same Entrant.connection, Bird.connection
-    assert_not_same Entrant.connection, Course.connection
+    assert_same Entrant.lease_connection, Bird.lease_connection
+    assert_not_same Entrant.lease_connection, Course.lease_connection
   end
 
   unless in_memory_db?
     def test_count_on_custom_connection
-      ActiveRecord::Base.remove_connection
+      assert_equal ARUnit2Model.lease_connection, College.lease_connection
+      assert_not_equal ActiveRecord::Base.lease_connection, College.lease_connection
       assert_equal 1, College.count
-    ensure
-      ActiveRecord::Base.establish_connection :arunit
     end
 
     def test_associations_should_work_when_model_has_no_connection
-      ActiveRecord::Base.remove_connection
       assert_nothing_raised do
         College.first.courses.first
       end
-    ensure
-      ActiveRecord::Base.establish_connection :arunit
     end
   end
+
+  def test_exception_contains_connection_pool
+    error = assert_raises(ActiveRecord::StatementInvalid) do
+      Course.where(wrong_column: "wrong").first!
+    end
+
+    assert_equal Course.lease_connection.pool, error.connection_pool
+  end
+
+  def test_exception_contains_correct_pool
+    course_conn = Course.lease_connection
+    entrant_conn = Entrant.lease_connection
+
+    assert_not_equal course_conn, entrant_conn
+
+    course_error = assert_raises(ActiveRecord::StatementInvalid) do
+      course_conn.execute("SELECT * FROM entrants")
+    end
+
+    assert_equal course_conn.pool, course_error.connection_pool
+
+    entrant_error = assert_raises(ActiveRecord::StatementInvalid) do
+      entrant_conn.execute("SELECT * FROM courses")
+    end
+
+    assert_equal entrant_conn.pool, entrant_error.connection_pool
+  end
 end

data/test/cases/nested_attributes_test.rb

@@ -2,6 +2,7 @@
 
 require "cases/helper"
 require "models/pirate"
+require "models/developer"
 require "models/ship"
 require "models/ship_part"
 require "models/bird"
@@ -11,6 +12,9 @@ require "models/human"
 require "models/interest"
 require "models/owner"
 require "models/pet"
+require "models/entry"
+require "models/message"
+require "models/cpk"
 require "active_support/hash_with_indifferent_access"
 
 class TestNestedAttributesInGeneral < ActiveRecord::TestCase
@@ -229,6 +233,17 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
       )
     end
   end
+
+  def test_updating_models_with_cpk_provided_as_strings
+    book = Cpk::Book.create!(id: [1, 2], shop_id: 3)
+    book.chapters.create!(id: [1, 3], title: "Title")
+
+    assert_queries_count(4) do
+      book.update!(chapters_attributes: { id: ["1", "3"], title: "New title" })
+    end
+    assert_equal 1, book.reload.chapters.count
+    assert_equal "New title", book.chapters.first.title
+  end
 end
 
 class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
@@ -359,6 +374,15 @@ class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
     assert_equal "Mister Pablo", @pirate.ship.name
   end
 
+  def test_should_defer_updating_nested_associations_until_after_base_attributes_are_set
+    ship = @pirate.ship
+
+    ship_part = ShipPart.new
+    ship_part.attributes = { ship_attributes: { name: "Prometheus" }, ship_id: ship.id }
+
+    assert_equal "Prometheus", ship_part.ship.name
+  end
+
   def test_should_not_destroy_the_associated_model_until_the_parent_is_saved
     @pirate.attributes = { ship_attributes: { id: @ship.id, _destroy: "1" } }
 
@@ -377,6 +401,7 @@ class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
 
   def test_should_accept_update_only_option
     @pirate.update(update_only_ship_attributes: { id: @pirate.ship.id, name: "Mayflower" })
+    assert_equal "Mayflower", @pirate.reload.ship.name
   end
 
   def test_should_create_new_model_when_nothing_is_there_and_update_only_is_true
@@ -419,6 +444,13 @@ class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
 
     Pirate.accepts_nested_attributes_for :update_only_ship, update_only: true, allow_destroy: false
   end
+
+  def test_should_raise_an_argument_error_if_something_other_than_a_hash_is_passed_in
+    exception = assert_raise ArgumentError do
+      @pirate.update(ship_attributes: "foo")
+    end
+    assert_equal "Hash expected for `ship` attributes, got String", exception.message
+  end
 end
 
 class TestNestedAttributesOnABelongsToAssociation < ActiveRecord::TestCase
@@ -595,6 +627,13 @@ class TestNestedAttributesOnABelongsToAssociation < ActiveRecord::TestCase
 
     Ship.accepts_nested_attributes_for :update_only_pirate, update_only: true, allow_destroy: false
   end
+
+  def test_should_raise_an_argument_error_if_something_other_than_a_hash_is_passed_in
+    exception = assert_raise ArgumentError do
+      @ship.update(pirate_attributes: "foo")
+    end
+    assert_equal "Hash expected for `pirate` attributes, got String", exception.message
+  end
 end
 
 module NestedAttributesOnACollectionAssociationTests
@@ -765,7 +804,7 @@ module NestedAttributesOnACollectionAssociationTests
     exception = assert_raise ArgumentError do
       @pirate.public_send(association_setter, "foo")
     end
-    assert_equal %{Hash or Array expected for attribute `#{@association_name}`, got String ("foo")}, exception.message
+    assert_equal %{Hash or Array expected for `#{@association_name}` attributes, got String}, exception.message
   end
 
   def test_should_work_with_update_as_well
@@ -850,6 +889,21 @@ module NestedAttributesOnACollectionAssociationTests
     end
   end
 
+  def test_assigning_nested_attributes_target
+    params = @alternate_params[association_getter].values
+    @pirate.public_send(association_setter, params)
+    @pirate.save
+    assert_equal [@child_1, @child_2], @pirate.association(@association_name).nested_attributes_target
+  end
+
+  def test_assigning_nested_attributes_target_with_nil_placeholder_for_rejected_item
+    params = @alternate_params[association_getter].values
+    params.insert(1, {})
+    @pirate.public_send(association_setter, params)
+    @pirate.save
+    assert_equal [@child_1, nil, @child_2], @pirate.association(@association_name).nested_attributes_target
+  end
+
   private
     def association_setter
       @association_setter ||= "#{@association_name}_attributes=".to_sym
@@ -1093,7 +1147,7 @@ class TestHasManyAutosaveAssociationWhichItselfHasAutosaveAssociations < ActiveR
     part = ship.parts.build(name: "Stern")
     ship.treasures.build(looter: part)
 
-    assert_queries 3 do
+    assert_queries_count(5) do
       ship.save!
     end
   end
@@ -1106,14 +1160,78 @@ class TestHasManyAutosaveAssociationWhichItselfHasAutosaveAssociations < ActiveR
   end
 end
 
-class TestNestedAttributesWithExtend < ActiveRecord::TestCase
-  setup do
-    Pirate.accepts_nested_attributes_for :treasures
+class TestIndexErrorsWithNestedAttributesOnlyMode < ActiveRecord::TestCase
+  def setup
+    tuning_peg_class = Class.new(ActiveRecord::Base) do
+      self.table_name = "tuning_pegs"
+      def self.name; "TuningPeg"; end
+
+      validates_numericality_of :pitch
+    end
+
+    @guitar_class = Class.new(ActiveRecord::Base) do
+      has_many :tuning_pegs, index_errors: :nested_attributes_order, anonymous_class: tuning_peg_class
+      accepts_nested_attributes_for :tuning_pegs, reject_if: lambda { |attrs| attrs[:pitch]&.odd? }
+
+      def self.name; "Guitar"; end
+    end
   end
 
+  test "index in nested_attributes_order order" do
+    guitar = @guitar_class.create!
+    guitar.tuning_pegs.create!(pitch: 1)
+    peg2 = guitar.tuning_pegs.create!(pitch: 2)
+
+    assert_predicate guitar, :valid?
+
+    guitar.update(tuning_pegs_attributes: [{ id: peg2.id, pitch: nil }])
+
+    assert_not_predicate guitar, :valid?
+    assert_equal [:"tuning_pegs[0].pitch"], guitar.errors.messages.keys
+  end
+
+  test "index unaffected by reject_if" do
+    guitar = @guitar_class.create!
+
+    guitar.update(
+      tuning_pegs_attributes: [
+        { pitch: 1 },
+        { pitch: nil },
+      ]
+    )
+
+    assert_not_predicate guitar, :valid?
+    assert_equal [:"tuning_pegs[1].pitch"], guitar.errors.messages.keys
+  end
+end
+
+class TestNestedAttributesWithExtend < ActiveRecord::TestCase
   def test_extend_affects_nested_attributes
-    pirate = Pirate.create!(catchphrase: "Don' botharrr talkin' like one, savvy?")
+    super_pirate = Class.new(ActiveRecord::Base) do
+      self.table_name = "pirates"
+
+      has_many :treasures, as: :looter, extend: Pirate::PostTreasuresExtension
+      self.accepts_nested_attributes_for :treasures
+
+      def self.name
+        "SuperPirate"
+      end
+    end
+
+    pirate = super_pirate.create!(catchphrase: "Don' botharrr talkin' like one, savvy?")
     pirate.treasures_attributes = [{ id: nil }]
     assert_equal "from extension", pirate.treasures[0].name
   end
 end
+
+class TestNestedAttributesForDelegatedType < ActiveRecord::TestCase
+  setup do
+    Entry.accepts_nested_attributes_for :entryable
+    @entry = Entry.new(entryable_type: "Message", entryable_attributes: { subject: "Hello world!" })
+  end
+
+  def test_should_build_a_new_record_based_on_the_delegated_type
+    assert_not_predicate @entry.entryable, :persisted?
+    assert_equal "Hello world!", @entry.entryable.subject
+  end
+end

data/test/cases/nested_attributes_with_callbacks_test.rb

@@ -138,9 +138,9 @@ class NestedAttributesWithCallbacksTest < ActiveRecord::TestCase
 
   def assert_assignment_affects_records_in_target(association_name)
     association = @pirate.public_send(association_name)
-    assert association.detect { |b| b == bird_to_update }.name_changed?,
+    assert_predicate association.detect { |b| b == bird_to_update }, :name_changed?,
       "Update record not updated"
-    assert association.detect { |b| b == bird_to_destroy }.marked_for_destruction?,
+    assert_predicate association.detect { |b| b == bird_to_destroy }, :marked_for_destruction?,
       "Destroy record not marked for destruction"
   end
 end