ibm_db 5.2.0 → 5.3.2

data/test/cases/base_test.rb

@@ -1,42 +1,52 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'models/post'
-require 'models/author'
-require 'models/topic'
-require 'models/reply'
-require 'models/category'
-require 'models/company'
-require 'models/customer'
-require 'models/developer'
-require 'models/computer'
-require 'models/project'
-require 'models/default'
-require 'models/auto_id'
-require 'models/boolean'
-require 'models/column_name'
-require 'models/subscriber'
-require 'models/keyboard'
-require 'models/comment'
-require 'models/minimalistic'
-require 'models/warehouse_thing'
-require 'models/parrot'
-require 'models/person'
-require 'models/edge'
-require 'models/joke'
-require 'models/bird'
-require 'models/car'
-require 'models/bulb'
-require 'rexml/document'
-require 'concurrent/atomic/count_down_latch'
+require "models/post"
+require "models/author"
+require "models/topic"
+require "models/reply"
+require "models/category"
+require "models/categorization"
+require "models/company"
+require "models/customer"
+require "models/developer"
+require "models/computer"
+require "models/project"
+require "models/default"
+require "models/auto_id"
+require "models/column_name"
+require "models/subscriber"
+require "models/comment"
+require "models/minimalistic"
+require "models/warehouse_thing"
+require "models/parrot"
+require "models/person"
+require "models/edge"
+require "models/joke"
+require "models/bird"
+require "models/car"
+require "models/bulb"
+require "models/pet"
+require "concurrent/atomic/count_down_latch"
+require "active_support/core_ext/enumerable"
 
 class FirstAbstractClass < ActiveRecord::Base
   self.abstract_class = true
+
+  connects_to database: { writing: :arunit, reading: :arunit }
 end
+
 class SecondAbstractClass < FirstAbstractClass
   self.abstract_class = true
+
+  connects_to database: { writing: :arunit, reading: :arunit }
+end
+
+class ThirdAbstractClass < SecondAbstractClass
+  self.abstract_class = true
 end
+
 class Photo < SecondAbstractClass; end
-class Category < ActiveRecord::Base; end
-class Categorization < ActiveRecord::Base; end
 class Smarts < ActiveRecord::Base; end
 class CreditCard < ActiveRecord::Base
   class PinNumber < ActiveRecord::Base
@@ -47,8 +57,6 @@ class CreditCard < ActiveRecord::Base
   class Brand < Category; end
 end
 class MasterCreditCard < ActiveRecord::Base; end
-class Post < ActiveRecord::Base; end
-class Computer < ActiveRecord::Base; end
 class NonExistentTable < ActiveRecord::Base; end
 class TestOracleDefault < ActiveRecord::Base; end
 
@@ -58,12 +66,6 @@ end
 
 class Weird < ActiveRecord::Base; end
 
-class Boolean < ActiveRecord::Base
-  def has_fun
-    super
-  end
-end
-
 class LintTest < ActiveRecord::TestCase
   include ActiveModel::Lint::Tests
 
@@ -75,20 +77,60 @@ class LintTest < ActiveRecord::TestCase
 end
 
 class BasicsTest < ActiveRecord::TestCase
-  #fixtures :topics, :companies, :developers, :projects, :computers, :accounts, :minimalistics, 'warehouse_things', :authors, :categorizations, :categories, :posts
-  fixtures :topics, :companies, :developers, :projects, :computers, :accounts, :minimalistics, 'warehouse_things',  :categorizations, :categories, :posts
+  fixtures :topics, :companies, :developers, :projects, :computers, :accounts, :minimalistics, "warehouse_things", :authors, :author_addresses, :categorizations, :categories, :posts
+
+  def test_generated_association_methods_module_name
+    mod = Post.send(:generated_association_methods)
+    assert_equal "Post::GeneratedAssociationMethods", mod.inspect
+  end
+
+  def test_generated_relation_methods_module_name
+    mod = Post.send(:generated_relation_methods)
+    assert_equal "Post::GeneratedRelationMethods", mod.inspect
+  end
+
+  def test_arel_attribute_normalization
+    assert_equal Post.arel_table["body"], Post.arel_table[:body]
+    assert_equal Post.arel_table["body"], Post.arel_table[:text]
+  end
+
+  def test_deprecated_arel_attribute
+    assert_deprecated do
+      assert_equal Post.arel_table["body"], Post.arel_attribute(:body)
+    end
+  end
+
+  def test_deprecated_arel_attribute_on_relation
+    assert_deprecated do
+      assert_equal Post.arel_table["body"], Post.all.arel_attribute(:body)
+    end
+  end
+
+  def test_incomplete_schema_loading
+    topic = Topic.first
+    payload = { foo: 42 }
+    topic.update!(content: payload)
+
+    Topic.reset_column_information
+
+    Topic.connection.stub(:lookup_cast_type_from_column, ->(_) { raise "Some Error" }) do
+      assert_raises RuntimeError do
+        Topic.columns_hash
+      end
+    end
+
+    assert_equal payload, Topic.first.content
+  end
 
   def test_column_names_are_escaped
-    puts "In base_test test_column_names_are_escaped"
     conn      = ActiveRecord::Base.connection
     classname = conn.class.name[/[^:]*$/]
     badchar   = {
-      'SQLite3Adapter'    => '"',
-      'Mysql2Adapter'     => '`',
-      'PostgreSQLAdapter' => '"',
-      'OracleAdapter'     => '"',
-      'IBM_DBAdapter'     => '"',
-      'FbAdapter'         => '"'
+      "SQLite3Adapter"    => '"',
+      "Mysql2Adapter"     => "`",
+      "PostgreSQLAdapter" => '"',
+      "OracleAdapter"     => '"',
+      "IBM_DBAdapter"     => '"',
     }.fetch(classname) {
       raise "need a bad char for #{classname}"
     }
@@ -98,35 +140,30 @@ class BasicsTest < ActiveRecord::TestCase
       # Oracle does not allow double quotes in table and column names at all
       # therefore quoting removes them
       assert_equal("#{badchar}foobar#{badchar}", quoted)
-	elsif current_adapter?(:IBM_DBAdapter)
-      assert_equal("foo#{badchar}bar", quoted)
+    elsif  current_adapter?(:IBM_DBAdapter)
+      assert_equal("foobar", quoted)
     else
       assert_equal("#{badchar}foo#{badchar * 2}bar#{badchar}", quoted)
     end
   end
 
   def test_columns_should_obey_set_primary_key
-    puts "In base_test test_columns_should_obey_set_primary_key"
     pk = Subscriber.columns_hash[Subscriber.primary_key]
-    assert_equal 'nick', pk.name, 'nick should be primary key'
+    assert_equal "nick", pk.name, "nick should be primary key"
   end
 
   def test_primary_key_with_no_id
-    puts "In base_test test_primary_key_with_no_id"
     assert_nil Edge.primary_key
   end
 
-  unless current_adapter?(:PostgreSQLAdapter, :OracleAdapter, :SQLServerAdapter, :IBM_DBAdapter, :FbAdapter)
-    def test_limit_with_comma
-	  puts "In base_test test_limit_with_comma"
-      assert_deprecated do
-        assert Topic.limit("1,2").to_a
-      end
-    end
+  def test_primary_key_and_references_columns_should_be_identical_type
+    pk = Author.columns_hash["id"]
+    ref = Post.columns_hash["author_id"]
+
+    assert_equal pk.sql_type, ref.sql_type
   end
 
   def test_many_mutations
-    puts "In base_test test_many_mutations"
     car = Car.new name: "<3<3<3"
     car.engines_count = 0
     20_000.times { car.engines_count += 1 }
@@ -134,53 +171,43 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_limit_without_comma
-    puts "In base_test test_limit_without_comma"
     assert_equal 1, Topic.limit("1").to_a.length
     assert_equal 1, Topic.limit(1).to_a.length
   end
 
   def test_limit_should_take_value_from_latest_limit
-    puts "In base_test test_limit_should_take_value_from_latest_limit"
     assert_equal 1, Topic.limit(2).limit(1).to_a.length
   end
 
   def test_invalid_limit
-    puts "In base_test test_invalid_limit"
     assert_raises(ArgumentError) do
       Topic.limit("asdfadf").to_a
     end
   end
 
   def test_limit_should_sanitize_sql_injection_for_limit_without_commas
-    puts "In base_test test_limit_should_sanitize_sql_injection_for_limit_without_commas"
     assert_raises(ArgumentError) do
       Topic.limit("1 select * from schema").to_a
     end
   end
 
   def test_limit_should_sanitize_sql_injection_for_limit_with_commas
-    puts "In base_test test_limit_should_sanitize_sql_injection_for_limit_with_commas"
-    assert_deprecated do
-      assert_raises(ArgumentError) do
-        Topic.limit("1, 7 procedure help()").to_a
-      end
+    assert_raises(ArgumentError) do
+      Topic.limit("1, 7 procedure help()").to_a
     end
   end
 
   def test_select_symbol
-    puts "In base_test test_select_symbol"
     topic_ids = Topic.select(:id).map(&:id).sort
     assert_equal Topic.pluck(:id).sort, topic_ids
   end
 
   def test_table_exists
-    puts "In base_test test_table_exists"
-    assert !NonExistentTable.table_exists?
-    assert Topic.table_exists?
+    assert_not_predicate NonExistentTable, :table_exists?
+    assert_predicate Topic, :table_exists?
   end
 
   def test_preserving_date_objects
