ibm_db 5.6.1 → 5.7.0

data/test/cases/reflection_test.rb

@@ -3,6 +3,7 @@
 require "cases/helper"
 require "models/topic"
 require "models/customer"
+require "models/comment"
 require "models/company"
 require "models/company_in_module"
 require "models/ship"
@@ -26,6 +27,12 @@ require "models/department"
 require "models/cake_designer"
 require "models/drink_designer"
 require "models/recipe"
+require "models/user_with_invalid_relation"
+require "models/hardback"
+require "models/sharded/comment"
+require "models/admin"
+require "models/admin/user"
+require "models/user"
 
 class ReflectionTest < ActiveRecord::TestCase
   include ActiveRecord::Reflection
@@ -43,25 +50,25 @@ class ReflectionTest < ActiveRecord::TestCase
 
   def test_read_attribute_names
     assert_equal(
-      %w( id title author_name author_email_address bonus_time written_on last_read content important group approved replies_count unique_replies_count parent_id parent_title type created_at updated_at ).sort,
+      %w( id title author_name author_email_address bonus_time written_on last_read content important binary_content group approved replies_count unique_replies_count parent_id parent_title type created_at updated_at ).sort,
       @first.attribute_names.sort
     )
   end
 
   def test_columns
-    assert_equal 18, Topic.columns.length
+    assert_equal 19, Topic.columns.length
   end
 
   def test_columns_are_returned_in_the_order_they_were_declared
     column_names = Topic.columns.map(&:name)
-    assert_equal %w(id title author_name author_email_address written_on bonus_time last_read content important approved replies_count unique_replies_count parent_id parent_title type group created_at updated_at), column_names
+    assert_equal %w(id title author_name author_email_address written_on bonus_time last_read content important binary_content approved replies_count unique_replies_count parent_id parent_title type group created_at updated_at), column_names
   end
 
   def test_content_columns
     content_columns        = Topic.content_columns
     content_column_names   = content_columns.map(&:name)
-    assert_equal 13, content_columns.length
-    assert_equal %w(title author_name author_email_address written_on bonus_time last_read content important group approved parent_title created_at updated_at).sort, content_column_names.sort
+    assert_equal 14, content_columns.length
+    assert_equal %w(title author_name author_email_address written_on bonus_time last_read content important binary_content group approved parent_title created_at updated_at).sort, content_column_names.sort
   end
 
   def test_column_string_type_and_limit
@@ -137,6 +144,82 @@ class ReflectionTest < ActiveRecord::TestCase
     assert_equal "PluralIrregular", reflection.class_name
   end
 
