ibm_db 5.6.1 → 5.7.0

data/test/cases/defaults_test.rb

@@ -14,10 +14,10 @@ class DefaultTest < ActiveRecord::TestCase
     end
   end
 
-  if current_adapter?(:PostgreSQLAdapter)
+  if current_adapter?(:PostgreSQLAdapter) || current_adapter?(:SQLite3Adapter)
     def test_multiline_default_text
       record = Default.new
-      # older postgres versions represent the default with escapes ("\\012" for a newline)
+      # older PostgreSQL versions represent the default with escapes ("\\012" for a newline)
       assert("--- []\n\n" == record.multiline_default || "--- []\\012\\012" == record.multiline_default)
     end
   end
@@ -27,7 +27,7 @@ class DefaultNumbersTest < ActiveRecord::TestCase
   class DefaultNumber < ActiveRecord::Base; end
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table :default_numbers do |t|
       t.integer :positive_integer, default: 7
       t.integer :negative_integer, default: -5
@@ -62,7 +62,7 @@ class DefaultStringsTest < ActiveRecord::TestCase
   class DefaultString < ActiveRecord::Base; end
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table :default_strings do |t|
       t.string :string_col, default: "Smith"
       t.string :string_col_with_quotes, default: "O'Connor"
@@ -83,12 +83,45 @@ class DefaultStringsTest < ActiveRecord::TestCase
   end
 end
 
-if supports_text_column_with_default?
-  class DefaultTextTest < ActiveRecord::TestCase
+class DefaultBinaryTest < ActiveRecord::TestCase
+  if current_adapter?(:SQLite3Adapter, :PostgreSQLAdapter)
+    class DefaultBinary < ActiveRecord::Base; end
+
+    setup do
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.create_table :default_binaries do |t|
+        t.binary :varbinary_col, null: false, limit: 64, default: "varbinary_default"
+        t.binary :varbinary_col_hex_looking, null: false, limit: 64, default: "0xDEADBEEF"
+      end
+      DefaultBinary.reset_column_information
+    end
+
+    def test_default_varbinary_string
+      assert_equal "varbinary_default", DefaultBinary.new.varbinary_col
+    end
+
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter) && !ActiveRecord::Base.lease_connection.mariadb?
+      def test_default_binary_string
+        assert_equal "binary_default", DefaultBinary.new.binary_col
+      end
+    end
+
+    def test_default_varbinary_string_that_looks_like_hex
+      assert_equal "0xDEADBEEF", DefaultBinary.new.varbinary_col_hex_looking
+    end
+
+    teardown do
+      @connection.drop_table :default_binaries
+    end
+  end
+end
+
+class DefaultTextTest < ActiveRecord::TestCase
+  if supports_text_column_with_default?
     class DefaultText < ActiveRecord::Base; end
 
     setup do
-      @connection = ActiveRecord::Base.connection
+      @connection = ActiveRecord::Base.lease_connection
       @connection.create_table :default_texts do |t|
         t.text :text_col, default: "Smith"
         t.text :text_col_with_quotes, default: "O'Connor"
@@ -110,18 +143,22 @@ if supports_text_column_with_default?
   end
 end
 
-if current_adapter?(:PostgreSQLAdapter)
-  class PostgresqlDefaultExpressionTest < ActiveRecord::TestCase
+class PostgresqlDefaultExpressionTest < ActiveRecord::TestCase
+  if current_adapter?(:PostgreSQLAdapter)
     include SchemaDumpingHelper
 
     test "schema dump includes default expression" do
       output = dump_table_schema("defaults")
-      if ActiveRecord::Base.connection.database_version >= 100000
+      if ActiveRecord::Base.lease_connection.database_version >= 100000
         assert_match %r/t\.date\s+"modified_date",\s+default: -> { "CURRENT_DATE" }/, output
         assert_match %r/t\.datetime\s+"modified_time",\s+default: -> { "CURRENT_TIMESTAMP" }/, output
