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

data/test/cases/adapters/mysql2/connection_test.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'support/connection_helper'
+require "support/connection_helper"
 
 class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
   include ConnectionHelper
@@ -9,7 +11,7 @@ class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
   def setup
     super
     @subscriber = SQLSubscriber.new
-    @subscription = ActiveSupport::Notifications.subscribe('sql.active_record', @subscriber)
+    @subscription = ActiveSupport::Notifications.subscribe("sql.active_record", @subscriber)
     @connection = ActiveRecord::Base.connection
   end
 
@@ -20,61 +22,52 @@ class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
 
   def test_bad_connection
     assert_raise ActiveRecord::NoDatabaseError do
-      configuration = ActiveRecord::Base.configurations['arunit'].merge(database: 'inexistent_activerecord_unittest')
+      db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+      configuration = db_config.configuration_hash.merge(database: "inexistent_activerecord_unittest")
       connection = ActiveRecord::Base.mysql2_connection(configuration)
-      connection.drop_table 'ex', if_exists: true
+      connection.drop_table "ex", if_exists: true
     end
   end
 
-  def test_truncate
-    rows = ActiveRecord::Base.connection.exec_query("select count(*) from comments")
-    count = rows.first.values.first
-    assert_operator count, :>, 0
-
-    ActiveRecord::Base.connection.truncate("comments")
-    rows = ActiveRecord::Base.connection.exec_query("select count(*) from comments")
-    count = rows.first.values.first
-    assert_equal 0, count
-  end
-
   def test_no_automatic_reconnection_after_timeout
-    assert @connection.active?
-    @connection.update('set @@wait_timeout=1')
+    assert_predicate @connection, :active?
+    @connection.update("set @@wait_timeout=1")
     sleep 2
-    assert !@connection.active?
-
+    assert_not_predicate @connection, :active?
+  ensure
     # Repair all fixture connections so other tests won't break.
     @fixture_connections.each(&:verify!)
   end
 
   def test_successful_reconnection_after_timeout_with_manual_reconnect
-    assert @connection.active?
-    @connection.update('set @@wait_timeout=1')
+    assert_predicate @connection, :active?
+    @connection.update("set @@wait_timeout=1")
     sleep 2
     @connection.reconnect!
-    assert @connection.active?
+    assert_predicate @connection, :active?
   end
 
   def test_successful_reconnection_after_timeout_with_verify
-    assert @connection.active?
-    @connection.update('set @@wait_timeout=1')
+    assert_predicate @connection, :active?
+    @connection.update("set @@wait_timeout=1")
     sleep 2
     @connection.verify!
-    assert @connection.active?
+    assert_predicate @connection, :active?
   end
 
   def test_execute_after_disconnect
     @connection.disconnect!
 
-    assert_raise(ActiveRecord::StatementInvalid) do
+    error = assert_raise(ActiveRecord::ConnectionNotEstablished) do
       @connection.execute("SELECT 1")
     end
+    assert_kind_of Mysql2::Error, error.cause
   end
 
   def test_quote_after_disconnect
     @connection.disconnect!
 
-    assert_raise(Mysql2::Error) do
+    assert_raise(ActiveRecord::ConnectionNotEstablished) do
       @connection.quote("string")
     end
   end
@@ -101,8 +94,8 @@ class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
   end
 
   def test_mysql_connection_collation_is_configured
-    assert_equal 'utf8_unicode_ci', @connection.show_variable('collation_connection')
-    assert_equal 'utf8_general_ci', ARUnit2Model.connection.show_variable('collation_connection')
+    assert_equal "utf8mb4_unicode_ci", @connection.show_variable("collation_connection")
+    assert_equal "utf8mb4_general_ci", ARUnit2Model.connection.show_variable("collation_connection")
   end
 
   def test_mysql_default_in_strict_mode
@@ -129,29 +122,29 @@ class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
 
   def test_mysql_sql_mode_variable_overrides_strict_mode
     run_without_connection do |orig_connection|
