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

data/test/cases/forbidden_attributes_protection_test.rb

@@ -1,83 +1,49 @@
-require 'cases/helper'
-require 'active_support/core_ext/hash/indifferent_access'
+# frozen_string_literal: true
 
-require 'models/company'
-require 'models/person'
-require 'models/ship'
-require 'models/ship_part'
-require 'models/treasure'
-
-class ProtectedParams
-  attr_accessor :permitted
-  alias :permitted? :permitted
-
-  delegate :keys, :key?, :has_key?, :empty?, to: :@parameters
-
-  def initialize(attributes)
-    @parameters = attributes.with_indifferent_access
-    @permitted = false
-  end
-
-  def permit!
-    @permitted = true
-    self
-  end
-
-  def [](key)
-    @parameters[key]
-  end
-
-  def to_h
-    @parameters
-  end
-
-  def stringify_keys
-    dup
-  end
-
-  def dup
-    super.tap do |duplicate|
-      duplicate.instance_variable_set :@permitted, @permitted
-    end
-  end
-end
+require "cases/helper"
+require "models/company"
+require "models/person"
+require "models/ship"
+require "models/ship_part"
+require "models/treasure"
+require "support/stubs/strong_parameters"
 
 class ForbiddenAttributesProtectionTest < ActiveRecord::TestCase
   def test_forbidden_attributes_cannot_be_used_for_mass_assignment
-    params = ProtectedParams.new(first_name: 'Guille', gender: 'm')
+    params = ProtectedParams.new(first_name: "Guille", gender: "m")
     assert_raises(ActiveModel::ForbiddenAttributesError) do
       Person.new(params)
     end
   end
 
   def test_permitted_attributes_can_be_used_for_mass_assignment
-    params = ProtectedParams.new(first_name: 'Guille', gender: 'm')
+    params = ProtectedParams.new(first_name: "Guille", gender: "m")
     params.permit!
     person = Person.new(params)
 
-    assert_equal 'Guille', person.first_name
-    assert_equal 'm', person.gender
+    assert_equal "Guille", person.first_name
+    assert_equal "m", person.gender
   end
 
   def test_forbidden_attributes_cannot_be_used_for_sti_inheritance_column
-    params = ProtectedParams.new(type: 'Client')
+    params = ProtectedParams.new(type: "Client")
     assert_raises(ActiveModel::ForbiddenAttributesError) do
       Company.new(params)
     end
   end
 
   def test_permitted_attributes_can_be_used_for_sti_inheritance_column
-    params = ProtectedParams.new(type: 'Client')
+    params = ProtectedParams.new(type: "Client")
     params.permit!
     person = Company.new(params)
     assert_equal person.class, Client
   end
 
   def test_regular_hash_should_still_be_used_for_mass_assignment
-    person = Person.new(first_name: 'Guille', gender: 'm')
+    person = Person.new(first_name: "Guille", gender: "m")
 
-    assert_equal 'Guille', person.first_name
-    assert_equal 'm', person.gender
+    assert_equal "Guille", person.first_name
+    assert_equal "m", person.gender
   end
 
   def test_blank_attributes_should_not_raise
@@ -86,7 +52,7 @@ class ForbiddenAttributesProtectionTest < ActiveRecord::TestCase
   end
 
   def test_create_with_checks_permitted
-    params = ProtectedParams.new(first_name: 'Guille', gender: 'm')
+    params = ProtectedParams.new(first_name: "Guille", gender: "m")
 
     assert_raises(ActiveModel::ForbiddenAttributesError) do
       Person.create_with(params).create!
@@ -94,21 +60,21 @@ class ForbiddenAttributesProtectionTest < ActiveRecord::TestCase
   end
 
   def test_create_with_works_with_permitted_params
-    params = ProtectedParams.new(first_name: 'Guille').permit!
+    params = ProtectedParams.new(first_name: "Guille").permit!
 
     person = Person.create_with(params).create!
-    assert_equal 'Guille', person.first_name
+    assert_equal "Guille", person.first_name
   end
 
   def test_create_with_works_with_params_values