-    puts "In base_test test_preserving_date_objects"
     # Oracle enhanced adapter allows to define Date attributes in model class (see topic.rb)
     assert_kind_of(
       Date, Topic.find(1).last_read,
@@ -189,20 +216,18 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_previously_changed
-    puts "In base_test test_previously_changed"
     topic = Topic.first
-    topic.title = '<3<3<3'
+    topic.title = "<3<3<3"
     assert_equal({}, topic.previous_changes)
 
     topic.save!
     expected = ["The First Topic", "<3<3<3"]
-    assert_equal(expected, topic.previous_changes['title'])
+    assert_equal(expected, topic.previous_changes["title"])
   end
 
   def test_previously_changed_dup
-    puts "In base_test test_previously_changed_dup"
     topic = Topic.first
-    topic.title = '<3<3<3'
+    topic.title = "<3<3<3"
     topic.save!
 
     t2 = topic.dup
@@ -216,7 +241,6 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_preserving_time_objects
-    puts "In base_test test_preserving_time_objects"
     assert_kind_of(
       Time, Topic.find(1).bonus_time,
       "The bonus_time attribute should be of the Time class"
@@ -228,7 +252,7 @@ class BasicsTest < ActiveRecord::TestCase
     )
 
     # For adapters which support microsecond resolution.
-    if subsecond_precision_supported?
+    if supports_datetime_with_precision?
       assert_equal 11, Topic.find(1).written_on.sec
       assert_equal 223300, Topic.find(1).written_on.usec
       assert_equal 9900, Topic.find(2).written_on.usec
@@ -237,11 +261,10 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_preserving_time_objects_with_local_time_conversion_to_default_timezone_utc
-    puts "In base_test test_preserving_time_objects_with_local_time_conversion_to_default_timezone_utc"
     with_env_tz eastern_time_zone do
       with_timezone_config default: :utc do
         time = Time.local(2000)
-        topic = Topic.create('written_on' => time)
+        topic = Topic.create("written_on" => time)
         saved_time = Topic.find(topic.id).reload.written_on
         assert_equal time, saved_time
         assert_equal [0, 0, 0, 1, 1, 2000, 6, 1, false, "EST"], time.to_a
@@ -251,12 +274,11 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_preserving_time_objects_with_time_with_zone_conversion_to_default_timezone_utc
-    puts "In base_test test_preserving_time_objects_with_time_with_zone_conversion_to_default_timezone_utc"
     with_env_tz eastern_time_zone do
       with_timezone_config default: :utc do
-        Time.use_zone 'Central Time (US & Canada)' do
+        Time.use_zone "Central Time (US & Canada)" do
           time = Time.zone.local(2000)
-          topic = Topic.create('written_on' => time)
+          topic = Topic.create("written_on" => time)
           saved_time = Topic.find(topic.id).reload.written_on
           assert_equal time, saved_time
           assert_equal [0, 0, 0, 1, 1, 2000, 6, 1, false, "CST"], time.to_a
@@ -267,11 +289,10 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_preserving_time_objects_with_utc_time_conversion_to_default_timezone_local
-    puts "In base_test test_preserving_time_objects_with_utc_time_conversion_to_default_timezone_local"
     with_env_tz eastern_time_zone do
       with_timezone_config default: :local do
         time = Time.utc(2000)
-        topic = Topic.create('written_on' => time)
+        topic = Topic.create("written_on" => time)
         saved_time = Topic.find(topic.id).reload.written_on
         assert_equal time, saved_time
         assert_equal [0, 0, 0, 1, 1, 2000, 6, 1, false, "UTC"], time.to_a
@@ -281,12 +302,11 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_preserving_time_objects_with_time_with_zone_conversion_to_default_timezone_local
-    puts "In base_test test_preserving_time_objects_with_time_with_zone_conversion_to_default_timezone_local"
     with_env_tz eastern_time_zone do
       with_timezone_config default: :local do
-        Time.use_zone 'Central Time (US & Canada)' do
+        Time.use_zone "Central Time (US & Canada)" do
           time = Time.zone.local(2000)
-          topic = Topic.create('written_on' => time)
+          topic = Topic.create("written_on" => time)
           saved_time = Topic.find(topic.id).reload.written_on
           assert_equal time, saved_time
           assert_equal [0, 0, 0, 1, 1, 2000, 6, 1, false, "CST"], time.to_a
@@ -296,6 +316,18 @@ class BasicsTest < ActiveRecord::TestCase
     end
   end
 
+  def test_time_zone_aware_attribute_with_default_timezone_utc_on_utc_can_be_created
+    with_env_tz eastern_time_zone do
+      with_timezone_config aware_attributes: true, default: :utc, zone: "UTC" do
+        pet = Pet.create(name: "Bidu")
+        assert_predicate pet, :persisted?
+        saved_pet = Pet.find(pet.id)
+        assert_not_nil saved_pet.created_at
+        assert_not_nil saved_pet.updated_at
+      end
+    end
+  end
+
   def eastern_time_zone
     if Gem.win_platform?
       "EST5EDT"
@@ -305,7 +337,6 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_custom_mutator
-    puts "In base_test test_custom_mutator"
     topic = Topic.find(1)
     # This mutator is protected in the class definition
     topic.send(:approved=, true)
@@ -313,56 +344,50 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_initialize_with_attributes
-    puts "In base_test test_initialize_with_attributes"
-    topic = Topic.new({
-      "title" => "initialized from attributes", "written_on" => "2003-12-12 23:23"
-    })
+    topic = Topic.new(
+      "title" => "initialized from attributes", "written_on" => "2003-12-12 23:23")
 
     assert_equal("initialized from attributes", topic.title)
   end
 
   def test_initialize_with_invalid_attribute
-    puts "In base_test test_initialize_with_invalid_attribute"
-    Topic.new({ "title" => "test",
-      "last_read(1i)" => "2005", "last_read(2i)" => "2", "last_read(3i)" => "31"})
-  rescue ActiveRecord::MultiparameterAssignmentErrors => ex
+    ex = assert_raise(ActiveRecord::MultiparameterAssignmentErrors) do
+      Topic.new("title" => "test",
+        "written_on(4i)" => "16", "written_on(5i)" => "24", "written_on(6i)" => "00")
+    end
+
     assert_equal(1, ex.errors.size)
-    assert_equal("last_read", ex.errors[0].attribute)
+    assert_equal("written_on", ex.errors[0].attribute)
   end
 
   def test_create_after_initialize_without_block
-    puts "In base_test test_create_after_initialize_without_block"
-    cb = CustomBulb.create(:name => 'Dude')
-    assert_equal('Dude', cb.name)
+    cb = CustomBulb.create(name: "Dude")
+    assert_equal("Dude", cb.name)
     assert_equal(true, cb.frickinawesome)
   end
 
   def test_create_after_initialize_with_block
-    puts "In base_test test_create_after_initialize_with_block"
-    cb = CustomBulb.create {|c| c.name = 'Dude' }
-    assert_equal('Dude', cb.name)
+    cb = CustomBulb.create { |c| c.name = "Dude" }
+    assert_equal("Dude", cb.name)
     assert_equal(true, cb.frickinawesome)
   end
 
   def test_create_after_initialize_with_array_param
-    puts "In base_test test_create_after_initialize_with_array_param"
-    cbs = CustomBulb.create([{ name: 'Dude' }, { name: 'Bob' }])
-    assert_equal 'Dude', cbs[0].name
-    assert_equal 'Bob', cbs[1].name
+    cbs = CustomBulb.create([{ name: "Dude" }, { name: "Bob" }])
+    assert_equal "Dude", cbs[0].name
+    assert_equal "Bob", cbs[1].name
     assert cbs[0].frickinawesome
-    assert !cbs[1].frickinawesome
+    assert_not cbs[1].frickinawesome
   end
 
   def test_load
-    puts "In base_test test_load"
-    topics = Topic.all.merge!(:order => 'id').to_a
+    topics = Topic.all.merge!(order: "id").to_a
     assert_equal(5, topics.size)
     assert_equal(topics(:first).title, topics.first.title)
   end
 
   def test_load_with_condition
-    puts "In base_test test_load_with_condition"
-    topics = Topic.all.merge!(:where => "author_name = 'Mary'").to_a
+    topics = Topic.all.merge!(where: "author_name = 'Mary'").to_a
 
     assert_equal(1, topics.size)
     assert_equal(topics(:second).title, topics.first.title)
@@ -371,7 +396,6 @@ class BasicsTest < ActiveRecord::TestCase
   GUESSED_CLASSES = [Category, Smarts, CreditCard, CreditCard::PinNumber, CreditCard::PinNumber::CvvCode, CreditCard::SubPinNumber, CreditCard::Brand, MasterCreditCard]
 
   def test_table_name_guesses
-    puts "In base_test test_table_name_guesses"
     assert_equal "topics", Topic.table_name
 
     assert_equal "categories", Category.table_name
@@ -387,7 +411,6 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_singular_table_name_guesses
-    puts "In base_test test_singular_table_name_guesses"
     ActiveRecord::Base.pluralize_table_names = false
     GUESSED_CLASSES.each(&:reset_table_name)
 
@@ -405,7 +428,6 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_table_name_guesses_with_prefixes_and_suffixes
-    puts "In base_test test_table_name_guesses_with_prefixes_and_suffixes"
     ActiveRecord::Base.table_name_prefix = "test_"
     Category.reset_table_name
     assert_equal "test_categories", Category.table_name
@@ -425,7 +447,6 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_singular_table_name_guesses_with_prefixes_and_suffixes
-    puts "In base_test test_singular_table_name_guesses_with_prefixes_and_suffixes"
     ActiveRecord::Base.pluralize_table_names = false
 
     ActiveRecord::Base.table_name_prefix = "test_"
@@ -448,7 +469,6 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_table_name_guesses_with_inherited_prefixes_and_suffixes
-    puts "In base_test test_table_name_guesses_with_inherited_prefixes_and_suffixes"
     GUESSED_CLASSES.each(&:reset_table_name)
 
     CreditCard.table_name_prefix = "test_"
@@ -478,7 +498,6 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_singular_table_name_guesses_for_individual_table
-    puts "In base_test test_singular_table_name_guesses_for_individual_table"
     Post.pluralize_table_names = false
     Post.reset_table_name
     assert_equal "post", Post.table_name
@@ -488,23 +507,14 @@ class BasicsTest < ActiveRecord::TestCase
     Post.reset_table_name
   end
 
-  if current_adapter?(:Mysql2Adapter)    
-    puts "In base_test test_update_all_with_order_and_limit"
-    def test_update_all_with_order_and_limit
-      assert_equal 1, Topic.limit(1).order('id DESC').update_all(:content => 'bulk updated!')
-    end
-  end
-
   def test_null_fields
-    puts "In base_test test_null_fields"
     assert_nil Topic.find(1).parent_id
     assert_nil Topic.create("title" => "Hey you").parent_id
   end
 
   def test_default_values
-    puts "In base_test test_default_values"
     topic = Topic.new
-    assert topic.approved?
+    assert_predicate topic, :approved?
     assert_nil topic.written_on
     assert_nil topic.bonus_time
     assert_nil topic.last_read
@@ -512,7 +522,7 @@ class BasicsTest < ActiveRecord::TestCase
     topic.save
 
     topic = Topic.find(topic.id)
-    assert topic.approved?
+    assert_predicate topic, :approved?
     assert_nil topic.last_read
 
     # Oracle has some funky default handling, so it requires a bit of
@@ -526,27 +536,24 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   # Oracle does not have a TIME datatype.
-  unless current_adapter?(:OracleAdapter,:IBM_DBAdapter)
+  unless current_adapter?(:OracleAdapter)
     def test_utc_as_time_zone
-	  puts "In base_test test_utc_as_time_zone"
       with_timezone_config default: :utc do
         attributes = { "bonus_time" => "5:42:00AM" }
         topic = Topic.find(1)
         topic.attributes = attributes
         assert_equal Time.utc(2000, 1, 1, 5, 42, 0), topic.bonus_time
       end
-	end
-  end
+    end
 
     def test_utc_as_time_zone_and_new
-	  puts "In base_test test_utc_as_time_zone_and_new"
       with_timezone_config default: :utc do
-        attributes = { "bonus_time(1i)"=>"2000",
-          "bonus_time(2i)"=>"1",
-          "bonus_time(3i)"=>"1",
-          "bonus_time(4i)"=>"10",
-          "bonus_time(5i)"=>"35",
-          "bonus_time(6i)"=>"50" }
+        attributes = { "bonus_time(1i)" => "2000",
+          "bonus_time(2i)" => "1",
+          "bonus_time(3i)" => "1",
+          "bonus_time(4i)" => "10",
+          "bonus_time(5i)" => "35",
+          "bonus_time(6i)" => "50" }
         topic = Topic.new(attributes)
         assert_equal Time.utc(2000, 1, 1, 10, 35, 50), topic.bonus_time
       end
@@ -554,7 +561,6 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_default_values_on_empty_strings
-    puts "In base_test test_default_values_on_empty_strings"
     topic = Topic.new
     topic.approved  = nil
     topic.last_read = nil
@@ -568,35 +574,33 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_equality
-    puts "In base_test test_equality"
     assert_equal Topic.find(1), Topic.find(2).topic
   end
 
   def test_find_by_slug
-    puts "In base_test test_find_by_slug"
-    assert_equal Topic.find('1-meowmeow'), Topic.find(1)
+    assert_equal Topic.find("1-meowmeow"), Topic.find(1)
+  end
+
+  def test_out_of_range_slugs
+    assert_equal [Topic.find(1)], Topic.where(id: ["1-meowmeow", "9223372036854775808-hello"])
   end
 
   def test_find_by_slug_with_array
-    puts "In base_test test_find_by_slug_with_array"
-    assert_equal Topic.find([1, 2]), Topic.find(['1-meowmeow', '2-hello'])
-    assert_equal 'The Second Topic of the day', Topic.find(['2-hello', '1-meowmeow']).first.title
+    assert_equal Topic.find([1, 2]), Topic.find(["1-meowmeow", "2-hello"])
+    assert_equal "The Second Topic of the day", Topic.find(["2-hello", "1-meowmeow"]).first.title
   end
 
   def test_find_by_slug_with_range
-    puts "In base_test test_find_by_slug_with_range"
-    assert_equal Topic.where(id: '1-meowmeow'..'2-hello'), Topic.where(id: 1..2)
+    assert_equal Topic.where(id: "1-meowmeow".."2-hello"), Topic.where(id: 1..2)
   end
 
   def test_equality_of_new_records
-    puts "In base_test test_equality_of_new_records"
     assert_not_equal Topic.new, Topic.new
     assert_equal false, Topic.new == Topic.new
   end
 
   def test_equality_of_destroyed_records
-    puts "In base_test test_equality_of_destroyed_records"
-    topic_1 = Topic.new(:title => 'test_1')
+    topic_1 = Topic.new(title: "test_1")
     topic_1.save
     topic_2 = Topic.find(topic_1.id)
     topic_1.destroy
@@ -605,58 +609,51 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_equality_with_blank_ids
-    puts "In base_test test_equality_with_blank_ids"
-    one = Subscriber.new(:id => '')
-    two = Subscriber.new(:id => '')
+    one = Subscriber.new(id: "")
+    two = Subscriber.new(id: "")
     assert_equal one, two
   end
 
   def test_equality_of_relation_and_collection_proxy
-    puts "In base_test test_equality_of_relation_and_collection_proxy"
     car = Car.create!
     car.bulbs.build
     car.save
 
-    assert car.bulbs == Bulb.where(car_id: car.id), 'CollectionProxy should be comparable with Relation'
-    assert Bulb.where(car_id: car.id) == car.bulbs, 'Relation should be comparable with CollectionProxy'
+    assert car.bulbs == Bulb.where(car_id: car.id), "CollectionProxy should be comparable with Relation"
+    assert Bulb.where(car_id: car.id) == car.bulbs, "Relation should be comparable with CollectionProxy"
   end
 
   def test_equality_of_relation_and_array
-    puts "In base_test test_equality_of_relation_and_array"
     car = Car.create!
     car.bulbs.build
     car.save
 
-    assert Bulb.where(car_id: car.id) == car.bulbs.to_a, 'Relation should be comparable with Array'
+    assert Bulb.where(car_id: car.id) == car.bulbs.to_a, "Relation should be comparable with Array"
   end
 
   def test_equality_of_relation_and_association_relation
-    puts "In base_test test_equality_of_relation_and_association_relation"
     car = Car.create!
     car.bulbs.build
     car.save
 
-    assert_equal Bulb.where(car_id: car.id), car.bulbs.includes(:car), 'Relation should be comparable with AssociationRelation'
-    assert_equal car.bulbs.includes(:car), Bulb.where(car_id: car.id), 'AssociationRelation should be comparable with Relation'
+    assert_equal Bulb.where(car_id: car.id), car.bulbs.includes(:car), "Relation should be comparable with AssociationRelation"
+    assert_equal car.bulbs.includes(:car), Bulb.where(car_id: car.id), "AssociationRelation should be comparable with Relation"
   end
 
   def test_equality_of_collection_proxy_and_association_relation
-    puts "In base_test test_equality_of_collection_proxy_and_association_relation"
     car = Car.create!
     car.bulbs.build
     car.save
 
-    assert_equal car.bulbs, car.bulbs.includes(:car), 'CollectionProxy should be comparable with AssociationRelation'
-    assert_equal car.bulbs.includes(:car), car.bulbs, 'AssociationRelation should be comparable with CollectionProxy'
+    assert_equal car.bulbs, car.bulbs.includes(:car), "CollectionProxy should be comparable with AssociationRelation"
+    assert_equal car.bulbs.includes(:car), car.bulbs, "AssociationRelation should be comparable with CollectionProxy"
   end
 
   def test_hashing
-    puts "In base_test test_hashing"
     assert_equal [ Topic.find(1) ], [ Topic.find(2).topic ] & [ Topic.find(1) ]
   end
 
   def test_successful_comparison_of_like_class_records
-    puts "In base_test test_successful_comparison_of_like_class_records"
     topic_1 = Topic.create!
     topic_2 = Topic.create!
 
@@ -664,40 +661,35 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_failed_comparison_of_unlike_class_records
-    puts "In base_test test_failed_comparison_of_unlike_class_records"
     assert_raises ArgumentError do
       [ topics(:first), posts(:welcome) ].sort
     end
   end
 
   def test_create_without_prepared_statement
-    puts "In base_test test_create_without_prepared_statement"
     topic = Topic.connection.unprepared_statement do
-      Topic.create(:title => 'foo')
+      Topic.create(title: "foo")
     end
 
     assert_equal topic, Topic.find(topic.id)
   end
 
   def test_destroy_without_prepared_statement
-    puts "In base_test test_destroy_without_prepared_statement"
-    topic = Topic.create(title: 'foo')
+    topic = Topic.create(title: "foo")
     Topic.connection.unprepared_statement do
       Topic.find(topic.id).destroy
     end
 
-    assert_equal nil, Topic.find_by_id(topic.id)
+    assert_nil Topic.find_by_id(topic.id)
   end
 
   def test_comparison_with_different_objects
-    puts "In base_test test_comparison_with_different_objects"
     topic = Topic.create
-    category = Category.create(:name => "comparison")
+    category = Category.create(name: "comparison")
     assert_nil topic <=> category
   end
 
   def test_comparison_with_different_objects_in_array
-    puts "In base_test test_comparison_with_different_objects_in_array"
     topic = Topic.create
     assert_raises(ArgumentError) do
       [1, topic].sort
@@ -705,10 +697,9 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_readonly_attributes
-    puts "In base_test test_readonly_attributes"
-    assert_equal Set.new([ 'title' , 'comments_count' ]), ReadonlyTitlePost.readonly_attributes
+    assert_equal Set.new([ "title", "comments_count" ]), ReadonlyTitlePost.readonly_attributes
 
-    post = ReadonlyTitlePost.create(:title => "cannot change this", :body => "changeable")
+    post = ReadonlyTitlePost.create(title: "cannot change this", body: "changeable")
     post.reload
     assert_equal "cannot change this", post.title
 
@@ -719,21 +710,19 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_unicode_column_name
-    puts "In base_test test_unicode_column_name"
     Weird.reset_column_information
-    weird = Weird.create(:なまえ => 'たこ焼き仮面')
-    assert_equal 'たこ焼き仮面', weird.なまえ
+    weird = Weird.create(なまえ: "たこ焼き仮面")
+    assert_equal "たこ焼き仮面", weird.なまえ
   end
 
   unless current_adapter?(:PostgreSQLAdapter)
     def test_respect_internal_encoding
-	  puts "In base_test test_respect_internal_encoding"
       old_default_internal = Encoding.default_internal
       silence_warnings { Encoding.default_internal = "EUC-JP" }
 
       Weird.reset_column_information
 
-      assert_equal ["EUC-JP"], Weird.columns.map {|c| c.name.encoding.name }.uniq
+      assert_equal ["EUC-JP"], Weird.columns.map { |c| c.name.encoding.name }.uniq
     ensure
       silence_warnings { Encoding.default_internal = old_default_internal }
       Weird.reset_column_information
@@ -741,27 +730,24 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_non_valid_identifier_column_name
-    puts "In base_test test_non_valid_identifier_column_name"
-    weird = Weird.create('a$b' => 'value')
+    weird = Weird.create("a$b" => "value")
     weird.reload
-    assert_equal 'value', weird.send('a$b')
-    assert_equal 'value', weird.read_attribute('a$b')
+    assert_equal "value", weird.public_send("a$b")
+    assert_equal "value", weird.read_attribute("a$b")
 
-    weird.update_columns('a$b' => 'value2')
+    weird.update_columns("a$b" => "value2")
     weird.reload
-    assert_equal 'value2', weird.send('a$b')
-    assert_equal 'value2', weird.read_attribute('a$b')
+    assert_equal "value2", weird.public_send("a$b")
+    assert_equal "value2", weird.read_attribute("a$b")
   end
 
   def test_group_weirds_by_from
-    puts "In base_test test_group_weirds_by_from"
-    Weird.create('a$b' => 'value', :from => 'aaron')
+    Weird.create("a$b" => "value", :from => "aaron")
     count = Weird.group(Weird.arel_table[:from]).count
-    assert_equal 1, count['aaron']
+    assert_equal 1, count["aaron"]
   end
 
   def test_attributes_on_dummy_time
-    puts "In base_test test_attributes_on_dummy_time"
     # Oracle does not have a TIME datatype.
     return true if current_adapter?(:OracleAdapter)
 
@@ -772,11 +758,13 @@ class BasicsTest < ActiveRecord::TestCase
       topic = Topic.find(1)
       topic.attributes = attributes
       assert_equal Time.local(2000, 1, 1, 5, 42, 0), topic.bonus_time
+
+      topic.save!
+      assert_equal topic, Topic.find_by(attributes)
     end
   end
 
   def test_attributes_on_dummy_time_with_invalid_time
-    puts "In base_test test_attributes_on_dummy_time_with_invalid_time"
     # Oracle does not have a TIME datatype.
     return true if current_adapter?(:OracleAdapter)
 
@@ -788,64 +776,34 @@ class BasicsTest < ActiveRecord::TestCase
     assert_nil topic.bonus_time
   end
 
-  def test_boolean
-    puts "In base_test test_boolean"
-    b_nil = Boolean.create({ "value" => nil })
-    nil_id = b_nil.id
-    b_false = Boolean.create({ "value" => false })
-    false_id = b_false.id
-    b_true = Boolean.create({ "value" => true })
-    true_id = b_true.id
+  def test_attributes
+    category = Category.new(name: "Ruby")
 
-    b_nil = Boolean.find(nil_id)
-    assert_nil b_nil.value
-    b_false = Boolean.find(false_id)
-    assert !b_false.value?
-    b_true = Boolean.find(true_id)
-    assert b_true.value?
-  end
-
-  def test_boolean_without_questionmark
-    puts "In base_test test_boolean_without_questionmark"
-    b_true = Boolean.create({ "value" => true })
-    true_id = b_true.id
-
-    subclass   = Class.new(Boolean).find true_id
-    superclass = Boolean.find true_id
-
-    assert_equal superclass.read_attribute(:has_fun), subclass.read_attribute(:has_fun)
-  end
-
-  def test_boolean_cast_from_string
-    puts "In base_test test_boolean_cast_from_string"
-    b_blank = Boolean.create({ "value" => "" })
-    blank_id = b_blank.id
-    b_false = Boolean.create({ "value" => "0" })
-    false_id = b_false.id
-    b_true = Boolean.create({ "value" => "1" })
-    true_id = b_true.id
+    expected_attributes = category.attribute_names.index_with do |attribute_name|
+      category.public_send(attribute_name)
+    end
 
-    b_blank = Boolean.find(blank_id)
-    assert_nil b_blank.value
-    b_false = Boolean.find(false_id)
-    assert !b_false.value?
-    b_true = Boolean.find(true_id)
-    assert b_true.value?
+    assert_instance_of Hash, category.attributes
+    assert_equal expected_attributes, category.attributes
   end
 
   def test_new_record_returns_boolean
-    puts "In base_test test_new_record_returns_boolean"
     assert_equal false, Topic.new.persisted?
     assert_equal true, Topic.find(1).persisted?
   end
 
+  def test_previously_new_record_returns_boolean
+    assert_equal false, Topic.new.previously_new_record?
+    assert_equal true, Topic.create.previously_new_record?
+    assert_equal false, Topic.find(1).previously_new_record?
+  end
+
   def test_dup
-    puts "In base_test test_dup"
     topic = Topic.find(1)
     duped_topic = nil
     assert_nothing_raised { duped_topic = topic.dup }
     assert_equal topic.title, duped_topic.title
-    assert !duped_topic.persisted?
+    assert_not_predicate duped_topic, :persisted?
 
     # test if the attributes have been duped
     topic.title = "a"
@@ -863,7 +821,7 @@ class BasicsTest < ActiveRecord::TestCase
 
     # test if saved clone object differs from original
     duped_topic.save
-    assert duped_topic.persisted?
+    assert_predicate duped_topic, :persisted?
     assert_not_equal duped_topic.id, topic.id
 
     duped_topic.reload
@@ -872,10 +830,9 @@ class BasicsTest < ActiveRecord::TestCase
 
   DeveloperSalary = Struct.new(:amount)
   def test_dup_with_aggregate_of_same_name_as_attribute
-    puts "In base_test test_dup_with_aggregate_of_same_name_as_attribute"
     developer_with_aggregate = Class.new(ActiveRecord::Base) do
-      self.table_name = 'developers'
-      composed_of :salary, :class_name => 'BasicsTest::DeveloperSalary', :mapping => [%w(salary amount)]
+      self.table_name = "developers"
+      composed_of :salary, class_name: "BasicsTest::DeveloperSalary", mapping: [%w(salary amount)]
     end
 
     dev = developer_with_aggregate.find(1)
@@ -885,7 +842,7 @@ class BasicsTest < ActiveRecord::TestCase
     assert_nothing_raised { dup = dev.dup }
     assert_kind_of DeveloperSalary, dup.salary
     assert_equal dev.salary.amount, dup.salary.amount
-    assert !dup.persisted?
+    assert_not_predicate dup, :persisted?
 
     # test if the attributes have been duped
     original_amount = dup.salary.amount
@@ -893,12 +850,11 @@ class BasicsTest < ActiveRecord::TestCase
     assert_equal original_amount, dup.salary.amount
 
     assert dup.save
-    assert dup.persisted?
+    assert_predicate dup, :persisted?
     assert_not_equal dup.id, dev.id
   end
 
   def test_dup_does_not_copy_associations
-    puts "In base_test test_dup_does_not_copy_associations"
     author = authors(:david)
     assert_not_equal [], author.posts
 
@@ -907,190 +863,107 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_clone_preserves_subtype
-    puts "In base_test test_clone_preserves_subtype"
     clone = nil
     assert_nothing_raised { clone = Company.find(3).clone }
     assert_kind_of Client, clone
   end
 
   def test_clone_of_new_object_with_defaults
-    puts "In base_test test_clone_of_new_object_with_defaults"
     developer = Developer.new
-    assert !developer.name_changed?
-    assert !developer.salary_changed?
+    assert_not_predicate developer, :name_changed?
+    assert_not_predicate developer, :salary_changed?
 
     cloned_developer = developer.clone
-    assert !cloned_developer.name_changed?
-    assert !cloned_developer.salary_changed?
+    assert_not_predicate cloned_developer, :name_changed?
+    assert_not_predicate cloned_developer, :salary_changed?
   end
 
   def test_clone_of_new_object_marks_attributes_as_dirty
-    puts "In base_test test_clone_of_new_object_marks_attributes_as_dirty"
-    developer = Developer.new :name => 'Bjorn', :salary => 100000
-    assert developer.name_changed?
-    assert developer.salary_changed?
+    developer = Developer.new name: "Bjorn", salary: 100000
+    assert_predicate developer, :name_changed?
+    assert_predicate developer, :salary_changed?
 
     cloned_developer = developer.clone
-    assert cloned_developer.name_changed?
-    assert cloned_developer.salary_changed?
+    assert_predicate cloned_developer, :name_changed?
+    assert_predicate cloned_developer, :salary_changed?
   end
 
   def test_clone_of_new_object_marks_as_dirty_only_changed_attributes
-    puts "In base_test test_clone_of_new_object_marks_as_dirty_only_changed_attributes"
-    developer = Developer.new :name => 'Bjorn'
+    developer = Developer.new name: "Bjorn"
     assert developer.name_changed?            # obviously
-    assert !developer.salary_changed?         # attribute has non-nil default value, so treated as not changed
+    assert_not developer.salary_changed?         # attribute has non-nil default value, so treated as not changed
 
     cloned_developer = developer.clone
-    assert cloned_developer.name_changed?
-    assert !cloned_developer.salary_changed?  # ... and cloned instance should behave same
+    assert_predicate cloned_developer, :name_changed?
+    assert_not cloned_developer.salary_changed?  # ... and cloned instance should behave same
   end
 
   def test_dup_of_saved_object_marks_attributes_as_dirty
-    puts "In base_test test_dup_of_saved_object_marks_attributes_as_dirty"
-    developer = Developer.create! :name => 'Bjorn', :salary => 100000
-    assert !developer.name_changed?
-    assert !developer.salary_changed?
+    developer = Developer.create! name: "Bjorn", salary: 100000
+    assert_not_predicate developer, :name_changed?
+    assert_not_predicate developer, :salary_changed?
 
     cloned_developer = developer.dup
     assert cloned_developer.name_changed?     # both attributes differ from defaults
-    assert cloned_developer.salary_changed?
+    assert_predicate cloned_developer, :salary_changed?
   end
 
   def test_dup_of_saved_object_marks_as_dirty_only_changed_attributes
-    puts "In base_test test_dup_of_saved_object_marks_as_dirty_only_changed_attributes"
-    developer = Developer.create! :name => 'Bjorn'
-    assert !developer.name_changed?           # both attributes of saved object should be treated as not changed
-    assert !developer.salary_changed?
+    developer = Developer.create! name: "Bjorn"
+    assert_not developer.name_changed?           # both attributes of saved object should be treated as not changed
+    assert_not_predicate developer, :salary_changed?
 
     cloned_developer = developer.dup
     assert cloned_developer.name_changed?     # ... but on cloned object should be
-    assert !cloned_developer.salary_changed?  # ... BUT salary has non-nil default which should be treated as not changed on cloned instance
+    assert_not cloned_developer.salary_changed?  # ... BUT salary has non-nil default which should be treated as not changed on cloned instance
   end
 
   def test_bignum
-    puts "In base_test test_bignum"
     company = Company.find(1)
-    company.rating = 2147483647
+    company.rating = 2147483648
     company.save
     company = Company.find(1)
-    assert_equal 2147483647, company.rating
+    assert_equal 2147483648, company.rating
+  end
+
+  def test_bignum_pk
+    company = Company.create!(id: 2147483648, name: "foo")
+    assert_equal company, Company.find(company.id)
   end
 
-  # TODO: extend defaults tests to other databases!
-  if current_adapter?(:PostgreSQLAdapter)
+  if current_adapter?(:PostgreSQLAdapter, :Mysql2Adapter, :SQLite3Adapter)
     def test_default
-	  puts "In base_test test_default"
       with_timezone_config default: :local do
         default = Default.new
 
         # fixed dates / times
         assert_equal Date.new(2004, 1, 1), default.fixed_date
-        assert_equal Time.local(2004, 1,1,0,0,0,0), default.fixed_time
+        assert_equal Time.local(2004, 1, 1, 0, 0, 0, 0), default.fixed_time
 
         # char types
-        assert_equal 'Y', default.char1
-        assert_equal 'a varchar field', default.char2
-        assert_equal 'a text field', default.char3
+        assert_equal "Y", default.char1
+        assert_equal "a varchar field", default.char2
+        # Mysql text type can't have default value
+        unless current_adapter?(:Mysql2Adapter)
+          assert_equal "a text field", default.char3
+        end
       end
     end
   end
 
-  class NumericData < ActiveRecord::Base
-    self.table_name = 'numeric_data'
-
-    attribute :my_house_population, :integer
-    attribute :atoms_in_universe, :integer
-  end
-
-  def test_big_decimal_conditions
-    puts "In base_test test_big_decimal_conditions"
-    m = NumericData.new(
-      :bank_balance => 1586.43,
-      :big_bank_balance => BigDecimal("1000234000567.95"),
-      :world_population => 6000000000,
-      :my_house_population => 3
-    )
-    assert m.save
-    assert_equal 0, NumericData.where("bank_balance > ?", 2000.0).count
-  end
-
-  def test_numeric_fields
-    puts "In base_test test_numeric_fields"
-    m = NumericData.new(
-      :bank_balance => 1586.43,
-      :big_bank_balance => BigDecimal("1000234000567.95"),
-      :world_population => 6000000000,
-      :my_house_population => 3
-    )
-    assert m.save
-
-    m1 = NumericData.find(m.id)
-    assert_not_nil m1
-
-    # As with migration_test.rb, we should make world_population >= 2**62
-    # to cover 64-bit platforms and test it is a Bignum, but the main thing
-    # is that it's an Integer.
-    unless current_adapter?(:IBM_DBAdapter)
-	assert_kind_of Integer, m1.world_population
-    else
-	assert_equal 6000000000, m1.world_population
-
-    assert_kind_of Integer, m1.my_house_population
-    assert_equal 3, m1.my_house_population
-
-    assert_kind_of BigDecimal, m1.bank_balance
-    assert_equal BigDecimal("1586.43"), m1.bank_balance
-
-    assert_kind_of BigDecimal, m1.big_bank_balance
-    assert_equal BigDecimal("1000234000567.95"), m1.big_bank_balance
-  end
-
-  def test_numeric_fields_with_scale
-    puts "In base_test test_numeric_fields_with_scale"
-    m = NumericData.new(
-      :bank_balance => 1586.43122334,
-      :big_bank_balance => BigDecimal("234000567.952344"),
-      :world_population => 6000000000,
-      :my_house_population => 3
-    )
-    assert m.save
-
-    m1 = NumericData.find(m.id)
-    assert_not_nil m1
-
-    # As with migration_test.rb, we should make world_population >= 2**62
-    # to cover 64-bit platforms and test it is a Bignum, but the main thing
-    # is that it's an Integer.
-    assert_kind_of Integer, m1.world_population
-    assert_equal 6000000000, m1.world_population
-
-    assert_kind_of Integer, m1.my_house_population
-    assert_equal 3, m1.my_house_population
-
-    assert_kind_of BigDecimal, m1.bank_balance
-    assert_equal BigDecimal("1586.43"), m1.bank_balance
-
-    assert_kind_of BigDecimal, m1.big_bank_balance
-    assert_equal BigDecimal("234000567.95"), m1.big_bank_balance
-  end
-
   def test_auto_id
-    puts "In base_test test_auto_id"
     auto = AutoId.new
     auto.save
     assert(auto.id > 0)
   end
 
   def test_sql_injection_via_find
-    puts "In base_test test_sql_injection_via_find"
     assert_raise(ActiveRecord::RecordNotFound, ActiveRecord::StatementInvalid) do
       Topic.find("123456 OR id > 0")
     end
   end
 
   def test_column_name_properly_quoted
-    puts "In base_test test_column_name_properly_quoted"
     col_record = ColumnName.new
     col_record.references = 40
     assert col_record.save
@@ -1101,35 +974,31 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_quoting_arrays
-    puts "In base_test test_quoting_arrays"
-    replies = Reply.all.merge!(:where => [ "id IN (?)", topics(:first).replies.collect(&:id) ]).to_a
+    replies = Reply.all.merge!(where: [ "id IN (?)", topics(:first).replies.collect(&:id) ]).to_a
     assert_equal topics(:first).replies.size, replies.size
 
-    replies = Reply.all.merge!(:where => [ "id IN (?)", [] ]).to_a
+    replies = Reply.all.merge!(where: [ "id IN (?)", [] ]).to_a
     assert_equal 0, replies.size
   end
 
   def test_quote
-    puts "In base_test test_quote"
     author_name = "\\ \001 ' \n \\n \""
-    topic = Topic.create('author_name' => author_name)
+    topic = Topic.create("author_name" => author_name)
     assert_equal author_name, Topic.find(topic.id).author_name
   end
 
   def test_toggle_attribute
-    puts "In base_test test_toggle_attribute"
-    assert !topics(:first).approved?
+    assert_not_predicate topics(:first), :approved?
     topics(:first).toggle!(:approved)
-    assert topics(:first).approved?
+    assert_predicate topics(:first), :approved?
     topic = topics(:first)
     topic.toggle(:approved)
-    assert !topic.approved?
+    assert_not_predicate topic, :approved?
     topic.reload
-    assert topic.approved?
+    assert_predicate topic, :approved?
   end
 
   def test_reload
-    puts "In base_test test_reload"
     t1 = Topic.find(1)
     t2 = Topic.find(1)
     t1.title = "something else"
@@ -1138,15 +1007,7 @@ class BasicsTest < ActiveRecord::TestCase
     assert_equal t1.title, t2.title
   end
 
-  def test_reload_with_exclusive_scope
-    puts "In base_test test_reload_with_exclusive_scope"
-    dev = DeveloperCalledDavid.first
-    dev.update!(name: "NotDavid" )
-    assert_equal dev, dev.reload
-  end
-
   def test_switching_between_table_name
-    puts "In base_test test_switching_between_table_name"
     k = Class.new(Joke)
 
     assert_difference("GoodJoke.count") do
@@ -1158,8 +1019,7 @@ class BasicsTest < ActiveRecord::TestCase
     end
   end
 
-  def test_clear_cash_when_setting_table_name
-    puts "In base_test test_clear_cash_when_setting_table_name"
+  def test_clear_cache_when_setting_table_name
     original_table_name = Joke.table_name
 
     Joke.table_name = "funny_jokes"
@@ -1177,7 +1037,6 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_dont_clear_sequence_name_when_setting_explicitly
-    puts "In base_test test_dont_clear_sequence_name_when_setting_explicitly"
     k = Class.new(Joke)
     k.sequence_name = "black_jokes_seq"
     k.table_name = "cold_jokes"
@@ -1190,7 +1049,6 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_dont_clear_inheritance_column_when_setting_explicitly
-    puts "In base_test test_dont_clear_inheritance_column_when_setting_explicitly"
     k = Class.new(Joke)
     k.inheritance_column = "my_type"
     before_inherit = k.inheritance_column
@@ -1202,14 +1060,12 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_set_table_name_symbol_converted_to_string
-    puts "In base_test test_set_table_name_symbol_converted_to_string"
     k = Class.new(Joke)
     k.table_name = :cold_jokes
-    assert_equal 'cold_jokes', k.table_name
+    assert_equal "cold_jokes", k.table_name
   end
 
   def test_quoted_table_name_after_set_table_name
-    puts "In base_test test_quoted_table_name_after_set_table_name"
     klass = Class.new(ActiveRecord::Base)
 
     klass.table_name = "foo"
@@ -1222,15 +1078,13 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_set_table_name_with_inheritance
-    puts "In base_test test_set_table_name_with_inheritance"
-    k = Class.new( ActiveRecord::Base )
+    k = Class.new(ActiveRecord::Base)
     def k.name; "Foo"; end
     def k.table_name; super + "ks"; end
     assert_equal "foosks", k.table_name
   end
 
   def test_sequence_name_with_abstract_class
-    puts "In base_test test_sequence_name_with_abstract_class"
     ak = Class.new(ActiveRecord::Base)
     ak.abstract_class = true
     k = Class.new(ak)
@@ -1241,111 +1095,78 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_count_with_join
-    puts "In base_test test_count_with_join"
     res = Post.count_by_sql "SELECT COUNT(*) FROM posts LEFT JOIN comments ON posts.id=comments.post_id WHERE posts.#{QUOTED_TYPE} = 'Post'"
-
     res2 = Post.where("posts.#{QUOTED_TYPE} = 'Post'").joins("LEFT JOIN comments ON posts.id=comments.post_id").count
     assert_equal res, res2
 
-    res3 = nil
-    assert_nothing_raised do
-      res3 = Post.where("posts.#{QUOTED_TYPE} = 'Post'").joins("LEFT JOIN comments ON posts.id=comments.post_id").count
-    end
-    assert_equal res, res3
-
     res4 = Post.count_by_sql "SELECT COUNT(p.id) FROM posts p, comments co WHERE p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id"
-    res5 = nil
-    assert_nothing_raised do
-      res5 = Post.where("p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id").joins("p, comments co").select("p.id").count
-    end
-
+    res5 = Post.where("p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id").joins("p, comments co").select("p.id").count
     assert_equal res4, res5
 
     res6 = Post.count_by_sql "SELECT COUNT(DISTINCT p.id) FROM posts p, comments co WHERE p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id"
-    res7 = nil
-    assert_nothing_raised do
-      res7 = Post.where("p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id").joins("p, comments co").select("p.id").distinct.count
-    end
+    res7 = Post.where("p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id").joins("p, comments co").select("p.id").distinct.count
     assert_equal res6, res7
   end
 
   def test_no_limit_offset
-    puts "In base_test test_no_limit_offset"
     assert_nothing_raised do
-      Developer.all.merge!(:offset => 2).to_a
+      Developer.all.merge!(offset: 2).to_a
     end
   end
 
-  def test_find_last
-    puts "In base_test test_find_last"
-    last  = Developer.last
-    assert_equal last, Developer.all.merge!(:order => 'id desc').first
-  end
-
   def test_last
-    puts "In base_test test_last"
-    assert_equal Developer.all.merge!(:order => 'id desc').first, Developer.last
+    assert_equal Developer.all.merge!(order: "id desc").first, Developer.last
   end
 
   def test_all
-    puts "In base_test test_all"
     developers = Developer.all
     assert_kind_of ActiveRecord::Relation, developers
     assert_equal Developer.all, developers
   end
 
   def test_all_with_conditions
-    puts "In base_test test_all_with_conditions"
-    assert_equal Developer.all.merge!(:order => 'id desc').to_a, Developer.order('id desc').to_a
+    assert_equal Developer.all.merge!(order: "id desc").to_a, Developer.order("id desc").to_a
   end
 
   def test_find_ordered_last
-    puts "In base_test test_find_ordered_last"
-    last  = Developer.all.merge!(:order => 'developers.salary ASC').last
-    assert_equal last, Developer.all.merge!(:order => 'developers.salary ASC').to_a.last
+    last = Developer.order("developers.salary ASC").last
+    assert_equal last, Developer.order("developers.salary": "ASC").to_a.last
   end
 
   def test_find_reverse_ordered_last
-    puts "In base_test test_find_reverse_ordered_last"
-    last  = Developer.all.merge!(:order => 'developers.salary DESC').last
-    assert_equal last, Developer.all.merge!(:order => 'developers.salary DESC').to_a.last
+    last = Developer.order("developers.salary DESC").last
+    assert_equal last, Developer.order("developers.salary": "DESC").to_a.last
   end
 
   def test_find_multiple_ordered_last
-    puts "In base_test test_find_multiple_ordered_last"
-    last  = Developer.all.merge!(:order => 'developers.name, developers.salary DESC').last
-    assert_equal last, Developer.all.merge!(:order => 'developers.name, developers.salary DESC').to_a.last
+    last = Developer.order("developers.name, developers.salary DESC").last
+    assert_equal last, Developer.order(:"developers.name", "developers.salary": "DESC").to_a.last
   end
 
   def test_find_keeps_multiple_order_values
-    puts "In base_test test_find_keeps_multiple_order_values"
-    combined = Developer.all.merge!(:order => 'developers.name, developers.salary').to_a
-    assert_equal combined, Developer.all.merge!(:order => ['developers.name', 'developers.salary']).to_a
+    combined = Developer.order("developers.name, developers.salary").to_a
+    assert_equal combined, Developer.order(:"developers.name", :"developers.salary").to_a
   end
 
   def test_find_keeps_multiple_group_values
-    puts "In base_test test_find_keeps_multiple_group_values"
-    combined = Developer.all.merge!(:group => 'developers.name, developers.salary, developers.id, developers.created_at, developers.updated_at, developers.created_on, developers.updated_on').to_a
-    assert_equal combined, Developer.all.merge!(:group => ['developers.name', 'developers.salary', 'developers.id', 'developers.created_at', 'developers.updated_at', 'developers.created_on', 'developers.updated_on']).to_a
+    combined = Developer.merge(group: "developers.name, developers.salary, developers.id, developers.mentor_id, developers.firm_id,  developers.legacy_created_at, developers.legacy_updated_at, developers.legacy_created_on, developers.legacy_updated_on").to_a
+    assert_equal combined, Developer.merge(group: ["developers.name", "developers.salary", "developers.id", "developers.mentor_id", "developers.firm_id", "developers.created_at", "developers.updated_at", "developers.created_on", "developers.updated_on"]).to_a
   end
 
   def test_find_symbol_ordered_last
-    puts "In base_test test_find_symbol_ordered_last"
-    last  = Developer.all.merge!(:order => :salary).last
-    assert_equal last, Developer.all.merge!(:order => :salary).to_a.last
+    last = Developer.all.merge!(order: :salary).last
+    assert_equal last, Developer.all.merge!(order: :salary).to_a.last
   end
 
   def test_abstract_class_table_name
-    puts "In base_test test_abstract_class_table_name"
     assert_nil AbstractCompany.table_name
   end
 
   def test_find_on_abstract_base_class_doesnt_use_type_condition
-    puts "In base_test test_find_on_abstract_base_class_doesnt_use_type_condition"
     old_class = LooseDescendant
     Object.send :remove_const, :LooseDescendant
 
-    descendant = old_class.create! :first_name => 'bob'
+    descendant = old_class.create! first_name: "bob"
     assert_not_nil LoosePerson.find(descendant.id), "Should have found instance of LooseDescendant when finding abstract LoosePerson: #{descendant.inspect}"
   ensure
     unless Object.const_defined?(:LooseDescendant)
@@ -1354,22 +1175,20 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_assert_queries
-    puts "In base_test test_assert_queries"
-    query = lambda { ActiveRecord::Base.connection.execute 'select count(*) from developers' }
+    query = lambda { ActiveRecord::Base.connection.execute "select count(*) from developers" }
     assert_queries(2) { 2.times { query.call } }
     assert_queries 1, &query
     assert_no_queries { assert true }
   end
 
   def test_benchmark_with_log_level
-    puts "In base_test test_benchmark_with_log_level"
     original_logger = ActiveRecord::Base.logger
     log = StringIO.new
     ActiveRecord::Base.logger = ActiveSupport::Logger.new(log)
     ActiveRecord::Base.logger.level = Logger::WARN
-    ActiveRecord::Base.benchmark("Debug Topic Count", :level => :debug) { Topic.count }
-    ActiveRecord::Base.benchmark("Warn Topic Count",  :level => :warn)  { Topic.count }
-    ActiveRecord::Base.benchmark("Error Topic Count", :level => :error) { Topic.count }
+    ActiveRecord::Base.benchmark("Debug Topic Count", level: :debug) { Topic.count }
+    ActiveRecord::Base.benchmark("Warn Topic Count",  level: :warn)  { Topic.count }
+    ActiveRecord::Base.benchmark("Error Topic Count", level: :error) { Topic.count }
     assert_no_match(/Debug Topic Count/, log.string)
     assert_match(/Warn Topic Count/, log.string)
     assert_match(/Error Topic Count/, log.string)
@@ -1378,33 +1197,33 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_benchmark_with_use_silence
-    puts "In base_test test_benchmark_with_use_silence"
     original_logger = ActiveRecord::Base.logger
     log = StringIO.new
     ActiveRecord::Base.logger = ActiveSupport::Logger.new(log)
     ActiveRecord::Base.logger.level = Logger::DEBUG
-    ActiveRecord::Base.benchmark("Logging", :level => :debug, :silence => false)  { ActiveRecord::Base.logger.debug "Quiet" }
+    ActiveRecord::Base.benchmark("Logging", level: :debug, silence: false)  { ActiveRecord::Base.logger.debug "Quiet" }
     assert_match(/Quiet/, log.string)
   ensure
     ActiveRecord::Base.logger = original_logger
   end
 
   def test_clear_cache!
-    puts "In base_test test_clear_cache"
     # preheat cache
-    c1 = Post.connection.schema_cache.columns('posts')
+    c1 = Post.connection.schema_cache.columns("posts")
+    assert_not_equal 0, Post.connection.schema_cache.size
+
     ActiveRecord::Base.clear_cache!
-    c2 = Post.connection.schema_cache.columns('posts')
-    c1.each_with_index do |v, i|
-      assert_not_same v, c2[i]
-    end
+    assert_equal 0, Post.connection.schema_cache.size
+
+    c2 = Post.connection.schema_cache.columns("posts")
+    assert_not_equal 0, Post.connection.schema_cache.size
+
     assert_equal c1, c2
   end
 
   def test_current_scope_is_reset
-    puts "In base_test test_current_scope_is_reset"
     Object.const_set :UnloadablePost, Class.new(ActiveRecord::Base)
-    UnloadablePost.send(:current_scope=, UnloadablePost.all)
+    UnloadablePost.current_scope = UnloadablePost.all
 
     UnloadablePost.unloadable
     klass = UnloadablePost
@@ -1412,20 +1231,28 @@ class BasicsTest < ActiveRecord::TestCase
     ActiveSupport::Dependencies.remove_unloadable_constants!
     assert_nil ActiveRecord::Scoping::ScopeRegistry.value_for(:current_scope, klass)
   ensure
-    Object.class_eval{ remove_const :UnloadablePost } if defined?(UnloadablePost)
+    Object.class_eval { remove_const :UnloadablePost } if defined?(UnloadablePost)
   end
 
   def test_marshal_round_trip
-    puts "In base_test test_marshal_round_trip"
     expected = posts(:welcome)
     marshalled = Marshal.dump(expected)
-    actual   = Marshal.load(marshalled)
+    actual = Marshal.load(marshalled)
+
+    assert_equal expected.attributes, actual.attributes
+  end
+
+  def test_marshal_inspected_round_trip
+    expected = posts(:welcome)
+    expected.inspect
+
+    marshalled = Marshal.dump(expected)
+    actual = Marshal.load(marshalled)
 
     assert_equal expected.attributes, actual.attributes
   end
 
   def test_marshal_new_record_round_trip
-    puts "In base_test test_marshal_new_record_round_trip"
     marshalled = Marshal.dump(Post.new)
     post       = Marshal.load(marshalled)
 
@@ -1433,7 +1260,6 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_marshalling_with_associations
-    puts "In base_test test_marshalling_with_associations"
     post = Post.new
     post.comments.build
 
@@ -1443,9 +1269,23 @@ class BasicsTest < ActiveRecord::TestCase
     assert_equal 1, post.comments.length
   end
 
+  if current_adapter?(:Mysql2Adapter)
+    def test_marshal_load_legacy_6_0_record_mysql
+      path = File.expand_path(
+        "support/marshal_compatibility_fixtures/legacy_6_0_record_mysql.dump",
+        TEST_ROOT
+      )
+      topic = Marshal.load(File.read(path))
+
+      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
+  end
+
   if Process.respond_to?(:fork) && !in_memory_db?
     def test_marshal_between_processes
-	  puts "In base_test test_marshal_between_processes"
       # Define a new model to ensure there are no caches
       if self.class.const_defined?("Post", false)
         flunk "there should be no post constant"
@@ -1472,11 +1312,12 @@ class BasicsTest < ActiveRecord::TestCase
       wr.close
       assert Marshal.load rd.read
       rd.close
+    ensure
+      self.class.send(:remove_const, "Post") if self.class.const_defined?("Post", false)
     end
   end
 
   def test_marshalling_new_record_round_trip_with_associations
-    puts "In base_test test_marshalling_new_record_round_trip_with_associations"
     post = Post.new
     post.comments.build
 
@@ -1486,114 +1327,143 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_attribute_names
-    puts "In base_test test_attribute_names"
-    assert_equal ["id", "type", "firm_id", "firm_name", "name", "client_of", "rating", "account_id", "description"],
-                 Company.attribute_names
+    expected = ["id", "type", "firm_id", "firm_name", "name", "client_of", "rating", "account_id", "description", "metadata"]
+    assert_equal expected, Company.attribute_names
   end
 
   def test_has_attribute
-    puts "In base_test test_has_attribute"
-    assert Company.has_attribute?('id')
-    assert Company.has_attribute?('type')
-    assert Company.has_attribute?('name')
-    assert_not Company.has_attribute?('lastname')
-    assert_not Company.has_attribute?('age')
+    assert Company.has_attribute?("id")
+    assert Company.has_attribute?("type")
+    assert Company.has_attribute?("name")
+    assert Company.has_attribute?("new_name")
+    assert Company.has_attribute?("metadata")
+    assert_not Company.has_attribute?("lastname")
+    assert_not Company.has_attribute?("age")
+
+    company = Company.new
+    assert company.has_attribute?("id")
+    assert company.has_attribute?("type")
+    assert company.has_attribute?("name")
+    assert company.has_attribute?("new_name")
+    assert company.has_attribute?("metadata")
+    assert_not company.has_attribute?("lastname")
+    assert_not company.has_attribute?("age")
   end
 
   def test_has_attribute_with_symbol
-    puts "In base_test test_has_attribute_with_symbol"
     assert Company.has_attribute?(:id)
+    assert Company.has_attribute?(:type)
+    assert Company.has_attribute?(:name)
+    assert Company.has_attribute?(:new_name)
+    assert Company.has_attribute?(:metadata)
+    assert_not Company.has_attribute?(:lastname)
     assert_not Company.has_attribute?(:age)
+
+    company = Company.new
+    assert company.has_attribute?(:id)
+    assert company.has_attribute?(:type)
+    assert company.has_attribute?(:name)
+    assert company.has_attribute?(:new_name)
+    assert company.has_attribute?(:metadata)
+    assert_not company.has_attribute?(:lastname)
+    assert_not company.has_attribute?(:age)
   end
 
   def test_attribute_names_on_table_not_exists
-    puts "In base_test test_attribute_names_on_table_not_exists"
     assert_equal [], NonExistentTable.attribute_names
   end
 
   def test_attribute_names_on_abstract_class
-    puts "In base_test test_attribute_names_on_abstract_class"
     assert_equal [], AbstractCompany.attribute_names
   end
 
   def test_touch_should_raise_error_on_a_new_object
-    puts "In base_test test_touch_should_raise_error_on_a_new_object"
-    company = Company.new(:rating => 1, :name => "37signals", :firm_name => "37signals")
+    company = Company.new(rating: 1, name: "37signals", firm_name: "37signals")
     assert_raises(ActiveRecord::ActiveRecordError) do
       company.touch :updated_at
     end
   end
 
-  def test_uniq_delegates_to_scoped
-    puts "In base_test test_uniq_delegates_to_scoped"
-    assert_deprecated do
-      assert_equal Bird.all.distinct, Bird.uniq
-    end
-  end
-
   def test_distinct_delegates_to_scoped
-    puts "In base_test test_distinct_delegates_to_scoped"
     assert_equal Bird.all.distinct, Bird.distinct
   end
 
   def test_table_name_with_2_abstract_subclasses
-    puts "In base_test test_table_name_with_2_abstract_subclasses"
     assert_equal "photos", Photo.table_name
   end
 
   def test_column_types_typecast
-    puts "In base_test test_column_types_typecast"
     topic = Topic.first
-    assert_not_equal 't.lo', topic.author_name
+    assert_not_equal "t.lo", topic.author_name
 
     attrs = topic.attributes.dup
-    attrs.delete 'id'
+    attrs.delete "id"
 
     typecast = Class.new(ActiveRecord::Type::Value) {
-      def cast value
+      def cast(value)
         "t.lo"
       end
     }
 
-    types = { 'author_name' => typecast.new }
+    types = { "author_name" => typecast.new }
     topic = Topic.instantiate(attrs, types)
 
-    assert_equal 't.lo', topic.author_name
+    assert_equal "t.lo", topic.author_name
   end
 
   def test_typecasting_aliases
-    puts "In base_test test_typecasting_aliases"
-    assert_equal 10, Topic.select('10 as tenderlove').first.tenderlove
+    assert_equal 10, Topic.select("10 as tenderlove").first.tenderlove
   end
 
   def test_slice
-    puts "In base_test test_slice"
-    company = Company.new(:rating => 1, :name => "37signals", :firm_name => "37signals")
+    company = Company.new(rating: 1, name: "37signals", firm_name: "37signals")
     hash = company.slice(:name, :rating, "arbitrary_method")
     assert_equal hash[:name], company.name
-    assert_equal hash['name'], company.name
+    assert_equal hash["name"], company.name
     assert_equal hash[:rating], company.rating
-    assert_equal hash['arbitrary_method'], company.arbitrary_method
+    assert_equal hash["arbitrary_method"], company.arbitrary_method
     assert_equal hash[:arbitrary_method], company.arbitrary_method
     assert_nil hash[:firm_name]
-    assert_nil hash['firm_name']
+    assert_nil hash["firm_name"]
+  end
+
+  def test_slice_accepts_array_argument
+    attrs = {
+      title: "slice",
+      author_name: "@Cohen-Carlisle",
+      content: "accept arrays so I don't have to splat"
+    }.with_indifferent_access
+    topic = Topic.new(attrs)
+    assert_equal attrs, topic.slice(attrs.keys)
+  end
+
+  def test_values_at
+    company = Company.new(name: "37signals", rating: 1)
+
+    assert_equal [ "37signals", 1, "I am Jack's profound disappointment" ],
+      company.values_at(:name, :rating, :arbitrary_method)
+    assert_equal [ "I am Jack's profound disappointment", 1, "37signals" ],
+      company.values_at(:arbitrary_method, :rating, :name)
+  end
+
+  def test_values_at_accepts_array_argument
+    topic = Topic.new(title: "Budget", author_name: "Jason")
+
+    assert_equal %w( Budget Jason ), topic.values_at(%w( title author_name ))
   end
 
   def test_default_values_are_deeply_dupped
-    puts "In base_test test_default_values_are_deeply_dupped"
     company = Company.new
     company.description << "foo"
     assert_equal "", Company.new.description
   end
 
   test "scoped can take a values hash" do
-    puts "In base_test scoped can take a values hash"
     klass = Class.new(ActiveRecord::Base)
-    assert_equal ['foo'], klass.all.merge!(select: 'foo').select_values
+    assert_equal ["foo"], klass.all.merge!(select: "foo").select_values
   end
 
   test "connection_handler can be overridden" do
-    puts "In base_test connection_handler can be overridden"
     klass = Class.new(ActiveRecord::Base)
     orig_handler = klass.connection_handler
     new_handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
@@ -1610,7 +1480,6 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   test "new threads get default the default connection handler" do
-    puts "In base_test new threads get default the default connection handler"
     klass = Class.new(ActiveRecord::Base)
     orig_handler = klass.connection_handler
     handler = nil
@@ -1626,7 +1495,6 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   test "changing a connection handler in a main thread does not poison the other threads" do
-    puts "In base_test changing a connection handler in a main thread does not poison the other threads"
     klass = Class.new(ActiveRecord::Base)
     orig_handler = klass.connection_handler
     new_handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
@@ -1655,23 +1523,24 @@ class BasicsTest < ActiveRecord::TestCase
   # AR::Base objects. If the future has made this irrelevant, feel free to
   # delete this.
   test "records without an id have unique hashes" do
-    puts "In base_test records without an id have unique hashes"
     assert_not_equal Post.new.hash, Post.new.hash
   end
 
+  test "records of different classes have different hashes" do
+    assert_not_equal Post.new(id: 1).hash, Developer.new(id: 1).hash
+  end
+
   test "resetting column information doesn't remove attribute methods" do
-    puts "In base_test changing a connection handler in a main thread does not poison the other threads"
     topic = topics(:first)
 
-    assert_not topic.id_changed?
+    assert_not_predicate topic, :id_changed?
 
     Topic.reset_column_information
 
-    assert_not topic.id_changed?
+    assert_not_predicate topic, :id_changed?
   end
 
   test "ignored columns are not present in columns_hash" do
-    puts "In base_test ignored columns are not present in columns_hash"
     cache_columns = Developer.connection.schema_cache.columns_hash(Developer.table_name)
     assert_includes cache_columns.keys, "first_name"
     assert_not_includes Developer.columns_hash.keys, "first_name"
@@ -1679,35 +1548,223 @@ class BasicsTest < ActiveRecord::TestCase
     assert_not_includes SymbolIgnoredDeveloper.columns_hash.keys, "first_name"
   end
 
+  test ".columns_hash raises an error if the record has an empty table name" do
+    expected_message = "FirstAbstractClass has no table configured. Set one with FirstAbstractClass.table_name="
+    exception = assert_raises(ActiveRecord::TableNotSpecified) do
+      FirstAbstractClass.columns_hash
+    end
+    assert_equal expected_message, exception.message
+  end
+
   test "ignored columns have no attribute methods" do
-    puts "In base_test ignored columns have no attribute methods"
-    refute Developer.new.respond_to?(:first_name)
-    refute Developer.new.respond_to?(:first_name=)
-    refute Developer.new.respond_to?(:first_name?)
-    refute SubDeveloper.new.respond_to?(:first_name)
-    refute SubDeveloper.new.respond_to?(:first_name=)
-    refute SubDeveloper.new.respond_to?(:first_name?)
-    refute SymbolIgnoredDeveloper.new.respond_to?(:first_name)
-    refute SymbolIgnoredDeveloper.new.respond_to?(:first_name=)
-    refute SymbolIgnoredDeveloper.new.respond_to?(:first_name?)
+    assert_not_respond_to Developer.new, :first_name
+    assert_not_respond_to Developer.new, :first_name=
+    assert_not_respond_to Developer.new, :first_name?
+    assert_not_respond_to SubDeveloper.new, :first_name
+    assert_not_respond_to SubDeveloper.new, :first_name=
+    assert_not_respond_to SubDeveloper.new, :first_name?
+    assert_not_respond_to SymbolIgnoredDeveloper.new, :first_name
+    assert_not_respond_to SymbolIgnoredDeveloper.new, :first_name=
+    assert_not_respond_to SymbolIgnoredDeveloper.new, :first_name?
   end
 
   test "ignored columns don't prevent explicit declaration of attribute methods" do
-    puts "In base_test ignored columns don't prevent explicit declaration of attribute methods"
-    assert Developer.new.respond_to?(:last_name)
-    assert Developer.new.respond_to?(:last_name=)
-    assert Developer.new.respond_to?(:last_name?)
-    assert SubDeveloper.new.respond_to?(:last_name)
-    assert SubDeveloper.new.respond_to?(:last_name=)
-    assert SubDeveloper.new.respond_to?(:last_name?)
-    assert SymbolIgnoredDeveloper.new.respond_to?(:last_name)
-    assert SymbolIgnoredDeveloper.new.respond_to?(:last_name=)
-    assert SymbolIgnoredDeveloper.new.respond_to?(:last_name?)
+    assert_respond_to Developer.new, :last_name
+    assert_respond_to Developer.new, :last_name=
+    assert_respond_to Developer.new, :last_name?
+    assert_respond_to SubDeveloper.new, :last_name
+    assert_respond_to SubDeveloper.new, :last_name=
+    assert_respond_to SubDeveloper.new, :last_name?
+    assert_respond_to SymbolIgnoredDeveloper.new, :last_name
+    assert_respond_to SymbolIgnoredDeveloper.new, :last_name=
+    assert_respond_to SymbolIgnoredDeveloper.new, :last_name?
   end
 
   test "ignored columns are stored as an array of string" do
-    puts "In base_test ignored columns are stored as an array of string"
     assert_equal(%w(first_name last_name), Developer.ignored_columns)
     assert_equal(%w(first_name last_name), SymbolIgnoredDeveloper.ignored_columns)
   end
+
+  test "when #reload called, ignored columns' attribute methods are not defined" do
+    developer = Developer.create!(name: "Developer")
+    assert_not_respond_to developer, :first_name
+    assert_not_respond_to developer, :first_name=
+
+    developer.reload
+
+    assert_not_respond_to developer, :first_name
+    assert_not_respond_to developer, :first_name=
+  end
+
+  test "when ignored attribute is loaded, cast type should be preferred over DB type" do
+    developer = AttributedDeveloper.create
+    developer.update_column :name, "name"
+
+    loaded_developer = AttributedDeveloper.where(id: developer.id).select("*").first
+    assert_equal "Developer: name", loaded_developer.name
+  end
+
+  test "when assigning new ignored columns it invalidates cache for column names" do
+    assert_not_includes ColumnNamesCachedDeveloper.column_names, "name"
+  end
+
+  test "ignored columns not included in SELECT" do
+    query = Developer.all.to_sql.downcase
+
+    # ignored column
+    assert_not query.include?("first_name")
+
+    # regular column
+    assert query.include?("name")
+  end
+
+  test "column names are quoted when using #from clause and model has ignored columns" do
+    assert_not_empty Developer.ignored_columns
+    query = Developer.from("developers").to_sql
+    quoted_id = "#{Developer.quoted_table_name}.#{Developer.quoted_primary_key}"
+
+    assert_match(/SELECT #{Regexp.escape(quoted_id)}.* FROM developers/, query)
+  end
+
+  test "using table name qualified column names unless having SELECT list explicitly" do
+    assert_equal developers(:david), Developer.from("developers").joins(:shared_computers).take
+  end
+
+  test "protected environments by default is an array with production" do
+    assert_equal ["production"], ActiveRecord::Base.protected_environments
+  end
+
+  def test_protected_environments_are_stored_as_an_array_of_string
+    previous_protected_environments = ActiveRecord::Base.protected_environments
+    ActiveRecord::Base.protected_environments = [:staging, "production"]
+    assert_equal ["staging", "production"], ActiveRecord::Base.protected_environments
+  ensure
+    ActiveRecord::Base.protected_environments = previous_protected_environments
+  end
+
+  test "cannot call connects_to on non-abstract or non-ActiveRecord::Base classes" do
+    error = assert_raises(NotImplementedError) do
+      Bird.connects_to(database: { writing: :arunit })
+    end
+
+    assert_equal "`connects_to` can only be called on ActiveRecord::Base or abstract classes", error.message
+  end
+
+  test "cannot call connected_to on subclasses of ActiveRecord::Base with legacy connection handling" do
+    old_value = ActiveRecord::Base.legacy_connection_handling
+    ActiveRecord::Base.legacy_connection_handling = true
+
+    error = assert_raises(NotImplementedError) do
+      Bird.connected_to(role: :reading) { }
+    end
+
+    assert_equal "`connected_to` can only be called on ActiveRecord::Base with legacy connection handling.", error.message
+  ensure
+    clean_up_legacy_connection_handlers
+    ActiveRecord::Base.legacy_connection_handling = old_value
+  end
+
+  test "cannot call connected_to with role and shard on non-abstract classes" do
+    error = assert_raises(NotImplementedError) do
+      Bird.connected_to(role: :reading, shard: :default) { }
+    end
+
+    assert_equal "calling `connected_to` is only allowed on ActiveRecord::Base or abstract classes.", error.message
+  end
+
+  test "can call connected_to with role and shard on abstract classes" do
+    SecondAbstractClass.connected_to(role: :reading, shard: :default) do
+      assert SecondAbstractClass.connected_to?(role: :reading, shard: :default)
+    end
+  end
+
+  test "cannot call connected_to on the abstract class that did not establish the connection" do
+    error = assert_raises(NotImplementedError) do
+      ThirdAbstractClass.connected_to(role: :reading) { }
+    end
+
+    assert_equal "calling `connected_to` is only allowed on the abstract class that established the connection.", error.message
+  end
+
+  test "#connecting_to with role" do
+    SecondAbstractClass.connecting_to(role: :reading)
+
+    assert SecondAbstractClass.connected_to?(role: :reading)
+    assert SecondAbstractClass.current_preventing_writes
+  ensure
+    ActiveRecord::Base.connected_to_stack.pop
+  end
+
+  test "#connecting_to with role and shard" do
+    SecondAbstractClass.connecting_to(role: :reading, shard: :default)
+
+    assert SecondAbstractClass.connected_to?(role: :reading, shard: :default)
+  ensure
+    ActiveRecord::Base.connected_to_stack.pop
+  end
+
+  test "#connecting_to with prevent_writes" do
+    SecondAbstractClass.connecting_to(role: :writing, prevent_writes: true)
+
+    assert SecondAbstractClass.connected_to?(role: :writing)
+    assert SecondAbstractClass.current_preventing_writes
+  ensure
+    ActiveRecord::Base.connected_to_stack.pop
+  end
+
+  test "#connecting_to doesn't work with legacy connection handling" do
+    old_value = ActiveRecord::Base.legacy_connection_handling
+    ActiveRecord::Base.legacy_connection_handling = true
+
+    assert_raises NotImplementedError do
+      SecondAbstractClass.connecting_to(role: :writing, prevent_writes: true)
+    end
+  ensure
+    ActiveRecord::Base.legacy_connection_handling = old_value
+  end
+
+  test "#connected_to_many doesn't work with legacy connection handling" do
+    old_value = ActiveRecord::Base.legacy_connection_handling
+    ActiveRecord::Base.legacy_connection_handling = true
+
+    assert_raises NotImplementedError do
+      ActiveRecord::Base.connected_to_many([SecondAbstractClass], role: :writing)
+    end
+  ensure
+    ActiveRecord::Base.legacy_connection_handling = old_value
+  end
+
+  test "#connected_to_many cannot be called on anything but ActiveRecord::Base" do
+    assert_raises NotImplementedError do
+      SecondAbstractClass.connected_to_many([SecondAbstractClass], role: :writing)
+    end
+  end
+
+  test "#connected_to_many cannot be called with classes that include ActiveRecord::Base" do
+    assert_raises NotImplementedError do
+      ActiveRecord::Base.connected_to_many([ActiveRecord::Base], role: :writing)
+    end
+  end
+
+  test "#connected_to_many sets prevent_writes if role is reading" do
+    ActiveRecord::Base.connected_to_many([SecondAbstractClass], role: :reading) do
+      assert SecondAbstractClass.current_preventing_writes
+      assert_not ActiveRecord::Base.current_preventing_writes
+    end
+  end
+
+  test "#connected_to_many with a single argument for classes" do
+    ActiveRecord::Base.connected_to_many(SecondAbstractClass, role: :reading) do
+      assert SecondAbstractClass.current_preventing_writes
+      assert_not ActiveRecord::Base.current_preventing_writes
+    end
+  end
+
+  test "#connected_to_many with a multiple classes without brackets works" do
+    ActiveRecord::Base.connected_to_many(FirstAbstractClass, SecondAbstractClass, role: :reading) do
+      assert FirstAbstractClass.current_preventing_writes
+      assert SecondAbstractClass.current_preventing_writes
+      assert_not ActiveRecord::Base.current_preventing_writes
+    end
+  end
 end