-      ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { 'sql_mode' => 'ansi' }))
-      result = ActiveRecord::Base.connection.select_value('SELECT @@SESSION.sql_mode')
+      ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { "sql_mode" => "ansi" }))
+      result = ActiveRecord::Base.connection.select_value("SELECT @@SESSION.sql_mode")
       assert_no_match %r(STRICT_ALL_TABLES), result
     end
   end
 
-  def test_passing_arbitary_flags_to_adapter
+  def test_passing_arbitrary_flags_to_adapter
     run_without_connection do |orig_connection|
-      ActiveRecord::Base.establish_connection(orig_connection.merge({flags: Mysql2::Client::COMPRESS}))
-      assert_equal (Mysql2::Client::COMPRESS |  Mysql2::Client::FOUND_ROWS), ActiveRecord::Base.connection.raw_connection.query_options[:flags]
+      ActiveRecord::Base.establish_connection(orig_connection.merge(flags: Mysql2::Client::COMPRESS))
+      assert_equal (Mysql2::Client::COMPRESS | Mysql2::Client::FOUND_ROWS), ActiveRecord::Base.connection.raw_connection.query_options[:flags]
     end
   end
 
   def test_passing_flags_by_array_to_adapter
     run_without_connection do |orig_connection|
-      ActiveRecord::Base.establish_connection(orig_connection.merge({flags: ['COMPRESS'] }))
+      ActiveRecord::Base.establish_connection(orig_connection.merge(flags: ["COMPRESS"]))
       assert_equal ["COMPRESS", "FOUND_ROWS"], ActiveRecord::Base.connection.raw_connection.query_options[:flags]
     end
   end
 
   def test_mysql_set_session_variable
     run_without_connection do |orig_connection|
-      ActiveRecord::Base.establish_connection(orig_connection.deep_merge({:variables => {:default_week_format => 3}}))
+      ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { default_week_format: 3 }))
       session_mode = ActiveRecord::Base.connection.exec_query "SELECT @@SESSION.DEFAULT_WEEK_FORMAT"
       assert_equal 3, session_mode.rows.first.first.to_i
     end
@@ -159,7 +152,7 @@ class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
 
   def test_mysql_set_session_variable_to_default
     run_without_connection do |orig_connection|
-      ActiveRecord::Base.establish_connection(orig_connection.deep_merge({:variables => {:default_week_format => :default}}))
+      ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { default_week_format: :default }))
       global_mode = ActiveRecord::Base.connection.exec_query "SELECT @@GLOBAL.DEFAULT_WEEK_FORMAT"
       session_mode = ActiveRecord::Base.connection.exec_query "SELECT @@SESSION.DEFAULT_WEEK_FORMAT"
       assert_equal global_mode.rows, session_mode.rows
@@ -167,21 +160,27 @@ class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
   end
 
   def test_logs_name_show_variable
-    @connection.show_variable 'foo'
+    ActiveRecord::Base.connection.materialize_transactions
+    @subscriber.logged.clear
+    @connection.show_variable "foo"
     assert_equal "SCHEMA", @subscriber.logged[0][1]
   end
 
-  def test_logs_name_rename_column_sql
+  def test_logs_name_rename_column_for_alter
     @connection.execute "CREATE TABLE `bar_baz` (`foo` varchar(255))"
     @subscriber.logged.clear
-    @connection.send(:rename_column_sql, 'bar_baz', 'foo', 'foo2')
-    assert_equal "SCHEMA", @subscriber.logged[0][1]
+    @connection.send(:rename_column_for_alter, "bar_baz", "foo", "foo2")
+    if @connection.send(:supports_rename_column?)
+      assert_empty @subscriber.logged
+    else
+      assert_equal "SCHEMA", @subscriber.logged[0][1]
+    end
   ensure
     @connection.execute "DROP TABLE `bar_baz`"
   end
 
   def test_get_and_release_advisory_lock