+        assert_match %r/t\.datetime\s+"modified_time_without_precision",\s+precision: nil,\s+default: -> { "CURRENT_TIMESTAMP" }/, output
+        assert_match %r/t\.datetime\s+"modified_time_with_precision_0",\s+precision: 0,\s+default: -> { "CURRENT_TIMESTAMP" }/, output
       else
         assert_match %r/t\.date\s+"modified_date",\s+default: -> { "\('now'::text\)::date" }/, output
         assert_match %r/t\.datetime\s+"modified_time",\s+default: -> { "now\(\)" }/, output
+        assert_match %r/t\.datetime\s+"modified_time_without_precision",\s+precision: nil,\s+default: -> { "now\(\)" }/, output
+        assert_match %r/t\.datetime\s+"modified_time_with_precision_0",\s+precision: 0,\s+default: -> { "now\(\)" }/, output
       end
       assert_match %r/t\.date\s+"modified_date_function",\s+default: -> { "now\(\)" }/, output
       assert_match %r/t\.datetime\s+"modified_time_function",\s+default: -> { "now\(\)" }/, output
@@ -129,46 +166,61 @@ if current_adapter?(:PostgreSQLAdapter)
   end
 end
 
-if current_adapter?(:Mysql2Adapter)
-  class MysqlDefaultExpressionTest < ActiveRecord::TestCase
+class MysqlDefaultExpressionTest < ActiveRecord::TestCase
+  if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
     include SchemaDumpingHelper
 
     if supports_default_expression?
       test "schema dump includes default expression" do
         output = dump_table_schema("defaults")
-        assert_match %r/t\.binary\s+"uuid",\s+limit: 36,\s+default: -> { "\(uuid\(\)\)" }/i, output
+        assert_match %r/t\.binary\s+"uuid",\s+limit: 36,\s+default: -> { "\(?uuid\(\)\)?" }/i, output
       end
-    end
 
-    if supports_datetime_with_precision?
-      test "schema dump datetime includes default expression" do
-        output = dump_table_schema("datetime_defaults")
-        assert_match %r/t\.datetime\s+"modified_datetime",\s+default: -> { "CURRENT_TIMESTAMP(?:\(\))?" }/i, output
+      test "schema dump includes default expression with single quotes reflected correctly" do
+        output = dump_table_schema("defaults")
+        assert_match %r/t\.string\s+"char2_concatenated",\s+default: -> { "\(?concat\(`char2`,(_utf8mb4)?'-'\)\)?" }/i, output
       end
+    end
 
-      test "schema dump datetime includes precise default expression" do
-        output = dump_table_schema("datetime_defaults")
-        assert_match %r/t\.datetime\s+"precise_datetime",.+default: -> { "CURRENT_TIMESTAMP\(6\)" }/i, output
-      end
+    test "schema dump datetime includes default expression" do
+      output = dump_table_schema("datetime_defaults")
+      assert_match %r/t\.datetime\s+"modified_datetime",\s+precision: nil,\s+default: -> { "CURRENT_TIMESTAMP(?:\(\))?" }/i, output
+    end
 
-      test "schema dump timestamp includes default expression" do
-        output = dump_table_schema("timestamp_defaults")
-        assert_match %r/t\.timestamp\s+"modified_timestamp",\s+default: -> { "CURRENT_TIMESTAMP(?:\(\))?" }/i, output
-      end
+    test "schema dump datetime includes precise default expression" do
+      output = dump_table_schema("datetime_defaults")
+      assert_match %r/t\.datetime\s+"precise_datetime",\s+default: -> { "CURRENT_TIMESTAMP\(6\)" }/i, output
+    end
 