-    params = ProtectedParams.new(first_name: 'Guille')
+    params = ProtectedParams.new(first_name: "Guille")
 
     person = Person.create_with(first_name: params[:first_name]).create!
-    assert_equal 'Guille', person.first_name
+    assert_equal "Guille", person.first_name
   end
 
   def test_where_checks_permitted
-    params = ProtectedParams.new(first_name: 'Guille', gender: 'm')
+    params = ProtectedParams.new(first_name: "Guille", gender: "m")
 
     assert_raises(ActiveModel::ForbiddenAttributesError) do
       Person.where(params).create!
@@ -116,21 +82,21 @@ class ForbiddenAttributesProtectionTest < ActiveRecord::TestCase
   end
 
   def test_where_works_with_permitted_params
-    params = ProtectedParams.new(first_name: 'Guille').permit!
+    params = ProtectedParams.new(first_name: "Guille").permit!
 
     person = Person.where(params).create!
-    assert_equal 'Guille', person.first_name
+    assert_equal "Guille", person.first_name
   end
 
   def test_where_works_with_params_values
-    params = ProtectedParams.new(first_name: 'Guille')
+    params = ProtectedParams.new(first_name: "Guille")
 
     person = Person.where(first_name: params[:first_name]).create!
-    assert_equal 'Guille', person.first_name
+    assert_equal "Guille", person.first_name
   end
 
   def test_where_not_checks_permitted
-    params = ProtectedParams.new(first_name: 'Guille', gender: 'm')
+    params = ProtectedParams.new(first_name: "Guille", gender: "m")
 
     assert_raises(ActiveModel::ForbiddenAttributesError) do
       Person.where().not(params)
@@ -138,13 +104,13 @@ class ForbiddenAttributesProtectionTest < ActiveRecord::TestCase
   end
 
   def test_where_not_works_with_permitted_params
-    params = ProtectedParams.new(first_name: 'Guille').permit!
+    params = ProtectedParams.new(first_name: "Guille").permit!
     Person.create!(params)
-    assert_empty Person.where.not(params).select {|p| p.first_name == 'Guille' }
+    assert_empty Person.where.not(params).select { |p| p.first_name == "Guille" }
   end
 
   def test_strong_params_style_objects_work_with_singular_associations
-    params = ProtectedParams.new( name: "Stern", ship_attributes: ProtectedParams.new(name: "The Black Rock").permit!).permit!
+    params = ProtectedParams.new(name: "Stern", ship_attributes: ProtectedParams.new(name: "The Black Rock").permit!).permit!
     part = ShipPart.new(params)
 
     assert_equal "Stern", part.name
@@ -155,11 +121,10 @@ class ForbiddenAttributesProtectionTest < ActiveRecord::TestCase
     params = ProtectedParams.new(
       trinkets_attributes: ProtectedParams.new(
         "0" => ProtectedParams.new(name: "Necklace").permit!,
-        "1" => ProtectedParams.new(name: "Spoon").permit! ) ).permit!
+        "1" => ProtectedParams.new(name: "Spoon").permit!)).permit!
     part = ShipPart.new(params)
 
     assert_equal "Necklace", part.trinkets[0].name
     assert_equal "Spoon", part.trinkets[1].name
   end
-
 end

data/test/cases/habtm_destroy_order_test.rb

@@ -1,24 +1,26 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/lesson"
 require "models/student"
 
 class HabtmDestroyOrderTest < ActiveRecord::TestCase
   test "may not delete a lesson with students" do
-    sicp = Lesson.new(:name => "SICP")
-    ben = Student.new(:name => "Ben Bitdiddle")
+    sicp = Lesson.new(name: "SICP")
+    ben = Student.new(name: "Ben Bitdiddle")
     sicp.students << ben
     sicp.save!
     assert_raises LessonError do
-      assert_no_difference('Lesson.count') do
+      assert_no_difference("Lesson.count") do
         sicp.destroy
       end
     end
-    assert !sicp.destroyed?
+    assert_not_predicate sicp, :destroyed?
   end
 
