ibm_db 5.2.0-x86-mingw32 → 5.3.2-x86-mingw32

data/test/cases/attribute_methods_test.rb

@@ -1,15 +1,18 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'models/minimalistic'
-require 'models/developer'
-require 'models/auto_id'
-require 'models/boolean'
-require 'models/computer'
-require 'models/topic'
-require 'models/company'
-require 'models/category'
-require 'models/reply'
-require 'models/contact'
-require 'models/keyboard'
+require "models/minimalistic"
+require "models/developer"
+require "models/auto_id"
+require "models/boolean"
+require "models/computer"
+require "models/topic"
+require "models/company"
+require "models/category"
+require "models/reply"
+require "models/contact"
+require "models/keyboard"
+require "models/numeric_data"
 
 class AttributeMethodsTest < ActiveRecord::TestCase
   include InTimeZone
@@ -19,7 +22,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
   def setup
     @old_matchers = ActiveRecord::Base.send(:attribute_method_matchers).dup
     @target = Class.new(ActiveRecord::Base)
-    @target.table_name = 'topics'
+    @target.table_name = "topics"
   end
 
   teardown do
@@ -27,45 +30,54 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     ActiveRecord::Base.send(:attribute_method_matchers).concat(@old_matchers)
   end
 
-  def test_attribute_for_inspect_string
+  test "attribute_for_inspect with a string" do
     t = topics(:first)
     t.title = "The First Topic Now Has A Title With\nNewlines And More Than 50 Characters"
 
     assert_equal '"The First Topic Now Has A Title With\nNewlines And ..."', t.attribute_for_inspect(:title)
+    assert_equal '"The First Topic Now Has A Title With\nNewlines And ..."', t.attribute_for_inspect(:heading)
   end
 
-  def test_attribute_for_inspect_date
+  test "attribute_for_inspect with a date" do
     t = topics(:first)
 
-    assert_equal %("#{t.written_on.to_s(:db)}"), t.attribute_for_inspect(:written_on)
+    assert_equal %("#{t.written_on.to_s(:inspect)}"), t.attribute_for_inspect(:written_on)
   end
 