-      test "schema dump timestamp includes precise default expression" do
-        output = dump_table_schema("timestamp_defaults")
-        assert_match %r/t\.timestamp\s+"precise_timestamp",.+default: -> { "CURRENT_TIMESTAMP\(6\)" }/i, output
-      end
+    test "schema dump datetime includes precise default expression with on update" do
+      output = dump_table_schema("datetime_defaults")
+      assert_match %r/t\.datetime\s+"updated_datetime",\s+default: -> { "CURRENT_TIMESTAMP\(6\) ON UPDATE CURRENT_TIMESTAMP\(6\)" }/i, output
+    end
 
-      test "schema dump timestamp without default expression" do
-        output = dump_table_schema("timestamp_defaults")
-        assert_match %r/t\.timestamp\s+"nullable_timestamp"$/, output
-      end
+    test "schema dump timestamp includes default expression" do
+      output = dump_table_schema("timestamp_defaults")
+      assert_match %r/t\.timestamp\s+"modified_timestamp",\s+default: -> { "CURRENT_TIMESTAMP(?:\(\))?" }/i, output
+    end
+
+    test "schema dump timestamp includes precise default expression" do
+      output = dump_table_schema("timestamp_defaults")
+      assert_match %r/t\.timestamp\s+"precise_timestamp",.+default: -> { "CURRENT_TIMESTAMP\(6\)" }/i, output
+    end
+
+    test "schema dump timestamp includes precise default expression with on update" do
+      output = dump_table_schema("timestamp_defaults")
+      assert_match %r/t\.timestamp\s+"updated_timestamp",.+default: -> { "CURRENT_TIMESTAMP\(6\) ON UPDATE CURRENT_TIMESTAMP\(6\)" }/i, output
+    end
+
+    test "schema dump timestamp without default expression" do
+      output = dump_table_schema("timestamp_defaults")
+      assert_match %r/t\.timestamp\s+"nullable_timestamp"$/, output
     end
   end
+end
 
-  class DefaultsTestWithoutTransactionalFixtures < ActiveRecord::TestCase
+class DefaultsTestWithoutTransactionalFixtures < ActiveRecord::TestCase
+  if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
     # ActiveRecord::Base#create! (and #save and other related methods) will
     # open a new transaction. When in transactional tests mode, this will
     # cause Active Record to create a new savepoint. However, since MySQL doesn't
@@ -180,13 +232,12 @@ if current_adapter?(:Mysql2Adapter)
     self.use_transactional_tests = false
 
     def using_strict(strict)
-      connection = ActiveRecord::Base.remove_connection
-      conn_hash = connection.configuration_hash
+      db_config = ActiveRecord::Base.connection_pool.db_config
+      conn_hash = db_config.configuration_hash
       ActiveRecord::Base.establish_connection conn_hash.merge(strict: strict)
       yield
     ensure
-      ActiveRecord::Base.remove_connection
-      ActiveRecord::Base.establish_connection connection
+      ActiveRecord::Base.establish_connection db_config
     end
 
     # Strict mode controls how MySQL handles invalid or missing values
@@ -239,7 +290,7 @@ if current_adapter?(:Mysql2Adapter)
     def with_mysql_not_null_table
       klass = Class.new(ActiveRecord::Base)
       klass.table_name = "test_mysql_not_null_defaults"
-      klass.connection.create_table klass.table_name do |t|
+      klass.lease_connection.create_table klass.table_name do |t|
         t.integer :non_null_integer, null: false
         t.string  :non_null_string,  null: false
         t.text    :non_null_text,    null: false
@@ -248,7 +299,22 @@ if current_adapter?(:Mysql2Adapter)
 
       yield klass
     ensure
