ibm_db 5.6.1 → 5.7.0

data/test/cases/timestamp_test.rb

@@ -118,11 +118,8 @@ class TimestampTest < ActiveRecord::TestCase
     task = Task.first
     previous_value = task.ending
     task.touch(:ending)
-
-    now = Time.now.change(usec: 0)
-
     assert_not_equal previous_value, task.ending
-    assert_in_delta now, task.ending, 1
+    assert_in_delta Time.now, task.ending, 1
   end
 
   def test_touching_an_attribute_updates_timestamp_with_given_time
@@ -143,12 +140,10 @@ class TimestampTest < ActiveRecord::TestCase
     previous_ending = task.ending
     task.touch(:starting, :ending)
 
-    now = Time.now.change(usec: 0)
-
     assert_not_equal previous_starting, task.starting
     assert_not_equal previous_ending, task.ending
-    assert_in_delta now, task.starting, 1
-    assert_in_delta now, task.ending, 1
+    assert_in_delta Time.now, task.starting, 1
+    assert_in_delta Time.now, task.ending, 1
   end
 
   def test_touching_a_record_without_timestamps_is_unexceptional
@@ -221,6 +216,88 @@ class TimestampTest < ActiveRecord::TestCase
     end
   end
 
+  def test_saving_an_unchanged_record_with_a_mutating_before_save_callback_updates_its_timestamp
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "developers"
+
+      include Developer::TimestampAliases
+
+      before_save :change_name
+
+      private
+        def change_name
+          return if new_record?
+
+          self.name = "Jack Bauer"
+        end
+    end
+
+    @developer = klass.create!
+    @previously_updated_at = @developer.updated_at
+    @previous_name = @developer.name
+
+    travel(1.second) do
+      @developer.save!
+    end
+
+    assert_not_equal @previous_name, @developer.name
+    assert_not_equal @previously_updated_at, @developer.updated_at
+  end
+
+  def test_saving_an_unchanged_record_with_a_mutating_before_update_callback_updates_its_timestamp
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "developers"
+
+      include Developer::TimestampAliases
+
+      before_update :change_name
+
+      private
+        def change_name
+          return if new_record?
+
+          self.name = "Jack Bauer"
+        end
+    end
+
+    @developer = klass.create!
+    @previously_updated_at = @developer.updated_at
+    @previous_name = @developer.name
+
+    travel(1.second) do
+      @developer.save!
+    end
+
+    @developer.reload
+
+    assert_not_equal @previous_name, @developer.name
+    assert_not_equal @previously_updated_at, @developer.updated_at
+  end
+
+  def test_saving_an_unchanged_record_with_a_non_mutating_before_update_callback_does_not_update_its_timestamp
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "developers"
+
+      include Developer::TimestampAliases
+
+      before_update :change_name
+
+      private
+        def change_name; end
+    end
+
+    @developer = klass.create!
+    @previously_updated_at = @developer.updated_at
+
+    travel(1.second) do
+      @developer.save!
+    end
+
+    @developer.reload
+
+    assert_equal @previously_updated_at, @developer.updated_at
+  end
+
   def test_saving_a_record_with_a_belongs_to_that_specifies_touching_the_parent_should_update_the_parent_updated_at
     pet   = Pet.first
     owner = pet.owner
@@ -437,7 +514,34 @@ class TimestampTest < ActiveRecord::TestCase
     assert_not_equal time, pet.updated_at
   end
 
-  def test_timestamp_column_values_are_present_in_the_callbacks
+  def test_timestamp_column_values_are_present_in_create_callbacks
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "people"
+
+      before_create do
+        self.born_at = created_at
+      end
+    end
+
+    person = klass.create first_name: "David"
+    assert_not_nil person.born_at
+  end
+
+  def test_timestamp_column_values_are_present_in_update_callbacks
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "people"
+
+      before_update do
+        self.born_at = created_at
+      end
+    end
+
+    person = klass.create first_name: "David"
+    person.update first_name: "John"
+    assert_not_nil person.born_at
+  end
+
+  def test_timestamp_column_values_are_present_in_save_callbacks
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = "people"
 
@@ -447,7 +551,7 @@ class TimestampTest < ActiveRecord::TestCase
     end
 
     person = klass.create first_name: "David"
-    assert_not_equal person.born_at, nil
+    assert_not_nil person.born_at
   end
 
   def test_timestamp_attributes_for_create_in_model
@@ -475,7 +579,7 @@ class TimestampsWithoutTransactionTest < ActiveRecord::TestCase
   end
 
   def test_do_not_write_timestamps_on_save_if_they_are_not_attributes
-    with_example_table ActiveRecord::Base.connection, "timestamp_attribute_posts", "id integer primary key" do
+    with_example_table ActiveRecord::Base.lease_connection, "timestamp_attribute_posts", "id integer primary key" do
       post = TimestampAttributePost.new(id: 1)
       post.save! # should not try to assign and persist created_at, updated_at
       assert_nil post.created_at
