ibm_db 5.2.0-x86-mingw32 → 5.3.2-x86-mingw32

data/test/cases/test_fixtures_test.rb

@@ -1,36 +1,96 @@
-require 'cases/helper'
+# frozen_string_literal: true
+
+require "cases/helper"
+require "tempfile"
+require "fileutils"
+require "models/zine"
 
 class TestFixturesTest < ActiveRecord::TestCase
   setup do
     @klass = Class.new
-    @klass.send(:include, ActiveRecord::TestFixtures)
+    @klass.include(ActiveRecord::TestFixtures)
   end
 
-  def test_deprecated_use_transactional_fixtures=
-    assert_deprecated 'use use_transactional_tests= instead' do
-      @klass.use_transactional_fixtures = true
-    end
+  def test_use_transactional_tests_defaults_to_true
+    assert_equal true, @klass.use_transactional_tests
   end
 
-  def test_use_transactional_tests_prefers_use_transactional_fixtures
-    ActiveSupport::Deprecation.silence do
-      @klass.use_transactional_fixtures = false
-    end
+  def test_use_transactional_tests_can_be_overridden
+    @klass.use_transactional_tests = "foobar"
 
-    assert_equal false, @klass.use_transactional_tests
+    assert_equal "foobar", @klass.use_transactional_tests
   end
 
-  def test_use_transactional_tests_defaults_to_true
-    ActiveSupport::Deprecation.silence do
-      @klass.use_transactional_fixtures = nil
+  unless in_memory_db?
+    def test_doesnt_rely_on_active_support_test_case_specific_methods_with_legacy_connection_handling
+      old_value = ActiveRecord::Base.legacy_connection_handling
+      ActiveRecord::Base.legacy_connection_handling = true
+
+      tmp_dir = Dir.mktmpdir
+      File.write(File.join(tmp_dir, "zines.yml"), <<~YML)
+      going_out:
+        title: Hello
+      YML
+
+      klass = Class.new(Minitest::Test) do
+        include ActiveRecord::TestFixtures
+
+        self.fixture_path = tmp_dir
+        self.use_transactional_tests = true
+
+        fixtures :all
+
+        def test_run_successfuly
+          assert_equal("Hello", Zine.first.title)
+          assert_equal("Hello", zines(:going_out).title)
+        end
+      end
+
+      old_handler = ActiveRecord::Base.connection_handler
+      ActiveRecord::Base.connection_handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
+      ActiveRecord::Base.connection_handlers = {}
+      ActiveRecord::Base.establish_connection(:arunit)
+
+      test_result = klass.new("test_run_successfuly").run
+      assert_predicate(test_result, :passed?)
+    ensure
+      clean_up_legacy_connection_handlers
+      ActiveRecord::Base.connection_handler = old_handler
+      FileUtils.rm_r(tmp_dir)
+      ActiveRecord::Base.legacy_connection_handling = old_value
     end
 
-    assert_equal true, @klass.use_transactional_tests
-  end
+    def test_doesnt_rely_on_active_support_test_case_specific_methods
+      tmp_dir = Dir.mktmpdir
+      File.write(File.join(tmp_dir, "zines.yml"), <<~YML)
+      going_out:
+        title: Hello
+      YML
 
-  def test_use_transactional_tests_can_be_overridden
-    @klass.use_transactional_tests = "foobar"
+      klass = Class.new(Minitest::Test) do
+        include ActiveRecord::TestFixtures
 
-    assert_equal "foobar", @klass.use_transactional_tests
+        self.fixture_path = tmp_dir
+        self.use_transactional_tests = true
+
+        fixtures :all
+
+        def test_run_successfuly
+          assert_equal("Hello", Zine.first.title)
+          assert_equal("Hello", zines(:going_out).title)
+        end
+      end
+
+      old_handler = ActiveRecord::Base.connection_handler
+      ActiveRecord::Base.connection_handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
+      ActiveRecord::Base.establish_connection(:arunit)
+
+      test_result = klass.new("test_run_successfuly").run
+      assert_predicate(test_result, :passed?)
+    ensure
+      ActiveRecord::Base.connection_handler = old_handler
+      clean_up_connection_handler
+      FileUtils.rm_r(tmp_dir)
+    end
   end
 end