+  def test_reflection_klass_not_found_with_no_class_name_option
+    error = assert_raise(NameError) do
+      UserWithInvalidRelation.reflect_on_association(:not_a_class).klass
+    end
+
+    assert_equal "NotAClass", error.name
+    assert_match %r/missing/i, error.message
+    assert_match "NotAClass", error.message
+    assert_match "UserWithInvalidRelation#not_a_class", error.message
+    assert_match ":class_name", error.message
+  end
+
+  def test_reflection_klass_not_found_with_pointer_to_non_existent_class_name
+    error = assert_raise(NameError) do
+      UserWithInvalidRelation.reflect_on_association(:class_name_provided_not_a_class).klass
+    end
+
+    assert_equal "NotAClass", error.name
+    assert_match %r/missing/i, error.message
+    assert_match %r/\bNotAClass\b/, error.message
+    assert_match "UserWithInvalidRelation#class_name_provided_not_a_class", error.message
+    assert_no_match ":class_name", error.message
+  end
+
+  def test_reflection_klass_requires_ar_subclass
+    [ :account_invalid,          # has_one, without :class_name
+      :account_class_name,       # has_one, with :class_name
+      :info_invalids,            # has_many through, without :class_name
+      :infos_class_name,         # has_many through, with :class_name
+      :infos_through_class_name, # has_many through other :class_name, with :class_name
+    ].each do |rel|
+      error = assert_raise(ArgumentError) do
+        UserWithInvalidRelation.reflect_on_association(rel).klass
+      end
+
+      assert_match "not an ActiveRecord::Base subclass", error.message
+      assert_match "UserWithInvalidRelation##{rel}", error.message
+    end
+  end
+
+  def test_reflection_klass_with_same_demodularized_name
+    reflection = ActiveRecord::Reflection.create(
+      :has_one,
+      :user,
+      nil,
+      {},
+      Admin::User
+    )
+
+    assert_equal User, reflection.klass
+  end
+
+  def test_reflection_klass_with_same_demodularized_different_modularized_name
+    reflection = ActiveRecord::Reflection.create(
+      :has_one,
+      :user,
+      nil,
+      { class_name: "Nested::User" },
+      Admin::User
+    )
+
+    assert_equal Nested::User, reflection.klass
+  end
+
+  def test_reflection_klass_with_same_modularized_name
+    reflection = ActiveRecord::Reflection.create(
+      :has_many,
+      :nested_users,
+      nil,
+      {},
+      Nested::NestedUser
+    )
+
+    assert_equal Nested::NestedUser, reflection.klass
+  end
+
   def test_aggregation_reflection
     reflection_for_address = AggregateReflection.new(
       :address, nil, { mapping: [ %w(address_street street), %w(address_city city), %w(address_country country) ] }, Customer
@@ -246,7 +329,7 @@ class ReflectionTest < ActiveRecord::TestCase
   end
 
   def test_reflections_should_return_keys_as_strings
-    assert Category.reflections.keys.all? { |key| key.is_a? String }, "Model.reflections is expected to return string for keys"
+    assert Category.reflections.keys.all?(String), "Model.reflections is expected to return string for keys"
   end
 
   def test_has_and_belongs_to_many_reflection
@@ -283,7 +366,7 @@ class ReflectionTest < ActiveRecord::TestCase
     assert_equal 2, hotel.chefs.count
   end
 
-  def test_scope_chain_does_not_interfere_with_hmt_with_polymorphic_case_and_sti
+  def test_scope_chain_does_not_interfere_with_hmt_with_polymorphic_case_and_subclass_source
     hotel = Hotel.create!
     hotel.mocktail_designers << MocktailDesigner.create!
 
@@ -300,6 +383,20 @@ class ReflectionTest < ActiveRecord::TestCase
     assert_equal 0, hotel.chef_lists.count
   end
 
+  def test_scope_chain_does_not_interfere_with_hmt_with_polymorphic_and_subclass_source_2
+    author = Author.create!(name: "John Doe")
+    hardback = BestHardback.create!
+    author.best_hardbacks << hardback
+
+    assert_equal [hardback], author.best_hardbacks
+    assert_equal [hardback], author.reload.best_hardbacks
+
+    author.best_hardbacks = []
+
+    assert_empty author.best_hardbacks
+    assert_empty author.reload.best_hardbacks
+  end
+
   def test_scope_chain_of_polymorphic_association_does_not_leak_into_other_hmt_associations
     hotel = Hotel.create!
     department = hotel.departments.create!
@@ -405,6 +502,11 @@ class ReflectionTest < ActiveRecord::TestCase
   def test_foreign_key
     assert_equal "author_id", Author.reflect_on_association(:posts).foreign_key.to_s
     assert_equal "category_id", Post.reflect_on_association(:categorizations).foreign_key.to_s
+    assert_equal "comment_id", FirstPost.reflect_on_association(:comment_with_inverse).foreign_key.to_s
+  end
+
+  def test_foreign_key_is_inferred_from_model_name
+    assert_equal "post_id", PostRecord.reflect_on_association(:comments).foreign_key.to_s
   end
 
   def test_symbol_for_class_name
@@ -418,6 +520,13 @@ class ReflectionTest < ActiveRecord::TestCase
     assert_equal "A class was passed to `:class_name` but we are expecting a string.", error.message
   end
 
+  def test_class_for_source_type
+    error = assert_raises(ArgumentError) do
+      ActiveRecord::Reflection.create(:has_many, :tagged_posts, nil, { through: :taggings, source: :taggable, source_type: Post }, Tag)
+    end
+    assert_equal "A class was passed to `:source_type` but we are expecting a string.", error.message
+  end
+
   def test_join_table
     category = Struct.new(:table_name, :pluralize_table_names).new("categories", true)
     product = Struct.new(:table_name, :pluralize_table_names).new("products", true)
@@ -500,13 +609,102 @@ class ReflectionTest < ActiveRecord::TestCase
 
   def test_reflect_on_association_accepts_symbols
     assert_nothing_raised do
-      assert_equal Hotel.reflect_on_association(:departments).name, :departments
+      assert_equal :departments, Hotel.reflect_on_association(:departments).name
     end
   end
 
   def test_reflect_on_association_accepts_strings
     assert_nothing_raised do
-      assert_equal Hotel.reflect_on_association("departments").name, :departments
+      assert_equal :departments, Hotel.reflect_on_association("departments").name
+    end
+  end
+
+  def test_reflect_on_missing_source_assocation
+    assert_nothing_raised do
+      assert_nil Hotel.reflect_on_association(:lost_items).source_reflection
+    end
+  end
+
+  def test_reflect_on_missing_source_assocation_raise_exception
+    assert_raises(ActiveRecord::HasManyThroughSourceAssociationNotFoundError) do
+      Hotel.reflect_on_association(:lost_items).check_validity!
+    end
+  end
+
+  def test_name_error_from_incidental_code_is_not_converted_to_name_error_for_association
+    UserWithInvalidRelation.stub(:const_missing, proc { oops }) do
+      reflection = UserWithInvalidRelation.reflect_on_association(:not_a_class)
+
+      error = assert_raises(NameError) do
+        reflection.klass
+      end
+
+      assert_equal :oops, error.name
+      assert_match "oops", error.message
+      assert_no_match "NotAClass", error.message
+      assert_no_match "not_a_class", error.message
+    end
+  end
+
+  def test_automatic_inverse_suppresses_name_error_for_association
+    reflection = UserWithInvalidRelation.reflect_on_association(:not_a_class)
+    assert_not reflection.dup.has_inverse? # dup to prevent global memoization
+  end
+
+  def test_automatic_inverse_does_not_suppress_name_error_from_incidental_code
+    UserWithInvalidRelation.stub(:const_missing, proc { oops }) do
+      reflection = UserWithInvalidRelation.reflect_on_association(:not_a_class)
+
+      error = assert_raises(NameError) do
+        reflection.dup.has_inverse? # dup to prevent global memoization
+      end
+
+      assert_equal :oops, error.name
+      assert_match "oops", error.message
+      assert_no_match "NotAClass", error.message
+      assert_no_match "not_a_class", error.message
+    end
+  end
+
+  def test_association_primary_key_uses_explicit_primary_key_option_as_first_priority
+    actual = Sharded::Comment.reflect_on_association(:blog_post_by_id).association_primary_key
+    assert_equal "id", actual
+  end
+
+  def test_belongs_to_reflection_with_query_constraints_infers_correct_foreign_key
+    blog_foreign_key = Sharded::Comment.reflect_on_association(:blog).foreign_key
+    blog_post_foreign_key = Sharded::Comment.reflect_on_association(:blog_post).foreign_key
+
+    assert_equal "blog_id", blog_foreign_key
+    assert_equal ["blog_id", "blog_post_id"], blog_post_foreign_key
+  end
+
+  def test_using_query_constraints_warns_about_changing_behavior
+    has_many_expected_message = <<~MSG.squish
+      Setting `query_constraints:` option on `Firm.has_many :clients` is not allowed.
+      To get the same behavior, use the `foreign_key` option instead.
+    MSG
+
+    assert_raises(ActiveRecord::ConfigurationError, match: has_many_expected_message) do
+      ActiveRecord::Reflection.create(:has_many, :clients, nil, { query_constraints: [:firm_id, :firm_name] }, Firm)
+    end
+
+    has_one_expected_message = <<~MSG.squish
+      Setting `query_constraints:` option on `Firm.has_one :account` is not allowed.
+      To get the same behavior, use the `foreign_key` option instead.
+    MSG
+
+    assert_raises(ActiveRecord::ConfigurationError, match: has_one_expected_message) do
+      ActiveRecord::Reflection.create(:has_one, :account, nil, { query_constraints: [:firm_id, :firm_name] }, Firm)
+    end
+
+    belongs_to_expected_message = <<~MSG.squish
+      Setting `query_constraints:` option on `Firm.belongs_to :client` is not allowed.
+      To get the same behavior, use the `foreign_key` option instead.
+    MSG
+
+    assert_raises(ActiveRecord::ConfigurationError, match: belongs_to_expected_message) do
+      ActiveRecord::Reflection.create(:belongs_to, :client, nil, { query_constraints: [:firm_id, :firm_name] }, Firm)
     end
   end
 

data/test/cases/relation/and_test.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/author"
+
+module ActiveRecord
+  class AndTest < ActiveRecord::TestCase
+    fixtures :authors, :author_addresses
+
+    def test_and
+      david, mary, bob = authors(:david, :mary, :bob)
+
+      david_and_mary = Author.where(id: [david, mary]).order(:id)
+      mary_and_bob   = Author.where(id: [mary, bob]).order(:id)
+
+      assert_equal [mary], david_and_mary.and(mary_and_bob)
+    end
+
+    def test_and_with_non_relation_attribute
+      hash = { "id" => 123 }
+      error = assert_raises(ArgumentError) do
+        Author.and(hash)
+      end
+
+      assert_equal(
+        "You have passed Hash object to #and. Pass an ActiveRecord::Relation object instead.",
+        error.message
+      )
+    end
+
+    def test_and_with_structurally_incompatible_scope
+      posts_scope = Author.unscope(:order).limit(10).offset(10).select(:id).order(:id)
+      error = assert_raises(ArgumentError) do
+        Author.limit(10).select(:id).order(:name).and(posts_scope)
+      end
+
+      assert_equal(
+        "Relation passed to #and must be structurally compatible. Incompatible values: [:order, :offset]",
+        error.message
+      )
+    end
+  end
+end

data/test/cases/relation/delegation_test.rb

@@ -3,7 +3,8 @@
 require "cases/helper"
 require "models/post"
 require "models/comment"
-require "active_support/core_ext/symbol/starts_ends_with"
+require "models/project"
+require "models/developer"
 
 module ActiveRecord
   module DelegationTests
@@ -14,7 +15,8 @@ module ActiveRecord
       :map, :none?, :one?, :partition, :reject, :reverse, :rotate,
       :sample, :second, :sort, :sort_by, :slice, :third, :index, :rindex,
       :to_ary, :to_set, :to_xml, :to_yaml, :join,
-      :in_groups, :in_groups_of, :to_sentence, :to_formatted_s, :as_json
+      :in_groups, :in_groups_of, :to_sentence, :to_formatted_s, :to_fs, :as_json,
+      :intersect?
     ]
 
     ARRAY_DELEGATES.each do |method|