-    lock_name = "test_lock_name"
+    lock_name = "test lock'n'name"
 
     got_lock = @connection.get_advisory_lock(lock_name)
     assert got_lock, "get_advisory_lock should have returned true but it didn't"
@@ -192,19 +191,18 @@ class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
     released_lock = @connection.release_advisory_lock(lock_name)
     assert released_lock, "expected release_advisory_lock to return true but it didn't"
 
-    assert test_lock_free(lock_name), 'expected the test lock to be available after releasing'
+    assert test_lock_free(lock_name), "expected the test lock to be available after releasing"
   end
 
   def test_release_non_existent_advisory_lock
-    lock_name = "fake_lock_name"
+    lock_name = "fake lock'n'name"
     released_non_existent_lock = @connection.release_advisory_lock(lock_name)
     assert_equal released_non_existent_lock, false,
-      'expected release_advisory_lock to return false when there was no lock to release'
+      "expected release_advisory_lock to return false when there was no lock to release"
   end
 
-  protected
-
-  def test_lock_free(lock_name)
-    @connection.select_value("SELECT IS_FREE_LOCK('#{lock_name}');") == 1
-  end
+  private
+    def test_lock_free(lock_name)
+      @connection.select_value("SELECT IS_FREE_LOCK(#{@connection.quote(lock_name)})") == 1
+    end
 end

data/test/cases/adapters/mysql2/count_deleted_rows_with_lock_test.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/connection_helper"
+require "models/author"
+require "models/bulb"
+
+module ActiveRecord
+  class CountDeletedRowsWithLockTest < ActiveRecord::Mysql2TestCase
+    test "delete and create in different threads synchronize correctly" do
+      Bulb.unscoped.delete_all
+      Bulb.create!(name: "Jimmy", color: "blue")
+
+      delete_thread = Thread.new do
+        Bulb.unscoped.delete_all
+      end
+
+      create_thread = Thread.new do
+        Author.create!(name: "Tommy")
+      end
+
+      delete_thread.join
+      create_thread.join
+
+      assert_equal 1, delete_thread.value
+    end
+  end
+end

data/test/cases/adapters/mysql2/datetime_precision_quoting_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class Mysql2DatetimePrecisionQuotingTest < ActiveRecord::Mysql2TestCase
@@ -5,41 +7,43 @@ class Mysql2DatetimePrecisionQuotingTest < ActiveRecord::Mysql2TestCase
     @connection = ActiveRecord::Base.connection
   end
 
-  test 'microsecond precision for MySQL gte 5.6.4' do
-    stub_version '5.6.4'
-    assert_microsecond_precision
-  end
-
-  test 'no microsecond precision for MySQL lt 5.6.4' do
-    stub_version '5.6.3'
-    assert_no_microsecond_precision
+  test "microsecond precision for MySQL gte 5.6.4" do
+    stub_version "5.6.4" do
+      assert_microsecond_precision
+    end
   end
 
-  test 'microsecond precision for MariaDB gte 5.3.0' do
-    stub_version '5.5.5-10.1.8-MariaDB-log'
-    assert_microsecond_precision
+  test "no microsecond precision for MySQL lt 5.6.4" do
+    stub_version "5.6.3" do
+      assert_no_microsecond_precision
+    end
   end
 
-  test 'no microsecond precision for MariaDB lt 5.3.0' do
-    stub_version '5.2.9-MariaDB'
-    assert_no_microsecond_precision
+  test "microsecond precision for MariaDB gte 5.3.0" do
+    stub_version "5.5.5-10.1.8-MariaDB-log" do
+      assert_microsecond_precision
+    end
   end
 
   private
     def assert_microsecond_precision
-      assert_match_quoted_microsecond_datetime(/\.000001\z/)
+      assert_match_quoted_microsecond_datetime(/\.123456\z/)
     end
 
     def assert_no_microsecond_precision