data/test/cases/time_precision_test.rb

@@ -1,103 +1,125 @@
-require 'cases/helper'
-require 'support/schema_dumping_helper'
+# frozen_string_literal: true
 
-if subsecond_precision_supported?
-class TimePrecisionTest < ActiveRecord::TestCase
-  include SchemaDumpingHelper
-  self.use_transactional_tests = false
+require "cases/helper"
+require "support/schema_dumping_helper"
 
-  class Foo < ActiveRecord::Base; end
+if supports_datetime_with_precision?
+  class TimePrecisionTest < ActiveRecord::TestCase
+    include SchemaDumpingHelper
+    self.use_transactional_tests = false
 
-  setup do
-    @connection = ActiveRecord::Base.connection
-    Foo.reset_column_information
-  end
+    class Foo < ActiveRecord::Base; end
 
-  teardown do
-    @connection.drop_table :foos
-	#, if_exists: true
-  end
+    setup do
+      @connection = ActiveRecord::Base.connection
+      Foo.reset_column_information
+    end
 
-  def test_time_data_type_with_precision
-    @connection.create_table(:foos, force: true)
-    @connection.add_column :foos, :start,  :time, precision: 3
-    @connection.add_column :foos, :finish, :time, precision: 6
-    assert_equal 3, Foo.columns_hash['start'].precision
-    assert_equal 6, Foo.columns_hash['finish'].precision
-  end
+    teardown do
+      @connection.drop_table :foos, if_exists: true
+    end
 
-  def test_time_precision_is_truncated_on_assignment
-    @connection.create_table(:foos, force: true)
-    @connection.add_column :foos, :start,  :time, precision: 0
-    @connection.add_column :foos, :finish, :time, precision: 6
+    def test_time_data_type_with_precision
+      @connection.create_table(:foos, force: true)
+      @connection.add_column :foos, :start,  :time, precision: 3
+      @connection.add_column :foos, :finish, :time, precision: 6
+      assert_equal 3, Foo.columns_hash["start"].precision
+      assert_equal 6, Foo.columns_hash["finish"].precision
+    end
 
-    time = ::Time.now.change(nsec: 123456789)
-    foo = Foo.new(start: time, finish: time)
+    def test_time_precision_is_truncated_on_assignment
+      @connection.create_table(:foos, force: true)
+      @connection.add_column :foos, :start,  :time, precision: 0
+      @connection.add_column :foos, :finish, :time, precision: 6
 
-    assert_equal 0, foo.start.nsec
-    assert_equal 123456000, foo.finish.nsec
+      time = ::Time.now.change(nsec: 123456789)
+      foo = Foo.new(start: time, finish: time)
 
-    foo.save!
-    foo.reload
+      assert_equal 0, foo.start.nsec
+      assert_equal 123456000, foo.finish.nsec
 
-    assert_equal 0, foo.start.nsec
-    assert_equal 123456000, foo.finish.nsec
-  end
+      foo.save!
+      foo.reload
 
-  def test_passing_precision_to_time_does_not_set_limit
-    @connection.create_table(:foos, force: true) do |t|
-      t.time :start,  precision: 3
-      t.time :finish, precision: 6
+      assert_equal 0, foo.start.nsec
+      assert_equal 123456000, foo.finish.nsec
     end
-    assert_nil Foo.columns_hash['start'].limit
-    assert_nil Foo.columns_hash['finish'].limit
-  end
 
-  def test_invalid_time_precision_raises_error
-    assert_raises ActiveRecord::ActiveRecordError do
-      @connection.create_table(:foos, force: true) do |t|
-        t.time :start,  precision: 7
-        t.time :finish, precision: 7
+    unless current_adapter?(:Mysql2Adapter)
+      def test_no_time_precision_isnt_truncated_on_assignment
+        @connection.create_table(:foos, force: true)
+        @connection.add_column :foos, :start,  :time
+        @connection.add_column :foos, :finish, :time, precision: 6
+
+        time = ::Time.now.change(nsec: 123)
+        foo = Foo.new(start: time, finish: time)
+
+        assert_equal 123, foo.start.nsec
+        assert_equal 0, foo.finish.nsec
+
+        foo.save!
+        foo.reload
+
+        assert_equal 0, foo.start.nsec
+        assert_equal 0, foo.finish.nsec
       end
     end