-  test 'should not raise error if have foreign key in the join table' do
-    student = Student.new(:name => "Ben Bitdiddle")
-    lesson = Lesson.new(:name => "SICP")
+  test "should not raise error if have foreign key in the join table" do
+    student = Student.new(name: "Ben Bitdiddle")
+    lesson = Lesson.new(name: "SICP")
     lesson.students << student
     lesson.save!
     assert_nothing_raised do
@@ -28,34 +30,32 @@ class HabtmDestroyOrderTest < ActiveRecord::TestCase
 
   test "not destroying a student with lessons leaves student<=>lesson association intact" do
     # test a normal before_destroy doesn't destroy the habtm joins
-    begin
-      sicp = Lesson.new(:name => "SICP")
-      ben = Student.new(:name => "Ben Bitdiddle")
-      # add a before destroy to student
-      Student.class_eval do
-        before_destroy do
-          raise ActiveRecord::Rollback unless lessons.empty?
-        end
+    sicp = Lesson.new(name: "SICP")
+    ben = Student.new(name: "Ben Bitdiddle")
+    # add a before destroy to student
+    Student.class_eval do
+      before_destroy do
+        raise ActiveRecord::Rollback unless lessons.empty?
       end
-      ben.lessons << sicp
-      ben.save!
-      ben.destroy
-      assert !ben.reload.lessons.empty?
-    ensure
-      # get rid of it so Student is still like it was
-      Student.reset_callbacks(:destroy)
     end
+    ben.lessons << sicp
+    ben.save!
+    ben.destroy
+    assert_not_empty ben.reload.lessons
+  ensure
+    # get rid of it so Student is still like it was
+    Student.reset_callbacks(:destroy)
   end
 
   test "not destroying a lesson with students leaves student<=>lesson association intact" do
     # test a more aggressive before_destroy  doesn't destroy the habtm joins and still throws the exception
-    sicp = Lesson.new(:name => "SICP")
-    ben = Student.new(:name => "Ben Bitdiddle")
+    sicp = Lesson.new(name: "SICP")
+    ben = Student.new(name: "Ben Bitdiddle")
     sicp.students << ben
     sicp.save!
     assert_raises LessonError do
       sicp.destroy
     end
-    assert !sicp.reload.students.empty?
+    assert_not_empty sicp.reload.students
   end
 end

data/test/cases/helper.rb

@@ -1,17 +1,17 @@
-require 'config'
+# frozen_string_literal: true
 
-require 'active_support/testing/autorun'
-require 'active_support/testing/method_call_assertions'
-require 'stringio'
+require "config"
 
-require 'active_record'
-require 'cases/test_case'
-require 'active_support/dependencies'
-require 'active_support/logger'
-require 'active_support/core_ext/string/strip'
+require "stringio"
 
-require 'support/config'
-require 'support/connection'
+require "active_record"
+require "cases/test_case"
+require "active_support/dependencies"
+require "active_support/logger"
+require "active_support/core_ext/kernel/singleton_class"
+
+require "support/config"
+require "support/connection"
 
 # TODO: Move all these random hacks into the ARTest namespace and into the support/ dir
 
@@ -27,10 +27,7 @@ I18n.enforce_available_locales = false
 ARTest.connect
 
 # Quote "type" if it's a reserved word for the current connection.
-QUOTED_TYPE = ActiveRecord::Base.connection.quote_column_name('type')
-
-# FIXME: Remove this when the deprecation cycle on TZ aware types by default ends.
-ActiveRecord::Base.time_zone_aware_types << :time
+QUOTED_TYPE = ActiveRecord::Base.connection.quote_column_name("type")
 
 def current_adapter?(*types)
   types.any? do |type|
@@ -41,26 +38,53 @@ end
 
 def in_memory_db?
   current_adapter?(:SQLite3Adapter) &&
-  ActiveRecord::Base.connection_pool.spec.config[:database] == ":memory:"
+  ActiveRecord::Base.connection_pool.db_config.database == ":memory:"
 end
 
-def subsecond_precision_supported?
-  ActiveRecord::Base.connection.supports_datetime_with_precision?
+def mysql_enforcing_gtid_consistency?
+  current_adapter?(:Mysql2Adapter) && "ON" == ActiveRecord::Base.connection.show_variable("enforce_gtid_consistency")
 end
 
