activerecord-sqlserver-adapter 6.1.2.1 → 7.2.4

data/test/cases/column_test_sqlserver.rb

@@ -277,8 +277,8 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
       _(col.sql_type).must_equal           "date"
       _(col.type).must_equal               :date
       _(col.null).must_equal               true
-      _(col.default).must_equal            connection_dblib_73? ? Date.civil(0001, 1, 1) : "0001-01-01"
-      _(obj.date).must_equal               Date.civil(0001, 1, 1)
+      _(col.default).must_equal            connection_tds_73 ? Date.civil(1, 1, 1) : "0001-01-01"
+      _(obj.date).must_equal               Date.civil(1, 1, 1)
       _(col.default_function).must_be_nil
       type = connection.lookup_cast_type_from_column(col)
       _(type).must_be_instance_of Type::Date
@@ -287,22 +287,22 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
       _(type.scale).must_be_nil
       # Can cast strings. SQL Server format.
       obj.date = "04-01-0001"
-      _(obj.date).must_equal Date.civil(0001, 4, 1)
+      _(obj.date).must_equal Date.civil(1, 4, 1)
       obj.save!
-      _(obj.date).must_equal Date.civil(0001, 4, 1)
+      _(obj.date).must_equal Date.civil(1, 4, 1)
       obj.reload
-      _(obj.date).must_equal Date.civil(0001, 4, 1)
+      _(obj.date).must_equal Date.civil(1, 4, 1)
       # Can cast strings. ISO format.
       obj.date = "0001-04-01"
-      _(obj.date).must_equal Date.civil(0001, 4, 1)
+      _(obj.date).must_equal Date.civil(1, 4, 1)
       obj.save!
-      _(obj.date).must_equal Date.civil(0001, 4, 1)
+      _(obj.date).must_equal Date.civil(1, 4, 1)
       obj.reload
-      _(obj.date).must_equal Date.civil(0001, 4, 1)
+      _(obj.date).must_equal Date.civil(1, 4, 1)
       # Can filter by date range
       _(obj).must_equal obj.class.where(date: obj.date..Date::Infinity.new).first
       # Can keep and return assigned date.
-      assert_obj_set_and_save :date, Date.civil(1972, 04, 14)
+      assert_obj_set_and_save :date, Date.civil(1972, 4, 14)
       # Can accept and cast time objects.
       obj.date = Time.utc(2010, 4, 14, 12, 34, 56, 3000)
       _(obj.date).must_equal               Date.civil(2010, 4, 14)
@@ -315,7 +315,7 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
       _(col.sql_type).must_equal           "datetime"
       _(col.type).must_equal               :datetime
       _(col.null).must_equal               true
-      time = Time.utc 1753, 01, 01, 00, 00, 00, 123000
+      time = Time.utc 1753, 1, 1, 0, 0, 0, 123000
       _(col.default).must_equal            time, "Microseconds were <#{col.default.usec}> vs <123000>"
       _(obj.datetime).must_equal           time, "Microseconds were <#{obj.datetime.usec}> vs <123000>"
       _(col.default_function).must_be_nil
@@ -327,7 +327,7 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
       obj.save!
       _(obj).must_equal obj.class.where(datetime: time).first
       # Can save to proper accuracy and return again.
-      time = Time.utc 2010, 04, 01, 12, 34, 56, 3000
+      time = Time.utc 2010, 4, 1, 12, 34, 56, 3000
       obj.datetime = time
       _(obj.datetime).must_equal time, "Microseconds were <#{obj.datetime.usec}> vs <3000>"
       obj.save!
@@ -338,8 +338,8 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
       # Can filter by datetime range
       _(obj).must_equal obj.class.where(datetime: time..DateTime::Infinity.new).first
       # Will cast to true DB value on attribute write, save and return again.
-      time = Time.utc 2010, 04, 01, 12, 34, 56, 234567
-      time2 = Time.utc 2010, 04, 01, 12, 34, 56, 233000
+      time = Time.utc 2010, 4, 1, 12, 34, 56, 234567
+      time2 = Time.utc 2010, 4, 1, 12, 34, 56, 233000
       obj.datetime = time
       _(obj.datetime).must_equal time2, "Microseconds were <#{obj.datetime.usec}> vs <233000>"
       obj.save!
@@ -357,7 +357,7 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     end
 
     it "datetime2" do
-      skip "datetime2 not supported in this protocol version" unless connection_dblib_73?
+      skip "datetime2 not supported in this protocol version" unless connection_tds_73
       col = column("datetime2_7")
       _(col.sql_type).must_equal           "datetime2(7)"
       _(col.type).must_equal               :datetime
@@ -422,26 +422,28 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     end
 
     it "datetimeoffset" do
