ibm_db 5.6.1-arm64-darwin-24

data/test/cases/connection_adapters/schema_cache_test.rb

@@ -0,0 +1,294 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class SchemaCacheTest < ActiveRecord::TestCase
+      def setup
+        @connection       = ActiveRecord::Base.connection
+        @cache            = SchemaCache.new @connection
+        @database_version = @connection.get_database_version
+      end
+
+      def test_primary_key
+        assert_equal "id", @cache.primary_keys("posts")
+      end
+
+      def test_yaml_dump_and_load
+        # Create an empty cache.
+        cache = SchemaCache.new @connection
+
+        tempfile = Tempfile.new(["schema_cache-", ".yml"])
+        # Dump it. It should get populated before dumping.
+        cache.dump_to(tempfile.path)
+
+        # Load the cache.
+        cache = SchemaCache.load_from(tempfile.path)
+
+        # Give it a connection. Usually the connection
+        # would get set on the cache when it's retrieved
+        # from the pool.
+        cache.connection = @connection
+
+        assert_no_queries do
+          assert_equal 12, cache.columns("posts").size
+          assert_equal 12, cache.columns_hash("posts").size
+          assert cache.data_sources("posts")
+          assert_equal "id", cache.primary_keys("posts")
+          assert_equal 1, cache.indexes("posts").size
+          assert_equal @database_version.to_s, cache.database_version.to_s
+        end
+      ensure
+        tempfile.unlink
+      end
+
+      def test_yaml_dump_and_load_with_gzip
+        # Create an empty cache.
+        cache = SchemaCache.new @connection
+
+        tempfile = Tempfile.new(["schema_cache-", ".yml.gz"])
+        # Dump it. It should get populated before dumping.
+        cache.dump_to(tempfile.path)
+
+        # Unzip and load manually.
+        cache = Zlib::GzipReader.open(tempfile.path) do |gz|
+          YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(gz.read) : YAML.load(gz.read)
+        end
+
+        # Give it a connection. Usually the connection
+        # would get set on the cache when it's retrieved
+        # from the pool.
+        cache.connection = @connection
+
+        assert_no_queries do
+          assert_equal 12, cache.columns("posts").size
+          assert_equal 12, cache.columns_hash("posts").size
+          assert cache.data_sources("posts")
+          assert_equal "id", cache.primary_keys("posts")
+          assert_equal 1, cache.indexes("posts").size
+          assert_equal @database_version.to_s, cache.database_version.to_s
+        end
+
+        # Load the cache the usual way.
+        cache = SchemaCache.load_from(tempfile.path)
+
+        # Give it a connection.
+        cache.connection = @connection
+
+        assert_no_queries do
+          assert_equal 12, cache.columns("posts").size
+          assert_equal 12, cache.columns_hash("posts").size
+          assert cache.data_sources("posts")
+          assert_equal "id", cache.primary_keys("posts")
+          assert_equal 1, cache.indexes("posts").size
+          assert_equal @database_version.to_s, cache.database_version.to_s
+        end
+      ensure
+        tempfile.unlink
+      end
+
+      def test_yaml_loads_5_1_dump
+        cache = SchemaCache.load_from(schema_dump_path)
+        cache.connection = @connection
+
+        assert_no_queries do
+          assert_equal 11, cache.columns("posts").size
+          assert_equal 11, cache.columns_hash("posts").size
+          assert cache.data_sources("posts")
+          assert_equal "id", cache.primary_keys("posts")
+        end
+      end
+
+      def test_yaml_loads_5_1_dump_without_indexes_still_queries_for_indexes
+        cache = SchemaCache.load_from(schema_dump_path)
+        cache.connection = @connection
+
+        assert_queries :any, ignore_none: true do
+          assert_equal 1, cache.indexes("posts").size
+        end
+      end
+
+      def test_yaml_loads_5_1_dump_without_database_version_still_queries_for_database_version
+        cache = SchemaCache.load_from(schema_dump_path)
+        cache.connection = @connection
+
+        # We can't verify queries get executed because the database version gets
+        # cached in both MySQL and PostgreSQL outside of the schema cache.
+        assert_nil cache.instance_variable_get(:@database_version)
+        assert_equal @database_version.to_s, cache.database_version.to_s
+      end
+
+      def test_primary_key_for_non_existent_table
+        assert_nil @cache.primary_keys("omgponies")
+      end
+
+      def test_caches_columns
+        columns = @cache.columns("posts")
+        assert_equal columns, @cache.columns("posts")
+      end
+
+      def test_caches_columns_hash
+        columns_hash = @cache.columns_hash("posts")
+        assert_equal columns_hash, @cache.columns_hash("posts")
+      end
+
+      def test_caches_indexes
+        indexes = @cache.indexes("posts")
+        assert_equal indexes, @cache.indexes("posts")
+      end
+
+      def test_caches_database_version
+        @cache.database_version # cache database_version
+
+        assert_no_queries do
+          assert_equal @database_version.to_s, @cache.database_version.to_s
+
+          if current_adapter?(:Mysql2Adapter)
+            assert_not_nil @cache.database_version.full_version_string
+          end
+        end
+      end
+
+      def test_clearing
+        @cache.columns("posts")
+        @cache.columns_hash("posts")
+        @cache.data_sources("posts")
+        @cache.primary_keys("posts")
+        @cache.indexes("posts")
+
+        @cache.clear!
+
+        assert_equal 0, @cache.size
+        assert_nil @cache.instance_variable_get(:@database_version)
+      end
+
+      def test_marshal_dump_and_load
+        # Create an empty cache.
+        cache = SchemaCache.new @connection
+
+        # Populate it.
+        cache.add("posts")
+
+        # Create a new cache by marchal dumping / loading.
+        cache = Marshal.load(Marshal.dump(cache))
+
+        assert_no_queries do
+          assert_equal 12, cache.columns("posts").size
+          assert_equal 12, cache.columns_hash("posts").size
+          assert cache.data_sources("posts")
+          assert_equal "id", cache.primary_keys("posts")
+          assert_equal 1, cache.indexes("posts").size
+          assert_equal @database_version.to_s, cache.database_version.to_s
+        end
+      end
+
+      def test_marshal_dump_and_load_via_disk
+        # Create an empty cache.
+        cache = SchemaCache.new @connection
+
+        tempfile = Tempfile.new(["schema_cache-", ".dump"])
+        # Dump it. It should get populated before dumping.
+        cache.dump_to(tempfile.path)
+
+        # Load a new cache.
+        cache = SchemaCache.load_from(tempfile.path)
+        cache.connection = @connection
+
+        assert_no_queries do
+          assert_equal 12, cache.columns("posts").size
+          assert_equal 12, cache.columns_hash("posts").size
+          assert cache.data_sources("posts")
+          assert_equal "id", cache.primary_keys("posts")
+          assert_equal 1, cache.indexes("posts").size
+          assert_equal @database_version.to_s, cache.database_version.to_s
+        end
+      ensure
+        tempfile.unlink
+      end
+
+      def test_marshal_dump_and_load_with_gzip
+        # Create an empty cache.
+        cache = SchemaCache.new @connection
+
+        tempfile = Tempfile.new(["schema_cache-", ".dump.gz"])
+        # Dump it. It should get populated before dumping.
+        cache.dump_to(tempfile.path)
+
+        # Load a new cache manually.
+        cache = Zlib::GzipReader.open(tempfile.path) { |gz| Marshal.load(gz.read) }
+        cache.connection = @connection
+
+        assert_no_queries do
+          assert_equal 12, cache.columns("posts").size
+          assert_equal 12, cache.columns_hash("posts").size
+          assert cache.data_sources("posts")
+          assert_equal "id", cache.primary_keys("posts")
+          assert_equal 1, cache.indexes("posts").size
+          assert_equal @database_version.to_s, cache.database_version.to_s
+        end
+
+        # Load a new cache.
+        cache = SchemaCache.load_from(tempfile.path)
+        cache.connection = @connection
+
+        assert_no_queries do
+          assert_equal 12, cache.columns("posts").size
+          assert_equal 12, cache.columns_hash("posts").size
+          assert cache.data_sources("posts")
+          assert_equal "id", cache.primary_keys("posts")
+          assert_equal 1, cache.indexes("posts").size
+          assert_equal @database_version.to_s, cache.database_version.to_s
+        end
+      ensure
+        tempfile.unlink
+      end
+
+      def test_data_source_exist
+        assert @cache.data_source_exists?("posts")
+        assert_not @cache.data_source_exists?("foo")
+      end
+
+      def test_clear_data_source_cache
+        @cache.clear_data_source_cache!("posts")
+      end
+
+      test "#columns_hash? is populated by #columns_hash" do
+        assert_not @cache.columns_hash?("posts")
+
+        @cache.columns_hash("posts")
+
+        assert @cache.columns_hash?("posts")
+      end
+
+      test "#columns_hash? is not populated by #data_source_exists?" do
+        assert_not @cache.columns_hash?("posts")
+
+        @cache.data_source_exists?("posts")
+
+        assert_not @cache.columns_hash?("posts")
+      end
+
+      # This test covers a patch for a Ruby 2.6 bug that was only fixed in Ruby 2.7.
+      # See: https://bugs.ruby-lang.org/issues/15926
+      test "#deep_duplicate does not modify the frozen/ufrozen state of untainted or tainted string arguments" do
+        test_string = "banana"
+        [
+          test_string.dup,
+          test_string.dup.taint,
+          test_string.dup.freeze,
+          test_string.dup.taint.freeze
+        ].each do |str|
+          starting_frozen_state = str.frozen?
+          @cache.send(:deep_deduplicate, str)
+          assert_equal(starting_frozen_state, str.frozen?)
+        end
+      end
+
+      private
+        def schema_dump_path
+          "#{ASSETS_ROOT}/schema_dump_5_1.yml"
+        end
+    end
+  end
+end