@@ -44,6 +46,14 @@ module ActiveRecord
     end
   end
 
+  class DelegationRecordsTest < ActiveRecord::TestCase
+    include DelegationTests
+
+    def target
+      Comment.all.records
+    end
+  end
+
   class QueryingMethodsDelegationTest < ActiveRecord::TestCase
     QUERYING_METHODS =
       ActiveRecord::Batches.public_instance_methods(false) +
@@ -51,13 +61,14 @@ module ActiveRecord
       ActiveRecord::FinderMethods.public_instance_methods(false) - [:include?, :member?, :raise_record_not_found_exception!] +
       ActiveRecord::SpawnMethods.public_instance_methods(false) - [:spawn, :merge!] +
       ActiveRecord::QueryMethods.public_instance_methods(false).reject { |method|
-        method.end_with?("=", "!", "value", "values", "clause")
-      } - [:reverse_order, :arel, :extensions, :construct_join_dependency] + [
+        method.end_with?("=", "!", "?", "value", "values", "clause")
+      } - [:all, :reverse_order, :arel, :extensions, :construct_join_dependency] + [
         :any?, :many?, :none?, :one?,
         :first_or_create, :first_or_create!, :first_or_initialize,
         :find_or_create_by, :find_or_create_by!, :find_or_initialize_by,
         :create_or_find_by, :create_or_find_by!,
-        :destroy_all, :delete_all, :update_all, :touch_all, :delete_by, :destroy_by
+        :destroy, :destroy_all, :delete, :delete_all, :update_all, :touch_all, :delete_by, :destroy_by,
+        :insert, :insert_all, :insert!, :insert_all!, :upsert, :upsert_all,
       ]
 
     def test_delegate_querying_methods