-  def test_attribute_for_inspect_array
+  test "attribute_for_inspect with an array" do
     t = topics(:first)
     t.content = [Object.new]
 
     assert_match %r(\[#<Object:0x[0-9a-f]+>\]), t.attribute_for_inspect(:content)
   end
 
-  def test_attribute_for_inspect_long_array
+  test "attribute_for_inspect with a long array" do
     t = topics(:first)
     t.content = (1..11).to_a
 
     assert_equal "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]", t.attribute_for_inspect(:content)
   end
 
-  def test_attribute_present
+  test "attribute_for_inspect with a non-primary key id attribute" do
+    t = topics(:first).becomes(TitlePrimaryKeyTopic)
+    t.title = "The First Topic Now Has A Title With\nNewlines And More Than 50 Characters"
+
+    assert_equal "1", t.attribute_for_inspect(:id)
+  end
+
+  test "attribute_present" do
     t = Topic.new
     t.title = "hello there!"
     t.written_on = Time.now
     t.author_name = ""
     assert t.attribute_present?("title")
+    assert t.attribute_present?("heading")
     assert t.attribute_present?("written_on")
-    assert !t.attribute_present?("content")
-    assert !t.attribute_present?("author_name")
+    assert_not t.attribute_present?("content")
+    assert_not t.attribute_present?("author_name")
   end
 
-  def test_attribute_present_with_booleans
+  test "attribute_present with booleans" do
     b1 = Boolean.new
     b1.value = false
     assert b1.attribute_present?(:value)
@@ -75,7 +87,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert b2.attribute_present?(:value)
 
     b3 = Boolean.new
-    assert !b3.attribute_present?(:value)
+    assert_not b3.attribute_present?(:value)
 
     b4 = Boolean.new
     b4.value = false
@@ -83,44 +95,44 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert Boolean.find(b4.id).attribute_present?(:value)
   end
 
-  def test_caching_nil_primary_key
+  test "caching a nil primary key" do
     klass = Class.new(Minimalistic)
     assert_called(klass, :reset_primary_key, returns: nil) do
       2.times { klass.primary_key }
     end
   end
 
-  def test_attribute_keys_on_new_instance
+  test "attribute keys on a new instance" do
     t = Topic.new
-    assert_equal nil, t.title, "The topics table has a title column, so it should be nil"
+    assert_nil t.title, "The topics table has a title column, so it should be nil"
     assert_raise(NoMethodError) { t.title2 }
   end
 
-  def test_boolean_attributes
-    assert !Topic.find(1).approved?
-    assert Topic.find(2).approved?
+  test "boolean attributes" do
+    assert_not_predicate Topic.find(1), :approved?
+    assert_predicate Topic.find(2), :approved?
   end
 
-  def test_set_attributes
+  test "set attributes" do
     topic = Topic.find(1)
-    topic.attributes = { "title" => "Budget", "author_name" => "Jason" }
+    topic.attributes = { title: "Budget", author_name: "Jason" }
     topic.save
     assert_equal("Budget", topic.title)
     assert_equal("Jason", topic.author_name)
     assert_equal(topics(:first).author_email_address, Topic.find(1).author_email_address)
   end
 
-  def test_set_attributes_without_hash
+  test "set attributes without a hash" do
     topic = Topic.new
-    assert_raise(ArgumentError) { topic.attributes = '' }
+    assert_raise(ArgumentError) { topic.attributes = "" }
   end
 
-  def test_integers_as_nil
-    test = AutoId.create('value' => '')
+  test "integers as nil" do
+    test = AutoId.create(value: "")
     assert_nil AutoId.find(test.id).value
   end
 
-  def test_set_attributes_with_block
+  test "set attributes with a block" do
     topic = Topic.new do |t|
       t.title       = "Budget"
       t.author_name = "Jason"
@@ -130,7 +142,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal("Jason", topic.author_name)
   end
 
-  def test_respond_to?
+  test "respond_to?" do
     topic = Topic.find(1)
     assert_respond_to topic, "title"
     assert_respond_to topic, "title?"
@@ -140,79 +152,62 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_respond_to topic, :title=
     assert_respond_to topic, "author_name"
     assert_respond_to topic, "attribute_names"
-    assert !topic.respond_to?("nothingness")
-    assert !topic.respond_to?(:nothingness)
+    assert_not_respond_to topic, "nothingness"
+    assert_not_respond_to topic, :nothingness
   end
 
-  def test_respond_to_with_custom_primary_key
+  test "respond_to? with a custom primary key" do
     keyboard = Keyboard.create
     assert_not_nil keyboard.key_number
     assert_equal keyboard.key_number, keyboard.id
-    assert keyboard.respond_to?('key_number')
-    assert keyboard.respond_to?('id')
+    assert_respond_to keyboard, "key_number"
+    assert_respond_to keyboard, "id"
   end
 
-  def test_id_before_type_cast_with_custom_primary_key
+  test "id_before_type_cast with a custom primary key" do
     keyboard = Keyboard.create
-    keyboard.key_number = '10'
-    assert_equal '10', keyboard.id_before_type_cast
-    assert_equal nil, keyboard.read_attribute_before_type_cast('id')
-    assert_equal '10', keyboard.read_attribute_before_type_cast('key_number')
-    assert_equal '10', keyboard.read_attribute_before_type_cast(:key_number)
+    keyboard.key_number = "10"
+    assert_equal "10", keyboard.id_before_type_cast
+    assert_nil keyboard.read_attribute_before_type_cast("id")
+    assert_equal "10", keyboard.read_attribute_before_type_cast("key_number")
+    assert_equal "10", keyboard.read_attribute_before_type_cast(:key_number)
   end
 
-  # Syck calls respond_to? before actually calling initialize
-  def test_respond_to_with_allocated_object
-    klass = Class.new(ActiveRecord::Base) do
-      self.table_name = 'topics'
-    end
-
-    topic = klass.allocate
-    assert !topic.respond_to?("nothingness")
-    assert !topic.respond_to?(:nothingness)
-    assert_respond_to topic, "title"
-    assert_respond_to topic, :title
-  end
-
-  # IRB inspects the return value of "MyModel.allocate".
-  def test_allocated_object_can_be_inspected
+  # IRB inspects the return value of MyModel.allocate.
+  test "allocated objects can be inspected" do
     topic = Topic.allocate
     assert_equal "#<Topic not initialized>", topic.inspect
   end
 
-  def test_array_content
+  test "array content" do
+    content = %w( one two three )
     topic = Topic.new
-    topic.content = %w( one two three )
+    topic.content = content
     topic.save
 
-    assert_equal(%w( one two three ), Topic.find(topic.id).content)
+    assert_equal content, Topic.find(topic.id).content
   end
 
-  def test_read_attributes_before_type_cast
-    category = Category.new({:name=>"Test category", :type => nil})
-    category_attrs = {"name"=>"Test category", "id" => nil, "type" => nil, "categorizations_count" => nil}
-    assert_equal category_attrs , category.attributes_before_type_cast
+  test "read attributes_before_type_cast" do
+    category = Category.new(name: "Test category", type: nil)
+    category_attrs = { "name" => "Test category", "id" => nil, "type" => nil, "categorizations_count" => nil }
+    assert_equal category_attrs, category.attributes_before_type_cast
   end
 
   if current_adapter?(:Mysql2Adapter)
-    def test_read_attributes_before_type_cast_on_boolean
-      bool = Boolean.create!({ "value" => false })
-      if RUBY_PLATFORM =~ /java/
-        # JRuby will return the value before typecast as string
-        assert_equal "0", bool.reload.attributes_before_type_cast["value"]
-      else
-        assert_equal 0, bool.reload.attributes_before_type_cast["value"]
-      end
+    test "read attributes_before_type_cast on a boolean" do
+      bool = Boolean.create!("value" => false)
+      assert_equal 0, bool.reload.attributes_before_type_cast["value"]
     end
   end
 
-  def test_read_attributes_before_type_cast_on_datetime
+  test "read attributes_before_type_cast on a datetime" do
     in_time_zone "Pacific Time (US & Canada)" do
       record = @target.new
 
       record.written_on = "345643456"
       assert_equal "345643456", record.written_on_before_type_cast
-      assert_equal nil, record.written_on
+      assert_nil record.written_on
 
       record.written_on = "2009-10-11 12:13:14"
       assert_equal "2009-10-11 12:13:14", record.written_on_before_type_cast
@@ -221,7 +216,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  def test_read_attributes_after_type_cast_on_datetime
+  test "read attributes_after_type_cast on a date" do
     tz = "Pacific Time (US & Canada)"
 
     in_time_zone tz do
@@ -242,7 +237,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  def test_hash_content
+  test "hash content" do
     topic = Topic.new
     topic.content = { "one" => 1, "two" => 2 }
     topic.save
@@ -256,7 +251,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal 3, Topic.find(topic.id).content["three"]
   end
 
-  def test_update_array_content
+  test "update array content" do
     topic = Topic.new
     topic.content = %w( one two three )
 
@@ -270,55 +265,73 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal(%w( one two three four five ), topic.content)
   end
 
-  def test_case_sensitive_attributes_hash
-    # DB2 is not case-sensitive
-    return true if current_adapter?(:DB2Adapter)
-
-    assert_equal @loaded_fixtures['computers']['workstation'].to_hash, Computer.first.attributes
+  test "case-sensitive attributes hash" do
+    assert_equal @loaded_fixtures["computers"]["workstation"].to_hash, Computer.first.attributes
   end
 
-  def test_attributes_without_primary_key
+  test "attributes without primary key" do
     klass = Class.new(ActiveRecord::Base) do
-      self.table_name = 'developers_projects'
+      self.table_name = "developers_projects"
     end
 
     assert_equal klass.column_names, klass.new.attributes.keys
-    assert_not klass.new.has_attribute?('id')
+    assert_not klass.new.has_attribute?("id")
   end
 
-  def test_hashes_not_mangled
-    new_topic = { :title => "New Topic" }
-    new_topic_values = { :title => "AnotherTopic" }
+  test "hashes are not mangled" do
+    new_topic = { title: "New Topic", content: { key: "First value" } }
+    new_topic_values = { title: "AnotherTopic", content: { key: "Second value" } }
 
     topic = Topic.new(new_topic)
     assert_equal new_topic[:title], topic.title
+    assert_equal new_topic[:content], topic.content
 
-    topic.attributes= new_topic_values
+    topic.attributes = new_topic_values
     assert_equal new_topic_values[:title], topic.title
+    assert_equal new_topic_values[:content], topic.content
   end
 
-  def test_create_through_factory
-    topic = Topic.create("title" => "New Topic")
+  test "create through factory" do
+    topic = Topic.create(title: "New Topic")
     topicReloaded = Topic.find(topic.id)
     assert_equal(topic, topicReloaded)
   end
 
-  def test_write_attribute
+  test "write_attribute" do
     topic = Topic.new
-    topic.send(:write_attribute, :title, "Still another topic")
+    topic.write_attribute :title, "Still another topic"
     assert_equal "Still another topic", topic.title
 
     topic[:title] = "Still another topic: part 2"
     assert_equal "Still another topic: part 2", topic.title
 
-    topic.send(:write_attribute, "title", "Still another topic: part 3")
+    topic.write_attribute "title", "Still another topic: part 3"
     assert_equal "Still another topic: part 3", topic.title
 
     topic["title"] = "Still another topic: part 4"
     assert_equal "Still another topic: part 4", topic.title
   end
 
-  def test_read_attribute
+  test "write_attribute can write aliased attributes as well" do
+    topic = Topic.new(title: "Don't change the topic")
+    topic.write_attribute :heading, "New topic"
+
+    assert_equal "New topic", topic.title
+  end
+
+  test "write_attribute raises ActiveModel::MissingAttributeError when the attribute does not exist" do
+    topic = Topic.first
+    assert_raises(ActiveModel::MissingAttributeError) { topic.update_columns(no_column_exists: "Hello!") }
+    assert_raises(ActiveModel::UnknownAttributeError) { topic.update(no_column_exists: "Hello!") }
+  end
+
+  test "write_attribute allows writing to aliased attributes" do
+    topic = Topic.first
+    assert_nothing_raised { topic.update_columns(heading: "Hello!") }
+    assert_nothing_raised { topic.update(heading: "Hello!") }
+  end
+
+  test "read_attribute" do
     topic = Topic.new
     topic.title = "Don't change the topic"
     assert_equal "Don't change the topic", topic.read_attribute("title")
@@ -328,23 +341,33 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal "Don't change the topic", topic[:title]
   end
 
-  def test_read_attribute_raises_missing_attribute_error_when_not_exists
-    computer = Computer.select('id').first
+  test "read_attribute can read aliased attributes as well" do
+    topic = Topic.new(title: "Don't change the topic")
+
+    assert_equal "Don't change the topic", topic.read_attribute("heading")
+    assert_equal "Don't change the topic", topic["heading"]
+
+    assert_equal "Don't change the topic", topic.read_attribute(:heading)
+    assert_equal "Don't change the topic", topic[:heading]
+  end
+
+  test "read_attribute raises ActiveModel::MissingAttributeError when the attribute does not exist" do
+    computer = Computer.select("id").first
     assert_raises(ActiveModel::MissingAttributeError) { computer[:developer] }
-    assert_raises(ActiveModel::MissingAttributeError) { computer[:extendedWarranty] }
-    assert_raises(ActiveModel::MissingAttributeError) { computer[:no_column_exists] = 'Hello!' }
-    assert_nothing_raised { computer[:developer] = 'Hello!' }
+    assert_raises(ActiveModel::MissingAttributeError) { computer[:extendedwarranty] }
+    assert_raises(ActiveModel::MissingAttributeError) { computer[:no_column_exists] = "Hello!" }
+    assert_nothing_raised { computer[:developer] = "Hello!" }
   end
 
-  def test_read_attribute_when_false
+  test "read_attribute when false" do
     topic = topics(:first)
     topic.approved = false
-    assert !topic.approved?, "approved should be false"
+    assert_not topic.approved?, "approved should be false"
     topic.approved = "false"
-    assert !topic.approved?, "approved should be false"
+    assert_not topic.approved?, "approved should be false"
   end
 
-  def test_read_attribute_when_true
+  test "read_attribute when true" do
     topic = topics(:first)
     topic.approved = true
     assert topic.approved?, "approved should be true"
@@ -352,13 +375,13 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert topic.approved?, "approved should be true"
   end
 
-  def test_read_write_boolean_attribute
+  test "boolean attributes writing and reading" do
     topic = Topic.new
     topic.approved = "false"
-    assert !topic.approved?, "approved should be false"
+    assert_not topic.approved?, "approved should be false"
 
     topic.approved = "false"
-    assert !topic.approved?, "approved should be false"
+    assert_not topic.approved?, "approved should be false"
 
     topic.approved = "true"
     assert topic.approved?, "approved should be true"
@@ -367,26 +390,26 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert topic.approved?, "approved should be true"
   end
 
-  def test_overridden_write_attribute
+  test "overridden write_attribute" do
     topic = Topic.new
     def topic.write_attribute(attr_name, value)
       super(attr_name, value.downcase)
     end
 
-    topic.send(:write_attribute, :title, "Yet another topic")
+    topic.write_attribute :title, "Yet another topic"
     assert_equal "yet another topic", topic.title
 
     topic[:title] = "Yet another topic: part 2"
     assert_equal "yet another topic: part 2", topic.title
 
-    topic.send(:write_attribute, "title", "Yet another topic: part 3")
+    topic.write_attribute "title", "Yet another topic: part 3"
     assert_equal "yet another topic: part 3", topic.title
 
     topic["title"] = "Yet another topic: part 4"
     assert_equal "yet another topic: part 4", topic.title
   end
 
-  def test_overridden_read_attribute
+  test "overridden read_attribute" do
     topic = Topic.new
     topic.title = "Stop changing the topic"
     def topic.read_attribute(attr_name)
@@ -400,41 +423,108 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal "STOP CHANGING THE TOPIC", topic[:title]
   end
 
-  def test_read_overridden_attribute
-    topic = Topic.new(:title => 'a')
-    def topic.title() 'b' end
-    assert_equal 'a', topic[:title]
+  test "read overridden attribute" do
+    topic = Topic.new(title: "a")
+    def topic.title() "b" end
+    assert_equal "a", topic[:title]
   end
 
-  def test_query_attribute_string
+  test "string attribute predicate" do
     [nil, "", " "].each do |value|
-      assert_equal false, Topic.new(:author_name => value).author_name?
+      assert_equal false, Topic.new(author_name: value).author_name?
     end
 
-    assert_equal true, Topic.new(:author_name => "Name").author_name?
+    assert_equal true, Topic.new(author_name: "Name").author_name?
+
+    ActiveModel::Type::Boolean::FALSE_VALUES.each do |value|
+      assert_predicate Topic.new(author_name: value), :author_name?
+    end
   end
 
-  def test_query_attribute_number
+  test "number attribute predicate" do
     [nil, 0, "0"].each do |value|
-      assert_equal false, Developer.new(:salary => value).salary?
+      assert_equal false, Developer.new(salary: value).salary?
     end
 
-    assert_equal true, Developer.new(:salary => 1).salary?
-    assert_equal true, Developer.new(:salary => "1").salary?
+    assert_equal true, Developer.new(salary: 1).salary?
+    assert_equal true, Developer.new(salary: "1").salary?
   end
 
-  def test_query_attribute_boolean
+  test "boolean attribute predicate" do
     [nil, "", false, "false", "f", 0].each do |value|
-      assert_equal false, Topic.new(:approved => value).approved?
+      assert_equal false, Topic.new(approved: value).approved?
     end
 
     [true, "true", "1", 1].each do |value|
-      assert_equal true, Topic.new(:approved => value).approved?
+      assert_equal true, Topic.new(approved: value).approved?
     end
   end
 
-  def test_query_attribute_with_custom_fields
-    object = Company.find_by_sql(<<-SQL).first
+  test "user-defined text attribute predicate" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = Topic.table_name
+
+      attribute :user_defined_text, :text
+    end
+
+    topic = klass.new(user_defined_text: "text")
+    assert_predicate topic, :user_defined_text?
+
+    ActiveModel::Type::Boolean::FALSE_VALUES.each do |value|
+      topic = klass.new(user_defined_text: value)
+      assert_predicate topic, :user_defined_text?
+    end
+  end
+
+  test "user-defined date attribute predicate" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = Topic.table_name
+
+      attribute :user_defined_date, :date
+    end
+
+    topic = klass.new(user_defined_date: Date.current)
+    assert_predicate topic, :user_defined_date?
+  end
+
+  test "user-defined datetime attribute predicate" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = Topic.table_name
+
+      attribute :user_defined_datetime, :datetime
+    end
+
+    topic = klass.new(user_defined_datetime: Time.current)
+    assert_predicate topic, :user_defined_datetime?
+  end
+
+  test "user-defined time attribute predicate" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = Topic.table_name
+
+      attribute :user_defined_time, :time
+    end
+
+    topic = klass.new(user_defined_time: Time.current)
+    assert_predicate topic, :user_defined_time?
+  end
+
+  test "user-defined json attribute predicate" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = Topic.table_name
+
+      attribute :user_defined_json, :json
+    end
+
+    topic = klass.new(user_defined_json: { key: "value" })
+    assert_predicate topic, :user_defined_json?
+
+    topic = klass.new(user_defined_json: {})
+    assert_not_predicate topic, :user_defined_json?
+  end
+
+  test "custom field attribute predicate" do
+    object = Company.find_by_sql(<<~SQL).first
       SELECT c1.*, c2.type as string_value, c2.rating as int_value
         FROM companies c1, companies c2
        WHERE c1.firm_id = c2.id
@@ -442,107 +532,107 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     SQL
 
     assert_equal "Firm", object.string_value
-    assert object.string_value?
+    assert_predicate object, :string_value?
 
     object.string_value = "  "
-    assert !object.string_value?
+    assert_not_predicate object, :string_value?
 
     assert_equal 1, object.int_value.to_i
-    assert object.int_value?
+    assert_predicate object, :int_value?
 
     object.int_value = "0"
-    assert !object.int_value?
+    assert_not_predicate object, :int_value?
   end
 
-  def test_non_attribute_access_and_assignment
+  test "non-attribute read and write" do
     topic = Topic.new
-    assert !topic.respond_to?("mumbo")
+    assert_not_respond_to topic, "mumbo"
     assert_raise(NoMethodError) { topic.mumbo }
     assert_raise(NoMethodError) { topic.mumbo = 5 }
   end
 
-  def test_undeclared_attribute_method_does_not_affect_respond_to_and_method_missing
-    topic = @target.new(:title => 'Budget')
-    assert topic.respond_to?('title')
-    assert_equal 'Budget', topic.title
-    assert !topic.respond_to?('title_hello_world')
+  test "undeclared attribute method does not affect respond_to? and method_missing" do
+    topic = @target.new(title: "Budget")
+    assert_respond_to topic, "title"
+    assert_equal "Budget", topic.title
+    assert_not_respond_to topic, "title_hello_world"
     assert_raise(NoMethodError) { topic.title_hello_world }
   end
 
-  def test_declared_prefixed_attribute_method_affects_respond_to_and_method_missing
-    topic = @target.new(:title => 'Budget')
+  test "declared prefixed attribute method affects respond_to? and method_missing" do
+    topic = @target.new(title: "Budget")
     %w(default_ title_).each do |prefix|
       @target.class_eval "def #{prefix}attribute(*args) args end"
       @target.attribute_method_prefix prefix
 
       meth = "#{prefix}title"
-      assert topic.respond_to?(meth)
-      assert_equal ['title'], topic.send(meth)
-      assert_equal ['title', 'a'], topic.send(meth, 'a')
-      assert_equal ['title', 1, 2, 3], topic.send(meth, 1, 2, 3)
+      assert_respond_to topic, meth
+      assert_equal ["title"], topic.public_send(meth)
+      assert_equal ["title", "a"], topic.public_send(meth, "a")
+      assert_equal ["title", 1, 2, 3], topic.public_send(meth, 1, 2, 3)
     end
   end
 
-  def test_declared_suffixed_attribute_method_affects_respond_to_and_method_missing
+  test "declared suffixed attribute method affects respond_to? and method_missing" do
     %w(_default _title_default _it! _candidate= able?).each do |suffix|
       @target.class_eval "def attribute#{suffix}(*args) args end"
       @target.attribute_method_suffix suffix
-      topic = @target.new(:title => 'Budget')
+      topic = @target.new(title: "Budget")
 
       meth = "title#{suffix}"
-      assert topic.respond_to?(meth)
-      assert_equal ['title'], topic.send(meth)
-      assert_equal ['title', 'a'], topic.send(meth, 'a')
-      assert_equal ['title', 1, 2, 3], topic.send(meth, 1, 2, 3)
+      assert_respond_to topic, meth
+      assert_equal ["title"], topic.public_send(meth)
+      assert_equal ["title", "a"], topic.public_send(meth, "a")
+      assert_equal ["title", 1, 2, 3], topic.public_send(meth, 1, 2, 3)
     end
   end
 
-  def test_declared_affixed_attribute_method_affects_respond_to_and_method_missing
-    [['mark_', '_for_update'], ['reset_', '!'], ['default_', '_value?']].each do |prefix, suffix|
+  test "declared affixed attribute method affects respond_to? and method_missing" do
+    [["mark_", "_for_update"], ["reset_", "!"], ["default_", "_value?"]].each do |prefix, suffix|
       @target.class_eval "def #{prefix}attribute#{suffix}(*args) args end"
-      @target.attribute_method_affix({ :prefix => prefix, :suffix => suffix })
-      topic = @target.new(:title => 'Budget')
+      @target.attribute_method_affix(prefix: prefix, suffix: suffix)
+      topic = @target.new(title: "Budget")
 
       meth = "#{prefix}title#{suffix}"
-      assert topic.respond_to?(meth)
-      assert_equal ['title'], topic.send(meth)
-      assert_equal ['title', 'a'], topic.send(meth, 'a')
-      assert_equal ['title', 1, 2, 3], topic.send(meth, 1, 2, 3)
+      assert_respond_to topic, meth
+      assert_equal ["title"], topic.public_send(meth)
+      assert_equal ["title", "a"], topic.public_send(meth, "a")
+      assert_equal ["title", 1, 2, 3], topic.public_send(meth, 1, 2, 3)
     end
   end
 
-  def test_should_unserialize_attributes_for_frozen_records
-    myobj = {:value1 => :value2}
-    topic = Topic.create("content" => myobj)
+  test "should unserialize attributes for frozen records" do
+    myobj = { value1: :value2 }
+    topic = Topic.create(content: myobj)
     topic.freeze
     assert_equal myobj, topic.content
   end
 
-  def test_typecast_attribute_from_select_to_false
-    Topic.create(:title => 'Budget')
-    # Oracle does not support boolean expressions in SELECT
-    if current_adapter?(:OracleAdapter, :FbAdapter)
-      topic = Topic.all.merge!(:select => "topics.*, 0 as is_test").first
+  test "typecast attribute from select to false" do
+    Topic.create(title: "Budget")
+    # Oracle does not support boolean expressions in SELECT.
+    if current_adapter?(:OracleAdapter) or current_adapter?(:IBM_DBAdapter)
+      topic = Topic.all.merge!(select: "topics.*, 0 as is_test").first
     else
-      topic = Topic.all.merge!(:select => "topics.*, 1=2 as is_test").first
+      topic = Topic.all.merge!(select: "topics.*, 1=2 as is_test").first
     end
-    assert !topic.is_test?
+    assert_not_predicate topic, :is_test?
   end
 
-  def test_typecast_attribute_from_select_to_true
-    Topic.create(:title => 'Budget')
-    # Oracle does not support boolean expressions in SELECT
-    if current_adapter?(:OracleAdapter, :FbAdapter)
-      topic = Topic.all.merge!(:select => "topics.*, 1 as is_test").first
+  test "typecast attribute from select to true" do
+    Topic.create(title: "Budget")
+    # Oracle does not support boolean expressions in SELECT.
+    if current_adapter?(:OracleAdapter) or current_adapter?(:IBM_DBAdapter)
+      topic = Topic.all.merge!(select: "topics.*, 1 as is_test").first
     else
-      topic = Topic.all.merge!(:select => "topics.*, 2=2 as is_test").first
+      topic = Topic.all.merge!(select: "topics.*, 2=2 as is_test").first
     end
-    assert topic.is_test?
+    assert_predicate topic, :is_test?
   end
 
-  def test_raises_dangerous_attribute_error_when_defining_activerecord_method_in_model
+  test "raises ActiveRecord::DangerousAttributeError when defining an AR method in a model" do
     %w(save create_or_update).each do |method|
-      klass = Class.new ActiveRecord::Base
+      klass = Class.new(ActiveRecord::Base)
       klass.class_eval "def #{method}() 'defined #{method}' end"
       assert_raise ActiveRecord::DangerousAttributeError do
         klass.instance_method_already_implemented?(method)
@@ -550,7 +640,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  def test_converted_values_are_returned_after_assignment
+  test "converted values are returned after assignment" do
     developer = Developer.new(name: 1337, salary: "50000")
 
     assert_equal "50000", developer.salary_before_type_cast
@@ -565,7 +655,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal "1337", developer.name
   end
 
-  def test_write_nil_to_time_attributes
+  test "write nil to time attribute" do
     in_time_zone "Pacific Time (US & Canada)" do
       record = @target.new
       record.written_on = nil
@@ -573,7 +663,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  def test_write_time_to_date_attributes
+  test "write time to date attribute" do
     in_time_zone "Pacific Time (US & Canada)" do
       record = @target.new
       record.last_read = Time.utc(2010, 1, 1, 10)
@@ -581,7 +671,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  def test_time_attributes_are_retrieved_in_current_time_zone
+  test "time attributes are retrieved in the current time zone" do
     in_time_zone "Pacific Time (US & Canada)" do
       utc_time = Time.utc(2008, 1, 1)
       record   = @target.new
@@ -593,7 +683,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  def test_setting_time_zone_aware_attribute_to_utc
+  test "setting a time zone-aware attribute to UTC" do
     in_time_zone "Pacific Time (US & Canada)" do
       utc_time = Time.utc(2008, 1, 1)
       record   = @target.new
@@ -604,11 +694,11 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  def test_setting_time_zone_aware_attribute_in_other_time_zone
+  test "setting time zone-aware attribute in other time zone" do
     utc_time = Time.utc(2008, 1, 1)
     cst_time = utc_time.in_time_zone("Central Time (US & Canada)")
     in_time_zone "Pacific Time (US & Canada)" do
-      record   = @target.new
+      record = @target.new
       record.written_on = cst_time
       assert_equal utc_time, record.written_on
       assert_equal ActiveSupport::TimeZone["Pacific Time (US & Canada)"], record.written_on.time_zone
@@ -616,23 +706,23 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  def test_setting_time_zone_aware_read_attribute
+  test "setting time zone-aware read attribute" do
     utc_time = Time.utc(2008, 1, 1)
     cst_time = utc_time.in_time_zone("Central Time (US & Canada)")
     in_time_zone "Pacific Time (US & Canada)" do
-      record = @target.create(:written_on => cst_time).reload
+      record = @target.create(written_on: cst_time).reload
       assert_equal utc_time, record[:written_on]
       assert_equal ActiveSupport::TimeZone["Pacific Time (US & Canada)"], record[:written_on].time_zone
       assert_equal Time.utc(2007, 12, 31, 16), record[:written_on].time
     end
   end
 
-  def test_setting_time_zone_aware_attribute_with_string
+  test "setting time zone-aware attribute with a string" do
     utc_time = Time.utc(2008, 1, 1)
     (-11..13).each do |timezone_offset|
       time_string = utc_time.in_time_zone(timezone_offset).to_s
       in_time_zone "Pacific Time (US & Canada)" do
-        record   = @target.new
+        record = @target.new
         record.written_on = time_string
         assert_equal Time.zone.parse(time_string), record.written_on
         assert_equal ActiveSupport::TimeZone["Pacific Time (US & Canada)"], record.written_on.time_zone
@@ -641,30 +731,30 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  def test_time_zone_aware_attribute_saved
+  test "time zone-aware attribute saved" do
     in_time_zone 1 do
-      record = @target.create(:written_on => '2012-02-20 10:00')
+      record = @target.create(written_on: "2012-02-20 10:00")
 
-      record.written_on = '2012-02-20 09:00'
+      record.written_on = "2012-02-20 09:00"
       record.save
       assert_equal Time.zone.local(2012, 02, 20, 9), record.reload.written_on
     end
   end
 
-  def test_setting_time_zone_aware_attribute_to_blank_string_returns_nil
+  test "setting a time zone-aware attribute to a blank string returns nil" do
     in_time_zone "Pacific Time (US & Canada)" do
-      record   = @target.new
-      record.written_on = ' '
+      record = @target.new
+      record.written_on = " "
       assert_nil record.written_on
       assert_nil record[:written_on]
     end
   end
 
-  def test_setting_time_zone_aware_attribute_interprets_time_zone_unaware_string_in_time_zone
-    time_string = 'Tue Jan 01 00:00:00 2008'
+  test "setting a time zone-aware attribute interprets time zone-unaware string in time zone" do
+    time_string = "Tue Jan 01 00:00:00 2008"
     (-11..13).each do |timezone_offset|
       in_time_zone timezone_offset do
-        record   = @target.new
+        record = @target.new
         record.written_on = time_string
         assert_equal Time.zone.parse(time_string), record.written_on
         assert_equal ActiveSupport::TimeZone[timezone_offset], record.written_on.time_zone
@@ -673,10 +763,10 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  def test_setting_time_zone_aware_datetime_in_current_time_zone
+  test "setting a time zone-aware datetime in the current time zone" do
     utc_time = Time.utc(2008, 1, 1)
     in_time_zone "Pacific Time (US & Canada)" do
-      record   = @target.new
+      record = @target.new
       record.written_on = utc_time.in_time_zone
       assert_equal utc_time, record.written_on
       assert_equal ActiveSupport::TimeZone["Pacific Time (US & Canada)"], record.written_on.time_zone
@@ -684,15 +774,20 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  def test_yaml_dumping_record_with_time_zone_aware_attribute
+  test "YAML dumping a record with time zone-aware attribute" do
     in_time_zone "Pacific Time (US & Canada)" do
       record = Topic.new(id: 1)
       record.written_on = "Jan 01 00:00:00 2014"
-      assert_equal record, YAML.load(YAML.dump(record))
+      payload = YAML.dump(record)
+      assert_equal record, YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(payload) : YAML.load(payload)
     end
+  ensure
+    # NOTE: Reset column info because global topics
+    # don't have tz-aware attributes by default.
+    Topic.reset_column_information
   end
 
-  def test_setting_time_zone_aware_time_in_current_time_zone
+  test "setting a time zone-aware time in the current time zone" do
     in_time_zone "Pacific Time (US & Canada)" do
       record = @target.new
       time_string = "10:00:00"
@@ -702,12 +797,12 @@ class AttributeMethodsTest < ActiveRecord::TestCase
       assert_equal expected_time, record.bonus_time
       assert_equal ActiveSupport::TimeZone["Pacific Time (US & Canada)"], record.bonus_time.time_zone
 
-      record.bonus_time = ''
+      record.bonus_time = ""
       assert_nil record.bonus_time
     end
   end
 
-  def test_setting_time_zone_aware_time_with_dst
+  test "setting a time zone-aware time with DST" do
     in_time_zone "Pacific Time (US & Canada)" do
       current_time = Time.zone.local(2014, 06, 15, 10)
       record = @target.new(bonus_time: current_time)
@@ -721,26 +816,36 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  def test_removing_time_zone_aware_types
+  test "setting invalid string to a zone-aware time attribute" do
+    in_time_zone "Pacific Time (US & Canada)" do
+      record = @target.new
+      time_string = "ABC"
+
+      record.bonus_time = time_string
+      assert_nil record.bonus_time
+    end
+  end
+
+  test "removing time zone-aware types" do
     with_time_zone_aware_types(:datetime) do
       in_time_zone "Pacific Time (US & Canada)" do
         record = @target.new(bonus_time: "10:00:00")
         expected_time = Time.utc(2000, 01, 01, 10)
 
         assert_equal expected_time, record.bonus_time
-        assert record.bonus_time.utc?
+        assert_predicate record.bonus_time, :utc?
       end
     end
   end
 
-  def test_time_zone_aware_attributes_dont_recurse_infinitely_on_invalid_values
+  test "time zone-aware attributes do not recurse infinitely on invalid values" do
     in_time_zone "Pacific Time (US & Canada)" do
       record = @target.new(bonus_time: [])
-      assert_equal nil, record.bonus_time
+      assert_nil record.bonus_time
     end
   end
 
-  def test_setting_time_zone_conversion_for_attributes_should_write_value_on_class_variable
+  test "setting a time_zone_conversion_for_attributes should write the value on a class variable" do
     Topic.skip_time_zone_conversion_for_attributes = [:field_a]
     Minimalistic.skip_time_zone_conversion_for_attributes = [:field_b]
 
@@ -748,89 +853,91 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal [:field_b], Minimalistic.skip_time_zone_conversion_for_attributes
   end
 
-  def test_read_attributes_respect_access_control
+  test "attribute readers respect access control" do
     privatize("title")
 
-    topic = @target.new(:title => "The pros and cons of programming naked.")
-    assert !topic.respond_to?(:title)
+    topic = @target.new(title: "The pros and cons of programming naked.")
+    assert_not_respond_to topic, :title
     exception = assert_raise(NoMethodError) { topic.title }
-    assert exception.message.include?("private method")
+    assert_includes exception.message, "private method"
     assert_equal "I'm private", topic.send(:title)
   end
 
-  def test_write_attributes_respect_access_control
+  test "attribute writers respect access control" do
     privatize("title=(value)")
 
     topic = @target.new
-    assert !topic.respond_to?(:title=)
-    exception = assert_raise(NoMethodError) { topic.title = "Pants"}
-    assert exception.message.include?("private method")
+    assert_not_respond_to topic, :title=
+    exception = assert_raise(NoMethodError) { topic.title = "Pants" }
+    assert_includes exception.message, "private method"
     topic.send(:title=, "Very large pants")
   end
 
-  def test_question_attributes_respect_access_control
+  test "attribute predicates respect access control" do
     privatize("title?")
 
-    topic = @target.new(:title => "Isaac Newton's pants")
-    assert !topic.respond_to?(:title?)
+    topic = @target.new(title: "Isaac Newton's pants")
+    assert_not_respond_to topic, :title?
     exception = assert_raise(NoMethodError) { topic.title? }
-    assert exception.message.include?("private method")
+    assert_includes exception.message, "private method"
     assert topic.send(:title?)
   end
 
-  def test_bulk_update_respects_access_control
+  test "bulk updates respect access control" do
     privatize("title=(value)")
 
-    assert_raise(ActiveRecord::UnknownAttributeError) { @target.new(:title => "Rants about pants") }
-    assert_raise(ActiveRecord::UnknownAttributeError) { @target.new.attributes = { :title => "Ants in pants" } }
+    assert_raise(ActiveRecord::UnknownAttributeError) { @target.new(title: "Rants about pants") }
+    assert_raise(ActiveRecord::UnknownAttributeError) { @target.new.attributes = { title: "Ants in pants" } }
   end
 
-  def test_bulk_update_raise_unknown_attribute_error
+  test "bulk update raises ActiveRecord::UnknownAttributeError" do
     error = assert_raises(ActiveRecord::UnknownAttributeError) {
       Topic.new(hello: "world")
     }
     assert_instance_of Topic, error.record
     assert_equal "hello", error.attribute
-    assert_equal "unknown attribute 'hello' for Topic.", error.message
+    assert_match "unknown attribute 'hello' for Topic.", error.message
   end
 
-  def test_methods_override_in_multi_level_subclass
+  test "method overrides in multi-level subclasses" do
     klass = Class.new(Developer) do
       def name
         "dev:#{read_attribute(:name)}"
       end
     end
 
-    2.times { klass = Class.new klass }
-    dev = klass.new(name: 'arthurnn')
+    2.times { klass = Class.new(klass) }
+    dev = klass.new(name: "arthurnn")
     dev.save!
-    assert_equal 'dev:arthurnn', dev.reload.name
+    assert_equal "dev:arthurnn", dev.reload.name
   end
 
-  def test_global_methods_are_overwritten
+  test "global methods are overwritten" do
     klass = Class.new(ActiveRecord::Base) do
-      self.table_name = 'computers'
+      self.table_name = "computers"
     end
 
-    assert !klass.instance_method_already_implemented?(:system)
+    assert_not klass.instance_method_already_implemented?(:system)
     computer = klass.new
     assert_nil computer.system
   end
 
-  def test_global_methods_are_overwritten_when_subclassing
-    klass = Class.new(ActiveRecord::Base) { self.abstract_class = true }
+  test "global methods are overwritten when subclassing" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.abstract_class = true
+    end
 
     subklass = Class.new(klass) do
-      self.table_name = 'computers'
+      self.table_name = "computers"
     end
 
-    assert !klass.instance_method_already_implemented?(:system)
-    assert !subklass.instance_method_already_implemented?(:system)
+    assert_not klass.instance_method_already_implemented?(:system)
+    assert_not subklass.instance_method_already_implemented?(:system)
     computer = subklass.new
     assert_nil computer.system
   end
 
-  def test_instance_method_should_be_defined_on_the_base_class
+  test "instance methods should be defined on the base class" do
     subklass = Class.new(Topic)
 
     Topic.define_attribute_methods
@@ -846,14 +953,21 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert subklass.method_defined?(:id), "subklass is missing id method"
   end
 
-  def test_read_attribute_with_nil_should_not_asplode
-    assert_equal nil, Topic.new.read_attribute(nil)
+  test "define_attribute_method works with both symbol and string" do
+    klass = Class.new(ActiveRecord::Base)
+
+    assert_nothing_raised { klass.define_attribute_method(:foo) }
+    assert_nothing_raised { klass.define_attribute_method("bar") }
+  end
+
+  test "read_attribute with nil should not asplode" do
+    assert_nil Topic.new.read_attribute(nil)
   end
 
   # If B < A, and A defines an accessor for 'foo', we don't want to override
   # that by defining a 'foo' method in the generated methods module for B.
   # (That module will be inserted between the two, e.g. [B, <GeneratedAttributes>, A].)
-  def test_inherited_custom_accessors
+  test "inherited custom accessors" do
     klass = new_topic_like_ar_class do
       self.abstract_class = true
       def title; "omg"; end
@@ -869,9 +983,9 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal "lol", topic.author_name
   end
 
-  def test_inherited_custom_accessors_with_reserved_names
+  test "inherited custom accessors with reserved names" do
     klass = Class.new(ActiveRecord::Base) do
-      self.table_name = 'computers'
+      self.table_name = "computers"
       self.abstract_class = true
       def system; "omg"; end
       def system=(val); self.developer = val; end
@@ -887,18 +1001,18 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal 99, computer.developer
   end
 
-  def test_on_the_fly_super_invokable_generated_attribute_methods_via_method_missing
+  test "on_the_fly_super_invokable_generated_attribute_methods_via_method_missing" do
     klass = new_topic_like_ar_class do
       def title
-        super + '!'
+        super + "!"
       end
     end
 
     real_topic = topics(:first)
-    assert_equal real_topic.title + '!', klass.find(real_topic.id).title
+    assert_equal real_topic.title + "!", klass.find(real_topic.id).title
   end
 
-  def test_on_the_fly_super_invokable_generated_predicate_attribute_methods_via_method_missing
+  test "on-the-fly super-invokable generated attribute predicates via method_missing" do
     klass = new_topic_like_ar_class do
       def title?
         !super
@@ -909,7 +1023,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal !real_topic.title?, klass.find(real_topic.id).title?
   end
 
-  def test_calling_super_when_parent_does_not_define_method_raises_error
+  test "calling super when the parent does not define method raises NoMethodError" do
     klass = new_topic_like_ar_class do
       def some_method_that_is_not_on_super
         super
@@ -921,46 +1035,46 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  def test_attribute_method?
+  test "attribute_method?" do
     assert @target.attribute_method?(:title)
     assert @target.attribute_method?(:title=)
     assert_not @target.attribute_method?(:wibble)
   end
 
-  def test_attribute_method_returns_false_if_table_does_not_exist
-    @target.table_name = 'wibble'
+  test "attribute_method? returns false if the table does not exist" do
+    @target.table_name = "wibble"
     assert_not @target.attribute_method?(:title)
   end
 
-  def test_attribute_names_on_new_record
+  test "attribute_names on a new record" do
     model = @target.new
 
     assert_equal @target.column_names, model.attribute_names
   end
 
-  def test_attribute_names_on_queried_record
+  test "attribute_names on a queried record" do
     model = @target.last!
 
     assert_equal @target.column_names, model.attribute_names
   end
 
-  def test_attribute_names_with_custom_select
-    model = @target.select('id').last!
+  test "attribute_names with a custom select" do
+    model = @target.select("id").last!
 
-    assert_equal ['id'], model.attribute_names
-    # Sanity check, make sure other columns exist
-    assert_not_equal ['id'], @target.column_names
+    assert_equal ["id"], model.attribute_names
+    # Sanity check, make sure other columns exist.
+    assert_not_equal ["id"], @target.column_names
   end
 
-  def test_came_from_user
+  test "came_from_user?" do
     model = @target.first
 
-    assert_not model.id_came_from_user?
+    assert_not_predicate model, :id_came_from_user?
     model.id = "omg"
-    assert model.id_came_from_user?
+    assert_predicate model, :id_came_from_user?
   end
 
-  def test_accessed_fields
+  test "accessed_fields" do
     model = @target.first
 
     assert_equal [], model.accessed_fields
@@ -970,40 +1084,41 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal ["title"], model.accessed_fields
   end
 
-  private
-
-  def new_topic_like_ar_class(&block)
-    klass = Class.new(ActiveRecord::Base) do
-      self.table_name = 'topics'
-      class_eval(&block)
-    end
-
-    assert_empty klass.generated_attribute_methods.instance_methods(false)
-    klass
+  test "generated attribute methods ancestors have correct module" do
+    mod = Topic.send(:generated_attribute_methods)
+    assert_equal "Topic::GeneratedAttributeMethods", mod.inspect
   end
 
-  def with_time_zone_aware_types(*types)
-    old_types = ActiveRecord::Base.time_zone_aware_types
-    ActiveRecord::Base.time_zone_aware_types = types
-    yield
-  ensure
-    ActiveRecord::Base.time_zone_aware_types = old_types
+  test "read_attribute_before_type_cast with aliased attribute" do
+    model = NumericData.new(new_bank_balance: "abcd")
+    assert_equal "abcd", model.read_attribute_before_type_cast("new_bank_balance")
   end
 
-  def cached_columns
-    Topic.columns.map(&:name)
-  end
+  private
+    def new_topic_like_ar_class(&block)
+      klass = Class.new(ActiveRecord::Base) do
+        self.table_name = "topics"
+        class_eval(&block)
+      end
 
-  def time_related_columns_on_topic
-    Topic.columns.select { |c| [:time, :date, :datetime, :timestamp].include?(c.type) }
-  end
+      assert_empty klass.send(:generated_attribute_methods).instance_methods(false)
+      klass
+    end
 
-  def privatize(method_signature)
-    @target.class_eval(<<-private_method, __FILE__, __LINE__ + 1)
-      private
-      def #{method_signature}
-        "I'm private"
-      end
-    private_method
-  end
+    def with_time_zone_aware_types(*types)
+      old_types = ActiveRecord::Base.time_zone_aware_types
+      ActiveRecord::Base.time_zone_aware_types = types
+      yield
+    ensure
+      ActiveRecord::Base.time_zone_aware_types = old_types
+    end
+
+    def privatize(method_signature)
+      @target.class_eval(<<-private_method, __FILE__, __LINE__ + 1)
+        private
+        def #{method_signature}
+          "I'm private"
+        end
+      private_method
+    end
 end