ibm_db 5.2.0-x86-mingw32 → 5.4.0-x86-mingw32

data/test/cases/database_configurations/resolver_test.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PoolConfig
+      class ResolverTest < ActiveRecord::TestCase
+        def resolve_db_config(pool_config, config = {})
+          configs = ActiveRecord::DatabaseConfigurations.new(config)
+          configs.resolve(pool_config)
+        end
+
+        def test_url_invalid_adapter
+          error = assert_raises(LoadError) do
+            Base.connection_handler.establish_connection "ridiculous://foo?encoding=utf8"
+          end
+
+          assert_match "Could not load the 'ridiculous' Active Record adapter. Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary adapter gem to your Gemfile.", error.message
+        end
+
+        def test_error_if_no_adapter_method
+          error = assert_raises(AdapterNotFound) do
+            Base.connection_handler.establish_connection "abstract://foo?encoding=utf8"
+          end
+
+          assert_match "database configuration specifies nonexistent abstract adapter", error.message
+        end
+
+        # The abstract adapter is used simply to bypass the bit of code that
+        # checks that the adapter file can be required in.
+
+        def test_url_from_environment
+          pool_config = resolve_db_config :production, "production" => "abstract://foo?encoding=utf8"
+
+          assert_equal({
+            adapter:  "abstract",
+            host:     "foo",
+            encoding: "utf8"
+          }, pool_config.configuration_hash)
+        end
+
+        def test_url_sub_key
+          pool_config = resolve_db_config :production, "production" => { "url" => "abstract://foo?encoding=utf8" }
+
+          assert_equal({
+            adapter:  "abstract",
+            host:     "foo",
+            encoding: "utf8"
+          }, pool_config.configuration_hash)
+        end
+
+        def test_url_sub_key_merges_correctly
+          hash = { "url" => "abstract://foo?encoding=utf8&", "adapter" => "sqlite3", "host" => "bar", "pool" => "3" }
+          pool_config = resolve_db_config :production, "production" => hash
+
+          assert_equal({
+            adapter:  "abstract",
+            host:     "foo",
+            encoding: "utf8",
+            pool:     "3"
+          }, pool_config.configuration_hash)
+        end
+
+        def test_url_host_no_db
+          pool_config = resolve_db_config "abstract://foo?encoding=utf8"
+          assert_equal({
+            adapter:  "abstract",
+            host:     "foo",
+            encoding: "utf8"
+          }, pool_config.configuration_hash)
+        end
+
+        def test_url_missing_scheme
+          assert_raises ActiveRecord::DatabaseConfigurations::InvalidConfigurationError do
+            resolve_db_config "foo"
+          end
+        end
+
+        def test_url_host_db
+          pool_config = resolve_db_config "abstract://foo/bar?encoding=utf8"
+          assert_equal({
+            adapter:  "abstract",
+            database: "bar",
+            host:     "foo",
+            encoding: "utf8"
+          }, pool_config.configuration_hash)
+        end
+
+        def test_url_port
+          pool_config = resolve_db_config "abstract://foo:123?encoding=utf8"
+
+          assert_equal({
+            adapter:  "abstract",
+            port:     123,
+            host:     "foo",
+            encoding: "utf8"
+          }, pool_config.configuration_hash)
+        end
+
+        def test_encoded_password
+          password = "am@z1ng_p@ssw0rd#!"
+          encoded_password = URI.encode_www_form_component(password)
+          pool_config = resolve_db_config "abstract://foo:#{encoded_password}@localhost/bar"
+
+          assert_equal password, pool_config.configuration_hash[:password]
+        end
+
+        def test_url_with_authority_for_sqlite3
+          pool_config = resolve_db_config "sqlite3:///foo_test"
+
+          assert_equal("/foo_test", pool_config.database)
+        end
+
+        def test_url_absolute_path_for_sqlite3
+          pool_config = resolve_db_config "sqlite3:/foo_test"
+
+          assert_equal("/foo_test", pool_config.database)
+        end
+
+        def test_url_relative_path_for_sqlite3
+          pool_config = resolve_db_config "sqlite3:foo_test"
+
+          assert_equal("foo_test", pool_config.database)
+        end
+
+        def test_url_memory_db_for_sqlite3
+          pool_config = resolve_db_config "sqlite3::memory:"
+          assert_equal(":memory:", pool_config.database)
+        end
+
+        def test_url_sub_key_for_sqlite3
+          pool_config = resolve_db_config :production, "production" => { "url" => "sqlite3:foo?encoding=utf8" }
+
+          assert_equal({
+            adapter:  "sqlite3",
+            database: "foo",
+            encoding: "utf8"
+          }, pool_config.configuration_hash)
+        end
+
+        def test_pool_config_with_invalid_type
+          assert_raises TypeError do
+            Base.connection_handler.establish_connection(Object.new)
+          end
+        end
+      end
+    end
+  end
+end

