ibm_db 5.2.0-x86-mingw32 → 5.4.0-x86-mingw32

data/test/cases/dirty_test.rb

@@ -1,37 +1,23 @@
-require 'cases/helper'
-require 'models/topic'    # For booleans
-require 'models/pirate'   # For timestamps
-require 'models/parrot'
-require 'models/person'   # For optimistic locking
-require 'models/aircraft'
+# frozen_string_literal: true
 
-class Pirate # Just reopening it, not defining it
-  attr_accessor :detected_changes_in_after_update # Boolean for if changes are detected
-  attr_accessor :changes_detected_in_after_update # Actual changes
-
-  after_update :check_changes
-
-private
-  # after_save/update and the model itself
-  # can end up checking dirty status and acting on the results
-  def check_changes
-    if self.changed?
-      self.detected_changes_in_after_update = true
-      self.changes_detected_in_after_update = self.changes
-    end
-  end
-end
-
-class NumericData < ActiveRecord::Base
-  self.table_name = 'numeric_data'
-end
+require "cases/helper"
+require "models/topic"    # For booleans
+require "models/pirate"   # For timestamps
+require "models/parrot"
+require "models/person"   # For optimistic locking
+require "models/aircraft"
+require "models/numeric_data"
 
 class DirtyTest < ActiveRecord::TestCase
   include InTimeZone
 
   # Dummy to force column loads so query counts are clean.
   def setup
-    Person.create :first_name => 'foo'
+    Person.create first_name: "foo"
+  end
+
+  def teardown
+    Person.delete_by(first_name: "foo")
   end
 
   def test_attribute_changes
@@ -41,82 +27,82 @@ class DirtyTest < ActiveRecord::TestCase
     assert_equal false, pirate.non_validated_parrot_id_changed?
 
     # Change catchphrase.
-    pirate.catchphrase = 'arrr'
-    assert pirate.catchphrase_changed?
+    pirate.catchphrase = "arrr"
+    assert_predicate pirate, :catchphrase_changed?
     assert_nil pirate.catchphrase_was
-    assert_equal [nil, 'arrr'], pirate.catchphrase_change
+    assert_equal [nil, "arrr"], pirate.catchphrase_change
 
     # Saved - no changes.
     pirate.save!
-    assert !pirate.catchphrase_changed?
+    assert_not_predicate pirate, :catchphrase_changed?
     assert_nil pirate.catchphrase_change
 
     # Same value - no changes.
-    pirate.catchphrase = 'arrr'
-    assert !pirate.catchphrase_changed?
+    pirate.catchphrase = "arrr"
+    assert_not_predicate pirate, :catchphrase_changed?
     assert_nil pirate.catchphrase_change
   end
 
   def test_time_attributes_changes_with_time_zone
-    in_time_zone 'Paris' do
+    in_time_zone "Paris" do
       target = Class.new(ActiveRecord::Base)
-      target.table_name = 'pirates'
+      target.table_name = "pirates"
 
       # New record - no changes.
       pirate = target.new
-      assert !pirate.created_on_changed?
+      assert_not_predicate pirate, :created_on_changed?
       assert_nil pirate.created_on_change
 
       # Saved - no changes.
-      pirate.catchphrase = 'arrrr, time zone!!'
+      pirate.catchphrase = "arrrr, time zone!!"
       pirate.save!
-      assert !pirate.created_on_changed?
+      assert_not_predicate pirate, :created_on_changed?
       assert_nil pirate.created_on_change
 
       # Change created_on.
       old_created_on = pirate.created_on
       pirate.created_on = Time.now - 1.day
-      assert pirate.created_on_changed?
+      assert_predicate pirate, :created_on_changed?
       assert_kind_of ActiveSupport::TimeWithZone, pirate.created_on_was
       assert_equal old_created_on, pirate.created_on_was
       pirate.created_on = old_created_on
-      assert !pirate.created_on_changed?
+      assert_not_predicate pirate, :created_on_changed?
     end
   end
 
   def test_setting_time_attributes_with_time_zone_field_to_itself_should_not_be_marked_as_a_change
-    in_time_zone 'Paris' do
+    in_time_zone "Paris" do
       target = Class.new(ActiveRecord::Base)
-      target.table_name = 'pirates'
+      target.table_name = "pirates"
 
       pirate = target.create!
       pirate.created_on = pirate.created_on
-      assert !pirate.created_on_changed?
+      assert_not_predicate pirate, :created_on_changed?
     end
   end
 
   def test_time_attributes_changes_without_time_zone_by_skip
-    in_time_zone 'Paris' do
+    in_time_zone "Paris" do
       target = Class.new(ActiveRecord::Base)
-      target.table_name = 'pirates'
+      target.table_name = "pirates"
 
       target.skip_time_zone_conversion_for_attributes = [:created_on]
 
       # New record - no changes.
       pirate = target.new
-      assert !pirate.created_on_changed?
+      assert_not_predicate pirate, :created_on_changed?
       assert_nil pirate.created_on_change
 
       # Saved - no changes.
-      pirate.catchphrase = 'arrrr, time zone!!'
+      pirate.catchphrase = "arrrr, time zone!!"
       pirate.save!
-      assert !pirate.created_on_changed?
+      assert_not_predicate pirate, :created_on_changed?
       assert_nil pirate.created_on_change
 
       # Change created_on.
       old_created_on = pirate.created_on
       pirate.created_on = Time.now + 1.day