-      skip "datetimeoffset not supported in this protocol version" unless connection_dblib_73?
+      skip "datetimeoffset not supported in this protocol version" unless connection_tds_73
       col = column("datetimeoffset_7")
       _(col.sql_type).must_equal           "datetimeoffset(7)"
       _(col.type).must_equal               :datetimeoffset
       _(col.null).must_equal               true
-      _(col.default).must_equal            Time.new(1984, 01, 24, 04, 20, 00, -28800).change(nsec: 123456700), "Nanoseconds <#{col.default.nsec}> vs <123456700>"
-      _(obj.datetimeoffset_7).must_equal   Time.new(1984, 01, 24, 04, 20, 00, -28800).change(nsec: 123456700), "Nanoseconds were <#{obj.datetimeoffset_7.nsec}> vs <999999900>"
+      _(col.default).must_equal            Time.new(1984, 1, 24, 4, 20, 0, -28800).change(nsec: 123456700), "Nanoseconds <#{col.default.nsec}> vs <123456700>"
+      _(obj.datetimeoffset_7).must_equal   Time.new(1984, 1, 24, 4, 20, 0, -28800).change(nsec: 123456700), "Nanoseconds were <#{obj.datetimeoffset_7.nsec}> vs <999999900>"
       _(col.default_function).must_be_nil
       type = connection.lookup_cast_type_from_column(col)
       _(type).must_be_instance_of Type::DateTimeOffset
       _(type.limit).must_be_nil
       _(type.precision).must_equal 7
       _(type.scale).must_be_nil
-      # Can save 100 nanosecond precisoins and return again.
-      obj.datetimeoffset_7 = Time.new(2010, 04, 01, 12, 34, 56, +18000).change(nsec: 123456755)
-      _(obj.datetimeoffset_7).must_equal Time.new(2010, 04, 01, 12, 34, 56, +18000).change(nsec: 123456800), "Nanoseconds were <#{obj.datetimeoffset_7.nsec}> vs <123456800>"
+
+      # Can save 100 nanosecond precisions and return again.
+      obj.datetimeoffset_7 = Time.new(2010, 4, 1, 12, 34, 56, +18000).change(nsec: 123456755)
+      _(obj.datetimeoffset_7).must_equal Time.new(2010, 4, 1, 12, 34, 56, +18000).change(nsec: 123456800), "Nanoseconds were <#{obj.datetimeoffset_7.nsec}> vs <123456800>"
       obj.save!
-      _(obj.datetimeoffset_7).must_equal Time.new(2010, 04, 01, 12, 34, 56, +18000).change(nsec: 123456800), "Nanoseconds were <#{obj.datetimeoffset_7.nsec}> vs <123456800>"
+      _(obj.datetimeoffset_7).must_equal Time.new(2010, 4, 1, 12, 34, 56, +18000).change(nsec: 123456800), "Nanoseconds were <#{obj.datetimeoffset_7.nsec}> vs <123456800>"
       obj.reload
-      _(obj.datetimeoffset_7).must_equal Time.new(2010, 04, 01, 12, 34, 56, +18000).change(nsec: 123456800), "Nanoseconds were <#{obj.datetimeoffset_7.nsec}> vs <123456800>"
+      _(obj.datetimeoffset_7).must_equal Time.new(2010, 4, 1, 12, 34, 56, +18000).change(nsec: 123456800), "Nanoseconds were <#{obj.datetimeoffset_7.nsec}> vs <123456800>"
+
       # Maintains the timezone
       time = ActiveSupport::TimeZone["America/Los_Angeles"].local 2010, 12, 31, 23, 59, 59, Rational(123456800, 1000)
       obj.datetimeoffset_7 = time
@@ -449,6 +451,7 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
       obj.save!
       _(obj.datetimeoffset_7).must_equal time
       _(obj.reload.datetimeoffset_7).must_equal time
+
       # With other precisions.
       time = ActiveSupport::TimeZone["America/Los_Angeles"].local 2010, 12, 31, 23, 59, 59, Rational(123456755, 1000)
       col = column("datetimeoffset_3")
@@ -470,8 +473,8 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
       _(col.sql_type).must_equal           "smalldatetime"
       _(col.type).must_equal               :smalldatetime
       _(col.null).must_equal               true
-      _(col.default).must_equal            Time.utc(1901, 01, 01, 15, 45, 00, 000)
-      _(obj.smalldatetime).must_equal      Time.utc(1901, 01, 01, 15, 45, 00, 000)
+      _(col.default).must_equal            Time.utc(1901, 1, 1, 15, 45, 0, 0)
+      _(obj.smalldatetime).must_equal      Time.utc(1901, 1, 1, 15, 45, 0, 0)
       _(col.default_function).must_be_nil
       type = connection.lookup_cast_type_from_column(col)
       _(type).must_be_instance_of Type::SmallDateTime