-def mysql_enforcing_gtid_consistency?
-  current_adapter?(:Mysql2Adapter) && 'ON' == ActiveRecord::Base.connection.show_variable('enforce_gtid_consistency')
+def supports_default_expression?
+  if current_adapter?(:PostgreSQLAdapter)
+    true
+  elsif current_adapter?(:Mysql2Adapter)
+    conn = ActiveRecord::Base.connection
+    !conn.mariadb? && conn.database_version >= "8.0.13"
+  end
 end
 
-def supports_savepoints?
-  ActiveRecord::Base.connection.supports_savepoints?
+def supports_text_column_with_default?
+  if current_adapter?(:Mysql2Adapter)
+    conn = ActiveRecord::Base.connection
+    conn.mariadb? && conn.database_version >= "10.2.1"
+  else
+    true
+  end
+end
+
+%w[
+  supports_savepoints?
+  supports_partial_index?
+  supports_partitioned_indexes?
+  supports_expression_index?
+  supports_insert_returning?
+  supports_insert_on_duplicate_skip?
+  supports_insert_on_duplicate_update?
+  supports_insert_conflict_target?
+  supports_optimizer_hints?
+  supports_datetime_with_precision?
+].each do |method_name|
+  define_method method_name do
+    ActiveRecord::Base.connection.public_send(method_name)
+  end
 end
 
-def with_env_tz(new_tz = 'US/Eastern')
-  old_tz, ENV['TZ'] = ENV['TZ'], new_tz
+def with_env_tz(new_tz = "US/Eastern")
+  old_tz, ENV["TZ"] = ENV["TZ"], new_tz
   yield
 ensure
-  old_tz ? ENV['TZ'] = old_tz : ENV.delete('TZ')
+  old_tz ? ENV["TZ"] = old_tz : ENV.delete("TZ")
 end
 
 def with_timezone_config(cfg)
@@ -134,18 +158,24 @@ def disable_extension!(extension, connection)
   connection.reconnect!
 end
 
-require "cases/validations_repair_helper"
-class ActiveSupport::TestCase
-  include ActiveRecord::TestFixtures
-  include ActiveRecord::ValidationsRepairHelper
-  include ActiveSupport::Testing::MethodCallAssertions
+def clean_up_legacy_connection_handlers
+  handler = ActiveRecord::Base.default_connection_handler
+  ActiveRecord::Base.connection_handlers = {}
 
-  self.fixture_path = FIXTURES_ROOT
-  self.use_instantiated_fixtures  = false
-  self.use_transactional_tests = true
+  handler.connection_pool_names.each do |name|
+    next if ["ActiveRecord::Base", "ARUnit2Model", "Contact", "ContactSti", "FirstAbstractClass", "SecondAbstractClass"].include?(name)
 
-  def create_fixtures(*fixture_set_names, &block)
-    ActiveRecord::FixtureSet.create_fixtures(ActiveSupport::TestCase.fixture_path, fixture_set_names, fixture_class_names, &block)
+    handler.send(:owner_to_pool_manager).delete(name)
+  end
+end
+
+def clean_up_connection_handler
+  handler = ActiveRecord::Base.connection_handler
+  handler.instance_variable_get(:@owner_to_pool_manager).each do |owner, pool_manager|
+    pool_manager.role_names.each do |role_name|
+      next if role_name == ActiveRecord::Base.default_role
+      pool_manager.remove_role(role_name)
+    end
   end
 end
 
@@ -162,6 +192,8 @@ def load_schema
   if File.exist?(adapter_specific_schema_file)
     load adapter_specific_schema_file
   end
+
+  ActiveRecord::FixtureSet.reset_cache
 ensure
   $stdout = original_stdout
 end
@@ -187,18 +219,15 @@ end
 
 module InTimeZone
   private
