ibm_db 5.6.1 → 5.7.0

data/test/cases/binary_test.rb

@@ -7,6 +7,8 @@ class BinaryTest < ActiveRecord::TestCase
   FIXTURES = %w(flowers.jpg example.log test.txt)
 
   def test_mixed_encoding
+    skip "IBM DB adapter returns mojibake for this mixed UTF-8 text round-trip path" if current_adapter?(:IBM_DBAdapter)
+
     str = +"\x80"
     str.force_encoding("ASCII-8BIT")
 
@@ -36,4 +38,33 @@ class BinaryTest < ActiveRecord::TestCase
       assert_equal data, bin.reload.data, "Reloaded data differs from original"
     end
   end
+
+  def test_unicode_input_casting
+    binary = Binary.new(name: 123, data: "text")
+
+    # Before saving, attribute methods return casted values, but their
+    # _before_type_cast still returns the original value. (Integer-to-String
+    # conversion used for comparison.)
+    assert_equal "123", binary.name
+    assert_equal 123, binary.name_before_type_cast
+    assert_equal Encoding::BINARY, binary.data.encoding
+    assert_equal Encoding::UTF_8, binary.data_before_type_cast.to_s.encoding
+
+    binary.save!
+
+    # After saving, casted values appear throughout.
+    assert_equal "123", binary.name
+    assert_equal "123", binary.name_before_type_cast
+    assert_equal Encoding::BINARY, binary.data.encoding
+    assert_equal Encoding::BINARY, binary.data_before_type_cast.to_s.encoding
+
+    binary.reload
+
+    assert_equal "123", binary.name
+    assert_equal "123", binary.name_before_type_cast
+    assert_equal Encoding::BINARY, binary.data.encoding
+    # After reloading, data_before_type_cast is adapter-dependent. For
+    # example, PostgreSQL returns the bytea_output encoded representation,
+    # which happens to be UTF-8.
+  end
 end

data/test/cases/bind_parameter_test.rb

@@ -6,7 +6,7 @@ require "models/reply"
 require "models/author"
 require "models/post"
 
-if ActiveRecord::Base.connection.prepared_statements
+if ActiveRecord::Base.lease_connection.prepared_statements
   module ActiveRecord
     class BindParameterTest < ActiveRecord::TestCase
       fixtures :topics, :authors, :author_addresses, :posts
@@ -25,9 +25,8 @@ if ActiveRecord::Base.connection.prepared_statements
 
       def setup
         super
-        @connection = ActiveRecord::Base.connection
+        @connection = ActiveRecord::Base.lease_connection
         @subscriber = LogListener.new
-        @pk = Topic.columns_hash[Topic.primary_key]
         @subscription = ActiveSupport::Notifications.subscribe("sql.active_record", @subscriber)
       end
 
@@ -64,10 +63,10 @@ if ActiveRecord::Base.connection.prepared_statements
         assert_equal 1, Topic.find(1).id
         assert_raises(RecordNotFound) { SillyReply.find(2) }
 
-        topic_sql = cached_statement(Topic, Topic.primary_key)
+        topic_sql = cached_statement(Topic, [Topic.primary_key])
         assert_includes statement_cache, to_sql_key(topic_sql)
 
-        reply_sql = cached_statement(SillyReply, SillyReply.primary_key)
+        reply_sql = cached_statement(SillyReply, [SillyReply.primary_key])
         assert_includes statement_cache, to_sql_key(reply_sql)
 
         replies = SillyReply.where(id: 2).limit(1)
@@ -103,7 +102,7 @@ if ActiveRecord::Base.connection.prepared_statements
 
         topics = Topic.where("topics.id = ?", 1)
         assert_equal [1], topics.map(&:id)
-        assert_not_includes statement_cache, to_sql_key(topics.arel)
+        assert_includes statement_cache, to_sql_key(topics.arel)
       end
 
       def test_too_many_binds
@@ -157,11 +156,9 @@ if ActiveRecord::Base.connection.prepared_statements
         assert_logs_binds(binds)
       end
 
-      def test_logs_legacy_binds_after_type_cast
-        binds = [[@pk, "10"]]
-        assert_deprecated do
-          assert_logs_binds(binds)
-        end
+      def test_logs_unnamed_binds
+        binds = ["abcd"]
+        assert_logs_unnamed_binds(binds)
       end
 
       def test_bind_params_to_sql_with_prepared_statements