data/test/cases/connection_adapters/type_lookup_test.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+unless current_adapter?(:PostgreSQLAdapter) # PostgreSQL does not use type strings for lookup
+  module ActiveRecord
+    module ConnectionAdapters
+      class TypeLookupTest < ActiveRecord::TestCase
+        setup do
+          @connection = ActiveRecord::Base.connection
+        end
+
+        def test_boolean_types
+          assert_lookup_type :boolean, "boolean"
+          assert_lookup_type :boolean, "BOOLEAN"
+        end
+
+        def test_string_types
+          assert_lookup_type :string, "char"
+          assert_lookup_type :string, "varchar"
+          assert_lookup_type :string, "VARCHAR"
+          assert_lookup_type :string, "varchar(255)"
+          assert_lookup_type :string, "character varying"
+        end
+
+        def test_binary_types
+          assert_lookup_type :binary, "binary"
+          assert_lookup_type :binary, "BINARY"
+          assert_lookup_type :binary, "blob"
+          assert_lookup_type :binary, "BLOB"
+        end
+
+        def test_text_types
+          assert_lookup_type :text, "text"
+          assert_lookup_type :text, "TEXT"
+          assert_lookup_type :text, "clob"
+          assert_lookup_type :text, "CLOB"
+        end
+
+        def test_date_types
+          assert_lookup_type :date, "date"
+          assert_lookup_type :date, "DATE"
+        end
+
+        def test_time_types
+          assert_lookup_type :time, "time"
+          assert_lookup_type :time, "TIME"
+        end
+
+        def test_datetime_types
+          assert_lookup_type :datetime, "datetime"
+          assert_lookup_type :datetime, "DATETIME"
+          assert_lookup_type :datetime, "timestamp"
+          assert_lookup_type :datetime, "TIMESTAMP"
+        end
+
+        def test_decimal_types
+          assert_lookup_type :decimal, "decimal"
+          assert_lookup_type :decimal, "decimal(2,8)"
+          assert_lookup_type :decimal, "DECIMAL"
+          assert_lookup_type :decimal, "numeric"
+          assert_lookup_type :decimal, "numeric(2,8)"
+          assert_lookup_type :decimal, "NUMERIC"
+          assert_lookup_type :decimal, "number"
+          assert_lookup_type :decimal, "number(2,8)"
+          assert_lookup_type :decimal, "NUMBER"
+        end
+
+        def test_float_types
+          assert_lookup_type :float, "float"
+          assert_lookup_type :float, "FLOAT"
+          assert_lookup_type :float, "double"
+          assert_lookup_type :float, "DOUBLE"
+        end
+
+        def test_integer_types
+          assert_lookup_type :integer, "integer"
+          assert_lookup_type :integer, "INTEGER"
+          assert_lookup_type :integer, "tinyint"
+          assert_lookup_type :integer, "smallint"
+          assert_lookup_type :integer, "bigint"
+        end
+
+        def test_bigint_limit
+          limit = @connection.send(:type_map).lookup("bigint").send(:_limit)
+          if current_adapter?(:OracleAdapter)
+            assert_equal 19, limit
+          else
+            assert_equal 8, limit
+          end
+        end
+
+        def test_decimal_without_scale
+          if current_adapter?(:OracleAdapter)
+            {
+              decimal: %w{decimal(2) decimal(2,0) numeric(2) numeric(2,0)},
+              integer: %w{number(2) number(2,0)}
+            }
+          else
+            { decimal: %w{decimal(2) decimal(2,0) numeric(2) numeric(2,0) number(2) number(2,0)} }
+          end.each do |expected_type, types|
+            types.each do |type|
+              cast_type = @connection.send(:type_map).lookup(type)
+
+              assert_equal expected_type, cast_type.type
+              assert_equal 2, cast_type.cast(2.1)
+            end
+          end
+        end
+
+        private
+          def assert_lookup_type(type, lookup)
+            cast_type = @connection.send(:type_map).lookup(lookup)
+            assert_equal type, cast_type.type
+          end
+      end
+    end
+  end
+end