@@ -484,21 +588,25 @@ class TimestampsWithoutTransactionTest < ActiveRecord::TestCase
   end
 
   def test_index_is_created_for_both_timestamps
-    ActiveRecord::Base.connection.create_table(:foos, force: true) do |t|
+    ActiveRecord::Base.lease_connection.create_table(:foos, force: true) do |t|
       t.timestamps null: true, index: true
     end
 
-    indexes = ActiveRecord::Base.connection.indexes("foos")
+    indexes = ActiveRecord::Base.lease_connection.indexes("foos")
     assert_equal ["created_at", "updated_at"], indexes.flat_map(&:columns).sort
   ensure
-    ActiveRecord::Base.connection.drop_table(:foos)
+    ActiveRecord::Base.lease_connection.drop_table(:foos)
   end
 
   private
     def with_example_table(connection, table_name, definition = nil)
-      definitions ||= <<~SQL
+      definition = <<~SQL
         id INTEGER GENERATED BY DEFAULT AS IDENTITY (START WITH 1000) PRIMARY KEY NOT NULL
       SQL
-      super(connection, table_name, definitions)
+
+      connection.execute("CREATE TABLE #{table_name}(#{definition})")
+      yield
+    ensure
+      connection.drop_table(table_name, if_exists: true)
     end
 end

data/test/cases/token_for_test.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/matey"
+require "models/user"
+require "models/cpk"
+require "models/room"
+require "active_support/message_verifier"
+
+class TokenForTest < ActiveRecord::TestCase
+  class User < ::User
+    generates_token_for :lookup
+
+    generates_token_for :password_reset, expires_in: 15.minutes do
+      password_digest.to_s[-(31 + 22), 10] # first 10 characters of BCrypt salt
+    end
+
+    generates_token_for :snapshot do
+      { updated_at: updated_at }
+    end
+  end
+
+  setup do
+    @original_verifier = ActiveRecord::Base.generated_token_verifier
+    ActiveRecord::Base.generated_token_verifier = ActiveSupport::MessageVerifier.new("secret")
+
+    @user = User.create!(password_digest: "$2a$4$#{"x" * 22}#{"y" * 31}")
+    @lookup_token = @user.generate_token_for(:lookup)
+    @password_reset_token = @user.generate_token_for(:password_reset)
+  end
+
+  teardown do
+    ActiveRecord::Base.generated_token_verifier = @original_verifier
+  end
+
+  test "finds record by token" do
+    assert_equal @user, User.find_by_token_for(:lookup, @lookup_token)
+    assert_equal @user, User.find_by_token_for!(:lookup, @lookup_token)
+  end
+
+  test "returns nil when record is not found" do
+    @user.destroy
+    assert_nil User.find_by_token_for(:lookup, @lookup_token)
+  end
+
+  test "raises on bang when record is not found" do
+    @user.destroy
+    assert_raises(ActiveRecord::RecordNotFound) do
+      User.find_by_token_for!(:lookup, @lookup_token)
+    end
+  end
+
+  test "raises when token definition does not exist" do
+    assert_raises { User.find_by_token_for(:bad, @lookup_token) }
+  end
+
+  test "does not find record when token is invalid" do
+    assert_nil User.find_by_token_for(:lookup, "bad")
+    assert_raises(ActiveSupport::MessageVerifier::InvalidSignature) do
+      User.find_by_token_for!(:lookup, "bad")
+    end
+  end
+
+  test "does not find record when token is for a different purpose" do
+    assert_nil User.find_by_token_for(:password_reset, @lookup_token)
+    assert_raises(ActiveSupport::MessageVerifier::InvalidSignature) do
+      User.find_by_token_for!(:password_reset, @lookup_token)
+    end
+  end
+
+  test "finds record when token has not expired and embedded data has not changed" do
+    assert_equal @user, User.find_by_token_for(:password_reset, @password_reset_token)
+  end
+
+  test "does not find record when token has expired" do
+    travel 1.day
+    assert_nil User.find_by_token_for(:password_reset, @password_reset_token)
+    assert_raises(ActiveSupport::MessageVerifier::InvalidSignature) do
+      User.find_by_token_for!(:password_reset, @password_reset_token)
+    end
+  end
+
+  test "tokens do not expire by default" do
+    travel 1000.years
+    assert_equal @user, User.find_by_token_for(:lookup, @lookup_token)
+  end
+
+  test "does not find record when expires_in is different" do
+    User.generates_token_for :lookup, expires_in: 1.year
+
+    assert_nil User.find_by_token_for(:lookup, @lookup_token)
+    new_lookup_token = @user.generate_token_for(:lookup)
+    assert_equal @user, User.find_by_token_for(:lookup, new_lookup_token)
+  ensure
+    User.generates_token_for :lookup
+  end
+
+  test "does not find record when embedded data is different" do
+    @user.update!(password: "new password")
+    assert_nil User.find_by_token_for(:password_reset, @password_reset_token)
+    assert_raises(ActiveSupport::MessageVerifier::InvalidSignature) do
+      User.find_by_token_for!(:password_reset, @password_reset_token)
+    end
+  end
+
+  test "supports JSON-serializable embedded data" do
+    snapshot_token = @user.generate_token_for(:snapshot)
+    assert_equal @user, User.find_by_token_for(:snapshot, snapshot_token)
+    @user.touch(time: @user.updated_at.advance(seconds: 1))
+    assert_nil User.find_by_token_for(:snapshot, snapshot_token)
+  end
+
+  test "finds record through relation" do
+    assert_equal @user, User.where("1=1").find_by_token_for(:lookup, @lookup_token)
+    assert_nil User.where("1=0").find_by_token_for(:lookup, @lookup_token)
+  end
+
+  test "finds record through subclass" do
+    subclass = Class.new(User)
+    subclassed_user = subclass.find_by_token_for(:lookup, @lookup_token)
+
+    assert_instance_of subclass, subclassed_user
+    assert_equal @user.id, subclassed_user.id
+  end
+
+  test "subclasses can redefine tokens" do
+    subclass = Class.new(User) do
+      generates_token_for :lookup
+    end
+    subclassed_user = subclass.find(@user.id)
+    subclassed_lookup_token = subclassed_user.generate_token_for(:lookup)
+
+    assert_equal subclassed_user, subclass.find_by_token_for(:lookup, subclassed_lookup_token)
+    assert_nil subclass.find_by_token_for(:lookup, @lookup_token)
+    assert_nil User.find_by_token_for(:lookup, subclassed_lookup_token)
+  end
+
+  test "finds record with a custom primary key" do
+    custom_pk = Class.new(User) do
+      self.primary_key = "auth_token"
+    end
+    custom_pk_user = custom_pk.find(@user.auth_token)
+    custom_pk_lookup_token = custom_pk_user.generate_token_for(:lookup)
+
+    assert_equal custom_pk_user, custom_pk.find_by_token_for(:lookup, custom_pk_lookup_token)
+    assert_nil custom_pk.find_by_token_for(:lookup, @lookup_token)
+  end
+
+  test "finds record with a composite primary key" do
+    book = Cpk::Book.create!(id: [1, 3], shop_id: 2)
+    token = book.generate_token_for(:test)
+
+    assert_equal book, Cpk::Book.find_by_token_for(:test, token)
+  end
+
+  test "raises when no primary key has been declared" do
+    no_pk = Class.new(Matey) do
+      generates_token_for :parley
+    end
+
+    assert_raises(ActiveRecord::UnknownPrimaryKey) do
+      no_pk.find_by_token_for(:parley, "this token will not be checked")
+    end
+  end
+end