-
-  def in_time_zone(zone)
-    old_zone  = Time.zone
-    old_tz    = ActiveRecord::Base.time_zone_aware_attributes
-
-    Time.zone = zone ? ActiveSupport::TimeZone[zone] : nil
-    ActiveRecord::Base.time_zone_aware_attributes = !zone.nil?
-    yield
-  ensure
-    Time.zone = old_zone
-    ActiveRecord::Base.time_zone_aware_attributes = old_tz
-  end
+    def in_time_zone(zone)
+      old_zone  = Time.zone
+      old_tz    = ActiveRecord::Base.time_zone_aware_attributes
+
+      Time.zone = zone ? ActiveSupport::TimeZone[zone] : nil
+      ActiveRecord::Base.time_zone_aware_attributes = !zone.nil?
+      yield
+    ensure
+      Time.zone = old_zone
+      ActiveRecord::Base.time_zone_aware_attributes = old_tz
+    end
 end
-
-require 'mocha/setup' # FIXME: stop using mocha

data/test/cases/hot_compatibility_test.rb

@@ -1,5 +1,7 @@
-require 'cases/helper'
-require 'support/connection_helper'
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/connection_helper"
 
 class HotCompatibilityTest < ActiveRecord::TestCase
   self.use_transactional_tests = false
@@ -12,7 +14,7 @@ class HotCompatibilityTest < ActiveRecord::TestCase
         t.string :bar
       end
 
-      def self.name; 'HotCompatibility'; end
+      def self.name; "HotCompatibility"; end
     end
   end
 
@@ -35,29 +37,29 @@ class HotCompatibilityTest < ActiveRecord::TestCase
 
     # but we can successfully create a record so long as we don't
     # reference the removed column
-    record = @klass.create! foo: 'foo'
+    record = @klass.create! foo: "foo"
     record.reload
-    assert_equal 'foo', record.foo
+    assert_equal "foo", record.foo
   end
 
   test "update after remove_column" do
-    record = @klass.create! foo: 'foo'
+    record = @klass.create! foo: "foo"
     assert_equal 3, @klass.columns.length
     @klass.connection.remove_column :hot_compatibilities, :bar
     assert_equal 3, @klass.columns.length
 
     record.reload
-    assert_equal 'foo', record.foo
-    record.foo = 'bar'
+    assert_equal "foo", record.foo
+    record.foo = "bar"
     record.save!
     record.reload
-    assert_equal 'bar', record.foo
+    assert_equal "bar", record.foo
   end
 
-  if current_adapter?(:PostgreSQLAdapter)
+  if current_adapter?(:PostgreSQLAdapter) && ActiveRecord::Base.connection.prepared_statements
     test "cleans up after prepared statement failure in a transaction" do
       with_two_connections do |original_connection, ddl_connection|
-        record = @klass.create! bar: 'bar'
+        record = @klass.create! bar: "bar"
 
         # prepare the reload statement in a transaction
         @klass.transaction do
@@ -83,7 +85,7 @@ class HotCompatibilityTest < ActiveRecord::TestCase
 
     test "cleans up after prepared statement failure in nested transactions" do
       with_two_connections do |original_connection, ddl_connection|
-        record = @klass.create! bar: 'bar'
+        record = @klass.create! bar: "bar"
 
         # prepare the reload statement in a transaction
         @klass.transaction do
@@ -113,30 +115,29 @@ class HotCompatibilityTest < ActiveRecord::TestCase
   end
 
   private
+    def get_prepared_statement_cache(connection)
+      connection.instance_variable_get(:@statements)
+        .instance_variable_get(:@cache)[Process.pid]
+    end
 
-  def get_prepared_statement_cache(connection)
-    connection.instance_variable_get(:@statements)
-      .instance_variable_get(:@cache)[Process.pid]
-  end
-
-  # Rails will automatically clear the prepared statements on the connection
-  # that runs the migration, so we use two connections to simulate what would
-  # actually happen on a production system; we'd have one connection running the
-  # migration from the rake task ("ddl_connection" here), and we'd have another
-  # connection in a web worker.
-  def with_two_connections
-    run_without_connection do |original_connection|
-      ActiveRecord::Base.establish_connection(original_connection.merge(pool_size: 2))
-      begin
-        ddl_connection = ActiveRecord::Base.connection_pool.checkout
+    # Rails will automatically clear the prepared statements on the connection
+    # that runs the migration, so we use two connections to simulate what would
+    # actually happen on a production system; we'd have one connection running the
+    # migration from the rake task ("ddl_connection" here), and we'd have another
+    # connection in a web worker.
+    def with_two_connections
+      run_without_connection do |original_connection|
+        ActiveRecord::Base.establish_connection(original_connection.merge(pool_size: 2))
         begin
