ibm_db 4.0.0-x86-mingw32 → 5.0.2-x86-mingw32

data/test/cases/secure_token_test.rb

@@ -1,32 +1,32 @@
-require 'cases/helper'
-require 'models/user'
-
-class SecureTokenTest < ActiveRecord::TestCase
-  setup do
-    @user = User.new
-  end
-
-  def test_token_values_are_generated_for_specified_attributes_and_persisted_on_save
-    @user.save
-    assert_not_nil @user.token
-    assert_not_nil @user.auth_token
-  end
-
-  def test_regenerating_the_secure_token
-    @user.save
-    old_token = @user.token
-    old_auth_token = @user.auth_token
-    @user.regenerate_token
-    @user.regenerate_auth_token
-
-    assert_not_equal @user.token, old_token
-    assert_not_equal @user.auth_token, old_auth_token
-  end
-
-  def test_token_value_not_overwritten_when_present
-    @user.token = "custom-secure-token"
-    @user.save
-
-    assert_equal @user.token, "custom-secure-token"
-  end
-end
+require 'cases/helper'
+require 'models/user'
+
+class SecureTokenTest < ActiveRecord::TestCase
+  setup do
+    @user = User.new
+  end
+
+  def test_token_values_are_generated_for_specified_attributes_and_persisted_on_save
+    @user.save
+    assert_not_nil @user.token
+    assert_not_nil @user.auth_token
+  end
+
+  def test_regenerating_the_secure_token
+    @user.save
+    old_token = @user.token
+    old_auth_token = @user.auth_token
+    @user.regenerate_token
+    @user.regenerate_auth_token
+
+    assert_not_equal @user.token, old_token
+    assert_not_equal @user.auth_token, old_auth_token
+  end
+
+  def test_token_value_not_overwritten_when_present
+    @user.token = "custom-secure-token"
+    @user.save
+
+    assert_equal @user.token, "custom-secure-token"
+  end
+end

data/test/cases/serialization_test.rb

