ibm_db 5.6.1-arm64-darwin-24

data/test/cases/unsafe_raw_sql_test.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+require "models/comment"
+
+class UnsafeRawSqlTest < ActiveRecord::TestCase
+  fixtures :posts, :comments
+
+  test "order: allows string column name" do
+    ids_expected = Post.order(Arel.sql("title")).pluck(:id)
+
+    ids = Post.order("title").pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows symbol column name" do
+    ids_expected = Post.order(Arel.sql("title")).pluck(:id)
+
+    ids = Post.order(:title).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows downcase symbol direction" do
+    ids_expected = Post.order(Arel.sql("title") => Arel.sql("asc")).pluck(:id)
+
+    ids = Post.order(title: :asc).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows upcase symbol direction" do
+    ids_expected = Post.order(Arel.sql("title") => Arel.sql("ASC")).pluck(:id)
+
+    ids = Post.order(title: :ASC).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows string direction" do
+    ids_expected = Post.order(Arel.sql("title") => Arel.sql("asc")).pluck(:id)
+
+    ids = Post.order(title: "asc").pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows multiple columns" do
+    ids_expected = Post.order(Arel.sql("author_id"), Arel.sql("title")).pluck(:id)
+
+    ids = Post.order(:author_id, :title).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows mixed" do
+    ids_expected = Post.order(Arel.sql("author_id"), Arel.sql("title") => Arel.sql("asc")).pluck(:id)
+
+    ids = Post.order(:author_id, title: :asc).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows table and column names" do
+    ids_expected = Post.order(Arel.sql("title")).pluck(:id)
+
+    ids = Post.order("posts.title").pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows quoted table and column names" do
+    ids_expected = Post.order(Arel.sql("title")).pluck(:id)
+
+    quoted_title = Post.connection.quote_table_name("posts.title")
+    ids = Post.order(quoted_title).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows column name and direction in string" do
+    ids_expected = Post.order(Arel.sql("title desc")).pluck(:id)
+
+    ids = Post.order("title desc").pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows table name, column name and direction in string" do
+    ids_expected = Post.order(Arel.sql("title desc")).pluck(:id)
+
+    ids = Post.order("posts.title desc").pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows NULLS FIRST and NULLS LAST too" do
+    raise "precondition failed" if Post.count < 2
+
+    # Ensure there are NULL and non-NULL post types.
+    Post.first.update_column(:type, nil)
+    Post.last.update_column(:type, "Programming")
+
+    ["asc", "desc", ""].each do |direction|
+      %w(first last).each do |position|
+        ids_expected = Post.order(Arel.sql("type::text #{direction} nulls #{position}")).pluck(:id)
+
+        ids = Post.order("type::text #{direction} nulls #{position}").pluck(:id)
+
+        assert_equal ids_expected, ids
+      end
+    end
+  end if current_adapter?(:PostgreSQLAdapter)
+
+  test "order: disallows invalid column name" do
+    assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.order("REPLACE(title, 'misc', 'zzzz') asc").pluck(:id)
+    end
+  end
+
+  test "order: disallows invalid direction" do
+    assert_raises(ArgumentError) do
+      Post.order(title: :foo).pluck(:id)
+    end
+  end
+
+  test "order: disallows invalid column with direction" do
+    assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.order("REPLACE(title, 'misc', 'zzzz')" => :asc).pluck(:id)
+    end
+  end
+
+  test "order: always allows Arel" do
+    titles = Post.order(Arel.sql("length(title)")).pluck(:title)
+
+    assert_not_empty titles
+  end
+
+  test "order: allows Arel.sql with binds" do
+    ids_expected = Post.order(Arel.sql("REPLACE(title, 'misc', 'zzzz'), id")).pluck(:id)
+
+    ids = Post.order([Arel.sql("REPLACE(title, ?, ?), id"), "misc", "zzzz"]).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: disallows invalid bind statement" do
+    assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.order(["REPLACE(title, ?, ?), id", "misc", "zzzz"]).pluck(:id)
+    end
+  end
+
+  test "order: disallows invalid Array arguments" do
+    assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.order(["author_id", "REPLACE(title, 'misc', 'zzzz')"]).pluck(:id)
+    end
+  end
+
+  test "order: allows valid Array arguments" do
+    ids_expected = Post.order(Arel.sql("author_id, length(title)")).pluck(:id)
+
+    ids = Post.order(["author_id", "length(title)"]).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: logs deprecation warning for unrecognized column" do
+    e = assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.order("REPLACE(title, 'misc', 'zzzz')")
+    end
+
+    assert_match(/Query method called with non-attribute argument\(s\):/, e.message)
+  end
+
+  test "pluck: allows string column name" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    titles = Post.pluck("title")
+
+    assert_equal titles_expected, titles
+  end
+
+  test "pluck: allows string column name with function and alias" do
+    titles_expected = Post.pluck(Arel.sql("UPPER(title)"))
+
+    titles = Post.pluck("UPPER(title) AS title")
+
+    assert_equal titles_expected, titles
+  end
+
+  test "pluck: allows symbol column name" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    titles = Post.pluck(:title)
+
+    assert_equal titles_expected, titles
+  end
+
+  test "pluck: allows multiple column names" do
+    values_expected = Post.pluck(Arel.sql("title"), Arel.sql("id"))
+
+    values = Post.pluck(:title, :id)
+
+    assert_equal values_expected, values
+  end
+
+  test "pluck: allows column names with includes" do
+    values_expected = Post.includes(:comments).pluck(Arel.sql("title"), Arel.sql("id"))
+
+    values = Post.includes(:comments).pluck(:title, :id)
+
+    assert_equal values_expected, values
+  end
+
+  test "pluck: allows auto-generated attributes" do
+    values_expected = Post.pluck(Arel.sql("tags_count"))
+
+    values = Post.pluck(:tags_count)
+
+    assert_equal values_expected, values
+  end
+
+  test "pluck: allows table and column names" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    titles = Post.pluck("posts.title")
+
+    assert_equal titles_expected, titles
+  end
+
+  test "pluck: allows quoted table and column names" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    quoted_title = Post.connection.quote_table_name("posts.title")
+    titles = Post.pluck(quoted_title)
+
+    assert_equal titles_expected, titles
+  end
+
+  test "pluck: disallows invalid column name" do
+    assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.pluck("REPLACE(title, 'misc', 'zzzz')")
+    end
+  end
+
+  test "pluck: disallows invalid column name amongst valid names" do
+    assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.pluck(:title, "REPLACE(title, 'misc', 'zzzz')")
+    end
+  end
+
+  test "pluck: disallows invalid column names with includes" do
+    assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.includes(:comments).pluck(:title, "REPLACE(title, 'misc', 'zzzz')")
+    end
+  end
+
+  test "pluck: always allows Arel" do
+    excepted_values = Post.includes(:comments).pluck(:title).map { |title| [title, title.size] }
+    values = Post.includes(:comments).pluck(:title, Arel.sql("length(title)"))
+
+    assert_equal excepted_values, values
+  end
+
+  test "pluck: logs deprecation warning" do
+    e = assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.includes(:comments).pluck(:title, "REPLACE(title, 'misc', 'zzzz')")
+    end
+
+    assert_match(/Query method called with non-attribute argument\(s\):/, e.message)
+  end
+end