data/test/cases/database_configurations_test.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class DatabaseConfigurationsTest < ActiveRecord::TestCase
+  unless in_memory_db?
+    def test_empty_returns_true_when_db_configs_are_empty
+      old_config = ActiveRecord::Base.configurations
+      config = {}
+
+      ActiveRecord::Base.configurations = config
+
+      assert_predicate ActiveRecord::Base.configurations, :empty?
+      assert_predicate ActiveRecord::Base.configurations, :blank?
+    ensure
+      ActiveRecord::Base.configurations = old_config
+      ActiveRecord::Base.establish_connection :arunit
+    end
+  end
+
+  def test_configs_for_getter_with_env_name
+    configs = ActiveRecord::Base.configurations.configs_for(env_name: "arunit")
+
+    assert_equal 1, configs.size
+    assert_equal ["arunit"], configs.map(&:env_name)
+  end
+
+  def test_configs_for_getter_with_name
+    previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "arunit2"
+
+    config = ActiveRecord::Base.configurations.configs_for(name: "primary")
+
+    assert_equal "arunit2", config.env_name
+    assert_equal "primary", config.name
+  ensure
+    ENV["RAILS_ENV"] = previous_env
+  end
+
+  def test_configs_for_getter_with_env_and_name
+    config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+
+    assert_equal "arunit", config.env_name
+    assert_equal "primary", config.name
+  end
+
+  def test_default_hash_returns_config_hash_from_default_env
+    original_rails_env = ENV["RAILS_ENV"]
+    ENV["RAILS_ENV"] = "arunit"
+
+    assert_deprecated do
+      assert_equal ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary").configuration_hash, ActiveRecord::Base.configurations.default_hash
+    end
+  ensure
+    ENV["RAILS_ENV"] = original_rails_env
+  end
+
+  def test_find_db_config_returns_first_config_for_env
+    config = ActiveRecord::DatabaseConfigurations.new({
+        "test" => {
+          "config_1" => {
+            "database" => "db"
+          },
+          "config_2" => {
+            "database" => "db"
+          },
+          "config_3" => {
+            "database" => "db"
+          },
+        }
+      })
+
+    assert_equal "config_1", config.find_db_config("test").name
+  end
+
+  def test_find_db_config_returns_a_db_config_object_for_the_given_env
+    config = ActiveRecord::Base.configurations.find_db_config("arunit2")
+
+    assert_equal "arunit2", config.env_name
+    assert_equal "primary", config.name
+  end
+
+  def test_find_db_config_prioritize_db_config_object_for_the_current_env
+    config = ActiveRecord::DatabaseConfigurations.new({
+      "primary" => {
+        "adapter" => "randomadapter"
+      },
+      ActiveRecord::ConnectionHandling::DEFAULT_ENV.call => {
+        "primary" => {
+          "adapter" => "sqlite3",
+          "database" => ":memory:"
+        }
+      }
+    }).find_db_config("primary")
+
+    assert_equal "primary", config.name
+    assert_equal ActiveRecord::ConnectionHandling::DEFAULT_ENV.call, config.env_name
+    assert_equal ":memory:", config.database
+  end
+
+  def test_to_h_turns_db_config_object_back_into_a_hash_and_is_deprecated
+    configs = ActiveRecord::Base.configurations
+    assert_equal "ActiveRecord::DatabaseConfigurations", configs.class.name
+    assert_deprecated do
+      assert_equal "Hash", configs.to_h.class.name
+      assert_equal ["arunit", "arunit2", "arunit_without_prepared_statements"], ActiveRecord::Base.configurations.to_h.keys.sort
+    end
+  end
+end
+
+class LegacyDatabaseConfigurationsTest < ActiveRecord::TestCase
+  def test_can_turn_configurations_into_a_hash_and_is_deprecated
+    assert_deprecated do
+      assert ActiveRecord::Base.configurations.to_h.is_a?(Hash), "expected to be a hash but was not."
+      assert_equal ["arunit", "arunit2", "arunit_without_prepared_statements"].sort, ActiveRecord::Base.configurations.to_h.keys.sort
+    end
+  end
+
+  def test_deprecated_config_method
+    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+
+    assert_equal db_config.configuration_hash.stringify_keys, assert_deprecated { db_config.config }
+  end
+
+  def test_unsupported_method_raises
+    assert_raises NoMethodError do
+      ActiveRecord::Base.configurations.fetch(:foo)
+    end
+  end
+
+  def test_spec_name_in_configs_for_is_deprecated
+    assert_deprecated do
+      db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", spec_name: "primary")
+
+      assert_equal "primary", db_config.name
+    end
+  end
+
+  def test_spec_name_getter_is_deprecated
+    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+
+    assert_deprecated do
+      assert_equal "primary", db_config.spec_name
+    end
+  end
+end