@@ -1,104 +1,104 @@
-require "cases/helper"
-require 'models/contact'
-require 'models/topic'
-require 'models/book'
-require 'models/author'
-require 'models/post'
-
-class SerializationTest < ActiveRecord::TestCase
-  fixtures :books
-
-  FORMATS = [ :json ]
-
-  def setup
-    @contact_attributes = {
-      :name           => 'aaron stack',
-      :age            => 25,
-      :avatar         => 'binarydata',
-      :created_at     => Time.utc(2006, 8, 1),
-      :awesome        => false,
-      :preferences    => { :gem => '<strong>ruby</strong>' },
-      :alternative_id => nil,
-      :id             => nil
-    }
-  end
-
-  def test_include_root_in_json_is_false_by_default
-    assert_equal false, ActiveRecord::Base.include_root_in_json, "include_root_in_json should be false by default but was not"
-  end
-
-  def test_serialize_should_be_reversible
-    FORMATS.each do |format|
-      @serialized = Contact.new.send("to_#{format}")
-      contact = Contact.new.send("from_#{format}", @serialized)
-
-      assert_equal @contact_attributes.keys.collect(&:to_s).sort, contact.attributes.keys.collect(&:to_s).sort, "For #{format}"
-    end
-  end
-
-  def test_serialize_should_allow_attribute_only_filtering
-    FORMATS.each do |format|
-      @serialized = Contact.new(@contact_attributes).send("to_#{format}", :only => [ :age, :name ])
-      contact = Contact.new.send("from_#{format}", @serialized)
-      assert_equal @contact_attributes[:name], contact.name, "For #{format}"
-      assert_nil contact.avatar, "For #{format}"
-    end
-  end
-
-  def test_serialize_should_allow_attribute_except_filtering
-    FORMATS.each do |format|
-      @serialized = Contact.new(@contact_attributes).send("to_#{format}", :except => [ :age, :name ])
-      contact = Contact.new.send("from_#{format}", @serialized)
-      assert_nil contact.name, "For #{format}"
-      assert_nil contact.age, "For #{format}"
-      assert_equal @contact_attributes[:awesome], contact.awesome, "For #{format}"
-    end
-  end
-
-  def test_include_root_in_json_allows_inheritance
-    original_root_in_json = ActiveRecord::Base.include_root_in_json
-    ActiveRecord::Base.include_root_in_json = true
-
-    klazz = Class.new(ActiveRecord::Base)
-    klazz.table_name = 'topics'
-    assert klazz.include_root_in_json
-
-    klazz.include_root_in_json = false
-    assert ActiveRecord::Base.include_root_in_json
-    assert !klazz.include_root_in_json
-    assert !klazz.new.include_root_in_json
-  ensure
-    ActiveRecord::Base.include_root_in_json = original_root_in_json
-  end
-
-  def test_read_attribute_for_serialization_with_format_without_method_missing
-    klazz = Class.new(ActiveRecord::Base)
-    klazz.table_name = 'books'
-
-    book = klazz.new
-    assert_nil book.read_attribute_for_serialization(:format)
-  end
-
-  def test_read_attribute_for_serialization_with_format_after_init
-    klazz = Class.new(ActiveRecord::Base)
-    klazz.table_name = 'books'
-
-    book = klazz.new(format: 'paperback')
-    assert_equal 'paperback', book.read_attribute_for_serialization(:format)
-  end
-
-  def test_read_attribute_for_serialization_with_format_after_find
-    klazz = Class.new(ActiveRecord::Base)
-    klazz.table_name = 'books'
-
-    book = klazz.find(books(:awdr).id)
-    assert_equal 'paperback', book.read_attribute_for_serialization(:format)
-  end
-
-  def test_find_records_by_serialized_attributes_through_join
-    author = Author.create!(name: "David")
-    author.serialized_posts.create!(title: "Hello")
-
-    assert_equal 1, Author.joins(:serialized_posts).where(name: "David", serialized_posts: { title: "Hello" }).length
-  end
-end
+require "cases/helper"
+require 'models/contact'
+require 'models/topic'
+require 'models/book'
+require 'models/author'
+require 'models/post'
+
+class SerializationTest < ActiveRecord::TestCase
+  fixtures :books
+
+  FORMATS = [ :json ]
+
+  def setup
+    @contact_attributes = {
+      :name           => 'aaron stack',
+      :age            => 25,
+      :avatar         => 'binarydata',
+      :created_at     => Time.utc(2006, 8, 1),
+      :awesome        => false,
+      :preferences    => { :gem => '<strong>ruby</strong>' },
+      :alternative_id => nil,
+      :id             => nil
+    }
+  end
+
+  def test_include_root_in_json_is_false_by_default
+    assert_equal false, ActiveRecord::Base.include_root_in_json, "include_root_in_json should be false by default but was not"
+  end
+
+  def test_serialize_should_be_reversible
+    FORMATS.each do |format|
+      @serialized = Contact.new.send("to_#{format}")
+      contact = Contact.new.send("from_#{format}", @serialized)
+
+      assert_equal @contact_attributes.keys.collect(&:to_s).sort, contact.attributes.keys.collect(&:to_s).sort, "For #{format}"
+    end
+  end
+
+  def test_serialize_should_allow_attribute_only_filtering
+    FORMATS.each do |format|
+      @serialized = Contact.new(@contact_attributes).send("to_#{format}", :only => [ :age, :name ])
+      contact = Contact.new.send("from_#{format}", @serialized)
+      assert_equal @contact_attributes[:name], contact.name, "For #{format}"
+      assert_nil contact.avatar, "For #{format}"
+    end
+  end
+
+  def test_serialize_should_allow_attribute_except_filtering
+    FORMATS.each do |format|
+      @serialized = Contact.new(@contact_attributes).send("to_#{format}", :except => [ :age, :name ])
+      contact = Contact.new.send("from_#{format}", @serialized)
+      assert_nil contact.name, "For #{format}"
+      assert_nil contact.age, "For #{format}"
+      assert_equal @contact_attributes[:awesome], contact.awesome, "For #{format}"
+    end
+  end
+
+  def test_include_root_in_json_allows_inheritance
+    original_root_in_json = ActiveRecord::Base.include_root_in_json
+    ActiveRecord::Base.include_root_in_json = true
+
+    klazz = Class.new(ActiveRecord::Base)
+    klazz.table_name = 'topics'
+    assert klazz.include_root_in_json
+
+    klazz.include_root_in_json = false
+    assert ActiveRecord::Base.include_root_in_json
+    assert !klazz.include_root_in_json
+    assert !klazz.new.include_root_in_json
+  ensure
+    ActiveRecord::Base.include_root_in_json = original_root_in_json
+  end
+
+  def test_read_attribute_for_serialization_with_format_without_method_missing
+    klazz = Class.new(ActiveRecord::Base)
+    klazz.table_name = 'books'
+
+    book = klazz.new
+    assert_nil book.read_attribute_for_serialization(:format)
+  end
+
+  def test_read_attribute_for_serialization_with_format_after_init
+    klazz = Class.new(ActiveRecord::Base)
+    klazz.table_name = 'books'
+
+    book = klazz.new(format: 'paperback')
+    assert_equal 'paperback', book.read_attribute_for_serialization(:format)
+  end
+
+  def test_read_attribute_for_serialization_with_format_after_find
+    klazz = Class.new(ActiveRecord::Base)
+    klazz.table_name = 'books'
+
+    book = klazz.find(books(:awdr).id)
+    assert_equal 'paperback', book.read_attribute_for_serialization(:format)
+  end
+
+  def test_find_records_by_serialized_attributes_through_join
+    author = Author.create!(name: "David")
+    author.serialized_posts.create!(title: "Hello")
+
+    assert_equal 1, Author.joins(:serialized_posts).where(name: "David", serialized_posts: { title: "Hello" }).length
+  end
+end