@@ -479,21 +482,21 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
       _(type.precision).must_be_nil
       _(type.scale).must_be_nil
       # Will remove fractional seconds and return again.
-      obj.smalldatetime = Time.utc(2078, 06, 05, 4, 20, 00, 3000)
-      _(obj.smalldatetime).must_equal Time.utc(2078, 06, 05, 4, 20, 00, 0), "Microseconds were <#{obj.smalldatetime.usec}> vs <0>"
+      obj.smalldatetime = Time.utc(2078, 6, 5, 4, 20, 0, 3000)
+      _(obj.smalldatetime).must_equal Time.utc(2078, 6, 5, 4, 20, 0, 0), "Microseconds were <#{obj.smalldatetime.usec}> vs <0>"
       obj.save!
-      _(obj.smalldatetime).must_equal Time.utc(2078, 06, 05, 4, 20, 00, 0), "Microseconds were <#{obj.reload.smalldatetime.usec}> vs <0>"
+      _(obj.smalldatetime).must_equal Time.utc(2078, 6, 5, 4, 20, 0, 0), "Microseconds were <#{obj.reload.smalldatetime.usec}> vs <0>"
       obj.reload
-      _(obj.smalldatetime).must_equal Time.utc(2078, 06, 05, 4, 20, 00, 0), "Microseconds were <#{obj.reload.smalldatetime.usec}> vs <0>"
+      _(obj.smalldatetime).must_equal Time.utc(2078, 6, 5, 4, 20, 0, 0), "Microseconds were <#{obj.reload.smalldatetime.usec}> vs <0>"
     end
 
     it "time(7)" do
-      skip "time() not supported in this protocol version" unless connection_dblib_73?
+      skip "time() not supported in this protocol version" unless connection_tds_73
       col = column("time_7")
       _(col.sql_type).must_equal           "time(7)"
       _(col.type).must_equal               :time
       _(col.null).must_equal               true
-      _(col.default).must_equal            Time.utc(1900, 01, 01, 04, 20, 00, Rational(288321500, 1000)), "Nanoseconds were <#{col.default.nsec}> vs <288321500>"
+      _(col.default).must_equal            Time.utc(1900, 1, 1, 4, 20, 0, Rational(288321500, 1000)), "Nanoseconds were <#{col.default.nsec}> vs <288321500>"
       _(col.default_function).must_be_nil
       type = connection.lookup_cast_type_from_column(col)
       _(type).must_be_instance_of Type::Time
@@ -501,26 +504,26 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
       _(type.precision).must_equal 7
       _(type.scale).must_be_nil
       # Time's #usec precision (low micro)
-      obj.time_7 = Time.utc(2000, 01, 01, 15, 45, 00, 300)
-      _(obj.time_7).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 300), "Microseconds were <#{obj.time_7.usec}> vs <0>"
-      _(obj.time_7).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 300), "Nanoseconds were <#{obj.time_7.nsec}> vs <300>"
+      obj.time_7 = Time.utc(2000, 1, 1, 15, 45, 0, 300)
+      _(obj.time_7).must_equal             Time.utc(2000, 1, 1, 15, 45, 0, 300), "Microseconds were <#{obj.time_7.usec}> vs <0>"
+      _(obj.time_7).must_equal             Time.utc(2000, 1, 1, 15, 45, 0, 300), "Nanoseconds were <#{obj.time_7.nsec}> vs <300>"
       obj.save!; obj.reload
-      _(obj.time_7).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 300), "Microseconds were <#{obj.time_7.usec}> vs <0>"
-      _(obj.time_7).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 300), "Nanoseconds were <#{obj.time_7.nsec}> vs <300>"
+      _(obj.time_7).must_equal             Time.utc(2000, 1, 1, 15, 45, 0, 300), "Microseconds were <#{obj.time_7.usec}> vs <0>"
+      _(obj.time_7).must_equal             Time.utc(2000, 1, 1, 15, 45, 0, 300), "Nanoseconds were <#{obj.time_7.nsec}> vs <300>"
       # Time's #usec precision (high micro)
-      obj.time_7 = Time.utc(2000, 01, 01, 15, 45, 00, 234567)
-      _(obj.time_7).must_equal Time.utc(2000, 01, 01, 15, 45, 00, 234567), "Microseconds were <#{obj.time_7.usec}> vs <234567>"
+      obj.time_7 = Time.utc(2000, 1, 1, 15, 45, 0, 234567)
+      _(obj.time_7).must_equal Time.utc(2000, 1, 1, 15, 45, 0, 234567), "Microseconds were <#{obj.time_7.usec}> vs <234567>"
       obj.save!; obj.reload