-      assert_match_quoted_microsecond_datetime(/\d\z/)
+      assert_match_quoted_microsecond_datetime(/:55\z/)
     end
 
     def assert_match_quoted_microsecond_datetime(match)
-      assert_match match, @connection.quoted_date(Time.now.change(usec: 1))
+      assert_match match, @connection.quoted_date(Time.now.change(sec: 55, usec: 123456))
     end
 
     def stub_version(full_version_string)
-      @connection.stubs(:full_version).returns(full_version_string)
-      @connection.remove_instance_variable(:@version) if @connection.instance_variable_defined?(:@version)
+      @connection.stub(:get_full_version, full_version_string) do
+        @connection.schema_cache.clear!
+        yield
+      end
+    ensure
+      @connection.schema_cache.clear!
     end
 end

data/test/cases/adapters/mysql2/enum_test.rb

@@ -1,26 +1,47 @@
+# frozen_string_literal: true
+
 require "cases/helper"
+require "support/schema_dumping_helper"
 
 class Mysql2EnumTest < ActiveRecord::Mysql2TestCase
+  self.use_transactional_tests = false
+
+  include SchemaDumpingHelper
+
   class EnumTest < ActiveRecord::Base
-  end
+    attribute :state, :integer
 
-  def test_enum_limit
-    column = EnumTest.columns_hash['enum_column']
-    assert_equal 8, column.limit
+    enum state: {
+      start: 0,
+      middle: 1,
+      finish: 2
+    }
   end
 
-  def test_should_not_be_blob_or_text_column
-    column = EnumTest.columns_hash['enum_column']
-    assert_not column.blob_or_text_column?
+  def setup
+    EnumTest.connection.create_table :enum_tests, id: false, force: true do |t|
+      t.column :enum_column, "enum('text','blob','tiny','medium','long','unsigned','bigint')"
+      t.column :state, "TINYINT(1)"
+    end
   end
 
   def test_should_not_be_unsigned
-    column = EnumTest.columns_hash['enum_column']
-    assert_not column.unsigned?
+    column = EnumTest.columns_hash["enum_column"]
+    assert_not_predicate column, :unsigned?
   end
 
   def test_should_not_be_bigint
-    column = EnumTest.columns_hash['enum_column']
-    assert_not column.bigint?
+    column = EnumTest.columns_hash["enum_column"]
+    assert_not_predicate column, :bigint?
+  end
+
+  def test_schema_dumping
+    schema = dump_table_schema "enum_tests"
+    assert_match %r{t\.column "enum_column", "enum\('text','blob','tiny','medium','long','unsigned','bigint'\)"$}, schema
+  end
+
+  def test_enum_with_attribute
+    enum_test = EnumTest.create!(state: :middle)
+    assert_equal "middle", enum_test.state
   end
 end

data/test/cases/adapters/mysql2/explain_test.rb

@@ -1,21 +1,23 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'models/developer'
-require 'models/computer'
+require "models/author"
+require "models/post"
 
 class Mysql2ExplainTest < ActiveRecord::Mysql2TestCase
-  fixtures :developers
+  fixtures :authors
 
   def test_explain_for_one_query
-    explain = Developer.where(id: 1).explain
-    assert_match %(EXPLAIN for: SELECT `developers`.* FROM `developers` WHERE `developers`.`id` = 1), explain
-    assert_match %r(developers |.* const), explain
+    explain = Author.where(id: 1).explain
+    assert_match %(EXPLAIN for: SELECT `authors`.* FROM `authors` WHERE `authors`.`id` = 1), explain
+    assert_match %r(authors |.* const), explain
   end
 
   def test_explain_with_eager_loading