-      klass.connection.drop_table(klass.table_name) rescue nil
+      klass.lease_connection.drop_table(klass.table_name) rescue nil
+    end
+  end
+end
+
+class Sqlite3DefaultExpressionTest < ActiveRecord::TestCase
+  if current_adapter?(:SQLite3Adapter)
+    include SchemaDumpingHelper
+
+    test "schema dump includes default expression" do
+      output = dump_table_schema("defaults")
+      assert_match %r/t\.date\s+"modified_date",\s+default: -> { "CURRENT_DATE" }/, output
+      assert_match %r/t\.datetime\s+"modified_time",\s+default: -> { "CURRENT_TIMESTAMP" }/, output
+      assert_match %r/t\.datetime\s+"modified_time_without_precision",\s+precision: nil,\s+default: -> { "CURRENT_TIMESTAMP" }/, output
+      assert_match %r/t\.datetime\s+"modified_time_with_precision_0",\s+precision: 0,\s+default: -> { "CURRENT_TIMESTAMP" }/, output
+      assert_match %r/t\.integer\s+"random_number",\s+default: -> { "ABS\(RANDOM\(\)\)" }/, output
     end
   end
 end

data/test/cases/delegated_type_test.rb

@@ -1,16 +1,31 @@
 # frozen_string_literal: true
 
 require "cases/helper"
+require "models/account"
 require "models/entry"
 require "models/message"
+require "models/recipient"
 require "models/comment"
+require "models/uuid_entry"
+require "models/uuid_message"
+require "models/uuid_comment"
 
 class DelegatedTypeTest < ActiveRecord::TestCase
-  fixtures :comments
+  fixtures :comments, :accounts, :posts
 
   setup do
-    @entry_with_message = Entry.create! entryable: Message.new(subject: "Hello world!")
-    @entry_with_comment = Entry.create! entryable: comments(:greetings)
+    @entry_with_message = Entry.create! entryable: Message.new(subject: "Hello world!"), account: accounts(:signals37)
+    @entry_with_comment = Entry.create! entryable: comments(:greetings), account: accounts(:signals37)
+    @entry_with_post = Entry.create! thing: posts(:welcome), account: accounts(:signals37)
+
+    if current_adapter?(:PostgreSQLAdapter)
+      @uuid_entry_with_message = UuidEntry.create! uuid: SecureRandom.uuid, entryable: UuidMessage.new(uuid: SecureRandom.uuid, subject: "Hello world!")
+      @uuid_entry_with_comment = UuidEntry.create! uuid: SecureRandom.uuid, entryable: UuidComment.new(uuid: SecureRandom.uuid, content: "comment")
+    end
+  end
+
+  test "delegated types" do
+    assert_equal ["Message", "Comment"], Entry.entryable_types
   end
 
   test "delegated class" do
@@ -18,25 +33,41 @@ class DelegatedTypeTest < ActiveRecord::TestCase
     assert_equal Comment, @entry_with_comment.entryable_class
   end
 
+  test "delegated class with custom foreign_type" do
+    assert_equal Message, @entry_with_message.thing_class
+    assert_equal Comment, @entry_with_comment.thing_class
+    assert_equal Post, @entry_with_post.thing_class
+  end
+
   test "delegated type name" do
     assert_equal "message", @entry_with_message.entryable_name
-    assert @entry_with_message.entryable_name.message?
+    assert_predicate @entry_with_message.entryable_name, :message?
 
     assert_equal "comment", @entry_with_comment.entryable_name
-    assert @entry_with_comment.entryable_name.comment?
+    assert_predicate @entry_with_comment.entryable_name, :comment?
   end
 
   test "delegated type predicates" do
-    assert @entry_with_message.message?
+    assert_predicate @entry_with_message, :message?
     assert_not @entry_with_message.comment?
 
-    assert @entry_with_comment.comment?
+    assert_predicate @entry_with_comment, :comment?
     assert_not @entry_with_comment.message?
   end
 
+  test "delegated type predicates with custom foreign_type" do
+    assert_predicate @entry_with_post, :post?
+    assert_not @entry_with_message.post?
+    assert_not @entry_with_comment.post?
+  end
+
   test "scope" do
-    assert Entry.messages.first.message?
-    assert Entry.comments.first.comment?
+    assert_predicate Entry.messages.first, :message?
+    assert_predicate Entry.comments.first, :comment?
+  end
+
+  test "scope with custom foreign_type" do
+    assert_predicate Entry.posts.first, :post?
   end
 
   test "accessor" do