-      _(obj.time_7).must_equal Time.utc(2000, 01, 01, 15, 45, 00, 234567), "Microseconds were <#{obj.time_7.usec}> vs <234567>"
+      _(obj.time_7).must_equal Time.utc(2000, 1, 1, 15, 45, 0, 234567), "Microseconds were <#{obj.time_7.usec}> vs <234567>"
       # Time's #usec precision (high nano rounded)
-      obj.time_7 = Time.utc(2000, 01, 01, 15, 45, 00, Rational(288321545, 1000))
-      _(obj.time_7).must_equal Time.utc(2000, 01, 01, 15, 45, 00, Rational(288321500, 1000)), "Nanoseconds were <#{obj.time_7.nsec}> vs <288321500>"
+      obj.time_7 = Time.utc(2000, 1, 1, 15, 45, 0, Rational(288321545, 1000))
+      _(obj.time_7).must_equal Time.utc(2000, 1, 1, 15, 45, 0, Rational(288321500, 1000)), "Nanoseconds were <#{obj.time_7.nsec}> vs <288321500>"
       obj.save!; obj.reload
-      _(obj.time_7).must_equal Time.utc(2000, 01, 01, 15, 45, 00, Rational(288321500, 1000)), "Nanoseconds were <#{obj.time_7.nsec}> vs <288321500>"
+      _(obj.time_7).must_equal Time.utc(2000, 1, 1, 15, 45, 0, Rational(288321500, 1000)), "Nanoseconds were <#{obj.time_7.nsec}> vs <288321500>"
     end
 
     it "time(2)" do
-      skip "time() not supported in this protocol version" unless connection_dblib_73?
+      skip "time() not supported in this protocol version" unless connection_tds_73
       col = column("time_2")
       _(col.sql_type).must_equal           "time(2)"
       _(col.type).must_equal               :time
@@ -533,29 +536,29 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
       _(type.precision).must_equal 2
       _(type.scale).must_be_nil
       # Always uses TinyTDS/Windows 2000-01-01 convention too.
-      obj.time_2 = Time.utc(2015, 01, 10, 15, 45, 00, 0)
-      _(obj.time_2).must_equal Time.utc(2000, 01, 01, 15, 45, 00, 0)
+      obj.time_2 = Time.utc(2015, 1, 10, 15, 45, 0, 0)
+      _(obj.time_2).must_equal Time.utc(2000, 1, 1, 15, 45, 0, 0)
       obj.save!; obj.reload
-      _(obj.time_2).must_equal Time.utc(2000, 01, 01, 15, 45, 00, 0)
+      _(obj.time_2).must_equal Time.utc(2000, 1, 1, 15, 45, 0, 0)
       # Time's #usec precision (barely in 2 precision equal to 0.03 seconds)
-      obj.time_2 = Time.utc(2000, 01, 01, 15, 45, 00, 30000)
-      _(obj.time_2).must_equal Time.utc(2000, 01, 01, 15, 45, 00, 30000), "Microseconds were <#{obj.time_2.usec}> vs <30000>"
+      obj.time_2 = Time.utc(2000, 1, 1, 15, 45, 0, 30000)
+      _(obj.time_2).must_equal Time.utc(2000, 1, 1, 15, 45, 0, 30000), "Microseconds were <#{obj.time_2.usec}> vs <30000>"
       obj.save!; obj.reload
-      _(obj.time_2).must_equal Time.utc(2000, 01, 01, 15, 45, 00, 30000), "Microseconds were <#{obj.time_2.usec}> vs <30000>"
+      _(obj.time_2).must_equal Time.utc(2000, 1, 1, 15, 45, 0, 30000), "Microseconds were <#{obj.time_2.usec}> vs <30000>"
       # Time's #usec precision (below 2 precision)
-      obj.time_2 = Time.utc(2000, 01, 01, 15, 45, 00, 4000)
-      _(obj.time_2).must_equal Time.utc(2000, 01, 01, 15, 45, 00, 0), "Microseconds were <#{obj.time_2.usec}> vs <0>"
+      obj.time_2 = Time.utc(2000, 1, 1, 15, 45, 0, 4000)
+      _(obj.time_2).must_equal Time.utc(2000, 1, 1, 15, 45, 0, 0), "Microseconds were <#{obj.time_2.usec}> vs <0>"
       obj.save!; obj.reload
-      _(obj.time_2).must_equal Time.utc(2000, 01, 01, 15, 45, 00, 0), "Microseconds were <#{obj.time_2.usec}> vs <0>"
+      _(obj.time_2).must_equal Time.utc(2000, 1, 1, 15, 45, 0, 0), "Microseconds were <#{obj.time_2.usec}> vs <0>"
     end
 
     it "time using default precision" do