data/test/cases/touch_later_test.rb

@@ -6,9 +6,11 @@ require "models/line_item"
 require "models/topic"
 require "models/node"
 require "models/tree"
+require "models/owner"
+require "models/pet"
 
 class TouchLaterTest < ActiveRecord::TestCase
-  fixtures :nodes, :trees
+  fixtures :nodes, :trees, :owners, :pets
 
   def test_touch_later_raise_if_non_persisted
     invoice = Invoice.new
@@ -120,4 +122,44 @@ class TouchLaterTest < ActiveRecord::TestCase
     assert_not_equal nodes(:grandparent).reload.updated_at, previous_grandparent_updated_at
     assert_not_equal trees(:root).reload.updated_at, previous_tree_updated_at
   end
+
+  def test_touching_through_nested_attributes_without_before_committed_on_all_records
+    original = ActiveRecord.before_committed_on_all_records
+    ActiveRecord.before_committed_on_all_records = false
+
+    time = Time.now.utc - 25.days
+
+    owner = owners(:blackbeard)
+
+    owner.touch(time: time)
+
+    assert_equal time.to_i, owner.reload.updated_at.to_i
+
+    owner.update pets_attributes: { "0" => { id: "1", name: "Alfred" } }
+
+    # The second copy of the record is not touched, so the owner's updated_at
+    # remains the same.
+    assert_equal time.to_i, owner.reload.updated_at.to_i
+  ensure
+    ActiveRecord.before_committed_on_all_records = original
+  end
+
+  def test_touching_through_nested_attributes_with_before_committed_on_all_records
+    original = ActiveRecord.before_committed_on_all_records
+    ActiveRecord.before_committed_on_all_records = true
+
+    time = Time.now.utc - 25.days
+
+    owner = owners(:blackbeard)
+
+    owner.touch(time: time)
+
+    assert_equal time.to_i, owner.reload.updated_at.to_i
+
+    owner.update pets_attributes: { "0" => { id: "1", name: "Alfred" } }
+
+    assert_not_equal time.to_i, owner.reload.updated_at.to_i
+  ensure
+    ActiveRecord.before_committed_on_all_records = original
+  end
 end