@@ -73,4 +84,20 @@ module ActiveRecord
       end
     end
   end
+
+  class DelegationCachingTest < ActiveRecord::TestCase
+    fixtures :projects, :developers
+
+    test "delegation doesn't override methods defined in other relation subclasses" do
+      # precondition, some methods are available on ActiveRecord::Relation subclasses
+      # but not ActiveRecord::Relation itself. Here `target` is just an example.
+      assert_equal false, ActiveRecord::Relation.method_defined?(:target)
+      assert_equal true, ActiveRecord::Associations::CollectionProxy.method_defined?(:target)
+
+      project = projects(:active_record)
+      original_owner = project.developers_with_callbacks.method(:target).owner
+      assert_equal :__target__, Developer.all.target
+      assert_equal original_owner, project.developers_with_callbacks.method(:target).owner
+    end
+  end
 end

data/test/cases/relation/delete_all_test.rb

@@ -5,9 +5,11 @@ require "models/author"
 require "models/post"
 require "models/pet"
 require "models/toy"
+require "models/comment"
+require "models/cpk"
 
 class DeleteAllTest < ActiveRecord::TestCase
-  fixtures :authors, :author_addresses, :posts, :pets, :toys
+  fixtures :authors, :author_addresses, :comments, :posts, :pets, :toys, :cpk_orders, :cpk_order_agreements
 
   def test_destroy_all
     davids = Author.where(name: "David")