-      skip "time() not supported in this protocol version" unless connection_dblib_73?
+      skip "time() not supported in this protocol version" unless connection_tds_73
       col = column("time_default")
       _(col.sql_type).must_equal           "time(7)"
       _(col.type).must_equal               :time
       _(col.null).must_equal               true
-      _(col.default).must_equal            Time.utc(1900, 01, 01, 15, 03, 42, Rational(62197800, 1000)), "Nanoseconds were <#{col.default.nsec}> vs <62197800>"
+      _(col.default).must_equal            Time.utc(1900, 1, 1, 15, 3, 42, Rational(62197800, 1000)), "Nanoseconds were <#{col.default.nsec}> vs <62197800>"
       _(col.default_function).must_be_nil
       type = connection.lookup_cast_type_from_column(col)
       _(type).must_be_instance_of Type::Time
@@ -563,22 +566,22 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
       _(type.precision).must_equal 7
       _(type.scale).must_be_nil
       # Time's #usec precision (low micro)
-      obj.time_default = Time.utc(2000, 01, 01, 15, 45, 00, 300)
-      _(obj.time_default).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 300), "Microseconds were <#{obj.time_default.usec}> vs <0>"
-      _(obj.time_default).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 300), "Nanoseconds were <#{obj.time_default.nsec}> vs <300>"
+      obj.time_default = Time.utc(2000, 1, 1, 15, 45, 0, 300)
+      _(obj.time_default).must_equal             Time.utc(2000, 1, 1, 15, 45, 0, 300), "Microseconds were <#{obj.time_default.usec}> vs <0>"
+      _(obj.time_default).must_equal             Time.utc(2000, 1, 1, 15, 45, 0, 300), "Nanoseconds were <#{obj.time_default.nsec}> vs <300>"
       obj.save!; obj.reload
-      _(obj.time_default).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 300), "Microseconds were <#{obj.time_default.usec}> vs <0>"
-      _(obj.time_default).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 300), "Nanoseconds were <#{obj.time_default.nsec}> vs <300>"
+      _(obj.time_default).must_equal             Time.utc(2000, 1, 1, 15, 45, 0, 300), "Microseconds were <#{obj.time_default.usec}> vs <0>"
+      _(obj.time_default).must_equal             Time.utc(2000, 1, 1, 15, 45, 0, 300), "Nanoseconds were <#{obj.time_default.nsec}> vs <300>"
       # Time's #usec precision (high micro)
-      obj.time_default = Time.utc(2000, 01, 01, 15, 45, 00, 234567)
-      _(obj.time_default).must_equal Time.utc(2000, 01, 01, 15, 45, 00, 234567), "Microseconds were <#{obj.time_default.usec}> vs <234567>"
+      obj.time_default = Time.utc(2000, 1, 1, 15, 45, 0, 234567)
+      _(obj.time_default).must_equal Time.utc(2000, 1, 1, 15, 45, 0, 234567), "Microseconds were <#{obj.time_default.usec}> vs <234567>"
       obj.save!; obj.reload
-      _(obj.time_default).must_equal Time.utc(2000, 01, 01, 15, 45, 00, 234567), "Microseconds were <#{obj.time_default.usec}> vs <234567>"
+      _(obj.time_default).must_equal Time.utc(2000, 1, 1, 15, 45, 0, 234567), "Microseconds were <#{obj.time_default.usec}> vs <234567>"
       # Time's #usec precision (high nano rounded)
-      obj.time_default = Time.utc(2000, 01, 01, 15, 45, 00, Rational(288321545, 1000))
-      _(obj.time_default).must_equal Time.utc(2000, 01, 01, 15, 45, 00, Rational(288321500, 1000)), "Nanoseconds were <#{obj.time_default.nsec}> vs <288321500>"
+      obj.time_default = Time.utc(2000, 1, 1, 15, 45, 0, Rational(288321545, 1000))
+      _(obj.time_default).must_equal Time.utc(2000, 1, 1, 15, 45, 0, Rational(288321500, 1000)), "Nanoseconds were <#{obj.time_default.nsec}> vs <288321500>"
       obj.save!; obj.reload
-      _(obj.time_default).must_equal Time.utc(2000, 01, 01, 15, 45, 00, Rational(288321500, 1000)), "Nanoseconds were <#{obj.time_default.nsec}> vs <288321500>"
+      _(obj.time_default).must_equal Time.utc(2000, 1, 1, 15, 45, 0, Rational(288321500, 1000)), "Nanoseconds were <#{obj.time_default.nsec}> vs <288321500>"
     end
 
     # Character Strings

data/test/cases/connection_test_sqlserver.rb

@@ -44,9 +44,9 @@ class ConnectionTestSQLServer < ActiveRecord::TestCase
       assert connection.spid.nil?
     end
 