data/test/cases/validations/absence_validation_test.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/face"
+require "models/interest"
+require "models/human"
+require "models/topic"
+
+class AbsenceValidationTest < ActiveRecord::TestCase
+  def test_non_association
+    boy_klass = Class.new(Human) do
+      def self.name; "Boy" end
+      validates_absence_of :name
+    end
+
+    assert_predicate boy_klass.new, :valid?
+    assert_not_predicate boy_klass.new(name: "Alex"), :valid?
+  end
+
+  def test_has_one_marked_for_destruction
+    boy_klass = Class.new(Human) do
+      def self.name; "Boy" end
+      validates_absence_of :face
+    end
+
+    boy = boy_klass.new(face: Face.new)
+    assert_not boy.valid?, "should not be valid if has_one association is present"
+    assert_equal 1, boy.errors[:face].size, "should only add one error"
+
+    boy.face.mark_for_destruction
+    assert boy.valid?, "should be valid if association is marked for destruction"
+  end
+
+  def test_has_many_marked_for_destruction
+    boy_klass = Class.new(Human) do
+      def self.name; "Boy" end
+      validates_absence_of :interests
+    end
+    boy = boy_klass.new
+    boy.interests << [i1 = Interest.new, i2 = Interest.new]
+    assert_not boy.valid?, "should not be valid if has_many association is present"
+
+    i1.mark_for_destruction
+    assert_not boy.valid?, "should not be valid if has_many association is present"
+
+    i2.mark_for_destruction
+    assert_predicate boy, :valid?
+  end
+
+  def test_does_not_call_to_a_on_associations
+    boy_klass = Class.new(Human) do
+      def self.name; "Boy" end
+      validates_absence_of :face
+    end
+
+    face_with_to_a = Face.new
+    def face_with_to_a.to_a; ["(/)", '(\)']; end
+
+    assert_nothing_raised { boy_klass.new(face: face_with_to_a).valid? }
+  end
+
+  def test_validates_absence_of_virtual_attribute_on_model
+    repair_validations(Interest) do
+      Interest.attr_accessor(:token)
+      Interest.validates_absence_of(:token)
+
+      interest = Interest.create!(topic: "Thought Leadering")
+      assert_predicate interest, :valid?
+
+      interest.token = "tl"
+
+      assert_predicate interest, :invalid?
+    end
+  end
+end