@@ -53,10 +55,23 @@ class DeleteAllTest < ActiveRecord::TestCase
     assert_predicate davids, :loaded?
   end
 
+  def test_delete_all_with_group_by_and_having
+    minimum_comments_count = 2
+    posts_to_be_deleted = Post.most_commented(minimum_comments_count).all.to_a
+    assert_operator posts_to_be_deleted.length, :>, 0
+
+    assert_difference("Post.count", -posts_to_be_deleted.length) do
+      Post.most_commented(minimum_comments_count).delete_all
+    end
+
+    posts_to_be_deleted.each do |deleted_post|
+      assert_raise(ActiveRecord::RecordNotFound) { deleted_post.reload }
+    end
+  end
+
   def test_delete_all_with_unpermitted_relation_raises_error
     assert_raises(ActiveRecord::ActiveRecordError) { Author.distinct.delete_all }
-    assert_raises(ActiveRecord::ActiveRecordError) { Author.group(:name).delete_all }
-    assert_raises(ActiveRecord::ActiveRecordError) { Author.having("SUM(id) < 3").delete_all }
+    assert_raises(ActiveRecord::ActiveRecordError) { Author.with(limited: Author.limit(2)).delete_all }
   end
 
   def test_delete_all_with_joins_and_where_part_is_hash
@@ -67,10 +82,10 @@ class DeleteAllTest < ActiveRecord::TestCase
       assert_equal pets.count, pets.delete_all
     end
 
-    if current_adapter?(:Mysql2Adapter)
-      assert_no_match %r/SELECT DISTINCT #{Regexp.escape(Pet.connection.quote_table_name("pets.pet_id"))}/, sqls.last
+    if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+      assert_no_match %r/SELECT DISTINCT #{Regexp.escape(quote_table_name("pets.pet_id"))}/, sqls.last
     else
-      assert_match %r/SELECT #{Regexp.escape(Pet.connection.quote_table_name("pets.pet_id"))}/, sqls.last
+      assert_match %r/SELECT #{Regexp.escape(quote_table_name("pets.pet_id"))}/, sqls.last
     end
   end
 
@@ -114,4 +129,10 @@ class DeleteAllTest < ActiveRecord::TestCase
     assert_raise(ActiveRecord::RecordNotFound) { posts(:thinking) }
     assert posts(:welcome)
   end
+
+  def test_delete_all_composite_model_with_join_subquery
+    agreement = cpk_order_agreements(:order_agreement_three)
+    join_scope = Cpk::Order.joins(:order_agreements).where(order_agreements: { signature: agreement.signature })
+    assert_equal 1, join_scope.delete_all
+  end
 end