-    it "reset the connection" do
+    it "reset raw connection on disconnect!" do
       connection.disconnect!
-      _(connection.raw_connection).must_be_nil
+      _(connection.instance_variable_get(:@raw_connection)).must_be_nil
     end
 
     it "be able to disconnect and reconnect at will" do
@@ -60,9 +60,6 @@ class ConnectionTestSQLServer < ActiveRecord::TestCase
   private
 
   def disconnect_raw_connection!
-    case connection_options[:mode]
-    when :dblib
-      connection.raw_connection.close rescue nil
-    end
+    connection.raw_connection.close rescue nil
   end
 end

data/test/cases/dbconsole.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class DbConsole < ActiveRecord::TestCase
+  subject { ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter }
+
+  it "uses sqlplus to connect to database" do
+    subject.expects(:find_cmd_and_exec).with("sqlcmd", "-d", "db", "-U", "user", "-P", "secret", "-S", "tcp:localhost,1433")
+
+    config = make_db_config(adapter: "sqlserver", database: "db", username: "user", password: "secret", host: "localhost", port: 1433)
+
+    subject.dbconsole(config)
+  end
+
+  private
+
+  def make_db_config(config)
+    ActiveRecord::DatabaseConfigurations::HashConfig.new("test", "primary", config)
+  end
+end

data/test/cases/disconnected_test_sqlserver.rb

@@ -5,8 +5,9 @@ require "cases/helper_sqlserver"
 class TestDisconnectedAdapter < ActiveRecord::TestCase
   self.use_transactional_tests = false
 
+  undef_method :setup
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
   end
 
   teardown do
@@ -15,15 +16,16 @@ class TestDisconnectedAdapter < ActiveRecord::TestCase
     ActiveRecord::Base.establish_connection(db_config)
   end
 
-  test "can't execute procedures while disconnected" do
+  test "execute procedure after disconnect reconnects" do
     @connection.execute_procedure :sp_tables, "sst_datatypes"
     @connection.disconnect!
-    assert_raises(ActiveRecord::ConnectionNotEstablished, 'SQL Server client is not connected') do
+
+    assert_nothing_raised do
       @connection.execute_procedure :sp_tables, "sst_datatypes"
     end
   end
 