data/test/cases/database_selector_test.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/person"
+require "action_dispatch"
+
+module ActiveRecord
+  class DatabaseSelectorTest < ActiveRecord::TestCase
+    setup do
+      @session_store = {}
+      @session = ActiveRecord::Middleware::DatabaseSelector::Resolver::Session.new(@session_store)
+    end
+
+    teardown do
+      clean_up_connection_handler
+    end
+
+    def test_empty_session
+      assert_equal Time.at(0), @session.last_write_timestamp
+    end
+
+    def test_writing_the_session_timestamps
+      assert @session.update_last_write_timestamp
+
+      session2 = ActiveRecord::Middleware::DatabaseSelector::Resolver::Session.new(@session_store)
+      assert_equal @session.last_write_timestamp, session2.last_write_timestamp
+    end
+
+    def test_writing_session_time_changes
+      assert @session.update_last_write_timestamp
+
+      before = @session.last_write_timestamp
+      sleep(0.1)
+
+      assert @session.update_last_write_timestamp
+      assert_not_equal before, @session.last_write_timestamp
+    end
+
+    def test_read_from_replicas
+      @session_store[:last_write] = ActiveRecord::Middleware::DatabaseSelector::Resolver::Session.convert_time_to_timestamp(Time.now - 5.seconds)
+
+      resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver.new(@session)
+
+      called = false
+      resolver.read do
+        called = true
+        assert ActiveRecord::Base.connected_to?(role: :reading)
+      end
+      assert called
+    end
+
+    unless in_memory_db?
+      def test_can_write_while_reading_from_replicas_if_explicit
+        @session_store[:last_write] = ActiveRecord::Middleware::DatabaseSelector::Resolver::Session.convert_time_to_timestamp(Time.now - 5.seconds)
+
+        resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver.new(@session)
+
+        called = false
+        resolver.read do
+          ActiveRecord::Base.establish_connection :arunit
+
+          called = true
+
+          assert ActiveRecord::Base.connected_to?(role: :reading)
+          assert_predicate ActiveRecord::Base.connection, :preventing_writes?
+
+          ActiveRecord::Base.connected_to(role: :writing, prevent_writes: false) do
+            assert ActiveRecord::Base.connected_to?(role: :writing)
+            assert_not_predicate ActiveRecord::Base.connection, :preventing_writes?
+          end
+
+          assert ActiveRecord::Base.connected_to?(role: :reading)
+          assert_predicate ActiveRecord::Base.connection, :preventing_writes?
+        end
+        assert called
+      end
+    end
+
+    def test_read_from_primary
+      @session_store[:last_write] = ActiveRecord::Middleware::DatabaseSelector::Resolver::Session.convert_time_to_timestamp(Time.now)
+
+      resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver.new(@session)
+
+      called = false
+      resolver.read do
+        called = true
+        assert ActiveRecord::Base.connected_to?(role: :writing)
+      end
+      assert called
+    end
+
+    def test_write_to_primary
+      resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver.new(@session)
+
+      # Session should start empty
+      assert_nil @session_store[:last_write]
+
+      called = false
+      resolver.write do
+        assert ActiveRecord::Base.connected_to?(role: :writing)
+        called = true
+      end
+      assert called
+
+      # and be populated by the last write time
+      assert @session_store[:last_write]
+    end
+
+    def test_write_to_primary_and_update_custom_context
+      custom_context = Class.new(ActiveRecord::Middleware::DatabaseSelector::Resolver::Session) do
+        def update_last_write_timestamp
+          super
+          @wrote_to_primary = true
+        end
+
+        def save(response)
+          response[:wrote_to_primary] = @wrote_to_primary
+        end
+      end
+
+      resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver.new(custom_context.new(@session_store))
+
+      # Session should start empty
+      assert_nil @session_store[:last_write]
+
+      called = false
+      resolver.write do
+        assert ActiveRecord::Base.connected_to?(role: :writing)
+        called = true
+      end
+      assert called
+      response = {}
+      resolver.update_context(response)
+
+      # and be populated by the last write time
+      assert @session_store[:last_write]
+      # plus the response updated
+      assert response[:wrote_to_primary]
+    end
+
+    def test_write_to_primary_with_exception
+      resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver.new(@session)
+
+      # Session should start empty
+      assert_nil @session_store[:last_write]
+
+      called = false
+      assert_raises(ActiveRecord::RecordNotFound) do
+        resolver.write do
+          assert ActiveRecord::Base.connected_to?(role: :writing)
+          called = true
+          raise ActiveRecord::RecordNotFound
+        end
+      end
+      assert called
+
+      # and be populated by the last write time
+      assert @session_store[:last_write]
+    end
+
+    def test_read_from_primary_with_options
+      resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver.new(@session, delay: 5.seconds)
+
+      # Session should start empty
+      assert_nil @session_store[:last_write]
+
+      called = false
+      resolver.write do
+        assert ActiveRecord::Base.connected_to?(role: :writing)
+        called = true
+      end
+      assert called
+
+      # and be populated by the last write time
+      assert @session_store[:last_write]
+
+      read = false
+      resolver.read do
+        assert ActiveRecord::Base.connected_to?(role: :writing)
+        read = true
+      end
+      assert read
+    end
+
+    def test_preventing_writes_turns_off_for_primary_write
+      resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver.new(@session, delay: 5.seconds)
+
+      # Session should start empty
+      assert_nil @session_store[:last_write]
+
+      called = false
+      resolver.write do
+        assert ActiveRecord::Base.connected_to?(role: :writing)
+        called = true
+      end
+      assert called
+
+      # and be populated by the last write time
+      assert @session_store[:last_write]
+
+      read = false
+      write = false
+      resolver.read do
+        assert ActiveRecord::Base.connected_to?(role: :writing)
+        assert_predicate ActiveRecord::Base.connection, :preventing_writes?
+        read = true
+
+        resolver.write do
+          assert ActiveRecord::Base.connected_to?(role: :writing)
+          assert_not_predicate ActiveRecord::Base.connection, :preventing_writes?
+          write = true
+        end
+      end
+
+      assert write
+      assert read
+    end
+
+    def test_preventing_writes_works_in_a_threaded_environment
+      resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver.new(@session, delay: 5.seconds)
+      inside_preventing = Concurrent::Event.new
+      finished_checking = Concurrent::Event.new
+
+      @session.update_last_write_timestamp
+
+      t1 = Thread.new do
+        resolver.read do
+          inside_preventing.wait
+          assert ActiveRecord::Base.connected_to?(role: :writing)
+          assert_predicate ActiveRecord::Base.connection, :preventing_writes?
+          finished_checking.set
+        end
+      end
+
+      t2 = Thread.new do
+        resolver.write do
+          assert ActiveRecord::Base.connected_to?(role: :writing)
+          assert_not_predicate ActiveRecord::Base.connection, :preventing_writes?
+          inside_preventing.set
+          finished_checking.wait
+        end
+      end
+
+      t3 = Thread.new do
+        resolver.read do
+          assert ActiveRecord::Base.connected_to?(role: :writing)
+          assert_predicate ActiveRecord::Base.connection, :preventing_writes?
+        end
+      end
+
+      t1.join
+      t2.join
+      t3.join
+    end
+
+    def test_read_from_replica_with_no_delay
+      resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver.new(@session, delay: 0.seconds)
+
+      # Session should start empty
+      assert_nil @session_store[:last_write]
+
+      called = false
+      resolver.write do
+        assert ActiveRecord::Base.connected_to?(role: :writing)
+        called = true
+      end
+      assert called
+
+      # and be populated by the last write time
+      assert @session_store[:last_write]
+
+      read = false
+      resolver.read do
+        assert ActiveRecord::Base.connected_to?(role: :reading)
+        read = true
+      end
+      assert read
+    end
+
+    def test_the_middleware_chooses_writing_role_with_POST_request
+      middleware = ActiveRecord::Middleware::DatabaseSelector.new(lambda { |env|
+        assert ActiveRecord::Base.connected_to?(role: :writing)
+        [200, {}, ["body"]]
+      })
+      assert_equal [200, {}, ["body"]], middleware.call("REQUEST_METHOD" => "POST")
+    end
+
+    def test_the_middleware_chooses_reading_role_with_GET_request
+      middleware = ActiveRecord::Middleware::DatabaseSelector.new(lambda { |env|
+        assert ActiveRecord::Base.connected_to?(role: :reading)
+        [200, {}, ["body"]]
+      })
+      assert_equal [200, {}, ["body"]], middleware.call("REQUEST_METHOD" => "GET")
+    end
+  end
+end