-      assert pirate.created_on_changed?
+      assert_predicate pirate, :created_on_changed?
       # kind_of does not work because
       # ActiveSupport::TimeWithZone.name == 'Time'
       assert_instance_of Time, pirate.created_on_was
@@ -127,23 +113,23 @@ class DirtyTest < ActiveRecord::TestCase
   def test_time_attributes_changes_without_time_zone
     with_timezone_config aware_attributes: false do
       target = Class.new(ActiveRecord::Base)
-      target.table_name = 'pirates'
+      target.table_name = "pirates"
 
       # New record - no changes.
       pirate = target.new
-      assert !pirate.created_on_changed?
+      assert_not_predicate pirate, :created_on_changed?
       assert_nil pirate.created_on_change
 
       # Saved - no changes.
-      pirate.catchphrase = 'arrrr, time zone!!'
+      pirate.catchphrase = "arrrr, time zone!!"
       pirate.save!
-      assert !pirate.created_on_changed?
+      assert_not_predicate pirate, :created_on_changed?
       assert_nil pirate.created_on_change
 
       # Change created_on.
       old_created_on = pirate.created_on
       pirate.created_on = Time.now + 1.day
-      assert pirate.created_on_changed?
+      assert_predicate pirate, :created_on_changed?
       # kind_of does not work because
       # ActiveSupport::TimeWithZone.name == 'Time'
       assert_instance_of Time, pirate.created_on_was
@@ -151,28 +137,47 @@ class DirtyTest < ActiveRecord::TestCase
     end
   end
 
-
   def test_aliased_attribute_changes
     # the actual attribute here is name, title is an
     # alias setup via alias_attribute
     parrot = Parrot.new
-    assert !parrot.title_changed?
+    assert_not_predicate parrot, :title_changed?
     assert_nil parrot.title_change
 
-    parrot.name = 'Sam'
-    assert parrot.title_changed?
+    parrot.name = "Sam"
+    assert_predicate parrot, :title_changed?
     assert_nil parrot.title_was
     assert_equal parrot.name_change, parrot.title_change
   end
 
   def test_restore_attribute!
-    pirate = Pirate.create!(:catchphrase => 'Yar!')
-    pirate.catchphrase = 'Ahoy!'
+    pirate = Pirate.create!(catchphrase: "Yar!")
+    pirate.catchphrase = "Ahoy!"
+
+    assert_equal "Ahoy!", pirate.catchphrase
+    assert_equal ["Yar!", "Ahoy!"], pirate.catchphrase_change
 
     pirate.restore_catchphrase!
+
+    assert_nil pirate.catchphrase_change
     assert_equal "Yar!", pirate.catchphrase
     assert_equal Hash.new, pirate.changes
-    assert !pirate.catchphrase_changed?
+    assert_not_predicate pirate, :catchphrase_changed?
+  end
+
+  def test_clear_attribute_change
+    pirate = Pirate.create!(catchphrase: "Yar!")
+    pirate.catchphrase = "Ahoy!"
+
+    assert_equal "Ahoy!", pirate.catchphrase
+    assert_equal ["Yar!", "Ahoy!"], pirate.catchphrase_change
+
+    pirate.clear_catchphrase_change
+
+    assert_nil pirate.catchphrase_change
+    assert_equal "Ahoy!", pirate.catchphrase
+    assert_equal Hash.new, pirate.changes
+    assert_not_predicate pirate, :catchphrase_changed?
   end
 
   def test_nullable_number_not_marked_as_changed_if_new_value_is_blank
@@ -180,7 +185,7 @@ class DirtyTest < ActiveRecord::TestCase
 
     ["", nil].each do |value|
       pirate.parrot_id = value
-      assert !pirate.parrot_id_changed?
+      assert_not_predicate pirate, :parrot_id_changed?
       assert_nil pirate.parrot_id_change
     end
   end
@@ -190,7 +195,7 @@ class DirtyTest < ActiveRecord::TestCase
 
     ["", nil].each do |value|
       numeric_data.bank_balance = value
-      assert !numeric_data.bank_balance_changed?
+      assert_not_predicate numeric_data, :bank_balance_changed?
       assert_nil numeric_data.bank_balance_change
     end
   end
@@ -200,15 +205,15 @@ class DirtyTest < ActiveRecord::TestCase
 
     ["", nil].each do |value|
       numeric_data.temperature = value
-      assert !numeric_data.temperature_changed?
+      assert_not_predicate numeric_data, :temperature_changed?
       assert_nil numeric_data.temperature_change
     end
   end
 
   def test_nullable_datetime_not_marked_as_changed_if_new_value_is_blank
-    in_time_zone 'Edinburgh' do
+    in_time_zone "Edinburgh" do
       target = Class.new(ActiveRecord::Base)
-      target.table_name = 'topics'
+      target.table_name = "topics"
 
       topic = target.create
       assert_nil topic.written_on
@@ -216,7 +221,7 @@ class DirtyTest < ActiveRecord::TestCase
       ["", nil].each do |value|
         topic.written_on = value
         assert_nil topic.written_on
-        assert !topic.written_on_changed?
+        assert_not_predicate topic, :written_on_changed?
       end
     end
   end
@@ -224,40 +229,40 @@ class DirtyTest < ActiveRecord::TestCase
   def test_integer_zero_to_string_zero_not_marked_as_changed
     pirate = Pirate.new
     pirate.parrot_id = 0