-    explain = Developer.where(id: 1).includes(:audit_logs).explain
-    assert_match %(EXPLAIN for: SELECT `developers`.* FROM `developers` WHERE `developers`.`id` = 1), explain
-    assert_match %r(developers |.* const), explain
-    assert_match %(EXPLAIN for: SELECT `audit_logs`.* FROM `audit_logs` WHERE `audit_logs`.`developer_id` = 1), explain
-    assert_match %r(audit_logs |.* ALL), explain
+    explain = Author.where(id: 1).includes(:posts).explain
+    assert_match %(EXPLAIN for: SELECT `authors`.* FROM `authors` WHERE `authors`.`id` = 1), explain
+    assert_match %r(authors |.* const), explain
+    assert_match %(EXPLAIN for: SELECT `posts`.* FROM `posts` WHERE `posts`.`author_id` = 1), explain
+    assert_match %r(posts |.* ALL), explain
   end
 end

data/test/cases/adapters/mysql2/json_test.rb

@@ -1,195 +1,24 @@
-require 'cases/helper'
-require 'support/schema_dumping_helper'
+# frozen_string_literal: true
 
-if ActiveRecord::Base.connection.supports_json?
-class Mysql2JSONTest < ActiveRecord::Mysql2TestCase
-  include SchemaDumpingHelper
-  self.use_transactional_tests = false
-
-  class JsonDataType < ActiveRecord::Base
-    self.table_name = 'json_data_type'
-
-    store_accessor :settings, :resolution
-  end
+require "cases/helper"
+require "cases/json_shared_test_cases"
 
-  def setup
-    @connection = ActiveRecord::Base.connection
-    begin
-      @connection.create_table('json_data_type') do |t|
-        t.json 'payload'
-        t.json 'settings'
+if ActiveRecord::Base.connection.supports_json?
+  class Mysql2JSONTest < ActiveRecord::Mysql2TestCase
+    include JSONSharedTestCases
+    self.use_transactional_tests = false
+
+    def setup
+      super
+      @connection.create_table("json_data_type") do |t|
+        t.json "payload"
+        t.json "settings"
       end
     end
-  end
-
-  def teardown
-    @connection.drop_table :json_data_type, if_exists: true
-    JsonDataType.reset_column_information
-  end
-
-  def test_column
-    column = JsonDataType.columns_hash["payload"]
-    assert_equal :json, column.type
-    assert_equal 'json', column.sql_type
-
-    type = JsonDataType.type_for_attribute("payload")
-    assert_not type.binary?
-  end
-
-  def test_change_table_supports_json
-    @connection.change_table('json_data_type') do |t|
-      t.json 'users'
-    end
-    JsonDataType.reset_column_information
-    column = JsonDataType.columns_hash['users']
-    assert_equal :json, column.type
-  end
-
-  def test_schema_dumping
-    output = dump_table_schema("json_data_type")
-    assert_match(/t\.json\s+"settings"/, output)
-  end
-
-  def test_cast_value_on_write
-    x = JsonDataType.new payload: {"string" => "foo", :symbol => :bar}
-    assert_equal({"string" => "foo", :symbol => :bar}, x.payload_before_type_cast)
-    assert_equal({"string" => "foo", "symbol" => "bar"}, x.payload)
-    x.save
-    assert_equal({"string" => "foo", "symbol" => "bar"}, x.reload.payload)
-  end
-
-  def test_type_cast_json
-    type = JsonDataType.type_for_attribute("payload")
-
-    data = "{\"a_key\":\"a_value\"}"
-    hash = type.deserialize(data)
-    assert_equal({'a_key' => 'a_value'}, hash)
-    assert_equal({'a_key' => 'a_value'}, type.deserialize(data))
-
-    assert_equal({}, type.deserialize("{}"))
-    assert_equal({'key'=>nil}, type.deserialize('{"key": null}'))
-    assert_equal({'c'=>'}','"a"'=>'b "a b'}, type.deserialize(%q({"c":"}", "\"a\"":"b \"a b"})))
-  end
-
-  def test_rewrite
-    @connection.execute "insert into json_data_type (payload) VALUES ('{\"k\":\"v\"}')"
-    x = JsonDataType.first
-    x.payload = { '"a\'' => 'b' }
-    assert x.save!
-  end
-
-  def test_select
-    @connection.execute "insert into json_data_type (payload) VALUES ('{\"k\":\"v\"}')"
-    x = JsonDataType.first
-    assert_equal({'k' => 'v'}, x.payload)
-  end
-
-  def test_select_multikey
-    @connection.execute %q|insert into json_data_type (payload) VALUES ('{"k1":"v1", "k2":"v2", "k3":[1,2,3]}')|
-    x = JsonDataType.first
-    assert_equal({'k1' => 'v1', 'k2' => 'v2', 'k3' => [1,2,3]}, x.payload)
-  end
-
-  def test_null_json
-    @connection.execute %q|insert into json_data_type (payload) VALUES(null)|
-    x = JsonDataType.first
-    assert_equal(nil, x.payload)
-  end
-
-  def test_select_array_json_value
-    @connection.execute %q|insert into json_data_type (payload) VALUES ('["v0",{"k1":"v1"}]')|
-    x = JsonDataType.first
-    assert_equal(['v0', {'k1' => 'v1'}], x.payload)
-  end
 