data/test/cases/validations/association_validation_test.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/topic"
+require "models/reply"
+require "models/human"
+require "models/interest"
+
+class AssociationValidationTest < ActiveRecord::TestCase
+  fixtures :topics
+
+  repair_validations(Topic, Reply)
+
+  def test_validates_associated_many
+    Topic.validates_associated(:replies)
+    Reply.validates_presence_of(:content)
+    t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
+    t.replies << [r = Reply.new("title" => "A reply"), r2 = Reply.new("title" => "Another reply", "content" => "non-empty"), r3 = Reply.new("title" => "Yet another reply"), r4 = Reply.new("title" => "The last reply", "content" => "non-empty")]
+    assert_not_predicate t, :valid?
+    assert_predicate t.errors[:replies], :any?
+    assert_equal 1, r.errors.count  # make sure all associated objects have been validated
+    assert_equal 0, r2.errors.count
+    assert_equal 1, r3.errors.count
+    assert_equal 0, r4.errors.count
+    r.content = r3.content = "non-empty"
+    assert_predicate t, :valid?
+  end
+
+  def test_validates_associated_one
+    Reply.validates :topic, associated: true
+    Topic.validates_presence_of(:content)
+    r = Reply.new("title" => "A reply", "content" => "with content!")
+    r.topic = Topic.create("title" => "uhohuhoh")
+    assert_not_predicate r, :valid?
+    assert_predicate r.errors[:topic], :any?
+    r.topic.content = "non-empty"
+    assert_predicate r, :valid?
+  end
+
+  def test_validates_associated_marked_for_destruction
+    Topic.validates_associated(:replies)
+    Reply.validates_presence_of(:content)
+    t = Topic.new
+    t.replies << Reply.new
+    assert_predicate t, :invalid?
+    t.replies.first.mark_for_destruction
+    assert_predicate t, :valid?
+  end
+
+  def test_validates_associated_without_marked_for_destruction
+    reply = Class.new do
+      def valid?
+        true
+      end
+    end
+    Topic.validates_associated(:replies)
+    t = Topic.new
+    t.define_singleton_method(:replies) { [reply.new] }
+    assert_predicate t, :valid?
+  end
+
+  def test_validates_associated_with_custom_message_using_quotes
+    Reply.validates_associated :topic, message: "This string contains 'single' and \"double\" quotes"
+    Topic.validates_presence_of :content
+    r = Reply.create("title" => "A reply", "content" => "with content!")
+    r.topic = Topic.create("title" => "uhohuhoh")
+    assert_not_operator r, :valid?
+    assert_equal ["This string contains 'single' and \"double\" quotes"], r.errors[:topic]
+  end
+
+  def test_validates_associated_missing
+    Reply.validates_presence_of(:topic)
+    r = Reply.create("title" => "A reply", "content" => "with content!")
+    assert_not_predicate r, :valid?
+    assert_predicate r.errors[:topic], :any?
+
+    r.topic = Topic.first
+    assert_predicate r, :valid?
+  end
+
+  def test_validates_presence_of_belongs_to_association__parent_is_new_record
+    repair_validations(Interest) do
+      # Note that Interest and Human have the :inverse_of option set
+      Interest.validates_presence_of(:human)
+      human = Human.new(name: "John")
+      interest = human.interests.build(topic: "Airplanes")
+      assert interest.valid?, "Expected interest to be valid, but was not. Interest should have a human object associated"
+    end
+  end
+
+  def test_validates_presence_of_belongs_to_association__existing_parent
+    repair_validations(Interest) do
+      Interest.validates_presence_of(:human)
+      human = Human.create!(name: "John")
+      interest = human.interests.build(topic: "Airplanes")
+      assert interest.valid?, "Expected interest to be valid, but was not. Interest should have a human object associated"
+    end
+  end
+end

