ibm_db 5.6.1 → 5.7.0

data/test/cases/json_serialization_test.rb

@@ -33,7 +33,7 @@ class JsonSerializationTest < ActiveRecord::TestCase
       avatar: "binarydata",
       created_at: Time.utc(2006, 8, 1),
       awesome: true,
-      preferences: { shows: "anime" }
+      preferences: { "shows" => "anime" }
     )
   end
 
@@ -149,8 +149,8 @@ class JsonSerializationTest < ActiveRecord::TestCase
     @contact = ContactSti.new(@contact.attributes)
     assert_equal "ContactSti", @contact.type
 
-    def @contact.serializable_hash(options = {})
-      super({ except: %w(age) }.merge!(options))
+    def @contact.serializable_hash(options = nil)
+      super({ except: %w(age) }.merge!(options || {}))
     end
 
     json = @contact.to_json
@@ -268,7 +268,7 @@ class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
       authors = [@david, @mary]
       encoded = ActiveSupport::JSON.encode(authors, except: [
         :name, :author_address_id, :author_address_extra_id,
-        :organization_id, :owned_essay_id
+        :organization_id, :owned_essay_id, :published_author_id
       ])
       assert_equal %([{"id":1},{"id":2}]), encoded
     end
@@ -301,7 +301,7 @@ class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
 
   def test_should_be_able_to_encode_relation
     set_include_root_in_json(true) do
-      authors_relation = Author.where(id: [@david.id, @mary.id])
+      authors_relation = Author.where(id: [@david.id, @mary.id]).order(:id)
 
       json = ActiveSupport::JSON.encode authors_relation, only: :name
       assert_equal '[{"author":{"name":"David"}},{"author":{"name":"Mary"}}]', json

data/test/cases/json_shared_test_cases.rb

@@ -13,7 +13,7 @@ module JSONSharedTestCases
   end
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
   end
 
   def teardown
@@ -220,7 +220,7 @@ module JSONSharedTestCases
 
   def test_not_compatible_with_serialize_json
     new_klass = Class.new(klass) do
-      serialize :payload, JSON
+      serialize :payload, coder: JSON
     end
     assert_raises(ActiveRecord::AttributeMethods::Serialization::ColumnNotSerializableError) do
       new_klass.new
@@ -236,7 +236,7 @@ module JSONSharedTestCases
 
   def test_json_with_serialized_attributes
     new_klass = Class.new(klass) do
-      serialize :settings, MySettings
+      serialize :settings, coder: MySettings
     end
 
     new_klass.create!(settings: MySettings.new("one" => "two"))
@@ -276,15 +276,11 @@ module JSONSharedTestCases
     end
 
     def assert_type_match(type, sql_type)