-  end
 
-  def test_formatting_time_according_to_precision
-    @connection.create_table(:foos, force: true) do |t|
-      t.time :start,  precision: 0
-      t.time :finish, precision: 4
+    def test_passing_precision_to_time_does_not_set_limit
+      @connection.create_table(:foos, force: true) do |t|
+        t.time :start,  precision: 3
+        t.time :finish, precision: 6
+      end
+      assert_nil Foo.columns_hash["start"].limit
+      assert_nil Foo.columns_hash["finish"].limit
     end
-    time = ::Time.utc(2000, 1, 1, 12, 30, 0, 999999)
-    Foo.create!(start: time, finish: time)
-    assert foo = Foo.find_by(start: time)
-    assert_equal 1, Foo.where(finish: time).count
-    assert_equal time.to_s, foo.start.to_s
-    assert_equal time.to_s, foo.finish.to_s
-    assert_equal 000000, foo.start.usec
-    assert_equal 999900, foo.finish.usec
-  end
 
-  def test_schema_dump_includes_time_precision
-    @connection.create_table(:foos, force: true) do |t|
-      t.time :start,  precision: 4
-      t.time :finish, precision: 6
+    def test_invalid_time_precision_raises_error
+      assert_raises ArgumentError do
+        @connection.create_table(:foos, force: true) do |t|
+          t.time :start,  precision: 7
+          t.time :finish, precision: 7
+        end
+      end
     end
-    output = dump_table_schema("foos")
-    assert_match %r{t\.time\s+"start",\s+precision: 4$}, output
-    assert_match %r{t\.time\s+"finish",\s+precision: 6$}, output
-  end
 
-  if current_adapter?(:PostgreSQLAdapter, :SQLServerAdapter)
-    def test_time_precision_with_zero_should_be_dumped
+    def test_formatting_time_according_to_precision
       @connection.create_table(:foos, force: true) do |t|
         t.time :start,  precision: 0
-        t.time :finish, precision: 0
+        t.time :finish, precision: 4
+      end
+
+      time = ::Time.utc(2000, 1, 1, 12, 30, 0, 999999)
+      Foo.create!(start: time, finish: time)
+
+      assert foo = Foo.find_by(start: time)
+      assert_equal 1, Foo.where(finish: time).count
+      assert_equal time.to_s, foo.start.to_s
+      assert_equal time.to_s, foo.finish.to_s
+      assert_equal 000000, foo.start.usec
+      assert_equal 999900, foo.finish.usec
+    end
+
+    def test_schema_dump_includes_time_precision
+      @connection.create_table(:foos, force: true) do |t|
+        t.time :start,  precision: 4
+        t.time :finish, precision: 6
       end
       output = dump_table_schema("foos")
-      assert_match %r{t\.time\s+"start",\s+precision: 0$}, output
-      assert_match %r{t\.time\s+"finish",\s+precision: 0$}, output
+      assert_match %r{t\.time\s+"start",\s+precision: 4$}, output
+      assert_match %r{t\.time\s+"finish",\s+precision: 6$}, output
     end
-  end
 
-end
+    if current_adapter?(:PostgreSQLAdapter, :SQLServerAdapter)
+      def test_time_precision_with_zero_should_be_dumped
+        @connection.create_table(:foos, force: true) do |t|
+          t.time :start,  precision: 0
+          t.time :finish, precision: 0
+        end
+        output = dump_table_schema("foos")
+        assert_match %r{t\.time\s+"start",\s+precision: 0$}, output
+        assert_match %r{t\.time\s+"finish",\s+precision: 0$}, output
+      end
+    end
+  end
 end