data/test/cases/connection_management_test.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "rack"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class ConnectionManagementTest < ActiveRecord::TestCase
+      self.use_transactional_tests = false
+
+      class App
+        attr_reader :calls
+        def initialize
+          @calls = []
+        end
+
+        def call(env)
+          @calls << env
+          [200, {}, ["hi mom"]]
+        end
+      end
+
+      def setup
+        @env = {}
+        @app = App.new
+        @management = middleware(@app)
+
+        # make sure we have an active connection
+        assert ActiveRecord::Base.connection
+        assert_predicate ActiveRecord::Base.connection_handler, :active_connections?
+      end
+
+      def test_app_delegation
+        manager = middleware(@app)
+
+        manager.call @env
+        assert_equal [@env], @app.calls
+      end
+
+      def test_body_responds_to_each
+        _, _, body = @management.call(@env)
+        bits = []
+        body.each { |bit| bits << bit }
+        assert_equal ["hi mom"], bits
+      end
+
+      def test_connections_are_cleared_after_body_close
+        _, _, body = @management.call(@env)
+        body.close
+        assert_not_predicate ActiveRecord::Base.connection_handler, :active_connections?
+      end
+
+      def test_active_connections_are_not_cleared_on_body_close_during_transaction
+        ActiveRecord::Base.transaction do
+          _, _, body = @management.call(@env)
+          body.close
+          assert_predicate ActiveRecord::Base.connection_handler, :active_connections?
+        end
+      end
+
+      def test_connections_closed_if_exception
+        app       = Class.new(App) { def call(env); raise NotImplementedError; end }.new
+        explosive = middleware(app)
+        assert_raises(NotImplementedError) { explosive.call(@env) }
+        assert_not_predicate ActiveRecord::Base.connection_handler, :active_connections?
+      end
+
+      def test_connections_not_closed_if_exception_inside_transaction
+        ActiveRecord::Base.transaction do
+          app               = Class.new(App) { def call(env); raise RuntimeError; end }.new
+          explosive         = middleware(app)
+          assert_raises(RuntimeError) { explosive.call(@env) }
+          assert_predicate ActiveRecord::Base.connection_handler, :active_connections?
+        end
+      end
+
+      test "doesn't clear active connections when running in a test case" do
+        executor.wrap do
+          @management.call(@env)
+          assert_predicate ActiveRecord::Base.connection_handler, :active_connections?
+        end
+      end
+
+      test "proxy is polite to its body and responds to it" do
+        body = Class.new(String) { def to_path; "/path"; end }.new
+        app = lambda { |_| [200, {}, body] }
+        response_body = middleware(app).call(@env)[2]
+        assert_respond_to response_body, :to_path
+        assert_equal "/path", response_body.to_path
+      end
+
+      test "doesn't mutate the original response" do
+        original_response = [200, {}, "hi"]
+        app = lambda { |_| original_response }
+        middleware(app).call(@env)[2]
+        assert_equal "hi", original_response.last
+      end
+
+      private
+        def executor
+          @executor ||= Class.new(ActiveSupport::Executor).tap do |exe|
+            ActiveRecord::QueryCache.install_executor_hooks(exe)
+          end
+        end
+
+        def middleware(app)
+          lambda do |env|
+            a, b, c = executor.wrap { app.call(env) }
+            [a, b, Rack::BodyProxy.new(c) { }]
+          end
+        end
+    end
+  end
+end