-  test "can't execute query while disconnected" do
+  test "execute query after disconnect reconnects" do
     sql = "SELECT count(*) from products WHERE id IN(@0, @1)"
     binds = [
       ActiveRecord::Relation::QueryAttribute.new("id", 2, ActiveRecord::Type::BigInteger.new),
@@ -32,7 +34,8 @@ class TestDisconnectedAdapter < ActiveRecord::TestCase
 
     @connection.exec_query sql, "TEST", binds
     @connection.disconnect!
-    assert_raises(ActiveRecord::ConnectionNotEstablished, 'SQL Server client is not connected') do
+
+    assert_nothing_raised do
       @connection.exec_query sql, "TEST", binds
     end
   end

data/test/cases/eager_load_too_many_ids_test_sqlserver.rb

@@ -0,0 +1,18 @@
+require "cases/helper_sqlserver"
+require "models/citation"
+require "models/book"
+
+class EagerLoadingTooManyIdsTest < ActiveRecord::TestCase
+  fixtures :citations
+
+  def test_batch_preloading_too_many_ids
+    in_clause_length = 10_000
+
+    # We Monkey patch Preloader to work with batches of 10_000 records.
+    # Expect: N Books queries + Citation query
+    expected_query_count = (Citation.count / in_clause_length.to_f).ceil + 1
+    assert_queries_count(expected_query_count) do
+      Citation.preload(:reference_of).to_a.size
+    end
+  end
+end

data/test/cases/enum_test_sqlserver.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+
+class EnumTestSQLServer < ActiveRecord::TestCase
+
+  # Check that enums are supported for all string types.
+  # For each type we check: cast, serialize, and update by declaration.
+  # We create a custom class for each type to test.
+  %w[char_10 varchar_50 varchar_max text nchar_10 nvarchar_50 nvarchar_max ntext].each do |col_name|
+    describe "support #{col_name} enums" do
+      let(:klass) do
+        Class.new(ActiveRecord::Base) do
+          self.table_name = 'sst_datatypes'
+
+          enum col_name, { alpha: "A", beta: "B" }
+        end
+      end
+
+      it "type.cast" do
+        type = klass.type_for_attribute(col_name)
+
+        assert_equal "alpha",  type.cast('A')
+        assert_equal "beta",   type.cast('B')
+      end
+
+      it "type.serialize" do
+        type = klass.type_for_attribute(col_name)
+
+        assert_equal 'A', type.serialize('A')
+        assert_equal 'B', type.serialize('B')
+
+        assert_equal 'A', type.serialize(:alpha)
+        assert_equal 'B', type.serialize(:beta)
+      end
+
+      it "update by declaration" do
+        r = klass.new
+
+        r.alpha!
+        assert_predicate r, :alpha?
+
+        r.beta!
+        assert_not_predicate r, :alpha?
+        assert_predicate r, :beta?
+      end
+    end
+  end
+end

data/test/cases/execute_procedure_test_sqlserver.rb

@@ -42,12 +42,16 @@ class ExecuteProcedureTestSQLServer < ActiveRecord::TestCase
     assert_equal date_base.change(usec: 0), date_proc.change(usec: 0)
   end
 
+  def transaction_with_procedure_and_return
+    ActiveRecord::Base.transaction do
+      connection.execute_procedure("my_getutcdate")
+      return
+    end
+  end
+
   it 'test deprecation with transaction return when executing procedure' do
-    assert_deprecated do
-      ActiveRecord::Base.transaction do
-        connection.execute_procedure("my_getutcdate")
-        return
-      end
+    assert_not_deprecated(ActiveRecord.deprecator) do
+      transaction_with_procedure_and_return
     end
   end
 end

data/test/cases/fetch_test_sqlserver.rb

@@ -42,6 +42,25 @@ class FetchTestSqlserver < ActiveRecord::TestCase
     end
   end
 
+  describe "FROM subquery" do
+    let(:from_sql) { "(SELECT [books].* FROM [books]) [books]" }
+
+    it "SQL generated correctly for FROM subquery if order provided" do
+      query = Book.from(from_sql).order(:id).limit(5)
+
+      assert_equal query.to_sql, "SELECT [books].* FROM (SELECT [books].* FROM [books]) [books] ORDER BY [books].[id] ASC OFFSET 0 ROWS FETCH NEXT 5 ROWS ONLY"
+      assert_equal query.to_a.count, 5
+    end
+
+    it "exception thrown if FROM subquery is provided without an order" do
+      query = Book.from(from_sql).limit(5)
+
+      assert_raise(ActiveRecord::StatementInvalid) do
+        query.to_sql
+      end
+    end
+  end
+
   protected
 
   def create_10_books

data/test/cases/helper_sqlserver.rb

@@ -7,21 +7,27 @@ require "pry"
 require "support/core_ext/query_cache"
 require "support/minitest_sqlserver"
 require "support/test_in_memory_oltp"
+require "support/table_definition_sqlserver"
 require "cases/helper"
 require "support/load_schema_sqlserver"
 require "support/coerceable_test_sqlserver"
-require "support/sql_counter_sqlserver"
 require "support/connection_reflection"
+require "support/query_assertions"
 require "mocha/minitest"
 
+module ActiveSupport
+  class TestCase < ::Minitest::Test
+    include ARTest::SQLServer::CoerceableTest
+  end
+end
+
 module ActiveRecord
   class TestCase < ActiveSupport::TestCase
     SQLServer = ActiveRecord::ConnectionAdapters::SQLServer
 
-    include ARTest::SQLServer::CoerceableTest,
-            ARTest::SQLServer::ConnectionReflection,
-            ARTest::SQLServer::SqlCounterSqlserver,
-            ActiveSupport::Testing::Stream
+    include ARTest::SQLServer::ConnectionReflection,
+            ActiveSupport::Testing::Stream,
+            ARTest::SQLServer::QueryAssertions
 
     let(:logger) { ActiveRecord::Base.logger }
 

data/test/cases/index_test_sqlserver.rb

@@ -19,29 +19,31 @@ class IndexTestSQLServer < ActiveRecord::TestCase
   end
 
   it "add index with order" do
-    assert_sql(/CREATE.*INDEX.*\(\[last_name\] DESC\)/i) do
+    assert_queries_match(/CREATE.*INDEX.*\(\[last_name\] DESC\)/i) do
       connection.add_index "testings", ["last_name"], order: { last_name: :desc }
       connection.remove_index "testings", ["last_name"]
     end
-    assert_sql(/CREATE.*INDEX.*\(\[last_name\] DESC, \[first_name\]\)/i) do
+    assert_queries_match(/CREATE.*INDEX.*\(\[last_name\] DESC, \[first_name\]\)/i) do
       connection.add_index "testings", ["last_name", "first_name"], order: { last_name: :desc }
       connection.remove_index "testings", ["last_name", "first_name"]
     end
-    assert_sql(/CREATE.*INDEX.*\(\[last_name\] DESC, \[first_name\] ASC\)/i) do
+    assert_queries_match(/CREATE.*INDEX.*\(\[last_name\] DESC, \[first_name\] ASC\)/i) do
       connection.add_index "testings", ["last_name", "first_name"], order: { last_name: :desc, first_name: :asc }
       connection.remove_index "testings", ["last_name", "first_name"]
     end
   end
 
   it "add index with where" do
-    assert_sql(/CREATE.*INDEX.*\(\[last_name\]\) WHERE \[first_name\] = N'john doe'/i) do
+    assert_queries_match(/CREATE.*INDEX.*\(\[last_name\]\) WHERE \[first_name\] = N'john doe'/i) do
       connection.add_index "testings", "last_name", where: "[first_name] = N'john doe'"
       connection.remove_index "testings", "last_name"
     end
   end
 
   it "add index with expression" do
-    connection.execute "ALTER TABLE [testings] ADD [first_name_upper] AS UPPER([first_name])"
-    connection.add_index "testings", "first_name_upper"
+    assert_nothing_raised do
+      connection.execute "ALTER TABLE [testings] ADD [first_name_upper] AS UPPER([first_name])"
+      connection.add_index "testings", "first_name_upper"
+    end
   end
 end

data/test/cases/json_test_sqlserver.rb

@@ -2,7 +2,7 @@
 
 require "cases/helper_sqlserver"
 
-if ActiveRecord::Base.connection.supports_json?
+if ActiveRecord::Base.lease_connection.supports_json?
   class JsonTestSQLServer < ActiveRecord::TestCase
     before do
       @o1 = SSTestDatatypeMigrationJson.create! json_col: { "a" => "a", "b" => "b", "c" => "c" }

data/test/cases/lateral_test_sqlserver.rb

@@ -16,7 +16,7 @@ class LateralTestSQLServer < ActiveRecord::TestCase
     eq = Arel::Nodes::Equality.new(one, one)
 
     sql = author.project(Arel.star).where(author[:name].matches("David")).outer_join(subselect.lateral.as("bar")).on(eq).to_sql
-    results = ActiveRecord::Base.connection.exec_query sql
+    results = ActiveRecord::Base.lease_connection.exec_query sql
     assert_equal sql, "SELECT * FROM [authors] OUTER APPLY (SELECT * FROM [posts] WHERE [posts].[author_id] = [authors].[id] AND [posts].[id] = 42 ORDER BY [posts].[id] ASC OFFSET 0 ROWS FETCH NEXT 1 ROWS ONLY) AS bar WHERE [authors].[name] LIKE N'David'"
     assert_equal results.length, 1
   end
@@ -27,7 +27,7 @@ class LateralTestSQLServer < ActiveRecord::TestCase
     subselect = post.project(Arel.star).take(1).where(post[:author_id].eq(author[:id])).where(post[:id].eq(42))
 
     sql = author.project(Arel.star).where(author[:name].matches("David")).join(subselect.lateral.as("bar")).to_sql
-    results = ActiveRecord::Base.connection.exec_query sql
+    results = ActiveRecord::Base.lease_connection.exec_query sql
 
     assert_equal sql, "SELECT * FROM [authors] CROSS APPLY (SELECT * FROM [posts] WHERE [posts].[author_id] = [authors].[id] AND [posts].[id] = 42 ORDER BY [posts].[id] ASC OFFSET 0 ROWS FETCH NEXT 1 ROWS ONLY) AS bar WHERE [authors].[name] LIKE N'David'"
     assert_equal results.length, 0

data/test/cases/migration_test_sqlserver.rb

@@ -20,7 +20,7 @@ class MigrationTestSQLServer < ActiveRecord::TestCase
     it "not create a tables if error in migrations" do
       begin
         migrations_dir = File.join ARTest::SQLServer.migrations_root, "transaction_table"
-        quietly { ActiveRecord::MigrationContext.new(migrations_dir, ActiveRecord::SchemaMigration).up }
+        quietly { ActiveRecord::MigrationContext.new(migrations_dir).up }
       rescue Exception => e
         assert_match %r|this and all later migrations canceled|, e.message
       end
@@ -115,4 +115,22 @@ class MigrationTestSQLServer < ActiveRecord::TestCase
       refute_includes schemas, { "name" => "some schema" }
     end
   end
+
+  describe 'creating stored procedure' do
+    it 'stored procedure contains inserts are created successfully' do
+      sql = <<-SQL
+          CREATE OR ALTER PROCEDURE do_some_task
+          AS
+          IF NOT EXISTS(SELECT * FROM sys.objects WHERE type = 'U' AND name = 'SomeTableName')
+          BEGIN
+            CREATE TABLE SomeTableName (SomeNum int PRIMARY KEY CLUSTERED);
+            INSERT INTO SomeTableName(SomeNum) VALUES(1);
+          END
+        SQL
+
+      assert_nothing_raised { connection.execute(sql) }
+    ensure
+      connection.execute("DROP PROCEDURE IF EXISTS dbo.do_some_task;")
+    end
+  end
 end