ibm_db 5.6.1 → 5.7.0

data/test/cases/errors_test.rb

@@ -1,16 +1,19 @@
 # frozen_string_literal: true
 
 require "cases/helper"
+require "active_record/errors"
 
 class ErrorsTest < ActiveRecord::TestCase
   def test_can_be_instantiated_with_no_args
     base = ActiveRecord::ActiveRecordError
     error_klasses = ObjectSpace.each_object(Class).select { |klass| klass < base }
 
-    (error_klasses - [ActiveRecord::AmbiguousSourceReflectionForThroughAssociation]).each do |error_klass|
-      error_klass.new.inspect
-    rescue ArgumentError
-      raise "Instance of #{error_klass} can't be initialized with no arguments"
+    assert_nothing_raised do
+      (error_klasses - [ActiveRecord::AmbiguousSourceReflectionForThroughAssociation]).each do |error_klass|
+        error_klass.new.inspect
+      rescue ArgumentError
+        raise "Instance of #{error_klass} can't be initialized with no arguments"
+      end
     end
   end
 end

data/test/cases/excluding_test.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+require "models/comment"
+
+class ExcludingTest < ActiveRecord::TestCase
+  fixtures :posts, :comments
+
+  setup { @post = posts(:welcome) }
+
+  def test_result_set_does_not_include_single_excluded_record
+    assert_not_includes Post.excluding(@post),      @post
+    assert_not_includes Post.excluding(@post).to_a, @post
+
+    assert_not_includes Post.without(@post), @post
+  end
+
+  def test_result_set_does_not_include_collection_of_excluded_records
+    relation = Post.excluding(@post, posts(:thinking))
+    assert_not_includes relation, @post
+    assert_not_includes relation, posts(:thinking)
+  end
+
+  def test_result_set_does_not_include_collection_of_excluded_records_from_a_query
+    query = Post.where(id: @post)
+
+    assert_queries_match(/SELECT #{Regexp.escape(quote_table_name("posts.id"))} FROM/) do
+      records = Post.excluding(query).to_a
+
+      assert_not_includes records, @post
+    end
+  end
+
+  def test_result_set_does_not_include_collection_of_excluded_records_from_a_loaded_query
+    query = Post.where(id: @post).load
+
+    records = assert_queries_count 1 do
+      Post.excluding(query).to_a
+    end
+
+    assert_not_includes records, @post
+  end
+
+  def test_result_set_does_not_include_collection_of_excluded_records_and_queries
+    thinking = posts(:thinking)
+
+    records = assert_queries_count 2 do
+      Post.excluding(@post, Post.where(id: thinking)).to_a
+    end
+
+    assert_not_includes records, @post
+    assert_not_includes records, thinking
+  end
+
+  def test_result_set_through_association_does_not_include_single_excluded_record
+    comment_greetings, comment_more_greetings = comments(:greetings, :more_greetings)
+
+    relation = @post.comments.excluding(comment_greetings)
+    assert_not_includes relation, comment_greetings
+    assert_includes     relation, comment_more_greetings
+  end
+
+  def test_result_set_through_association_does_not_include_collection_of_excluded_records
+    comment_greetings, comment_more_greetings = comments(:greetings, :more_greetings)
+
+    relation = @post.comments.excluding([ comment_greetings, comment_more_greetings ])
+    assert_not_includes relation, comment_greetings
+    assert_not_includes relation, comment_more_greetings
+  end
+
+  def test_result_set_through_association_does_not_include_collection_of_excluded_records_from_a_relation
+    relation = @post.comments
+
+    assert_queries_match(/SELECT #{Regexp.escape(quote_table_name("comments.id"))} FROM/) do
+      records = Comment.excluding(relation).to_a
+
+      assert_not_empty records
+      assert_not_empty @post.comments
+      assert_empty records.intersection(@post.comments.to_a)
+    end
+  end
+
+  def test_result_set_through_association_does_not_include_collection_of_excluded_records_from_a_loaded_relation
+    relation = @post.comments.load
+
+    records = assert_queries_count 1 do
+      Comment.excluding(relation).to_a
+    end
+
+    assert_not_empty records
+    assert_not_empty @post.comments
+    assert_empty records.intersection(@post.comments.to_a)
+  end
+
+  def test_does_not_exclude_records_when_no_arguments
+    assert_no_excludes Post.excluding
+    assert_no_excludes Post.excluding(nil)
+    assert_no_excludes Post.excluding([])
+    assert_no_excludes Post.excluding([ nil ])
+  end
+
+  def test_raises_on_record_from_different_class
+    error = assert_raises(ArgumentError) { Post.excluding(@post, comments(:greetings)) }
+    assert_equal "You must only pass a single or collection of Post objects to #excluding.", error.message
+
+    error = assert_raises(ArgumentError) { Post.without(@post, comments(:greetings)) }
+    assert_equal "You must only pass a single or collection of Post objects to #without.", error.message
+  end
+
+  private
+    def assert_no_excludes(relation)
+      assert_includes relation, @post
+      assert_equal Post.count, relation.count
+    end
+end

data/test/cases/explain_subscriber_test.rb

@@ -4,7 +4,7 @@ require "cases/helper"
 require "active_record/explain_subscriber"
 require "active_record/explain_registry"
 
-if ActiveRecord::Base.connection.supports_explain?
+if ActiveRecord::Base.lease_connection.supports_explain?
   class ExplainSubscriberTest < ActiveRecord::TestCase
     SUBSCRIBER = ActiveRecord::ExplainSubscriber.new
 
@@ -55,6 +55,11 @@ if ActiveRecord::Base.connection.supports_explain?
       assert_equal 1, queries.size
     end
 
+    def test_collects_queries_starting_with_comment
+      SUBSCRIBER.finish(nil, nil, name: "SQL", sql: "/* comment */ select 1 from users")
+      assert_equal 1, queries.size
+    end
+
     teardown do
       ActiveRecord::ExplainRegistry.reset
     end

data/test/cases/explain_test.rb

@@ -3,7 +3,7 @@
 require "cases/helper"
 require "models/car"
 
-if ActiveRecord::Base.connection.supports_explain?
+if ActiveRecord::Base.lease_connection.supports_explain?
   class ExplainTest < ActiveRecord::TestCase
     fixtures :cars
 
@@ -11,13 +11,13 @@ if ActiveRecord::Base.connection.supports_explain?
       ActiveRecord::Base
     end
 
-    def connection
-      base.connection
+    def lease_connection
+      base.lease_connection
     end
 
     def test_relation_explain
-      message = Car.where(name: "honda").explain
-      assert_match(/^EXPLAIN for:/, message)
+      message = Car.where(name: "honda").explain.inspect
+      assert_match(/^EXPLAIN/, message)
     end
 
     def test_collecting_queries_for_explain
@@ -35,13 +35,103 @@ if ActiveRecord::Base.connection.supports_explain?
       end
     end
 
+    def test_relation_explain_with_average
+      expected_query = capture_sql {
+        Car.average(:id)
+      }.first
+      message = Car.all.explain.average(:id)
+      assert_match(/^EXPLAIN/, message)
+      assert_match(expected_query, message)
+    end
+
+    def test_relation_explain_with_count
+      expected_query = capture_sql {
+        Car.count
+      }.first
+      message = Car.all.explain.count
+      assert_match(/^EXPLAIN/, message)
+      assert_match(expected_query, message)
+    end
+
+    def test_relation_explain_with_count_and_argument
+      expected_query = capture_sql {
+        Car.count(:id)
+      }.first
+      message = Car.all.explain.count(:id)
+      assert_match(/^EXPLAIN/, message)
+      assert_match(expected_query, message)
+    end
+
+    def test_relation_explain_with_minimum
+      expected_query = capture_sql {
+        Car.minimum(:id)
+      }.first
+      message = Car.all.explain.minimum(:id)
+      assert_match(/^EXPLAIN/, message)
+      assert_match(expected_query, message)
+    end
+
+    def test_relation_explain_with_maximum
+      expected_query = capture_sql {
+        Car.maximum(:id)
+      }.first
+      message = Car.all.explain.maximum(:id)
+      assert_match(/^EXPLAIN/, message)
+      assert_match(expected_query, message)
+    end
+
+    def test_relation_explain_with_sum
+      expected_query = capture_sql {
+        Car.sum(:id)
+      }.first
+      message = Car.all.explain.sum(:id)
+      assert_match(/^EXPLAIN/, message)
+      assert_match(expected_query, message)
+    end
+
+    def test_relation_explain_with_first
+      expected_query = capture_sql {
+        Car.all.first
+      }.first
+      message = Car.all.explain.first
+      assert_match(/^EXPLAIN/, message)
+      assert_match(expected_query.sub(/LIMIT.*/, ""), message)
+    end
+
+    def test_relation_explain_with_last
+      expected_query = capture_sql {
+        Car.all.last
+      }.first
+      message = Car.all.explain.last
+      assert_match(/^EXPLAIN/, message)
+      assert_match(expected_query.sub(/LIMIT.*/, ""), message)
+    end
+
+    def test_relation_explain_with_pluck
+      expected_query = capture_sql {
+        Car.all.pluck
+      }.first
+      message = Car.all.explain.pluck
+      assert_match(/^EXPLAIN/, message)
+      assert_match(expected_query, message)
+    end
+
+    def test_relation_explain_with_pluck_with_args
+      expected_query = capture_sql {
+        Car.all.pluck(:id, :name)
+      }.first
+      message = Car.all.explain.pluck(:id, :name)
+      assert_match(/^EXPLAIN/, message)
+      assert_match(expected_query, message)
+    end
+
     def test_exec_explain_with_no_binds
       sqls    = %w(foo bar)
       binds   = [[], []]
       queries = sqls.zip(binds)
 
       stub_explain_for_query_plans do
-        expected = sqls.map { |sql| "EXPLAIN for: #{sql}\nquery plan #{sql}" }.join("\n")
+        expected = sqls.map { |sql| "#{expected_explain_clause} #{sql}\nquery plan #{sql}" }.join("\n")
         assert_equal expected, base.exec_explain(queries)
       end
     end
@@ -53,10 +143,10 @@ if ActiveRecord::Base.connection.supports_explain?
 
       stub_explain_for_query_plans(["query plan foo\n", "query plan bar\n"]) do
         expected = <<~SQL
-          EXPLAIN for: #{sqls[0]} [["wadus", 1]]
+          #{expected_explain_clause} #{sqls[0]} [["wadus", 1]]
           query plan foo
 
-          EXPLAIN for: #{sqls[1]} [["chaflan", 2]]
+          #{expected_explain_clause} #{sqls[1]} [["chaflan", 2]]
           query plan bar
         SQL
         assert_equal expected, base.exec_explain(queries)
@@ -67,13 +157,32 @@ if ActiveRecord::Base.connection.supports_explain?
       def stub_explain_for_query_plans(query_plans = ["query plan foo", "query plan bar"])
         explain_called = 0
 
-        connection.stub(:explain, proc { explain_called += 1; query_plans[explain_called - 1] }) do
-          yield
+        # Minitest's `stub` method is unable to correctly replicate method arguments
+        # signature, so we need to do a manual stubbing in this case.
+        metaclass = lease_connection.singleton_class
+        explain_method = metaclass.instance_method(:explain)
+        metaclass.define_method(:explain) do |_arel, _binds = [], _options = {}|
+          explain_called += 1
+          query_plans[explain_called - 1]
+        end
+        yield
+      ensure
+        if metaclass
+          metaclass.undef_method(:explain)
+          metaclass.define_method(:explain, explain_method)
         end
       end
 
       def bind_param(name, value)
         ActiveRecord::Relation::QueryAttribute.new(name, value, ActiveRecord::Type::Value.new)
       end
+
+      def expected_explain_clause
+        if lease_connection.respond_to?(:build_explain_clause)
+          lease_connection.build_explain_clause
+        else
+          "EXPLAIN for:"
+        end
+      end
   end
 end

data/test/cases/filter_attributes_test.rb

@@ -13,6 +13,7 @@ class FilterAttributesTest < ActiveRecord::TestCase
   setup do
     @previous_filter_attributes = ActiveRecord::Base.filter_attributes
     ActiveRecord::Base.filter_attributes = [:name]
+    ActiveRecord.use_yaml_unsafe_load = true
   end
 
   teardown do
@@ -90,7 +91,7 @@ class FilterAttributesTest < ActiveRecord::TestCase
         assert_equal 0, account.inspect.scan("[FILTERED]").length
       end
     ensure
-      Admin::Account.remove_instance_variable(:@filter_attributes)
+      Admin::Account.instance_variable_set(:@filter_attributes, nil)
     end
   end
 
@@ -109,7 +110,7 @@ class FilterAttributesTest < ActiveRecord::TestCase
     assert_includes user.inspect, "auth_token: [FILTERED]"
     assert_includes user.inspect, 'token: "[FILTERED]"'
   ensure
-    User.remove_instance_variable(:@filter_attributes)
+    User.instance_variable_set(:@filter_attributes, nil)
   end
 
   test "filter_attributes on pretty_print" do
@@ -117,11 +118,7 @@ class FilterAttributesTest < ActiveRecord::TestCase
     actual = "".dup
     PP.pp(user, StringIO.new(actual))
 
-    if RUBY_VERSION >= "2.7"
-      assert_includes actual, 'name: "[FILTERED]"'
-    else
-      assert_includes actual, "name: [FILTERED]"
-    end
+    assert_includes actual, "name: [FILTERED]"
     assert_equal 1, actual.scan("[FILTERED]").length
   end
 
@@ -141,13 +138,9 @@ class FilterAttributesTest < ActiveRecord::TestCase
     actual = "".dup
     PP.pp(user, StringIO.new(actual))
 
-    if RUBY_VERSION >= "2.7"
-      assert_includes actual, 'auth_token: "[FILTERED]"'
-    else
-      assert_includes actual, "auth_token: [FILTERED]"
-    end
-    assert_includes actual, 'token: "[FILTERED]"'
+    assert_includes actual, "auth_token: [FILTERED]"
+    assert_includes actual, "token: [FILTERED]"
   ensure
-    User.remove_instance_variable(:@filter_attributes)
+    User.instance_variable_set(:@filter_attributes, nil)
   end
 end

data/test/cases/finder_respond_to_test.rb

@@ -6,19 +6,19 @@ require "models/topic"
 class FinderRespondToTest < ActiveRecord::TestCase
   fixtures :topics
 
-  def test_should_preserve_normal_respond_to_behaviour_on_base
+  def test_should_preserve_normal_respond_to_behavior_on_base
     assert_respond_to ActiveRecord::Base, :new
     assert_not_respond_to ActiveRecord::Base, :find_by_something
   end
 
-  def test_should_preserve_normal_respond_to_behaviour_and_respond_to_newly_added_method
+  def test_should_preserve_normal_respond_to_behavior_and_respond_to_newly_added_method
     Topic.singleton_class.define_method(:method_added_for_finder_respond_to_test) { }
     assert_respond_to Topic, :method_added_for_finder_respond_to_test
   ensure
     Topic.singleton_class.remove_method :method_added_for_finder_respond_to_test
   end
 
-  def test_should_preserve_normal_respond_to_behaviour_and_respond_to_standard_object_method
+  def test_should_preserve_normal_respond_to_behavior_and_respond_to_standard_object_method
     assert_respond_to Topic, :to_s
   end