data/test/cases/serialized_attribute_test.rb

@@ -1,364 +1,364 @@
-require 'cases/helper'
-require 'models/topic'
-require 'models/reply'
-require 'models/person'
-require 'models/traffic_light'
-require 'models/post'
-require 'bcrypt'
-
-class SerializedAttributeTest < ActiveRecord::TestCase
-  fixtures :topics, :posts
-
-  MyObject = Struct.new :attribute1, :attribute2
-
-  teardown do
-    Topic.serialize("content")
-  end
-
-  def test_serialize_does_not_eagerly_load_columns
-    Topic.reset_column_information
-    assert_no_queries do
-      Topic.serialize(:content)
-    end
-  end
-
-  def test_serialized_attribute
-    Topic.serialize("content", MyObject)
-
-    myobj = MyObject.new('value1', 'value2')
-    topic = Topic.create("content" => myobj)
-    assert_equal(myobj, topic.content)
-
-    topic.reload
-    assert_equal(myobj, topic.content)
-  end
-
-  def test_serialized_attribute_in_base_class
-    Topic.serialize("content", Hash)
-
-    hash = { 'content1' => 'value1', 'content2' => 'value2' }
-    important_topic = ImportantTopic.create("content" => hash)
-    assert_equal(hash, important_topic.content)
-
-    important_topic.reload
-    assert_equal(hash, important_topic.content)
-  end
-
-  def test_serialized_attributes_from_database_on_subclass
-    Topic.serialize :content, Hash
-
-    t = Reply.new(content: { foo: :bar })
-    assert_equal({ foo: :bar }, t.content)
-    t.save!
-    t = Reply.last
-    assert_equal({ foo: :bar }, t.content)
-  end
-
-  def test_serialized_attribute_calling_dup_method
-    Topic.serialize :content, JSON
-
-    orig = Topic.new(content: { foo: :bar })
-    clone = orig.dup
-    assert_equal(orig.content, clone.content)
-  end
-
-  def test_serialized_json_attribute_returns_unserialized_value
-    Topic.serialize :content, JSON
-    my_post = posts(:welcome)
-
-    t = Topic.new(content: my_post)
-    t.save!
-    t.reload
-
-    assert_instance_of(Hash, t.content)
-    assert_equal(my_post.id, t.content["id"])
-    assert_equal(my_post.title, t.content["title"])
-  end
-
-  def test_json_read_legacy_null
-    Topic.serialize :content, JSON
-
-    # Force a row to have a JSON "null" instead of a database NULL (this is how
-    # null values are saved on 4.1 and before)
-    id = Topic.connection.insert "INSERT INTO topics (content) VALUES('null')"
-    t = Topic.find(id)
-
-    assert_nil t.content
-  end
-
-  def test_json_read_db_null
-    Topic.serialize :content, JSON
-
-    # Force a row to have a database NULL instead of a JSON "null"
-    id = Topic.connection.insert "INSERT INTO topics (content) VALUES(NULL)"
-    t = Topic.find(id)
-
-    assert_nil t.content
-  end
-
-  def test_serialized_attribute_declared_in_subclass
-    hash = { 'important1' => 'value1', 'important2' => 'value2' }
-    important_topic = ImportantTopic.create("important" => hash)
-    assert_equal(hash, important_topic.important)
-
-    important_topic.reload
-    assert_equal(hash, important_topic.important)
-    assert_equal(hash, important_topic.read_attribute(:important))
-  end
-
-  def test_serialized_time_attribute
-    myobj = Time.local(2008,1,1,1,0)
-    topic = Topic.create("content" => myobj).reload
-    assert_equal(myobj, topic.content)
-  end
-
-  def test_serialized_string_attribute
-    myobj = "Yes"
-    topic = Topic.create("content" => myobj).reload
-    assert_equal(myobj, topic.content)
-  end
-
-  def test_nil_serialized_attribute_without_class_constraint
-    topic = Topic.new
-    assert_nil topic.content
-  end
-
-  def test_nil_not_serialized_without_class_constraint
-    assert Topic.new(:content => nil).save
-    assert_equal 1, Topic.where(:content => nil).count
-  end
-
-  def test_nil_not_serialized_with_class_constraint
-    Topic.serialize :content, Hash
-    assert Topic.new(:content => nil).save
-    assert_equal 1, Topic.where(:content => nil).count
-  end
-
-  def test_serialized_attribute_should_raise_exception_on_assignment_with_wrong_type
-    Topic.serialize(:content, Hash)
-    assert_raise(ActiveRecord::SerializationTypeMismatch) do
-      Topic.new(content: 'string')
-    end
-  end
-
-  def test_should_raise_exception_on_serialized_attribute_with_type_mismatch
-    myobj = MyObject.new('value1', 'value2')
-    topic = Topic.new(:content => myobj)
-    assert topic.save
-    Topic.serialize(:content, Hash)
-    assert_raise(ActiveRecord::SerializationTypeMismatch) { Topic.find(topic.id).content }
-  end
-
-  def test_serialized_attribute_with_class_constraint
-    settings = { "color" => "blue" }
-    Topic.serialize(:content, Hash)
-    topic = Topic.new(:content => settings)
-    assert topic.save
-    assert_equal(settings, Topic.find(topic.id).content)
-  end
-
-  def test_serialized_default_class
-    Topic.serialize(:content, Hash)
-    topic = Topic.new
-    assert_equal Hash, topic.content.class
-    assert_equal Hash, topic.read_attribute(:content).class
-    topic.content["beer"] = "MadridRb"
-    assert topic.save
-    topic.reload
-    assert_equal Hash, topic.content.class
-    assert_equal "MadridRb", topic.content["beer"]
-  end
-
-  def test_serialized_no_default_class_for_object
-    topic = Topic.new
-    assert_nil topic.content
-  end
-
-  def test_serialized_boolean_value_true
-    topic = Topic.new(:content => true)
-    assert topic.save
-    topic = topic.reload
-    assert_equal topic.content, true
-  end
-
-  def test_serialized_boolean_value_false
-    topic = Topic.new(:content => false)
-    assert topic.save
-    topic = topic.reload
-    assert_equal topic.content, false
-  end
-
-  def test_serialize_with_coder
-    some_class = Struct.new(:foo) do
-      def self.dump(value)
-        value.foo
-      end
-
-      def self.load(value)
-        new(value)
-      end
-    end
-
-    Topic.serialize(:content, some_class)
-    topic = Topic.new(:content => some_class.new('my value'))
-    topic.save!
-    topic.reload
-    assert_kind_of some_class, topic.content
-    assert_equal topic.content, some_class.new('my value')
-  end
-
-  def test_serialize_attribute_via_select_method_when_time_zone_available
-    with_timezone_config aware_attributes: true do
-      Topic.serialize(:content, MyObject)
-
-      myobj = MyObject.new('value1', 'value2')
-      topic = Topic.create(content: myobj)
-
-      assert_equal(myobj, Topic.select(:content).find(topic.id).content)
-      assert_raise(ActiveModel::MissingAttributeError) { Topic.select(:id).find(topic.id).content }
-    end
-  end
-
-  def test_serialize_attribute_can_be_serialized_in_an_integer_column
-    insures = ['life']
-    person = SerializedPerson.new(first_name: 'David', insures: insures)
-    assert person.save
-    person = person.reload
-    assert_equal(insures, person.insures)
-  end
-
-  def test_regression_serialized_default_on_text_column_with_null_false
-    light = TrafficLight.new
-    assert_equal [], light.state
-    assert_equal [], light.long_state
-  end
-
-  def test_serialized_column_should_unserialize_after_update_column
-    t = Topic.create(content: "first")
-    assert_equal("first", t.content)
-
-    t.update_column(:content, ["second"])
-    assert_equal(["second"], t.content)
-    assert_equal(["second"], t.reload.content)
-  end
-
-  def test_serialized_column_should_unserialize_after_update_attribute
-    t = Topic.create(content: "first")
-    assert_equal("first", t.content)
-
-    t.update_attribute(:content, "second")
-    assert_equal("second", t.content)
-    assert_equal("second", t.reload.content)
-  end
-
-  def test_nil_is_not_changed_when_serialized_with_a_class
-    Topic.serialize(:content, Array)
-
-    topic = Topic.new(content: nil)
-
-    assert_not topic.content_changed?
-  end
-
-  def test_classes_without_no_arg_constructors_are_not_supported
-    assert_raises(ArgumentError) do
-      Topic.serialize(:content, Regexp)
-    end
-  end
-
-  def test_newly_emptied_serialized_hash_is_changed
-    Topic.serialize(:content, Hash)
-    topic = Topic.create(content: { "things" => "stuff" })
-    topic.content.delete("things")
-    topic.save!
-    topic.reload
-
-    assert_equal({}, topic.content)
-  end
-
-  def test_values_cast_from_nil_are_persisted_as_nil
-    # This is required to fulfil the following contract, which must be universally
-    # true in Active Record:
-    #
-    # model.attribute = value
-    # assert_equal model.attribute, model.tap(&:save).reload.attribute
-    Topic.serialize(:content, Hash)
-    topic = Topic.create!(content: {})
-    topic2 = Topic.create!(content: nil)
-
-    assert_equal [topic, topic2], Topic.where(content: nil)
-  end
-
-  def test_nil_is_always_persisted_as_null
-    Topic.serialize(:content, Hash)
-
-    topic = Topic.create!(content: { foo: "bar" })
-    topic.update_attribute :content, nil
-    assert_equal [topic], Topic.where(content: nil)
-  end
-
-  def test_mutation_detection_does_not_double_serialize
-    coder = Object.new
-    def coder.dump(value)
-      return if value.nil?
-      value + " encoded"
-    end
-    def coder.load(value)
-      return if value.nil?
-      value.gsub(" encoded", "")
-    end
-    type = Class.new(ActiveModel::Type::Value) do
-      include ActiveModel::Type::Helpers::Mutable
-
-      def serialize(value)
-        return if value.nil?
-        value + " serialized"
-      end
-
-      def deserialize(value)
-        return if value.nil?
-        value.gsub(" serialized", "")
-      end
-    end.new
-    model = Class.new(Topic) do
-      attribute :foo, type
-      serialize :foo, coder
-    end
-
-    topic = model.create!(foo: "bar")
-    topic.foo
-    refute topic.changed?
-  end
-end
-
-class ThreadedSerializedAttributeTest < ActiveRecord::TestCase
-  self.use_transactional_tests = false
-  fixtures :topics
-
-  def test_serialized_attribute_works_under_concurrent_initial_access
-    model = Topic.dup
-
-    topic = model.last
-    topic.update group: "1"
-
-    model.serialize :group, JSON
-    model.reset_column_information
-
-    # This isn't strictly necessary for the test, but a little bit of
-    # knowledge of internals allows us to make failures far more likely.
-    model.define_singleton_method(:define_attribute) do |*args|
-      Thread.pass
-      super(*args)
-    end
-
-    threads = 4.times.map do
-      Thread.new do
-        topic.reload.group
-      end
-    end
-
-    # All the threads should retrieve the value knowing it is JSON, and
-    # thus decode it. If this fails, some threads will instead see the
-    # raw string ("1"), or raise an exception.
-    assert_equal [1] * threads.size, threads.map(&:value)
-  end
-end
+require 'cases/helper'
+require 'models/topic'
+require 'models/reply'
+require 'models/person'
+require 'models/traffic_light'
+require 'models/post'
+require 'bcrypt'
+
+class SerializedAttributeTest < ActiveRecord::TestCase
+  fixtures :topics, :posts
+
+  MyObject = Struct.new :attribute1, :attribute2
+
+  teardown do
+    Topic.serialize("content")
+  end
+
+  def test_serialize_does_not_eagerly_load_columns
+    Topic.reset_column_information
+    assert_no_queries do
+      Topic.serialize(:content)
+    end
+  end
+
+  def test_serialized_attribute
+    Topic.serialize("content", MyObject)
+
+    myobj = MyObject.new('value1', 'value2')
+    topic = Topic.create("content" => myobj)
+    assert_equal(myobj, topic.content)
+
+    topic.reload
+    assert_equal(myobj, topic.content)
+  end
+
+  def test_serialized_attribute_in_base_class
+    Topic.serialize("content", Hash)
+
+    hash = { 'content1' => 'value1', 'content2' => 'value2' }
+    important_topic = ImportantTopic.create("content" => hash)
+    assert_equal(hash, important_topic.content)
+
+    important_topic.reload
+    assert_equal(hash, important_topic.content)
+  end
+
+  def test_serialized_attributes_from_database_on_subclass
+    Topic.serialize :content, Hash
+
+    t = Reply.new(content: { foo: :bar })
+    assert_equal({ foo: :bar }, t.content)
+    t.save!
+    t = Reply.last
+    assert_equal({ foo: :bar }, t.content)
+  end
+
+  def test_serialized_attribute_calling_dup_method
+    Topic.serialize :content, JSON
+
+    orig = Topic.new(content: { foo: :bar })
+    clone = orig.dup
+    assert_equal(orig.content, clone.content)
+  end
+
+  def test_serialized_json_attribute_returns_unserialized_value
+    Topic.serialize :content, JSON
+    my_post = posts(:welcome)
+
+    t = Topic.new(content: my_post)
+    t.save!
+    t.reload
+
+    assert_instance_of(Hash, t.content)
+    assert_equal(my_post.id, t.content["id"])
+    assert_equal(my_post.title, t.content["title"])
+  end
+
+  def test_json_read_legacy_null
+    Topic.serialize :content, JSON
+
+    # Force a row to have a JSON "null" instead of a database NULL (this is how
+    # null values are saved on 4.1 and before)
+    id = Topic.connection.insert "INSERT INTO topics (content) VALUES('null')"
+    t = Topic.find(id)
+
+    assert_nil t.content
+  end
+
+  def test_json_read_db_null
+    Topic.serialize :content, JSON
+
+    # Force a row to have a database NULL instead of a JSON "null"
+    id = Topic.connection.insert "INSERT INTO topics (content) VALUES(NULL)"
+    t = Topic.find(id)
+
+    assert_nil t.content
+  end
+
+  def test_serialized_attribute_declared_in_subclass
+    hash = { 'important1' => 'value1', 'important2' => 'value2' }
+    important_topic = ImportantTopic.create("important" => hash)
+    assert_equal(hash, important_topic.important)
+
+    important_topic.reload
+    assert_equal(hash, important_topic.important)
+    assert_equal(hash, important_topic.read_attribute(:important))
+  end
+
+  def test_serialized_time_attribute
+    myobj = Time.local(2008,1,1,1,0)
+    topic = Topic.create("content" => myobj).reload
+    assert_equal(myobj, topic.content)
+  end
+
+  def test_serialized_string_attribute
+    myobj = "Yes"
+    topic = Topic.create("content" => myobj).reload
+    assert_equal(myobj, topic.content)
+  end
+
+  def test_nil_serialized_attribute_without_class_constraint
+    topic = Topic.new
+    assert_nil topic.content
+  end
+
+  def test_nil_not_serialized_without_class_constraint
+    assert Topic.new(:content => nil).save
+    assert_equal 1, Topic.where(:content => nil).count
+  end
+
+  def test_nil_not_serialized_with_class_constraint
+    Topic.serialize :content, Hash
+    assert Topic.new(:content => nil).save
+    assert_equal 1, Topic.where(:content => nil).count
+  end
+
+  def test_serialized_attribute_should_raise_exception_on_assignment_with_wrong_type
+    Topic.serialize(:content, Hash)
+    assert_raise(ActiveRecord::SerializationTypeMismatch) do
+      Topic.new(content: 'string')
+    end
+  end
+
+  def test_should_raise_exception_on_serialized_attribute_with_type_mismatch
+    myobj = MyObject.new('value1', 'value2')
+    topic = Topic.new(:content => myobj)
+    assert topic.save
+    Topic.serialize(:content, Hash)
+    assert_raise(ActiveRecord::SerializationTypeMismatch) { Topic.find(topic.id).content }
+  end
+
+  def test_serialized_attribute_with_class_constraint
+    settings = { "color" => "blue" }
+    Topic.serialize(:content, Hash)
+    topic = Topic.new(:content => settings)
+    assert topic.save
+    assert_equal(settings, Topic.find(topic.id).content)
+  end
+
+  def test_serialized_default_class
+    Topic.serialize(:content, Hash)
+    topic = Topic.new
+    assert_equal Hash, topic.content.class
+    assert_equal Hash, topic.read_attribute(:content).class
+    topic.content["beer"] = "MadridRb"
+    assert topic.save
+    topic.reload
+    assert_equal Hash, topic.content.class
+    assert_equal "MadridRb", topic.content["beer"]
+  end
+
+  def test_serialized_no_default_class_for_object
+    topic = Topic.new
+    assert_nil topic.content
+  end
+
+  def test_serialized_boolean_value_true
+    topic = Topic.new(:content => true)
+    assert topic.save
+    topic = topic.reload
+    assert_equal topic.content, true
+  end
+
+  def test_serialized_boolean_value_false
+    topic = Topic.new(:content => false)
+    assert topic.save
+    topic = topic.reload
+    assert_equal topic.content, false
+  end
+
+  def test_serialize_with_coder
+    some_class = Struct.new(:foo) do
+      def self.dump(value)
+        value.foo
+      end
+
+      def self.load(value)
+        new(value)
+      end
+    end
+
+    Topic.serialize(:content, some_class)
+    topic = Topic.new(:content => some_class.new('my value'))
+    topic.save!
+    topic.reload
+    assert_kind_of some_class, topic.content
+    assert_equal topic.content, some_class.new('my value')
+  end
+
+  def test_serialize_attribute_via_select_method_when_time_zone_available
+    with_timezone_config aware_attributes: true do
+      Topic.serialize(:content, MyObject)
+
+      myobj = MyObject.new('value1', 'value2')
+      topic = Topic.create(content: myobj)
+
+      assert_equal(myobj, Topic.select(:content).find(topic.id).content)
+      assert_raise(ActiveModel::MissingAttributeError) { Topic.select(:id).find(topic.id).content }
+    end
+  end
+
+  def test_serialize_attribute_can_be_serialized_in_an_integer_column
+    insures = ['life']
+    person = SerializedPerson.new(first_name: 'David', insures: insures)
+    assert person.save
+    person = person.reload
+    assert_equal(insures, person.insures)
+  end
+
+  def test_regression_serialized_default_on_text_column_with_null_false
+    light = TrafficLight.new
+    assert_equal [], light.state
+    assert_equal [], light.long_state
+  end
+
+  def test_serialized_column_should_unserialize_after_update_column
+    t = Topic.create(content: "first")
+    assert_equal("first", t.content)
+
+    t.update_column(:content, ["second"])
+    assert_equal(["second"], t.content)
+    assert_equal(["second"], t.reload.content)
+  end
+
+  def test_serialized_column_should_unserialize_after_update_attribute
+    t = Topic.create(content: "first")
+    assert_equal("first", t.content)
+
+    t.update_attribute(:content, "second")
+    assert_equal("second", t.content)
+    assert_equal("second", t.reload.content)
+  end
+
+  def test_nil_is_not_changed_when_serialized_with_a_class
+    Topic.serialize(:content, Array)
+
+    topic = Topic.new(content: nil)
+
+    assert_not topic.content_changed?
+  end
+
+  def test_classes_without_no_arg_constructors_are_not_supported
+    assert_raises(ArgumentError) do
+      Topic.serialize(:content, Regexp)
+    end
+  end
+
+  def test_newly_emptied_serialized_hash_is_changed
+    Topic.serialize(:content, Hash)
+    topic = Topic.create(content: { "things" => "stuff" })
+    topic.content.delete("things")
+    topic.save!
+    topic.reload
+
+    assert_equal({}, topic.content)
+  end
+
+  def test_values_cast_from_nil_are_persisted_as_nil
+    # This is required to fulfil the following contract, which must be universally
+    # true in Active Record:
+    #
+    # model.attribute = value
+    # assert_equal model.attribute, model.tap(&:save).reload.attribute
+    Topic.serialize(:content, Hash)
+    topic = Topic.create!(content: {})
+    topic2 = Topic.create!(content: nil)
+
+    assert_equal [topic, topic2], Topic.where(content: nil)
+  end
+
+  def test_nil_is_always_persisted_as_null
+    Topic.serialize(:content, Hash)
+
+    topic = Topic.create!(content: { foo: "bar" })
+    topic.update_attribute :content, nil
+    assert_equal [topic], Topic.where(content: nil)
+  end
+
+  def test_mutation_detection_does_not_double_serialize
+    coder = Object.new
+    def coder.dump(value)
+      return if value.nil?
+      value + " encoded"
+    end
+    def coder.load(value)
+      return if value.nil?
+      value.gsub(" encoded", "")
+    end
+    type = Class.new(ActiveModel::Type::Value) do
+      include ActiveModel::Type::Helpers::Mutable
+
+      def serialize(value)
+        return if value.nil?
+        value + " serialized"
+      end
+
+      def deserialize(value)
+        return if value.nil?
+        value.gsub(" serialized", "")
+      end
+    end.new
+    model = Class.new(Topic) do
+      attribute :foo, type
+      serialize :foo, coder
+    end
+
+    topic = model.create!(foo: "bar")
+    topic.foo
+    refute topic.changed?
+  end
+end
+
+class ThreadedSerializedAttributeTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+  fixtures :topics
+
+  def test_serialized_attribute_works_under_concurrent_initial_access
+    model = Topic.dup
+
+    topic = model.last
+    topic.update group: "1"
+
+    model.serialize :group, JSON
+    model.reset_column_information
+
+    # This isn't strictly necessary for the test, but a little bit of
+    # knowledge of internals allows us to make failures far more likely.
+    model.define_singleton_method(:define_attribute) do |*args|
+      Thread.pass
+      super(*args)
+    end
+
+    threads = 4.times.map do
+      Thread.new do
+        topic.reload.group
+      end
+    end
+
+    # All the threads should retrieve the value knowing it is JSON, and
+    # thus decode it. If this fails, some threads will instead see the
+    # raw string ("1"), or raise an exception.
+    assert_equal [1] * threads.size, threads.map(&:value)
+  end
+end