data/test/cases/database_statements_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class DatabaseStatementsTest < ActiveRecord::TestCase
@@ -5,6 +7,13 @@ class DatabaseStatementsTest < ActiveRecord::TestCase
     @connection = ActiveRecord::Base.connection
   end
 
+  unless current_adapter?(:OracleAdapter)
+    def test_exec_insert
+      result = @connection.exec_insert("INSERT INTO accounts (firm_id,credit_limit) VALUES (42,5000)", nil, [])
+      assert_not_nil @connection.send(:last_inserted_id, result)
+    end
+  end
+
   def test_insert_should_return_the_inserted_id
     assert_not_nil return_the_inserted_id(method: :insert)
   end
@@ -13,22 +22,15 @@ class DatabaseStatementsTest < ActiveRecord::TestCase
     assert_not_nil return_the_inserted_id(method: :create)
   end
 
-  def test_insert_update_delete_sql_is_deprecated
-    assert_deprecated { @connection.insert_sql("INSERT INTO accounts (firm_id,credit_limit) VALUES (42,5000)") }
-    assert_deprecated { @connection.update_sql("UPDATE accounts SET credit_limit = 6000 WHERE firm_id = 42") }
-    assert_deprecated { @connection.delete_sql("DELETE FROM accounts WHERE firm_id = 42") }
-  end
-
   private