-      native_type = ActiveRecord::Base.connection.native_database_types[type][:name]
+      native_type = ActiveRecord::Base.lease_connection.native_database_types[type][:name]
       assert_match %r(\A#{native_type}\b), sql_type
     end
 
     def insert_statement_per_database(values)
-      if current_adapter?(:OracleAdapter)
-        "insert into json_data_type (id, payload) VALUES (json_data_type_seq.nextval, '#{values}')"
-      else
-        "insert into json_data_type (payload) VALUES ('#{values}')"
-      end
+      "insert into json_data_type (payload) VALUES ('#{values}')"
     end
 end

data/test/cases/locking_test.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "thread"
 require "cases/helper"
 require "models/person"
 require "models/job"
@@ -181,6 +180,7 @@ class OptimisticLockingTest < ActiveRecord::TestCase
     assert_equal 0, p1.lock_version
 
     p1.touch
+
     assert_equal 1, p1.lock_version
     assert_not_predicate p1, :changed?, "Changes should have been cleared"
     assert_predicate p1, :saved_changes?
@@ -291,7 +291,7 @@ class OptimisticLockingTest < ActiveRecord::TestCase
   end
 
   def test_touch_existing_lock_without_default_should_work_with_null_in_the_database
-    ActiveRecord::Base.connection.execute("INSERT INTO lock_without_defaults(title) VALUES('title1')")
+    ActiveRecord::Base.lease_connection.execute("INSERT INTO lock_without_defaults(title) VALUES('title1')")
     t1 = LockWithoutDefault.last
 
     assert_equal 0, t1.lock_version
@@ -319,7 +319,7 @@ class OptimisticLockingTest < ActiveRecord::TestCase
   end
 
   def test_lock_without_default_should_work_with_null_in_the_database
-    ActiveRecord::Base.connection.execute("INSERT INTO lock_without_defaults(title) VALUES('title1')")
+    ActiveRecord::Base.lease_connection.execute("INSERT INTO lock_without_defaults(title) VALUES('title1')")
     t1 = LockWithoutDefault.last
     t2 = LockWithoutDefault.find(t1.id)
 
@@ -341,7 +341,7 @@ class OptimisticLockingTest < ActiveRecord::TestCase
   end
 
   def test_update_with_lock_version_without_default_should_work_on_dirty_value_before_type_cast
-    ActiveRecord::Base.connection.execute("INSERT INTO lock_without_defaults(title) VALUES('title1')")
+    ActiveRecord::Base.lease_connection.execute("INSERT INTO lock_without_defaults(title) VALUES('title1')")
     t1 = LockWithoutDefault.last
 
     assert_equal 0, t1.lock_version
@@ -358,7 +358,7 @@ class OptimisticLockingTest < ActiveRecord::TestCase
   end
 
   def test_destroy_with_lock_version_without_default_should_work_on_dirty_value_before_type_cast
-    ActiveRecord::Base.connection.execute("INSERT INTO lock_without_defaults(title) VALUES('title1')")
+    ActiveRecord::Base.lease_connection.execute("INSERT INTO lock_without_defaults(title) VALUES('title1')")
     t1 = LockWithoutDefault.last
 
     assert_equal 0, t1.lock_version
@@ -379,7 +379,7 @@ class OptimisticLockingTest < ActiveRecord::TestCase
     assert_equal "title1", t1.title
     assert_equal 0, t1.lock_version
 
-    assert_queries(1) { t1.update(title: "title2") }
+    assert_queries_count(3) { t1.update(title: "title2") }
 
     t1.reload
     assert_equal "title2", t1.title
@@ -387,7 +387,7 @@ class OptimisticLockingTest < ActiveRecord::TestCase
 
     t2 = LockWithoutDefault.new(title: "title1")
 
-    assert_queries(1) { t2.save! }
+    assert_queries_count(3) { t2.save! }
 
     t2.reload
     assert_equal "title1", t2.title
@@ -408,7 +408,7 @@ class OptimisticLockingTest < ActiveRecord::TestCase
   end
 
   def test_lock_with_custom_column_without_default_should_work_with_null_in_the_database
-    ActiveRecord::Base.connection.execute("INSERT INTO lock_without_defaults_cust(title) VALUES('title1')")
+    ActiveRecord::Base.lease_connection.execute("INSERT INTO lock_without_defaults_cust(title) VALUES('title1')")
 
     t1 = LockWithCustomColumnWithoutDefault.last
     t2 = LockWithCustomColumnWithoutDefault.find(t1.id)
@@ -436,7 +436,7 @@ class OptimisticLockingTest < ActiveRecord::TestCase
     assert_equal "title1", t1.title
     assert_equal 0, t1.custom_lock_version
 
-    assert_queries(1) { t1.update(title: "title2") }
+    assert_queries_count(3) { t1.update(title: "title2") }
 
     t1.reload
     assert_equal "title2", t1.title
@@ -444,7 +444,7 @@ class OptimisticLockingTest < ActiveRecord::TestCase
 
     t2 = LockWithCustomColumnWithoutDefault.new(title: "title1")
 
-    assert_queries(1) { t2.save! }
+    assert_queries_count(3) { t2.save! }
 
     t2.reload
     assert_equal "title1", t2.title
@@ -452,20 +452,22 @@ class OptimisticLockingTest < ActiveRecord::TestCase
   end
 
   def test_readonly_attributes
-    assert_equal Set.new([ "name" ]), ReadonlyNameShip.readonly_attributes
+    assert_equal [ "name" ], ReadonlyNameShip.readonly_attributes
 
     s = ReadonlyNameShip.create(name: "unchangeable name")
     s.reload
     assert_equal "unchangeable name", s.name
 
-    s.update(name: "changed name")
+    assert_raises(ActiveRecord::ReadonlyAttributeError) do
+      s.update(name: "changed name")
+    end
     s.reload
     assert_equal "unchangeable name", s.name
   end
 
-  def test_quote_table_name
+  def test_quote_table_name_reserved_word_references
     ref = references(:michael_magician)
-    ref.favourite = !ref.favourite
+    ref.favorite = !ref.favorite
     assert ref.save
   end
 
@@ -545,7 +547,7 @@ class OptimisticLockingTest < ActiveRecord::TestCase
     assert_not_empty p.treasures
     p.destroy
     assert_empty p.treasures
-    assert_empty RichPerson.connection.select_all("SELECT * FROM peoples_treasures WHERE rich_person_id = 1")
+    assert_empty RichPerson.lease_connection.select_all("SELECT * FROM peoples_treasures WHERE rich_person_id = 1")
   end
 
   def test_yaml_dumping_with_lock_column
@@ -608,7 +610,7 @@ class OptimisticLockingWithSchemaChangeTest < ActiveRecord::TestCase
   end
 
   def test_destroy_existing_object_with_locking_column_value_null_in_the_database
-    ActiveRecord::Base.connection.execute("INSERT INTO lock_without_defaults(title) VALUES('title1')")
+    ActiveRecord::Base.lease_connection.execute("INSERT INTO lock_without_defaults(title) VALUES('title1')")
     t1 = LockWithoutDefault.last
 
     assert_equal 0, t1.lock_version
@@ -634,12 +636,12 @@ class OptimisticLockingWithSchemaChangeTest < ActiveRecord::TestCase
 
   private
     def add_counter_column_to(model, col = "test_count")
-      model.connection.add_column model.table_name, col, :integer, null: false, default: 0
+      model.lease_connection.add_column model.table_name, col, :integer, null: false, default: 0
       model.reset_column_information
     end
 
     def remove_counter_column_from(model, col = :test_count)
-      model.connection.remove_column model.table_name, col
+      model.lease_connection.remove_column model.table_name, col
       model.reset_column_information
     end
 
@@ -661,8 +663,8 @@ end
 # is so cumbersome. Will deadlock Ruby threads if the underlying db.execute
 # blocks, so separate script called by Kernel#system is needed.
 # (See exec vs. async_exec in the PostgreSQL adapter.)
-unless in_memory_db?
-  class PessimisticLockingTest < ActiveRecord::TestCase
+class PessimisticLockingTest < ActiveRecord::TestCase
+  unless in_memory_db?
     self.use_transactional_tests = false
     fixtures :people, :readers
 
@@ -673,7 +675,7 @@ unless in_memory_db?
     end
 
     # Test typical find.
-    def test_sane_find_with_lock
+    def test_typical_find_with_lock
       assert_nothing_raised do
         Person.transaction do
           Person.lock.find(1)
@@ -703,23 +705,23 @@ unless in_memory_db?
     def test_lock_raises_when_the_record_is_dirty
       person = Person.find 1
       person.first_name = "fooman"
-      assert_raises(RuntimeError) do
+      error = assert_raises(RuntimeError) do
         person.lock!
       end
+      assert_match(/Changed attributes: "first_name"/, error.message)
     end
 
     def test_locking_in_after_save_callback
       assert_nothing_raised do
         frog = ::Frog.create(name: "Old Frog")
         frog.name = "New Frog"
-        assert_not_deprecated do
+        assert_not_deprecated(ActiveRecord.deprecator) do
           frog.save!
         end
       end
     end
 
     def test_with_lock_commits_transaction
-      puts "Inside test_with_lock_commits_transaction"
       person = Person.find 1
       person.with_lock do
         person.first_name = "fooman"
@@ -739,15 +741,44 @@ unless in_memory_db?
       assert_equal old, person.reload.first_name
     end
 
+    def test_with_lock_configures_transaction
+      person = Person.find 1
+      Person.transaction do
+        outer_transaction = Person.lease_connection.transaction_manager.current_transaction
+        assert_equal true, outer_transaction.joinable?
+        person.with_lock(requires_new: true, joinable: false) do
+          current_transaction = Person.lease_connection.transaction_manager.current_transaction
+          assert_not_equal outer_transaction, current_transaction
+          assert_equal false, current_transaction.joinable?
+        end
+      end
+    end
+
     if current_adapter?(:PostgreSQLAdapter)
       def test_lock_sending_custom_lock_statement
         Person.transaction do
           person = Person.find(1)
-          assert_sql(/LIMIT \$?\d FOR SHARE NOWAIT/) do
+          assert_queries_match(/LIMIT \$?\d FOR SHARE NOWAIT/) do
             person.lock!("FOR SHARE NOWAIT")
           end
         end
       end
+
+      def test_with_lock_sets_isolation
+        person = Person.find 1
+        person.with_lock(isolation: :read_uncommitted) do
+          current_transaction = Person.lease_connection.transaction_manager.current_transaction
+          assert_equal :read_uncommitted, current_transaction.isolation_level
+        end
+      end
+
+      def test_with_lock_locks_with_no_args
+        person = Person.find 1
+        assert_queries_match(/LIMIT \$?\d FOR UPDATE/i) do
+          person.with_lock do
+          end
+        end
+      end
     end
 
     def test_no_locks_no_wait
@@ -756,29 +787,34 @@ unless in_memory_db?
     end
 
     private
-      def duel(zzz = 5)
+      def duel(&block)
         t0, t1, t2, t3 = nil, nil, nil, nil
 
+        a_wakeup = Concurrent::Event.new
+        b_wakeup = Concurrent::Event.new
+
         a = Thread.new do
           t0 = Time.now
-          Person.transaction do
+          Person.transaction(joinable: false) do
             yield
-            sleep zzz       # block thread 2 for zzz seconds
+            b_wakeup.set
+            a_wakeup.wait
           end
           t1 = Time.now
         end
 
         b = Thread.new do
-          sleep zzz / 2.0   # ensure thread 1 tx starts first
+          b_wakeup.wait
           t2 = Time.now
-          Person.transaction { yield }
+          Person.transaction(&block)
+          a_wakeup.set
           t3 = Time.now
         end
 
         a.join
         b.join
 
-        assert t1 > t0 + zzz
+        assert t1 > t0
         assert t2 > t0
         assert t3 > t2
         [t0.to_f..t1.to_f, t2.to_f..t3.to_f]

data/test/cases/log_subscriber_test.rb

@@ -9,8 +9,8 @@ require "active_support/log_subscriber/test_helper"
 class LogSubscriberTest < ActiveRecord::TestCase
   include ActiveSupport::LogSubscriber::TestHelper
   include ActiveSupport::Logger::Severity
-  REGEXP_CLEAR = Regexp.escape(ActiveRecord::LogSubscriber::CLEAR)
-  REGEXP_BOLD = Regexp.escape(ActiveRecord::LogSubscriber::BOLD)
+  REGEXP_CLEAR = Regexp.escape("\e[#{ActiveRecord::LogSubscriber::MODES[:clear]}m")
+  REGEXP_BOLD = Regexp.escape("\e[#{ActiveRecord::LogSubscriber::MODES[:bold]}m")
   REGEXP_MAGENTA = Regexp.escape(ActiveRecord::LogSubscriber::MAGENTA)
   REGEXP_CYAN = Regexp.escape(ActiveRecord::LogSubscriber::CYAN)
   SQL_COLORINGS = {
@@ -44,7 +44,7 @@ class LogSubscriberTest < ActiveRecord::TestCase
   def setup
     @old_logger = ActiveRecord::Base.logger
     Developer.primary_key
-    ActiveRecord::Base.connection.materialize_transactions
+    ActiveRecord::Base.lease_connection.materialize_transactions
     super
     ActiveRecord::LogSubscriber.attach_to(:active_record)
   end
@@ -133,6 +133,12 @@ class LogSubscriberTest < ActiveRecord::TestCase
     end
   end
 
+  def test_async_query
+    logger = TestDebugLogSubscriber.new
+    logger.sql(Event.new(0.9, sql: "SELECT * from models", name: "Model Load", async: true, lock_wait: 0.01))
+    assert_match(/ASYNC Model Load \(0\.0ms\) \(db time 0\.9ms\)  SELECT/i, logger.debugs.last)
+  end
+
   def test_query_logging_coloration_with_nested_select
     logger = TestDebugLogSubscriber.new
     logger.colorize_logging = true
@@ -183,28 +189,28 @@ class LogSubscriberTest < ActiveRecord::TestCase
     assert_match(/SELECT .*?FROM .?developers.?/i, @logger.logged(:debug).last)
   end
 
-  def test_vebose_query_logs
-    ActiveRecord::Base.verbose_query_logs = true
+  def test_verbose_query_logs
+    ActiveRecord.verbose_query_logs = true
 
     logger = TestDebugLogSubscriber.new
     logger.sql(Event.new(0, sql: "hi mom!"))
     assert_equal 2, @logger.logged(:debug).size
     assert_match(/↳/, @logger.logged(:debug).last)
   ensure
-    ActiveRecord::Base.verbose_query_logs = false
+    ActiveRecord.verbose_query_logs = false
   end
 
   def test_verbose_query_with_ignored_callstack
-    ActiveRecord::Base.verbose_query_logs = true
+    ActiveRecord.verbose_query_logs = true
 
     logger = TestDebugLogSubscriber.new
-    def logger.extract_query_source_location(*); nil; end
+    def logger.query_source_location; nil; end
 
     logger.sql(Event.new(0, sql: "hi mom!"))
     assert_equal 1, @logger.logged(:debug).size
     assert_no_match(/↳/, @logger.logged(:debug).last)
   ensure
-    ActiveRecord::Base.verbose_query_logs = false
+    ActiveRecord.verbose_query_logs = false
   end
 
   def test_verbose_query_logs_disabled_by_default
@@ -241,11 +247,7 @@ class LogSubscriberTest < ActiveRecord::TestCase
     assert_equal 0, @logger.logged(:debug).size
   end
 
-  def test_initializes_runtime
-    Thread.new { assert_equal 0, ActiveRecord::LogSubscriber.runtime }.join
-  end
-
-  if ActiveRecord::Base.connection.prepared_statements
+  if ActiveRecord::Base.lease_connection.prepared_statements
     def test_where_in_binds_logging_include_attribute_names
       Developer.where(id: [1, 2, 3, 4, 5]).load
       wait
@@ -261,7 +263,7 @@ class LogSubscriberTest < ActiveRecord::TestCase
     def test_binary_data_hash
       Binary.create(data: { a: 1 })
       wait
-      assert_match(/<7 bytes of binary data>/, @logger.logged(:debug).join)
+      assert_match(/<(6|7) bytes of binary data>/, @logger.logged(:debug).join)
     end
   end
 end

data/test/cases/marshal_serialization_test.rb

@@ -7,8 +7,36 @@ require "models/reply"
 class MarshalSerializationTest < ActiveRecord::TestCase
   fixtures :topics
 
-  def test_deserializing_rails_6_0_marshal_basic
-    topic = Marshal.load(marshal_fixture("rails_6_0_topic"))
+  setup do
+    @previous_format_version = ActiveRecord::Marshalling.format_version
+  end
+
+  teardown do
+    ActiveRecord::Marshalling.format_version = @previous_format_version
+  end
+
+  def test_deserializing_rails_6_1_marshal_basic
+    topic = Marshal.load(marshal_fixture("rails_6_1_topic"))
+
+    assert_not_predicate topic, :new_record?
+    assert_equal 1, topic.id
+    assert_equal "The First Topic", topic.title
+    assert_equal "Have a nice day", topic.content
+  end
+
+  def test_deserializing_rails_6_1_marshal_with_loaded_association_cache
+    topic = Marshal.load(marshal_fixture("rails_6_1_topic_associations"))
+
+    assert_not_predicate topic, :new_record?
+    assert_equal 1, topic.id
+    assert_equal "The First Topic", topic.title
+    assert_equal "Have a nice day", topic.content
+    assert_predicate topic.association(:replies), :loaded?
+    assert_predicate topic.replies.first.association(:topic), :loaded?
+  end
+
+  def test_deserializing_rails_7_1_marshal_basic
+    topic = Marshal.load(marshal_fixture("rails_7_1_topic"))
 
     assert_not_predicate topic, :new_record?
     assert_equal 1, topic.id
@@ -16,13 +44,58 @@ class MarshalSerializationTest < ActiveRecord::TestCase
     assert_equal "Have a nice day", topic.content
   end
 
-  def test_deserializing_rails_6_0_marshal_with_loaded_association_cache
-    topic = Marshal.load(marshal_fixture("rails_6_0_topic_associations"))
+  def test_deserializing_rails_7_1_marshal_with_loaded_association_cache
+    topic = Marshal.load(marshal_fixture("rails_7_1_topic_associations"))
 
     assert_not_predicate topic, :new_record?
     assert_equal 1, topic.id
     assert_equal "The First Topic", topic.title
     assert_equal "Have a nice day", topic.content
+    assert_predicate topic.association(:replies), :loaded?
+    assert_predicate topic.replies.first.association(:topic), :loaded?
+    assert_same topic, topic.replies.first.topic
+  end
+
+  def test_rails_6_1_rountrip
+    topic = Topic.find(1)
+    topic.replies.to_a
+    topic = Marshal.load(Marshal.dump(topic))
+
+    assert_not_predicate topic, :new_record?
+    assert_equal 1, topic.id
+    assert_equal "The First Topic", topic.title
+    assert_equal "Have a nice day", topic.content
+    assert_predicate topic.association(:replies), :loaded?
+  end
+
+  def test_rails_7_1_rountrip
+    ActiveRecord::Marshalling.format_version = 7.1
+
+    topic = Topic.find(1)
+    topic.replies.each(&:topic)
+    assert_not_equal 0, topic.replies.size
+    topic.replies.each do |reply|
+      assert_same topic, reply.topic
+    end
+
+    topic.association(:open_replies)
+    assert_equal true, topic.association_cached?(:open_replies)
+    assert_not_predicate topic.association(:open_replies), :loaded?
+
+    topic = Marshal.load(Marshal.dump(topic))
+
+    assert_not_predicate topic, :new_record?
+    assert_equal 1, topic.id
+    assert_equal "The First Topic", topic.title
+    assert_equal "Have a nice day", topic.content
+    assert_predicate topic.association(:replies), :loaded?
+
+    assert_not_predicate topic.association(:open_replies), :loaded?
+
+    assert_not_equal 0, topic.replies.size
+    topic.replies.each do |reply|
+      assert_same topic, reply.topic
+    end
   end
 
   private
@@ -32,7 +105,7 @@ class MarshalSerializationTest < ActiveRecord::TestCase
 
     def marshal_fixture_path(file_name)
       File.expand_path(
-        "support/marshal_compatibility_fixtures/#{ActiveRecord::Base.connection.adapter_name}/#{file_name}.dump",
+        "support/marshal_compatibility_fixtures/#{ActiveRecord::Base.lease_connection.adapter_name}/#{file_name}.dump",
         TEST_ROOT
       )
     end

data/test/cases/message_pack_test.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/author"
+require "models/binary"
+require "models/comment"
+require "models/post"
+require "active_support/message_pack"
+require "active_record/message_pack"
+
+class ActiveRecordMessagePackTest < ActiveRecord::TestCase
+  fixtures :posts, :comments, :authors, :author_addresses
+
+  test "enshrines type IDs" do
+    expected = {
+      119 => ActiveModel::Type::Binary::Data,
+      120 => ActiveRecord::Base,
+    }
+
+    factory = ::MessagePack::Factory.new
+    ActiveRecord::MessagePack::Extensions.install(factory)
+    actual = factory.registered_types.to_h do |entry|
+      [entry[:type], entry[:class]]
+    end
+
+    assert_equal expected, actual
+  end
+
+  test "roundtrips record and cached associations" do
+    post = Post.create!(title: "A Title", body: "A body.")
+    post.create_author!(name: "An Author")
+    post.comments.create!(body: "A comment.")
+    post.comments.create!(body: "Another comment.", author: post.author)
+    post.comments.load
+
+    assert_no_queries do
+      roundtripped_post = roundtrip(post)
+
+      assert_equal post, roundtripped_post
+      assert_equal post.author, roundtripped_post.author
+      assert_equal post.comments.to_a, roundtripped_post.comments.to_a
+      assert_equal post.comments.map(&:author), roundtripped_post.comments.map(&:author)
+
+      assert_same roundtripped_post, roundtripped_post.comments[0].post
+      assert_same roundtripped_post, roundtripped_post.comments[1].post
+      assert_same roundtripped_post.author, roundtripped_post.comments[1].author
+    end
+  end
+
+  test "roundtrips new_record? status" do
+    post = Post.new(title: "A Title", body: "A body.")
+    post.create_author!(name: "An Author")
+
+    assert_no_queries do
+      roundtripped_post = roundtrip(post)
+
+      assert_equal post.attributes, roundtripped_post.attributes
+      assert_equal post.new_record?, roundtripped_post.new_record?
+      assert_equal post.author, roundtripped_post.author
+      assert_equal post.author.new_record?, roundtripped_post.author.new_record?
+    end
+  end
+
+  test "roundtrips binary attribute" do
+    binary = Binary.new(data: Marshal.dump("data"))
+    assert_equal binary.attributes, roundtrip(binary).attributes
+  end
+
+  test "raises ActiveSupport::MessagePack::MissingClassError if record class no longer exists" do
+    klass = Class.new(Post)
+    def klass.name; "SomeLegacyClass"; end
+    dumped = serializer.dump(klass.new(title: "A Title", body: "A body."))
+
+    assert_raises ActiveSupport::MessagePack::MissingClassError do
+      serializer.load(dumped)
+    end
+  end
+
+  private
+    def serializer
+      @serializer ||= ::MessagePack::Factory.new.tap do |factory|
+        ActiveRecord::MessagePack::Extensions.install(factory)
+        ActiveSupport::MessagePack::Extensions.install(factory)
+        ActiveSupport::MessagePack::Extensions.install_unregistered_type_error(factory)
+      end
+    end
+
+    def roundtrip(input)
+      serializer.load(serializer.dump(input))
+    end
+end