ibm_db 3.0.5-x86-mingw32 → 4.0.0-x86-mingw32

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

@@ -0,0 +1,210 @@
+require "cases/helper"
+require 'support/connection_helper'
+
+class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
+  include ConnectionHelper
+
+  fixtures :comments
+
+  def setup
+    super
+    @subscriber = SQLSubscriber.new
+    @subscription = ActiveSupport::Notifications.subscribe('sql.active_record', @subscriber)
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    ActiveSupport::Notifications.unsubscribe(@subscription)
+    super
+  end
+
+  def test_bad_connection
+    assert_raise ActiveRecord::NoDatabaseError do
+      configuration = ActiveRecord::Base.configurations['arunit'].merge(database: 'inexistent_activerecord_unittest')
+      connection = ActiveRecord::Base.mysql2_connection(configuration)
+      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')
+    sleep 2
+    assert !@connection.active?
+
+    # 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')
+    sleep 2
+    @connection.reconnect!
+    assert @connection.active?
+  end
+
+  def test_successful_reconnection_after_timeout_with_verify
+    assert @connection.active?
+    @connection.update('set @@wait_timeout=1')
+    sleep 2
+    @connection.verify!
+    assert @connection.active?
+  end
+
+  def test_execute_after_disconnect
+    @connection.disconnect!
+
+    assert_raise(ActiveRecord::StatementInvalid) do
+      @connection.execute("SELECT 1")
+    end
+  end
+
+  def test_quote_after_disconnect
+    @connection.disconnect!
+
+    assert_raise(Mysql2::Error) do
+      @connection.quote("string")
+    end
+  end
+
+  def test_active_after_disconnect
+    @connection.disconnect!
+    assert_equal false, @connection.active?
+  end
+
+  def test_wait_timeout_as_string
+    run_without_connection do |orig_connection|
+      ActiveRecord::Base.establish_connection(orig_connection.merge(wait_timeout: "60"))
+      result = ActiveRecord::Base.connection.select_value("SELECT @@SESSION.wait_timeout")
+      assert_equal 60, result
+    end
+  end
+
+  def test_wait_timeout_as_url
+    run_without_connection do |orig_connection|
+      ActiveRecord::Base.establish_connection(orig_connection.merge("url" => "mysql2:///?wait_timeout=60"))
+      result = ActiveRecord::Base.connection.select_value("SELECT @@SESSION.wait_timeout")
+      assert_equal 60, result
+    end
+  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')
+  end
+
+  def test_mysql_default_in_strict_mode
+    result = @connection.select_value("SELECT @@SESSION.sql_mode")
+    assert_match %r(STRICT_ALL_TABLES), result
+  end
+
+  def test_mysql_strict_mode_disabled
+    run_without_connection do |orig_connection|
+      ActiveRecord::Base.establish_connection(orig_connection.merge(strict: false))
+      result = ActiveRecord::Base.connection.select_value("SELECT @@SESSION.sql_mode")
+      assert_no_match %r(STRICT_ALL_TABLES), result
+    end
+  end
+
+  def test_mysql_strict_mode_specified_default
+    run_without_connection do |orig_connection|
+      ActiveRecord::Base.establish_connection(orig_connection.merge(strict: :default))
+      global_sql_mode = ActiveRecord::Base.connection.select_value("SELECT @@GLOBAL.sql_mode")
+      session_sql_mode = ActiveRecord::Base.connection.select_value("SELECT @@SESSION.sql_mode")
+      assert_equal global_sql_mode, session_sql_mode
+    end
+  end
+
+  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')
+      assert_no_match %r(STRICT_ALL_TABLES), result
+    end
+  end
+
+  def test_passing_arbitary_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]
+    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'] }))
+      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}}))
+      session_mode = ActiveRecord::Base.connection.exec_query "SELECT @@SESSION.DEFAULT_WEEK_FORMAT"
+      assert_equal 3, session_mode.rows.first.first.to_i
+    end
+  end
+
+  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}}))
+      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
+    end
+  end
+
+  def test_logs_name_show_variable
+    @connection.show_variable 'foo'
+    assert_equal "SCHEMA", @subscriber.logged[0][1]
+  end
+
+  def test_logs_name_rename_column_sql
+    @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]
+  ensure
+    @connection.execute "DROP TABLE `bar_baz`"
+  end
+
+  def test_get_and_release_advisory_lock
+    lock_name = "test_lock_name"
+
+    got_lock = @connection.get_advisory_lock(lock_name)
+    assert got_lock, "get_advisory_lock should have returned true but it didn't"
+
+    assert_equal test_lock_free(lock_name), false,
+      "expected the test advisory lock to be held but it wasn't"
+
+    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'
+  end
+
+  def test_release_non_existent_advisory_lock
+    lock_name = "fake_lock_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'
+  end
+
+  protected
+
+  def test_lock_free(lock_name)
+    @connection.select_value("SELECT IS_FREE_LOCK('#{lock_name}');") == 1
+  end
+end

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

@@ -0,0 +1,45 @@
+require "cases/helper"
+
+class Mysql2DatetimePrecisionQuotingTest < ActiveRecord::Mysql2TestCase
+  setup do
+    @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
+  end
+
+  test 'microsecond precision for MariaDB gte 5.3.0' do
+    stub_version '5.5.5-10.1.8-MariaDB-log'
+    assert_microsecond_precision
+  end
+
+  test 'no microsecond precision for MariaDB lt 5.3.0' do
+    stub_version '5.2.9-MariaDB'
+    assert_no_microsecond_precision
+  end
+
+  private
+    def assert_microsecond_precision
+      assert_match_quoted_microsecond_datetime(/\.000001\z/)
+    end
+
+    def assert_no_microsecond_precision
+      assert_match_quoted_microsecond_datetime(/\d\z/)
+    end
+
+    def assert_match_quoted_microsecond_datetime(match)
+      assert_match match, @connection.quoted_date(Time.now.change(usec: 1))
+    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)
+    end
+end

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

@@ -0,0 +1,26 @@
+require "cases/helper"
+
+class Mysql2EnumTest < ActiveRecord::Mysql2TestCase
+  class EnumTest < ActiveRecord::Base
+  end
+
+  def test_enum_limit
+    column = EnumTest.columns_hash['enum_column']
+    assert_equal 8, column.limit
+  end
+
+  def test_should_not_be_blob_or_text_column
+    column = EnumTest.columns_hash['enum_column']
+    assert_not column.blob_or_text_column?
+  end
+
+  def test_should_not_be_unsigned
+    column = EnumTest.columns_hash['enum_column']
+    assert_not column.unsigned?
+  end
+
+  def test_should_not_be_bigint
+    column = EnumTest.columns_hash['enum_column']
+    assert_not column.bigint?
+  end
+end

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

@@ -0,0 +1,21 @@
+require "cases/helper"
+require 'models/developer'
+require 'models/computer'
+
+class Mysql2ExplainTest < ActiveRecord::Mysql2TestCase
+  fixtures :developers
+
+  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
+  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
+  end
+end

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

@@ -0,0 +1,195 @@
+require 'cases/helper'
+require 'support/schema_dumping_helper'
+
+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
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    begin
+      @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
+  end
+end
+end