data/test/cases/validations/i18n_generate_message_validation_test.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/topic"
+
+class I18nGenerateMessageValidationTest < ActiveRecord::TestCase
+  class Backend < I18n::Backend::Simple
+    include I18n::Backend::Fallbacks
+  end
+
+  def setup
+    Topic.clear_validators!
+    @topic = Topic.new
+    I18n.backend = Backend.new
+  end
+
+  def reset_i18n_load_path
+    @old_load_path, @old_backend = I18n.load_path.dup, I18n.backend
+    I18n.load_path.clear
+    I18n.backend = Backend.new
+    yield
+  ensure
+    I18n.load_path.replace @old_load_path
+    I18n.backend = @old_backend
+  end
+
+  # validates_associated: generate_message(attr_name, :invalid, :message => custom_message, :value => value)
+  def test_generate_message_invalid_with_default_message
+    assert_equal "is invalid", @topic.errors.generate_message(:title, :invalid, value: "title")
+  end
+
+  def test_generate_message_invalid_with_custom_message
+    assert_equal "custom message title", @topic.errors.generate_message(:title, :invalid, message: "custom message %{value}", value: "title")
+  end
+
+  # validates_uniqueness_of: generate_message(attr_name, :taken, :message => custom_message)
+  def test_generate_message_taken_with_default_message
+    assert_equal "has already been taken", @topic.errors.generate_message(:title, :taken, value: "title")
+  end
+
+  def test_generate_message_taken_with_custom_message
+    assert_equal "custom message title", @topic.errors.generate_message(:title, :taken, message: "custom message %{value}", value: "title")
+  end
+
+  # ActiveRecord#RecordInvalid exception
+
+  test "RecordInvalid exception can be localized" do
+    topic = Topic.new
+    topic.errors.add(:title, :invalid)
+    topic.errors.add(:title, :blank)
+    assert_equal "Validation failed: Title is invalid, Title can't be blank", ActiveRecord::RecordInvalid.new(topic).message
+  end
+
+  test "RecordInvalid exception translation falls back to the :errors namespace" do
+    reset_i18n_load_path do
+      I18n.backend.store_translations "en", errors: { messages: { record_invalid: "fallback message" } }
+      topic = Topic.new
+      topic.errors.add(:title, :blank)
+      assert_equal "fallback message", ActiveRecord::RecordInvalid.new(topic).message
+    end
+  end
+
+  test "translation for 'taken' can be overridden" do
+    reset_i18n_load_path do
+      I18n.backend.store_translations "en", errors: { attributes: { title: { taken: "Custom taken message" } } }
+      assert_equal "Custom taken message", @topic.errors.generate_message(:title, :taken, value: "title")
+    end
+  end
+
+  test "translation for 'taken' can be overridden in activerecord scope" do
+    reset_i18n_load_path do
+      I18n.backend.store_translations "en", activerecord: { errors: { messages: { taken: "Custom taken message" } } }
+      assert_equal "Custom taken message", @topic.errors.generate_message(:title, :taken, value: "title")
+    end
+  end
+
+  test "translation for 'taken' can be overridden in activerecord model scope" do
+    reset_i18n_load_path do
+      I18n.backend.store_translations "en", activerecord: { errors: { models: { topic: { taken: "Custom taken message" } } } }
+      assert_equal "Custom taken message", @topic.errors.generate_message(:title, :taken, value: "title")
+    end
+  end
+
+  test "translation for 'taken' can be overridden in activerecord attributes scope" do
+    reset_i18n_load_path do
+      I18n.backend.store_translations "en", activerecord: { errors: { models: { topic: { attributes: { title: { taken: "Custom taken message" } } } } } }
+      assert_equal "Custom taken message", @topic.errors.generate_message(:title, :taken, value: "title")
+    end
+  end
+
+  test "activerecord attributes scope falls back to parent locale before it falls back to the :errors namespace" do
+    reset_i18n_load_path do
+      I18n.backend.store_translations "en", activerecord: { errors: { models: { topic: { attributes: { title: { taken: "custom en message" } } } } } }
+      I18n.backend.store_translations "en-US", errors: { messages: { taken: "generic en-US fallback" } }
+
+      I18n.with_locale "en-US" do
+        assert_equal "custom en message", @topic.errors.generate_message(:title, :taken, value: "title")
+        assert_equal "generic en-US fallback", @topic.errors.generate_message(:heading, :taken, value: "heading")
+      end
+    end
+  end
+end