-    pirate.catchphrase = 'arrr'
+    pirate.catchphrase = "arrr"
     assert pirate.save!
 
-    assert !pirate.changed?
+    assert_not_predicate pirate, :changed?
 
-    pirate.parrot_id = '0'
-    assert !pirate.changed?
+    pirate.parrot_id = "0"
+    assert_not_predicate pirate, :changed?
   end
 
   def test_integer_zero_to_integer_zero_not_marked_as_changed
     pirate = Pirate.new
     pirate.parrot_id = 0
-    pirate.catchphrase = 'arrr'
+    pirate.catchphrase = "arrr"
     assert pirate.save!
 
-    assert !pirate.changed?
+    assert_not_predicate pirate, :changed?
 
     pirate.parrot_id = 0
-    assert !pirate.changed?
+    assert_not_predicate pirate, :changed?
   end
 
   def test_float_zero_to_string_zero_not_marked_as_changed
-    data = NumericData.new :temperature => 0.0
+    data = NumericData.new temperature: 0.0
     data.save!
 
-    assert_not data.changed?
+    assert_not_predicate data, :changed?
 
-    data.temperature = '0'
+    data.temperature = "0"
     assert_empty data.changes
 
-    data.temperature = '0.0'
+    data.temperature = "0.0"
     assert_empty data.changes
 
-    data.temperature = '0.00'
+    data.temperature = "0.00"
     assert_empty data.changes
   end
 
@@ -269,108 +274,122 @@ class DirtyTest < ActiveRecord::TestCase
 
     # check the change from 1 to ''
     pirate = Pirate.find_by_catchphrase("Yarrrr, me hearties")
-    pirate.parrot_id = ''
-    assert pirate.parrot_id_changed?
+    pirate.parrot_id = ""
+    assert_predicate pirate, :parrot_id_changed?
     assert_equal([1, nil], pirate.parrot_id_change)
     pirate.save
 
     # check the change from nil to 0
     pirate = Pirate.find_by_catchphrase("Yarrrr, me hearties")
     pirate.parrot_id = 0
-    assert pirate.parrot_id_changed?
+    assert_predicate pirate, :parrot_id_changed?
     assert_equal([nil, 0], pirate.parrot_id_change)
     pirate.save
 
     # check the change from 0 to ''
     pirate = Pirate.find_by_catchphrase("Yarrrr, me hearties")
-    pirate.parrot_id = ''
-    assert pirate.parrot_id_changed?
+    pirate.parrot_id = ""
+    assert_predicate pirate, :parrot_id_changed?
     assert_equal([0, nil], pirate.parrot_id_change)
   end
 
   def test_object_should_be_changed_if_any_attribute_is_changed
     pirate = Pirate.new
-    assert !pirate.changed?
+    assert_not_predicate pirate, :changed?
     assert_equal [], pirate.changed
     assert_equal Hash.new, pirate.changes
 
-    pirate.catchphrase = 'arrr'
-    assert pirate.changed?
+    pirate.catchphrase = "arrr"
+    assert_predicate pirate, :changed?
     assert_nil pirate.catchphrase_was
     assert_equal %w(catchphrase), pirate.changed
-    assert_equal({'catchphrase' => [nil, 'arrr']}, pirate.changes)
+    assert_equal({ "catchphrase" => [nil, "arrr"] }, pirate.changes)
 
     pirate.save
-    assert !pirate.changed?
+    assert_not_predicate pirate, :changed?
     assert_equal [], pirate.changed
     assert_equal Hash.new, pirate.changes
   end
 
   def test_attribute_will_change!
-    pirate = Pirate.create!(:catchphrase => 'arr')
+    pirate = Pirate.create!(catchphrase: "arr")
 
-    assert !pirate.catchphrase_changed?
+    assert_not_predicate pirate, :catchphrase_changed?
     assert pirate.catchphrase_will_change!
-    assert pirate.catchphrase_changed?
-    assert_equal ['arr', 'arr'], pirate.catchphrase_change
+    assert_predicate pirate, :catchphrase_changed?
+    assert_equal ["arr", "arr"], pirate.catchphrase_change
 
-    pirate.catchphrase << ' matey!'
-    assert pirate.catchphrase_changed?
-    assert_equal ['arr', 'arr matey!'], pirate.catchphrase_change
+    pirate.catchphrase << " matey!"
+    assert_predicate pirate, :catchphrase_changed?
+    assert_equal ["arr", "arr matey!"], pirate.catchphrase_change
+  end
+
+  def test_virtual_attribute_will_change
+    parrot = Parrot.create!(name: "Ruby")
+    parrot.send(:attribute_will_change!, :cancel_save_from_callback)
+    assert_predicate parrot, :has_changes_to_save?
   end
 
   def test_association_assignment_changes_foreign_key
-    pirate = Pirate.create!(:catchphrase => 'jarl')
-    pirate.parrot = Parrot.create!(:name => 'Lorre')
-    assert pirate.changed?
+    pirate = Pirate.create!(catchphrase: "jarl")
+    pirate.parrot = Parrot.create!(name: "Lorre")
+    assert_predicate pirate, :changed?
     assert_equal %w(parrot_id), pirate.changed
   end
 
   def test_attribute_should_be_compared_with_type_cast
     topic = Topic.new
-    assert topic.approved?
-    assert !topic.approved_changed?
+    assert_predicate topic, :approved?
+    assert_not_predicate topic, :approved_changed?
 
     # Coming from web form.