@@ -54,4 +85,33 @@ class DelegatedTypeTest < ActiveRecord::TestCase
     assert_equal @entry_with_comment.entryable_id, @entry_with_comment.comment_id
     assert_nil @entry_with_comment.message_id
   end
+
+  test "association uuid" do
+    skip unless current_adapter?(:PostgreSQLAdapter)
+
+    assert_equal @uuid_entry_with_message.entryable_uuid, @uuid_entry_with_message.uuid_message_uuid
+    assert_nil @uuid_entry_with_message.uuid_comment_uuid
+
+    assert_equal @uuid_entry_with_comment.entryable_uuid, @uuid_entry_with_comment.uuid_comment_uuid
+    assert_nil @uuid_entry_with_comment.uuid_message_uuid
+  end
+
+  test "touch account" do
+    previous_account_updated_at  = @entry_with_message.account.updated_at
+    previous_entry_updated_at    = @entry_with_message.updated_at
+    previous_message_updated_at  = @entry_with_message.entryable.updated_at
+
+    travel 5.seconds do
+      Recipient.create! message: @entry_with_message.entryable, email_address: "test@test.com"
+    end
+
+    assert_not_equal @entry_with_message.reload.account.updated_at, previous_account_updated_at
+    assert_not_equal @entry_with_message.reload.updated_at, previous_entry_updated_at
+    assert_not_equal @entry_with_message.reload.entryable.updated_at, previous_message_updated_at
+  end
+
+  test "builder method" do
+    assert_respond_to Entry.new, :build_entryable
+    assert_equal Message, Entry.new(entryable_type: "Message").build_entryable.class
+  end
 end

data/test/cases/dirty_test.rb

@@ -362,7 +362,7 @@ class DirtyTest < ActiveRecord::TestCase
     old_updated_on = 1.hour.ago.beginning_of_day
 
     with_partial_writes Pirate, false do
-      assert_queries(2) { 2.times { pirate.save! } }
+      assert_queries_count(6) { 2.times { pirate.save! } }
       Pirate.where(id: pirate.id).update_all(updated_on: old_updated_on)
     end
 
@@ -370,7 +370,7 @@ class DirtyTest < ActiveRecord::TestCase
       assert_no_queries { 2.times { pirate.save! } }
       assert_equal old_updated_on, pirate.reload.updated_on
 
-      assert_queries(1) { pirate.catchphrase = "bar"; pirate.save! }
+      assert_queries_count(3) { pirate.catchphrase = "bar"; pirate.save! }
       assert_not_equal old_updated_on, pirate.reload.updated_on
     end
   end
@@ -379,7 +379,7 @@ class DirtyTest < ActiveRecord::TestCase
     person = Person.new(first_name: "foo")
 
     with_partial_writes Person, false do
-      assert_queries(2) { 2.times { person.save! } }
+      assert_queries_count(6) { 2.times { person.save! } }
       Person.where(id: person.id).update_all(first_name: "baz")
     end
 
@@ -389,7 +389,7 @@ class DirtyTest < ActiveRecord::TestCase
       assert_no_queries { 2.times { person.save! } }
       assert_equal old_lock_version, person.reload.lock_version
 
-      assert_queries(1) { person.first_name = "bar"; person.save! }
+      assert_queries_count(3) { person.first_name = "bar"; person.save! }
       assert_not_equal old_lock_version, person.reload.lock_version
     end
   end
@@ -460,44 +460,44 @@ class DirtyTest < ActiveRecord::TestCase
 
   def test_save_should_store_serialized_attributes_even_with_partial_writes
     with_partial_writes(Topic) do
-      topic = Topic.create!(content: { a: "a" })
+      topic = Topic.create!(content: { "a" => "a" })
 
       assert_not_predicate topic, :changed?
 