data/test/cases/validations/i18n_validation_test.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/topic"
+require "models/reply"
+
+class I18nValidationTest < ActiveRecord::TestCase
+  repair_validations(Topic, Reply)
+
+  def setup
+    repair_validations(Topic, Reply)
+    Reply.validates_presence_of(:title)
+    @topic = Topic.new
+    @old_load_path, @old_backend = I18n.load_path.dup, I18n.backend
+    I18n.load_path.clear
+    I18n.backend = I18n::Backend::Simple.new
+    I18n.backend.store_translations("en", errors: { messages: { custom: nil } })
+  end
+
+  teardown do
+    I18n.load_path.replace @old_load_path
+    I18n.backend = @old_backend
+  end
+
+  def unique_topic
+    @unique ||= Topic.create title: "unique!"
+  end
+
+  def replied_topic
+    @replied_topic ||= begin
+      topic = Topic.create(title: "topic")
+      topic.replies << Reply.new
+      topic
+    end
+  end
+
+  # A set of common cases for ActiveModel::Validations message generation that
+  # are used to generate tests to keep things DRY
+  #
+  COMMON_CASES = [
+    # [ case,                              validation_options,            generate_message_options]
+    [ "given no options",                  {},                            {}],
+    [ "given custom message",              { message: "custom" },         { message: "custom" }],
+    [ "given if condition",                { if: lambda { true } },       {}],
+    [ "given unless condition",            { unless: lambda { false } },  {}],
+    [ "given option that is not reserved", { format: "jpg" },             { format: "jpg" }],
+    [ "given on condition",                { on: [:create, :update] },    {}]
+  ]
+
+  COMMON_CASES.each do |name, validation_options, generate_message_options|
+    test "validates_uniqueness_of on generated message #{name}" do
+      Topic.validates_uniqueness_of :title, validation_options
+      @topic.title = unique_topic.title
+      assert_called_with(ActiveModel::Error, :generate_message, [:title, :taken, @topic, generate_message_options.merge(value: "unique!")]) do
+        @topic.valid?
+        @topic.errors.messages
+      end
+    end
+  end
+
+  COMMON_CASES.each do |name, validation_options, generate_message_options|
+    test "validates_associated on generated message #{name}" do
+      Topic.validates_associated :replies, validation_options
+      assert_called_with(ActiveModel::Error, :generate_message, [:replies, :invalid, replied_topic, generate_message_options.merge(value: replied_topic.replies)]) do
+        replied_topic.save
+        replied_topic.errors.messages
+      end
+    end
+  end
+
+  def test_validates_associated_finds_custom_model_key_translation
+    I18n.backend.store_translations "en", activerecord: { errors: { models: { topic: { attributes: { replies: { invalid: "custom message" } } } } } }
+    I18n.backend.store_translations "en", activerecord: { errors: { messages: { invalid: "global message" } } }
+
+    Topic.validates_associated :replies
+    replied_topic.valid?
+    assert_equal ["custom message"], replied_topic.errors[:replies].uniq
+  end
+
+  def test_validates_associated_finds_global_default_translation
+    I18n.backend.store_translations "en", activerecord: { errors: { messages: { invalid: "global message" } } }
+
+    Topic.validates_associated :replies
+    replied_topic.valid?
+    assert_equal ["global message"], replied_topic.errors[:replies]
+  end
+end