-    params = {:topic => {:approved => 1}}
+    params = { topic: { approved: 1 } }
     # In the controller.
     topic.attributes = params[:topic]
-    assert topic.approved?
-    assert !topic.approved_changed?
+    assert_predicate topic, :approved?
+    assert_not_predicate topic, :approved_changed?
+  end
+
+  def test_string_attribute_should_compare_with_typecast_symbol_after_update
+    pirate = Pirate.create!(catchphrase: :foo)
+    pirate.update_column :catchphrase, :foo
+    pirate.catchphrase
+    assert_not_predicate pirate, :catchphrase_changed?
   end
 
   def test_partial_update
-    pirate = Pirate.new(:catchphrase => 'foo')
+    pirate = Pirate.new(catchphrase: "foo")
     old_updated_on = 1.hour.ago.beginning_of_day
 
     with_partial_writes Pirate, false do
       assert_queries(2) { 2.times { pirate.save! } }
-      Pirate.where(id: pirate.id).update_all(:updated_on => old_updated_on)
+      Pirate.where(id: pirate.id).update_all(updated_on: old_updated_on)
     end
 
     with_partial_writes Pirate, true do
-      assert_queries(0) { 2.times { pirate.save! } }
+      assert_no_queries { 2.times { pirate.save! } }
       assert_equal old_updated_on, pirate.reload.updated_on
 
-      assert_queries(1) { pirate.catchphrase = 'bar'; pirate.save! }
+      assert_queries(1) { pirate.catchphrase = "bar"; pirate.save! }
       assert_not_equal old_updated_on, pirate.reload.updated_on
     end
   end
 
   def test_partial_update_with_optimistic_locking
-    person = Person.new(:first_name => 'foo')
-    old_lock_version = 1
+    person = Person.new(first_name: "foo")
 
     with_partial_writes Person, false do
       assert_queries(2) { 2.times { person.save! } }
-      Person.where(id: person.id).update_all(:first_name => 'baz')
+      Person.where(id: person.id).update_all(first_name: "baz")
     end
 
+    old_lock_version = person.lock_version + 1
+
     with_partial_writes Person, true do
-      assert_queries(0) { 2.times { person.save! } }
+      assert_no_queries { 2.times { person.save! } }
       assert_equal old_lock_version, person.reload.lock_version
 
-      assert_queries(1) { person.first_name = 'bar'; person.save! }
+      assert_queries(1) { person.first_name = "bar"; person.save! }
       assert_not_equal old_lock_version, person.reload.lock_version
     end
   end
@@ -378,7 +397,7 @@ class DirtyTest < ActiveRecord::TestCase
   def test_changed_attributes_should_be_preserved_if_save_failure
     pirate = Pirate.new
     pirate.parrot_id = 1
-    assert !pirate.save
+    assert_not pirate.save
     check_pirate_after_save_failure(pirate)
 
     pirate = Pirate.new
@@ -388,71 +407,70 @@ class DirtyTest < ActiveRecord::TestCase
   end
 
   def test_reload_should_clear_changed_attributes
-    pirate = Pirate.create!(:catchphrase => "shiver me timbers")
+    pirate = Pirate.create!(catchphrase: "shiver me timbers")
     pirate.catchphrase = "*hic*"
-    assert pirate.changed?
+    assert_predicate pirate, :changed?
     pirate.reload
-    assert !pirate.changed?
+    assert_not_predicate pirate, :changed?
   end
 
   def test_dup_objects_should_not_copy_dirty_flag_from_creator
-    pirate = Pirate.create!(:catchphrase => "shiver me timbers")
+    pirate = Pirate.create!(catchphrase: "shiver me timbers")
     pirate_dup = pirate.dup
     pirate_dup.restore_catchphrase!
     pirate.catchphrase = "I love Rum"
-    assert pirate.catchphrase_changed?
-    assert !pirate_dup.catchphrase_changed?
+    assert_predicate pirate, :catchphrase_changed?
+    assert_not_predicate pirate_dup, :catchphrase_changed?
   end
 
   def test_reverted_changes_are_not_dirty
     phrase = "shiver me timbers"
-    pirate = Pirate.create!(:catchphrase => phrase)
+    pirate = Pirate.create!(catchphrase: phrase)
     pirate.catchphrase = "*hic*"
-    assert pirate.changed?
+    assert_predicate pirate, :changed?
     pirate.catchphrase = phrase
-    assert !pirate.changed?
+    assert_not_predicate pirate, :changed?
   end
 
   def test_reverted_changes_are_not_dirty_after_multiple_changes
     phrase = "shiver me timbers"
-    pirate = Pirate.create!(:catchphrase => phrase)
+    pirate = Pirate.create!(catchphrase: phrase)
     10.times do |i|
       pirate.catchphrase = "*hic*" * i
-      assert pirate.changed?
+      assert_predicate pirate, :changed?
     end
-    assert pirate.changed?
+    assert_predicate pirate, :changed?
     pirate.catchphrase = phrase
-    assert !pirate.changed?
+    assert_not_predicate pirate, :changed?
   end
 
-
   def test_reverted_changes_are_not_dirty_going_from_nil_to_value_and_back
-    pirate = Pirate.create!(:catchphrase => "Yar!")
+    pirate = Pirate.create!(catchphrase: "Yar!")
 
     pirate.parrot_id = 1