-      topic.content[:b] = "b"
+      topic.content["b"] = "b"
 
       assert_predicate topic, :changed?
 
       topic.save!
 
       assert_not_predicate topic, :changed?
-      assert_equal "b", topic.content[:b]
+      assert_equal "b", topic.content["b"]
 
       topic.reload
 
-      assert_equal "b", topic.content[:b]
+      assert_equal "b", topic.content["b"]
     end
   end
 
   def test_save_always_should_update_timestamps_when_serialized_attributes_are_present
     with_partial_writes(Topic) do
-      topic = Topic.create!(content: { a: "a" })
+      topic = Topic.create!(content: { "a" => "a" })
       topic.save!
 
       updated_at = topic.updated_at
       travel(1.second) do
-        topic.content[:hello] = "world"
+        topic.content["hello"] = "world"
         topic.save!
       end
 
       assert_not_equal updated_at, topic.updated_at
-      assert_equal "world", topic.content[:hello]
+      assert_equal "world", topic.content["hello"]
     end
   end
 
   def test_save_should_not_save_serialized_attribute_with_partial_writes_if_not_present
     with_partial_writes(Topic) do
-      topic = Topic.create!(author_name: "Bill", content: { a: "a" })
+      topic = Topic.create!(author_name: "Bill", content: { "a" => "a" })
       topic = Topic.select("id, author_name").find(topic.id)
       topic.update_columns author_name: "John"
       assert_not_nil topic.reload.content
@@ -505,11 +505,11 @@ class DirtyTest < ActiveRecord::TestCase
   end
 
   def test_changes_to_save_should_not_mutate_array_of_hashes
-    topic = Topic.new(author_name: "Bill", content: [{ a: "a" }])
+    topic = Topic.new(author_name: "Bill", content: [{ "a" => "a" }])
 
     topic.changes_to_save
 
-    assert_equal [{ a: "a" }], topic.content
+    assert_equal [{ "a" => "a" }], topic.content
   end
 
   def test_previous_changes
@@ -608,19 +608,18 @@ class DirtyTest < ActiveRecord::TestCase
 
   class Testings < ActiveRecord::Base; end
   def test_field_named_field
-    ActiveRecord::Base.connection.create_table :testings do |t|
+    ActiveRecord::Base.lease_connection.create_table :testings do |t|
       t.string :field
     end
     assert_nothing_raised do
       Testings.new.attributes
     end
   ensure
-    ActiveRecord::Base.connection.drop_table :testings rescue nil
+    ActiveRecord::Base.lease_connection.drop_table :testings rescue nil
     ActiveRecord::Base.clear_cache!
   end
 
   def test_datetime_attribute_can_be_updated_with_fractional_seconds
-    skip "Fractional seconds are not supported" unless supports_datetime_with_precision?
     in_time_zone "Paris" do
       target = Class.new(ActiveRecord::Base)
       target.table_name = "topics"
@@ -630,7 +629,7 @@ class DirtyTest < ActiveRecord::TestCase
       topic = target.create(written_on: written_on)
       topic.written_on += 0.3
 
-      assert topic.written_on_changed?, "Fractional second update not detected"
+      assert_predicate topic, :written_on_changed?, "Fractional second update not detected"
     end
   end
 
@@ -645,12 +644,12 @@ class DirtyTest < ActiveRecord::TestCase
   test "partial insert" do
     with_partial_writes Person do
       jon = nil
-      assert_sql(/first_name/i) do
-        jon = Person.create! first_name: "Jon"
+      assert_no_queries_match(/followers_count/) do
+        assert_queries_match(/first_name/) do
+          jon = Person.create! first_name: "Jon"
+        end
       end
 
-      assert ActiveRecord::SQLCounter.log_all.none? { |sql| sql.include?("followers_count") }
-
       jon.reload
       assert_equal "Jon", jon.first_name
       assert_equal 0, jon.followers_count
@@ -941,13 +940,71 @@ class DirtyTest < ActiveRecord::TestCase
     assert_not_predicate person, :changed?
   end
 