-
-  def return_the_inserted_id(method:)
-    # Oracle adapter uses prefetched primary key values from sequence and passes them to connection adapter insert method
-    if current_adapter?(:OracleAdapter)
-      sequence_name = "accounts_seq"
-      id_value = @connection.next_sequence_value(sequence_name)
-      @connection.send(method, "INSERT INTO accounts (id, firm_id,credit_limit) VALUES (accounts_seq.nextval,42,5000)", nil, :id, id_value, sequence_name)
-    else
-      @connection.send(method, "INSERT INTO accounts (firm_id,credit_limit) VALUES (42,5000)")
+    def return_the_inserted_id(method:)
+      # Oracle adapter uses prefetched primary key values from sequence and passes them to connection adapter insert method
+      if current_adapter?(:OracleAdapter)
+        sequence_name = "accounts_seq"
+        id_value = @connection.next_sequence_value(sequence_name)
+        @connection.send(method, "INSERT INTO accounts (id, firm_id,credit_limit) VALUES (accounts_seq.nextval,42,5000)", nil, :id, id_value, sequence_name)
+      else
+        @connection.send(method, "INSERT INTO accounts (firm_id,credit_limit) VALUES (42,5000)")
+      end
     end
-  end
 end

data/test/cases/date_test.rb

@@ -1,5 +1,7 @@
-require 'cases/helper'
-require 'models/topic'
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/topic"
 
 class DateTest < ActiveRecord::TestCase
   def test_date_with_time_value