-          yield original_connection, ddl_connection
+          ddl_connection = ActiveRecord::Base.connection_pool.checkout
+          begin
+            yield original_connection, ddl_connection
+          ensure
+            ActiveRecord::Base.connection_pool.checkin ddl_connection
+          end
         ensure
-          ActiveRecord::Base.connection_pool.checkin ddl_connection
+          ActiveRecord::Base.clear_all_connections!
         end
-      ensure
-        ActiveRecord::Base.clear_all_connections!
       end
     end
-  end
 end

data/test/cases/i18n_test.rb

@@ -1,45 +1,46 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'models/topic'
-require 'models/reply'
+require "models/topic"
+require "models/reply"
 
 class ActiveRecordI18nTests < ActiveRecord::TestCase
-
   def setup
     I18n.backend = I18n::Backend::Simple.new
   end
 
   def test_translated_model_attributes
-    I18n.backend.store_translations 'en', :activerecord => {:attributes => {:topic => {:title => 'topic title attribute'} } }
-    assert_equal 'topic title attribute', Topic.human_attribute_name('title')
+    I18n.backend.store_translations "en", activerecord: { attributes: { topic: { title: "topic title attribute" } } }
+    assert_equal "topic title attribute", Topic.human_attribute_name("title")
   end
 
   def test_translated_model_attributes_with_symbols
-    I18n.backend.store_translations 'en', :activerecord => {:attributes => {:topic => {:title => 'topic title attribute'} } }
-    assert_equal 'topic title attribute', Topic.human_attribute_name(:title)
+    I18n.backend.store_translations "en", activerecord: { attributes: { topic: { title: "topic title attribute" } } }
+    assert_equal "topic title attribute", Topic.human_attribute_name(:title)
   end
 
   def test_translated_model_attributes_with_sti
-    I18n.backend.store_translations 'en', :activerecord => {:attributes => {:reply => {:title => 'reply title attribute'} } }
-    assert_equal 'reply title attribute', Reply.human_attribute_name('title')
+    I18n.backend.store_translations "en", activerecord: { attributes: { reply: { title: "reply title attribute" } } }
+    assert_equal "reply title attribute", Reply.human_attribute_name("title")
   end
 
   def test_translated_model_attributes_with_sti_fallback
-    I18n.backend.store_translations 'en', :activerecord => {:attributes => {:topic => {:title => 'topic title attribute'} } }
-    assert_equal 'topic title attribute', Reply.human_attribute_name('title')
+    I18n.backend.store_translations "en", activerecord: { attributes: { topic: { title: "topic title attribute" } } }
+    assert_equal "topic title attribute", Reply.human_attribute_name("title")
   end
 
   def test_translated_model_names
-    I18n.backend.store_translations 'en', :activerecord => {:models => {:topic => 'topic model'} }
-    assert_equal 'topic model', Topic.model_name.human
+    I18n.backend.store_translations "en", activerecord: { models: { topic: "topic model" } }
+    assert_equal "topic model", Topic.model_name.human
   end
 
   def test_translated_model_names_with_sti
-    I18n.backend.store_translations 'en', :activerecord => {:models => {:reply => 'reply model'} }
-    assert_equal 'reply model', Reply.model_name.human
+    I18n.backend.store_translations "en", activerecord: { models: { reply: "reply model" } }
+    assert_equal "reply model", Reply.model_name.human
   end
 
   def test_translated_model_names_with_sti_fallback
-    I18n.backend.store_translations 'en', :activerecord => {:models => {:topic => 'topic model'} }
-    assert_equal 'topic model', Reply.model_name.human
+    I18n.backend.store_translations "en", activerecord: { models: { topic: "topic model" } }
+    assert_equal "topic model", Reply.model_name.human
   end
 end