-    assert pirate.changed?
-    assert pirate.parrot_id_changed?
-    assert !pirate.catchphrase_changed?
+    assert_predicate pirate, :changed?
+    assert_predicate pirate, :parrot_id_changed?
+    assert_not_predicate pirate, :catchphrase_changed?
 
     pirate.parrot_id = nil
-    assert !pirate.changed?
-    assert !pirate.parrot_id_changed?
-    assert !pirate.catchphrase_changed?
+    assert_not_predicate pirate, :changed?
+    assert_not_predicate pirate, :parrot_id_changed?
+    assert_not_predicate pirate, :catchphrase_changed?
   end
 
   def test_save_should_store_serialized_attributes_even_with_partial_writes
     with_partial_writes(Topic) do
-      topic = Topic.create!(:content => {:a => "a"})
+      topic = Topic.create!(content: { a: "a" })
 
-      assert_not topic.changed?
+      assert_not_predicate topic, :changed?
 
       topic.content[:b] = "b"
 
-      assert topic.changed?
+      assert_predicate topic, :changed?
 
       topic.save!
 
-      assert_not topic.changed?
+      assert_not_predicate topic, :changed?
       assert_equal "b", topic.content[:b]
 
       topic.reload
@@ -463,30 +481,37 @@ class DirtyTest < ActiveRecord::TestCase
 
   def test_save_always_should_update_timestamps_when_serialized_attributes_are_present
     with_partial_writes(Topic) do
-      topic = Topic.create!(:content => {:a => "a"})
+      topic = Topic.create!(content: { a: "a" })
       topic.save!
 
       updated_at = topic.updated_at
       travel(1.second) do
-        topic.content[:hello] = 'world'
+        topic.content[:hello] = "world"
         topic.save!
       end
 
       assert_not_equal updated_at, topic.updated_at
-      assert_equal 'world', topic.content[:hello]
+      assert_equal "world", topic.content[:hello]
     end
   end
 
   def test_save_should_not_save_serialized_attribute_with_partial_writes_if_not_present
     with_partial_writes(Topic) do
-      Topic.create!(:author_name => 'Bill', :content => {:a => "a"})
-      topic = Topic.select('id, author_name').first
-      topic.update_columns author_name: 'John'
-      topic = Topic.first
-      assert_not_nil topic.content
+      topic = Topic.create!(author_name: "Bill", content: { a: "a" })
+      topic = Topic.select("id, author_name").find(topic.id)
+      topic.update_columns author_name: "John"
+      assert_not_nil topic.reload.content
     end
   end
 
+  def test_changes_to_save_should_not_mutate_array_of_hashes
+    topic = Topic.new(author_name: "Bill", content: [{ a: "a" }])
+
+    topic.changes_to_save
+
+    assert_equal [{ a: "a" }], topic.content
+  end
+
   def test_previous_changes
     # original values should be in previous_changes
     pirate = Pirate.new
@@ -496,13 +521,14 @@ class DirtyTest < ActiveRecord::TestCase
     pirate.save!
 
     assert_equal 4, pirate.previous_changes.size
-    assert_equal [nil, "arrr"], pirate.previous_changes['catchphrase']
-    assert_equal [nil, pirate.id], pirate.previous_changes['id']
-    assert_nil pirate.previous_changes['updated_on'][0]
-    assert_not_nil pirate.previous_changes['updated_on'][1]
-    assert_nil pirate.previous_changes['created_on'][0]
-    assert_not_nil pirate.previous_changes['created_on'][1]
-    assert !pirate.previous_changes.key?('parrot_id')
+    assert_equal [nil, "arrr"], pirate.previous_changes["catchphrase"]
+    assert_nil pirate.catchphrase_previously_was
+    assert_equal [nil, pirate.id], pirate.previous_changes["id"]
+    assert_nil pirate.previous_changes["updated_on"][0]
+    assert_not_nil pirate.previous_changes["updated_on"][1]
+    assert_nil pirate.previous_changes["created_on"][0]
+    assert_not_nil pirate.previous_changes["created_on"][1]
+    assert_not pirate.previous_changes.key?("parrot_id")
 
     # original values should be in previous_changes
     pirate = Pirate.new
@@ -512,11 +538,12 @@ class DirtyTest < ActiveRecord::TestCase
     pirate.save
 
     assert_equal 4, pirate.previous_changes.size
-    assert_equal [nil, "arrr"], pirate.previous_changes['catchphrase']
-    assert_equal [nil, pirate.id], pirate.previous_changes['id']
-    assert pirate.previous_changes.include?('updated_on')
-    assert pirate.previous_changes.include?('created_on')
-    assert !pirate.previous_changes.key?('parrot_id')
+    assert_equal [nil, "arrr"], pirate.previous_changes["catchphrase"]
+    assert_nil pirate.catchphrase_previously_was
+    assert_equal [nil, pirate.id], pirate.previous_changes["id"]
+    assert_includes pirate.previous_changes, "updated_on"
+    assert_includes pirate.previous_changes, "created_on"
+    assert_not pirate.previous_changes.key?("parrot_id")
 
     pirate.catchphrase = "Yar!!"
     pirate.reload
@@ -530,11 +557,12 @@ class DirtyTest < ActiveRecord::TestCase
     pirate.save!
 
     assert_equal 2, pirate.previous_changes.size