+  test "partial insert off with unchanged default function attribute" do
+    skip "IBM_DB/DB2: column DEFAULT expressions do not support timezone arithmetic; " \
+         "CURRENT_TIMESTAMP DEFAULT stores local time and cannot be adjusted to UTC." if current_adapter?(:IBM_DBAdapter)
+    with_partial_writes Aircraft, false do
+      aircraft = Aircraft.new(name: "Boeing")
+      assert_equal "Boeing", aircraft.name
+
+      aircraft.save!
+      aircraft.reload
+
+      assert_equal "Boeing", aircraft.name
+      assert_in_delta Time.now, aircraft.manufactured_at, 1.1
+    end
+  end
+
+  test "partial insert off with changed default function attribute" do
+    with_partial_writes Aircraft, false do
+      manufactured_at = 1.years.ago
+      aircraft = Aircraft.new(name: "Boeing2", manufactured_at: manufactured_at)
+
+      assert_equal "Boeing2", aircraft.name
+      assert_equal manufactured_at.to_i, aircraft.manufactured_at.to_i
+
+      aircraft.save!
+      aircraft.reload
+
+      assert_equal "Boeing2", aircraft.name
+      assert_equal manufactured_at.utc.strftime("%Y-%m-%d %H:%M:%S"), aircraft.manufactured_at.strftime("%Y-%m-%d %H:%M:%S")
+    end
+  end
+
+  if current_adapter?(:PostgreSQLAdapter) && supports_identity_columns?
+    test "partial insert off with changed composite identity primary key attribute" do
+      klass = Class.new(ActiveRecord::Base) do
+        self.table_name = "cpk_postgresql_identity_table"
+      end
+
+      with_partial_writes(klass, false) do
+        record = klass.create!(another_id: 10)
+        assert_equal 10, record.another_id
+        assert_not_nil record.id
+      end
+    end
+  end
+
+  test "attribute_changed? properly type casts enum values" do
+    parrot = LiveParrot.create!(name: "Scipio", breed: :african)
+
+    parrot.breed = :australian
+
+    assert parrot.breed_changed?(from: "african", to: "australian")
+    assert parrot.breed_changed?(from: :african, to: :australian)
+    assert parrot.breed_changed?(from: 0, to: 1)
+  end
+
   private
     def with_partial_writes(klass, on = true)
-      old = klass.partial_writes?
-      klass.partial_writes = on
+      old_inserts = klass.partial_inserts?
+      old_updates = klass.partial_updates?
+      klass.partial_inserts = on
+      klass.partial_updates = on
       yield
     ensure
-      klass.partial_writes = old
+      klass.partial_inserts = old_inserts
+      klass.partial_updates = old_updates
     end
 
     def check_pirate_after_save_failure(pirate)

data/test/cases/disconnected_test.rb

@@ -6,25 +6,26 @@ class TestRecord < ActiveRecord::Base
 end
 
 class TestDisconnectedAdapter < ActiveRecord::TestCase
-  self.use_transactional_tests = false
-
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
   end
 
   teardown do
     return if in_memory_db?
-    db_config = ActiveRecord::Base.connection_db_config
-    ActiveRecord::Base.establish_connection(db_config)
   end
 
   unless in_memory_db?
-    test "can't execute statements while disconnected" do
+    test "reconnects to execute statements when disconnected" do
       @connection.execute "SELECT count(*) from products"
+      first_connection = @connection.instance_variable_get(:@raw_connection).__id__
+
       @connection.disconnect!
-      assert_raises(ActiveRecord::ConnectionNotEstablished) do
-        @connection.execute "SELECT count(*) from products"
-      end
+      assert_nil @connection.instance_variable_get(:@raw_connection)
+
+      @connection.execute "SELECT count(*) from products"
+      second_connection = @connection.instance_variable_get(:@raw_connection).__id__
+
+      assert_not_equal second_connection, first_connection
     end
   end
 end