@@ -9,7 +11,7 @@ class DateTest < ActiveRecord::TestCase
   end
 
   def test_date_with_string_value
-    string_value = '2016-05-11 19:00:00'
+    string_value = "2016-05-11 19:00:00"
     topic = Topic.create(last_read: string_value)
     assert_equal topic, Topic.find_by(last_read: string_value)
   end
@@ -21,23 +23,13 @@ class DateTest < ActiveRecord::TestCase
 
     valid_dates.each do |date_src|
       topic = Topic.new("last_read(1i)" => date_src[0].to_s, "last_read(2i)" => date_src[1].to_s, "last_read(3i)" => date_src[2].to_s)
-      # Oracle DATE columns are datetime columns and Oracle adapter returns Time value
-      if current_adapter?(:OracleAdapter)
-        assert_equal(topic.last_read.to_date, Date.new(*date_src))
-      else
-        assert_equal(topic.last_read, Date.new(*date_src))
-      end
+      assert_equal(topic.last_read, Date.new(*date_src))
     end
 
     invalid_dates.each do |date_src|
       assert_nothing_raised do
-        topic = Topic.new({"last_read(1i)" => date_src[0].to_s, "last_read(2i)" => date_src[1].to_s, "last_read(3i)" => date_src[2].to_s})
-        # Oracle DATE columns are datetime columns and Oracle adapter returns Time value
-        if current_adapter?(:OracleAdapter)
-          assert_equal(topic.last_read.to_date, Time.local(*date_src).to_date, "The date should be modified according to the behavior of the Time object")
-        else
-          assert_equal(topic.last_read, Time.local(*date_src).to_date, "The date should be modified according to the behavior of the Time object")
-        end
+        topic = Topic.new("last_read(1i)" => date_src[0].to_s, "last_read(2i)" => date_src[1].to_s, "last_read(3i)" => date_src[2].to_s)
+        assert_equal(topic.last_read, Time.local(*date_src).to_date, "The date should be modified according to the behavior of the Time object")
       end
     end
   end