-    assert_equal ["arrr", "Me Maties!"], pirate.previous_changes['catchphrase']
-    assert_not_nil pirate.previous_changes['updated_on'][0]
-    assert_not_nil pirate.previous_changes['updated_on'][1]
-    assert !pirate.previous_changes.key?('parrot_id')
-    assert !pirate.previous_changes.key?('created_on')
+    assert_equal ["arrr", "Me Maties!"], pirate.previous_changes["catchphrase"]
+    assert_equal "arrr", pirate.catchphrase_previously_was
+    assert_not_nil pirate.previous_changes["updated_on"][0]
+    assert_not_nil pirate.previous_changes["updated_on"][1]
+    assert_not pirate.previous_changes.key?("parrot_id")
+    assert_not pirate.previous_changes.key?("created_on")
 
     pirate = Pirate.find_by_catchphrase("Me Maties!")
 
@@ -544,11 +572,12 @@ class DirtyTest < ActiveRecord::TestCase
     pirate.save
 
     assert_equal 2, pirate.previous_changes.size
-    assert_equal ["Me Maties!", "Thar She Blows!"], pirate.previous_changes['catchphrase']
-    assert_not_nil pirate.previous_changes['updated_on'][0]
-    assert_not_nil pirate.previous_changes['updated_on'][1]
-    assert !pirate.previous_changes.key?('parrot_id')
-    assert !pirate.previous_changes.key?('created_on')
+    assert_equal ["Me Maties!", "Thar She Blows!"], pirate.previous_changes["catchphrase"]
+    assert_equal "Me Maties!", pirate.catchphrase_previously_was
+    assert_not_nil pirate.previous_changes["updated_on"][0]
+    assert_not_nil pirate.previous_changes["updated_on"][1]
+    assert_not pirate.previous_changes.key?("parrot_id")
+    assert_not pirate.previous_changes.key?("created_on")
 
     travel(1.second)
 
@@ -556,11 +585,12 @@ class DirtyTest < ActiveRecord::TestCase
     pirate.update(catchphrase: "Ahoy!")
 
     assert_equal 2, pirate.previous_changes.size
-    assert_equal ["Thar She Blows!", "Ahoy!"], pirate.previous_changes['catchphrase']
-    assert_not_nil pirate.previous_changes['updated_on'][0]
-    assert_not_nil pirate.previous_changes['updated_on'][1]
-    assert !pirate.previous_changes.key?('parrot_id')
-    assert !pirate.previous_changes.key?('created_on')
+    assert_equal ["Thar She Blows!", "Ahoy!"], pirate.previous_changes["catchphrase"]
+    assert_equal "Thar She Blows!", pirate.catchphrase_previously_was
+    assert_not_nil pirate.previous_changes["updated_on"][0]
+    assert_not_nil pirate.previous_changes["updated_on"][1]
+    assert_not pirate.previous_changes.key?("parrot_id")
+    assert_not pirate.previous_changes.key?("created_on")
 
     travel(1.second)
 
@@ -568,63 +598,61 @@ class DirtyTest < ActiveRecord::TestCase
     pirate.update_attribute(:catchphrase, "Ninjas suck!")
 
     assert_equal 2, pirate.previous_changes.size
-    assert_equal ["Ahoy!", "Ninjas suck!"], pirate.previous_changes['catchphrase']
-    assert_not_nil pirate.previous_changes['updated_on'][0]
-    assert_not_nil pirate.previous_changes['updated_on'][1]
-    assert !pirate.previous_changes.key?('parrot_id')
-    assert !pirate.previous_changes.key?('created_on')
-  ensure
-    travel_back
-  end
-
-  if ActiveRecord::Base.connection.supports_migrations?
-    class Testings < ActiveRecord::Base; end
-    def test_field_named_field
-      ActiveRecord::Base.connection.create_table :testings do |t|
-        t.string :field
-      end
-      assert_nothing_raised do
-        Testings.new.attributes
-      end
-    ensure
-      ActiveRecord::Base.connection.drop_table :testings rescue nil
+    assert_equal ["Ahoy!", "Ninjas suck!"], pirate.previous_changes["catchphrase"]
+    assert_equal "Ahoy!", pirate.catchphrase_previously_was
+    assert_not_nil pirate.previous_changes["updated_on"][0]
+    assert_not_nil pirate.previous_changes["updated_on"][1]
+    assert_not pirate.previous_changes.key?("parrot_id")
+    assert_not pirate.previous_changes.key?("created_on")
+  end
+
+  class Testings < ActiveRecord::Base; end
+  def test_field_named_field
+    ActiveRecord::Base.connection.create_table :testings do |t|
+      t.string :field
     end
+    assert_nothing_raised do
+      Testings.new.attributes
+    end
+  ensure
+    ActiveRecord::Base.connection.drop_table :testings rescue nil
+    ActiveRecord::Base.clear_cache!
   end
 
   def test_datetime_attribute_can_be_updated_with_fractional_seconds
-    skip "Fractional seconds are not supported" unless subsecond_precision_supported?
-    in_time_zone 'Paris' do
+    skip "Fractional seconds are not supported" unless supports_datetime_with_precision?
+    in_time_zone "Paris" do
       target = Class.new(ActiveRecord::Base)
-      target.table_name = 'topics'
+      target.table_name = "topics"
 
-      written_on = Time.utc(2012, 12, 1, 12, 0, 0).in_time_zone('Paris')
+      written_on = Time.utc(2012, 12, 1, 12, 0, 0).in_time_zone("Paris")
 
-      topic = target.create(:written_on => written_on)
+      topic = target.create(written_on: written_on)
       topic.written_on += 0.3
 