-  def test_select_nil_json_after_create
-    json = JsonDataType.create(payload: nil)
-    x = JsonDataType.where(payload:nil).first
-    assert_equal(json, x)
-  end
-
-  def test_select_nil_json_after_update
-    json = JsonDataType.create(payload: "foo")
-    x = JsonDataType.where(payload:nil).first
-    assert_equal(nil, x)
-
-    json.update_attributes payload: nil
-    x = JsonDataType.where(payload:nil).first
-    assert_equal(json.reload, x)
-  end
-
-  def test_rewrite_array_json_value
-    @connection.execute %q|insert into json_data_type (payload) VALUES ('["v0",{"k1":"v1"}]')|
-    x = JsonDataType.first
-    x.payload = ["v1", { "k2" => "v2" }, "v3"]
-    assert x.save!
-  end
-
-  def test_with_store_accessors
-    x = JsonDataType.new(resolution: "320×480")
-    assert_equal "320×480", x.resolution
-
-    x.save!
-    x = JsonDataType.first
-    assert_equal "320×480", x.resolution
-
-    x.resolution = "640×1136"
-    x.save!
-
-    x = JsonDataType.first
-    assert_equal "640×1136", x.resolution
-  end
-
-  def test_duplication_with_store_accessors
-    x = JsonDataType.new(resolution: "320×480")
-    assert_equal "320×480", x.resolution
-
-    y = x.dup
-    assert_equal "320×480", y.resolution
-  end
-
-  def test_yaml_round_trip_with_store_accessors
-    x = JsonDataType.new(resolution: "320×480")
-    assert_equal "320×480", x.resolution
-
-    y = YAML.load(YAML.dump(x))
-    assert_equal "320×480", y.resolution
-  end
-
-  def test_changes_in_place
-    json = JsonDataType.new
-    assert_not json.changed?
-
-    json.payload = { 'one' => 'two' }
-    assert json.changed?
-    assert json.payload_changed?
-
-    json.save!
-    assert_not json.changed?
-
-    json.payload['three'] = 'four'
-    assert json.payload_changed?
-
-    json.save!
-    json.reload
-
-    assert_equal({ 'one' => 'two', 'three' => 'four' }, json.payload)
-    assert_not json.changed?
-  end
-
-  def test_assigning_string_literal
-    json = JsonDataType.create(payload: "foo")
-    assert_equal "foo", json.payload
-  end
-
-  def test_assigning_number
-    json = JsonDataType.create(payload: 1.234)
-    assert_equal 1.234, json.payload
-  end
-
-  def test_assigning_boolean
-    json = JsonDataType.create(payload: true)
-    assert_equal true, json.payload
+    private
+      def column_type
+        :json
+      end
   end
 end
-end