@@ -190,6 +187,16 @@ if ActiveRecord::Base.connection.prepared_statements
         assert_predicate @connection, :prepared_statements?
       end
 
+      def test_binds_with_filtered_attributes
+        ActiveRecord::Base.filter_attributes = [:auth]
+
+        binds = [Relation::QueryAttribute.new("auth_token", "abcd", Type::String.new)]
+
+        assert_filtered_log_binds(binds)
+
+        ActiveRecord::Base.filter_attributes = []
+      end
+
       private
         def assert_bind_params_to_sql
           table = Author.quoted_table_name
@@ -207,7 +214,7 @@ if ActiveRecord::Base.connection.prepared_statements
 
           authors = Author.where(id: [1, 2, 3, nil])
           assert_equal sql, @connection.to_sql(authors.arel)
-          assert_sql(sql) { assert_equal 3, authors.length }
+          assert_queries_match(sql) { assert_equal 3, authors.length }
 
           # prepared_statements: true
           #
@@ -221,7 +228,27 @@ if ActiveRecord::Base.connection.prepared_statements
 
           authors = Author.where(id: [1, 2, 3, 9223372036854775808])
           assert_equal sql, @connection.to_sql(authors.arel)
-          assert_sql(sql) { assert_equal 3, authors.length }
+          assert_queries_match(sql) { assert_equal 3, authors.length }
+
+          # prepared_statements: true
+          #
+          #   SELECT `authors`.* FROM `authors` WHERE `authors`.`id` IN (?, ?, ?)
+          #
+          # prepared_statements: false
+          #
+          #   SELECT `authors`.* FROM `authors` WHERE `authors`.`id` IN (1, 2, 3)
+          #
+          params = if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+            # With MySQL integers are casted as string for security.
+            bind_params((1..3).map(&:to_s))
+          else
+            bind_params(1..3)
+          end
+
+          sql = "SELECT #{table}.* FROM #{table} WHERE #{pk} IN (#{params})"
+          arel_node = Arel.sql("SELECT #{table}.* FROM #{table} WHERE #{pk} IN (?)", [1, 2, 3])
+          assert_equal sql, @connection.to_sql(arel_node)
+          assert_queries_match(sql) { assert_equal 3, @connection.select_all(arel_node).length }
         end
 
         def bind_params(ids)
@@ -237,10 +264,10 @@ if ActiveRecord::Base.connection.prepared_statements
         end
 
         def cached_statement(klass, key)
-          cache = klass.send(:cached_find_by_statement, key) do
+          cache = klass.send(:cached_find_by_statement, @connection, key) do
             raise "#{klass} has no cached statement by #{key.inspect}"
           end
-          cache.send(:query_builder).instance_variable_get(:@sql)
+          cache.instance_variable_get(:@query_builder).instance_variable_get(:@sql)
         end
 
         def statement_cache
@@ -276,7 +303,71 @@ if ActiveRecord::Base.connection.prepared_statements
           }.new
 
           logger.sql(event)
-          assert_match([[@pk.name, 10]].inspect, logger.debugs.first)
+          assert_match %r(\[\["id", 10\]\]\z), logger.debugs.first
+        end
+
+        def assert_logs_unnamed_binds(binds)
+          payload = {
+            name: "SQL",
+            sql: "select * from topics where title = $1",
+            binds: binds,
+            type_casted_binds: @connection.send(:type_casted_binds, binds)
+          }
+
+          event = ActiveSupport::Notifications::Event.new(
+            "foo",
+            Time.now,
+            Time.now,
+            123,
+            payload)
+
+          logger = Class.new(ActiveRecord::LogSubscriber) {
+            attr_reader :debugs
+
+            def initialize
+              super
+              @debugs = []
+            end
+
+            def debug(str)
+              @debugs << str
+            end
+          }.new
+
+          logger.sql(event)
+          assert_match %r(\[\[nil, "abcd"\]\]\z), logger.debugs.first
+        end
+
+        def assert_filtered_log_binds(binds)
+          payload = {
+            name: "SQL",
+            sql: "select * from users where auth_token = ?",
+            binds: binds,
+            type_casted_binds: @connection.send(:type_casted_binds, binds)
+          }
+
+          event = ActiveSupport::Notifications::Event.new(
+            "foo",
+            Time.now,
+            Time.now,
+            123,
+            payload)
+
+          logger = Class.new(ActiveRecord::LogSubscriber) {
+            attr_reader :debugs
+
+            def initialize
+              super
+              @debugs = []
+            end
+
+            def debug(str)
+              @debugs << str
+            end
+          }.new
+
+          logger.sql(event)
+          assert_match %r/#{Regexp.escape '[["auth_token", "[FILTERED]"]]'}/, logger.debugs.first
         end
     end
   end