-      assert topic.written_on_changed?, 'Fractional second update not detected'
+      assert topic.written_on_changed?, "Fractional second update not detected"
     end
   end
 
   def test_datetime_attribute_doesnt_change_if_zone_is_modified_in_string
-    time_in_paris = Time.utc(2014, 1, 1, 12, 0, 0).in_time_zone('Paris')
-    pirate = Pirate.create!(:catchphrase => 'rrrr', :created_on => time_in_paris)
+    time_in_paris = Time.utc(2014, 1, 1, 12, 0, 0).in_time_zone("Paris")
+    pirate = Pirate.create!(catchphrase: "rrrr", created_on: time_in_paris)
 
-    pirate.created_on = pirate.created_on.in_time_zone('Tokyo').to_s
-    assert !pirate.created_on_changed?
+    pirate.created_on = pirate.created_on.in_time_zone("Tokyo").to_s
+    assert_not_predicate pirate, :created_on_changed?
   end
 
   test "partial insert" do
     with_partial_writes Person do
       jon = nil
       assert_sql(/first_name/i) do
-        jon = Person.create! first_name: 'Jon'
+        jon = Person.create! first_name: "Jon"
       end
 
-      assert ActiveRecord::SQLCounter.log_all.none? { |sql| sql =~ /followers_count/ }
+      assert ActiveRecord::SQLCounter.log_all.none? { |sql| sql.include?("followers_count") }
 
       jon.reload
-      assert_equal 'Jon', jon.first_name
+      assert_equal "Jon", jon.first_name
       assert_equal 0, jon.followers_count
       assert_not_nil jon.id
     end
@@ -642,7 +670,7 @@ class DirtyTest < ActiveRecord::TestCase
     pirate = Pirate.create!(catchphrase: "arrrr")
     pirate.catchphrase << " matey!"
 
-    assert pirate.catchphrase_changed?
+    assert_predicate pirate, :catchphrase_changed?
     expected_changes = {
       "catchphrase" => ["arrrr", "arrrr matey!"]
     }
@@ -650,13 +678,13 @@ class DirtyTest < ActiveRecord::TestCase
     assert_equal("arrrr", pirate.catchphrase_was)
     assert pirate.catchphrase_changed?(from: "arrrr")
     assert_not pirate.catchphrase_changed?(from: "anything else")
-    assert pirate.changed_attributes.include?(:catchphrase)
+    assert_includes pirate.changed_attributes, :catchphrase
 
     pirate.save!
     pirate.reload
 
     assert_equal "arrrr matey!", pirate.catchphrase
-    assert_not pirate.changed?
+    assert_not_predicate pirate, :changed?
   end
 
   test "in place mutation for binary" do
@@ -667,19 +695,60 @@ class DirtyTest < ActiveRecord::TestCase
 
     binary = klass.create!(data: "\\\\foo")
 
-    assert_not binary.changed?
+    assert_not_predicate binary, :changed?
 
     binary.data = binary.data.dup
 
-    assert_not binary.changed?
+    assert_not_predicate binary, :changed?
 
     binary = klass.last
 
-    assert_not binary.changed?
+    assert_not_predicate binary, :changed?
 
     binary.data << "bar"
 
-    assert binary.changed?
+    assert_predicate binary, :changed?
+  end
+
+  test "changes is correct for subclass" do
+    foo = Class.new(Pirate) do
+      def catchphrase
+        super.upcase
+      end
+    end
+
+    pirate = foo.create!(catchphrase: "arrrr")
+
+    new_catchphrase = "arrrr matey!"
+
+    pirate.catchphrase = new_catchphrase
+    assert_predicate pirate, :catchphrase_changed?
+
+    expected_changes = {
+      "catchphrase" => ["arrrr", new_catchphrase]
+    }
+
+    assert_equal new_catchphrase.upcase, pirate.catchphrase
+    assert_equal expected_changes, pirate.changes
+  end
+
+  test "changes is correct if override attribute reader" do
+    pirate = Pirate.create!(catchphrase: "arrrr")
+    def pirate.catchphrase
+      super.upcase
+    end
+
+    new_catchphrase = "arrrr matey!"
+
+    pirate.catchphrase = new_catchphrase
+    assert_predicate pirate, :catchphrase_changed?
+
+    expected_changes = {
+      "catchphrase" => ["arrrr", new_catchphrase]
+    }
+
+    assert_equal new_catchphrase.upcase, pirate.catchphrase
+    assert_equal expected_changes, pirate.changes
   end
 
   test "attribute_changed? doesn't compute in-place changes for unrelated attributes" do
@@ -689,27 +758,45 @@ class DirtyTest < ActiveRecord::TestCase
       end
     end
     klass = Class.new(ActiveRecord::Base) do
-      self.table_name = 'people'
+      self.table_name = "people"
       attribute :foo, test_type_class.new
     end
 
     model = klass.new(first_name: "Jim")
-    assert model.first_name_changed?
+    assert_predicate model, :first_name_changed?
   end
 
   test "attribute_will_change! doesn't try to save non-persistable attributes" do
     klass = Class.new(ActiveRecord::Base) do
-      self.table_name = 'people'
+      self.table_name = "people"
       attribute :non_persisted_attribute, :string
     end
 
     record = klass.new(first_name: "Sean")
     record.non_persisted_attribute_will_change!
 
-    assert record.non_persisted_attribute_changed?
+    assert_predicate record, :non_persisted_attribute_changed?
     assert record.save
   end
 