data/test/cases/relation/field_ordered_values_test.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/author"
+require "models/post"
+require "models/book"
+
+class FieldOrderedValuesTest < ActiveRecord::TestCase
+  fixtures :posts
+
+  def test_in_order_of
+    order = [3, 4, 1]
+    posts = Post.in_order_of(:id, order)
+
+    assert_equal(order, posts.map(&:id))
+  end
+
+  def test_in_order_of_empty
+    posts = Post.in_order_of(:id, [])
+
+    assert_empty(posts)
+  end
+
+  def test_in_order_of_with_enums_values
+    skip "DB2 unique index semantics treat multiple NULL values as duplicates for books fixtures" if current_adapter?(:IBM_DBAdapter)
+
+    Book.destroy_all
+    Book.create!(status: :proposed)
+    Book.create!(status: :written)
+    Book.create!(status: :published)
+
+    order = %w[written published proposed]
+    books = Book.in_order_of(:status, order)
+    assert_equal(order, books.map(&:status))
+
+    books = Book.in_order_of("status", order)
+    assert_equal(order, books.map(&:status))
+  end
+
+  def test_in_order_of_with_enums_keys
+    skip "DB2 unique index semantics treat multiple NULL values as duplicates for books fixtures" if current_adapter?(:IBM_DBAdapter)
+
+    Book.destroy_all
+    Book.create!(status: :proposed)
+    Book.create!(status: :written)
+    Book.create!(status: :published)
+
+    order = [Book.statuses[:written], Book.statuses[:published], Book.statuses[:proposed]]
+    books = Book.in_order_of(:status, order)
+
+    assert_equal(order, books.map { |book| Book.statuses[book.status] })
+  end
+
+  def test_in_order_of_expression
+    order = [3, 4, 1]
+    posts = Post.in_order_of(Arel.sql("id * 2"), order.map { |id| id * 2 })
+
+    assert_equal(order, posts.map(&:id))
+  end
+
+  def test_in_order_of_with_string_column
+    skip "DB2 unique index semantics treat multiple NULL values as duplicates for books fixtures" if current_adapter?(:IBM_DBAdapter)
+
+    Book.destroy_all
+    Book.create!(format: "paperback")
+    Book.create!(format: "ebook")
+    Book.create!(format: "hardcover")
+
+    order = %w[hardcover paperback ebook]
+    books = Book.in_order_of(:format, order)
+    assert_equal(order, books.map(&:format))
+
+    books = Book.in_order_of("format", order)
+    assert_equal(order, books.map(&:format))
+  end
+
+  def test_in_order_of_after_regular_order
+    order = [3, 4, 1]
+    posts = Post.where(type: "Post").order(:type).in_order_of(:id, order)
+    assert_equal(order, posts.map(&:id))
+
+    posts = Post.where(type: "Post").order(:type).in_order_of("id", order)
+    assert_equal(order, posts.map(&:id))
+  end
+
+  def test_in_order_of_with_nil
+    skip "DB2 unique index semantics treat multiple NULL values as duplicates for books fixtures" if current_adapter?(:IBM_DBAdapter)
+
+    Book.destroy_all
+    Book.create!(format: "paperback")
+    Book.create!(format: "ebook")
+    Book.create!(format: nil)
+
+    order = ["ebook", nil, "paperback"]
+    books = Book.in_order_of(:format, order)
+    assert_equal(order, books.map(&:format))
+
+    books = Book.in_order_of("format", order)
+    assert_equal(order, books.map(&:format))
+  end
+
+  def test_in_order_of_with_associations
+    Author.destroy_all
+    Book.destroy_all
+    john = Author.create(name: "John")
+    bob = Author.create(name: "Bob")
+    anna = Author.create(name: "Anna")
+
+    john.books.create
+    bob.books.create
+    anna.books.create
+
+    order = ["Bob", "Anna", "John"]
+    books = Book.joins(:author).in_order_of("authors.name", order)
+    assert_equal(order, books.map { |book| book.author.name })
+
+    books = Book.joins(:author).in_order_of(:"authors.name", order)
+    assert_equal(order, books.map { |book| book.author.name })
+  end
+
+  def test_in_order_of_with_filter_false
+    order = [3, 4, 1]
+    posts = Post.in_order_of(:id, order, filter: false)
+
+    assert_equal(order, posts.limit(3).map(&:id))
+    assert_equal(11, posts.count)
+  end
+end