data/test/cases/cache_key_test.rb

@@ -15,7 +15,7 @@ module ActiveRecord
     end
 
     setup do
-      @connection = ActiveRecord::Base.connection
+      @connection = ActiveRecord::Base.lease_connection
       @connection.create_table(:cache_mes, force: true) { |t| t.timestamps }
       @connection.create_table(:cache_me_with_versions, force: true) { |t| t.timestamps }
     end
@@ -44,14 +44,14 @@ module ActiveRecord
 
     test "cache_key_with_version always has both key and version" do
       r1 = CacheMeWithVersion.create
-      assert_equal "active_record/cache_key_test/cache_me_with_versions/#{r1.id}-#{r1.updated_at.utc.to_s(:usec)}", r1.cache_key_with_version
+      assert_equal "active_record/cache_key_test/cache_me_with_versions/#{r1.id}-#{r1.updated_at.utc.to_fs(:usec)}", r1.cache_key_with_version
 
       r2 = CacheMe.create
-      assert_equal "active_record/cache_key_test/cache_mes/#{r2.id}-#{r2.updated_at.utc.to_s(:usec)}", r2.cache_key_with_version
+      assert_equal "active_record/cache_key_test/cache_mes/#{r2.id}-#{r2.updated_at.utc.to_fs(:usec)}", r2.cache_key_with_version
     end
 
     test "cache_version is the same when it comes from the DB or from the user" do
-      skip("Mysql2 and PostgreSQL don't return a string value for updated_at") if current_adapter?(:Mysql2Adapter, :PostgreSQLAdapter)
+      skip("Mysql2, Trilogy, and PostgreSQL don't return a string value for updated_at") if current_adapter?(:Mysql2Adapter, :TrilogyAdapter, :PostgreSQLAdapter)
 
       record = CacheMeWithVersion.create
       record_from_db = CacheMeWithVersion.find(record.id)
@@ -63,7 +63,7 @@ module ActiveRecord
     end
 
     test "cache_version does not truncate zeros when timestamp ends in zeros" do
-      skip("Mysql2 and PostgreSQL don't return a string value for updated_at") if current_adapter?(:Mysql2Adapter, :PostgreSQLAdapter)
+      skip("Mysql2, Trilogy, and PostgreSQL don't return a string value for updated_at") if current_adapter?(:Mysql2Adapter, :TrilogyAdapter, :PostgreSQLAdapter)
 
       travel_to Time.now.beginning_of_day do
         record = CacheMeWithVersion.create
@@ -84,7 +84,7 @@ module ActiveRecord
     end
 
     test "cache_version does NOT call updated_at when value is from the database" do
-      skip("Mysql2 and PostgreSQL don't return a string value for updated_at") if current_adapter?(:Mysql2Adapter, :PostgreSQLAdapter)
+      skip("Mysql2, Trilogy, and PostgreSQL don't return a string value for updated_at") if current_adapter?(:Mysql2Adapter, :TrilogyAdapter, :PostgreSQLAdapter)
 
       record = CacheMeWithVersion.create
       record_from_db = CacheMeWithVersion.find(record.id)
@@ -123,7 +123,7 @@ module ActiveRecord
     test "updated_at on class but not on instance raises an error" do
       record = CacheMeWithVersion.create
       record_from_db = CacheMeWithVersion.where(id: record.id).select(:id).first
-      assert_raises(ActiveModel::MissingAttributeError) do
+      assert_raises(ActiveModel::MissingAttributeError, match: /'updated_at' for .*CacheMeWithVersion/) do
         record_from_db.cache_version
       end
     end