+  test "virtual attributes are not written with partial_writes off" do
+    with_partial_writes(ActiveRecord::Base, false) do
+      klass = Class.new(ActiveRecord::Base) do
+        self.table_name = "people"
+        attribute :non_persisted_attribute, :string
+      end
+
+      record = klass.new(first_name: "Sean")
+      record.non_persisted_attribute_will_change!
+
+      assert record.save
+
+      record.non_persisted_attribute_will_change!
+
+      assert record.save
+    end
+  end
+
   test "mutating and then assigning doesn't remove the change" do
     pirate = Pirate.create!(catchphrase: "arrrr")
     pirate.catchphrase << " matey!"
@@ -736,13 +823,122 @@ class DirtyTest < ActiveRecord::TestCase
 
   test "attributes assigned but not selected are dirty" do
     person = Person.select(:id).first
-    refute person.changed?
+    assert_not_predicate person, :changed?
 
     person.first_name = "Sean"
-    assert person.changed?
+    assert_predicate person, :changed?
 
     person.first_name = nil
-    assert person.changed?
+    assert_predicate person, :changed?
+  end
+
+  test "attributes not selected are still missing after save" do
+    person = Person.select(:id).first
+    assert_raises(ActiveModel::MissingAttributeError) { person.first_name }
+    assert person.save # calls forget_attribute_assignments
+    assert_raises(ActiveModel::MissingAttributeError) { person.first_name }
+  end
+
+  test "saved_change_to_attribute? returns whether a change occurred in the last save" do
+    person = Person.create!(first_name: "Sean")
+
+    assert_predicate person, :saved_change_to_first_name?
+    assert_not_predicate person, :saved_change_to_gender?
+    assert person.saved_change_to_first_name?(from: nil, to: "Sean")
+    assert person.saved_change_to_first_name?(from: nil)
+    assert person.saved_change_to_first_name?(to: "Sean")
+    assert_not person.saved_change_to_first_name?(from: "Jim", to: "Sean")
+    assert_not person.saved_change_to_first_name?(from: "Jim")
+    assert_not person.saved_change_to_first_name?(to: "Jim")
+  end
+
+  test "saved_change_to_attribute returns the change that occurred in the last save" do
+    person = Person.create!(first_name: "Sean", gender: "M")
+
+    assert_equal [nil, "Sean"], person.saved_change_to_first_name
+    assert_equal [nil, "M"], person.saved_change_to_gender
+
+    person.update(first_name: "Jim")
+
+    assert_equal ["Sean", "Jim"], person.saved_change_to_first_name
+    assert_nil person.saved_change_to_gender
+  end
+
+  test "attribute_before_last_save returns the original value before saving" do
+    person = Person.create!(first_name: "Sean", gender: "M")
+
+    assert_nil person.first_name_before_last_save
+    assert_nil person.gender_before_last_save
+
+    person.first_name = "Jim"
+
+    assert_nil person.first_name_before_last_save
+    assert_nil person.gender_before_last_save
+
+    person.save
+
+    assert_equal "Sean", person.first_name_before_last_save
+    assert_equal "M", person.gender_before_last_save
+  end
+
+  test "saved_changes? returns whether the last call to save changed anything" do
+    person = Person.create!(first_name: "Sean")
+
+    assert_predicate person, :saved_changes?
+
+    person.save
+
+    assert_not_predicate person, :saved_changes?
+  end
+
+  test "saved_changes returns a hash of all the changes that occurred" do
+    person = Person.create!(first_name: "Sean", gender: "M")
+
+    assert_equal [nil, "Sean"], person.saved_changes[:first_name]
+    assert_equal [nil, "M"], person.saved_changes[:gender]
+    assert_equal %w(id first_name gender created_at updated_at).sort, person.saved_changes.keys.sort
+
+    travel(1.second) do
+      person.update(first_name: "Jim")
+    end
+
+    assert_equal ["Sean", "Jim"], person.saved_changes[:first_name]
+    assert_equal %w(first_name lock_version updated_at).sort, person.saved_changes.keys.sort
+  end
+
+  test "changed? in after callbacks returns false" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "people"
+
+      after_save do
+        raise "changed? should be false" if changed?
+        raise "has_changes_to_save? should be false" if has_changes_to_save?
+        raise "saved_changes? should be true" unless saved_changes?
+        raise "id_in_database should not be nil" if id_in_database.nil?
+      end
+    end
+
+    person = klass.create!(first_name: "Sean")
+    assert_not_predicate person, :changed?
+  end
+
+  test "changed? in around callbacks after yield returns false" do
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "people"
+
+      around_create :check_around
+
+      def check_around
+        yield
+        raise "changed? should be false" if changed?
+        raise "has_changes_to_save? should be false" if has_changes_to_save?
+        raise "saved_changes? should be true" unless saved_changes?
+        raise "id_in_database should not be nil" if id_in_database.nil?
+      end
+    end
+
+    person = klass.create!(first_name: "Sean")
+    assert_not_predicate person, :changed?
   end
 
   private
@@ -755,8 +951,8 @@ class DirtyTest < ActiveRecord::TestCase
     end
 
     def check_pirate_after_save_failure(pirate)
-      assert pirate.changed?
-      assert pirate.parrot_id_changed?
+      assert_predicate pirate, :changed?
+      assert_predicate pirate, :parrot_id_changed?
       assert_equal %w(parrot_id), pirate.changed
       assert_nil pirate.parrot_id_was
     end