activerecord-jdbcsqlserver-adapter 50.0.0 → 52.0.0

data/test/cases/connection_test_sqlserver.rb

@@ -36,7 +36,7 @@ class ConnectionTestSQLServer < ActiveRecord::TestCase
   describe 'Connection management' do
 
     it 'set spid on connect' do
-      ['Fixnum', 'Integer'].must_include connection.spid.class.name
+      _(['Fixnum', 'Integer']).must_include connection.spid.class.name
     end
 
     it 'reset spid on disconnect!' do
@@ -46,7 +46,7 @@ class ConnectionTestSQLServer < ActiveRecord::TestCase
 
     it 'reset the connection' do
       connection.disconnect!
-      connection.raw_connection.must_be_nil
+      _(connection.raw_connection).must_be_nil
     end unless defined? JRUBY_VERSION
 
     it 'be able to disconnect and reconnect at will' do

data/test/cases/fetch_test_sqlserver.rb

@@ -36,11 +36,11 @@ class FetchTestSqlserver < ActiveRecord::TestCase
 
     it 'gauntlet' do
       Book.where(name:'Name-10').delete_all
-      Book.order(:name).limit(1).offset(1).map(&:name).must_equal ['Name-2']
-      Book.order(:name).limit(2).offset(2).map(&:name).must_equal ['Name-3', 'Name-4']
-      Book.order(:name).limit(2).offset(7).map(&:name).must_equal ['Name-8', 'Name-9']
-      Book.order(:name).limit(3).offset(7).map(&:name).must_equal ['Name-8', 'Name-9']
-      Book.order(:name).limit(3).offset(9).map(&:name).must_equal []
+      _(Book.order(:name).limit(1).offset(1).map(&:name)).must_equal ['Name-2']
+      _(Book.order(:name).limit(2).offset(2).map(&:name)).must_equal ['Name-3', 'Name-4']
+      _(Book.order(:name).limit(2).offset(7).map(&:name)).must_equal ['Name-8', 'Name-9']
+      _(Book.order(:name).limit(3).offset(7).map(&:name)).must_equal ['Name-8', 'Name-9']
+      _(Book.order(:name).limit(3).offset(9).map(&:name)).must_equal []
     end
 
   end

data/test/cases/helper_sqlserver.rb

@@ -2,6 +2,7 @@ require 'support/paths_sqlserver'
 require 'bundler/setup'
 Bundler.require :default, :development
 require 'pry'
+require 'support/core_ext/query_cache'
 require 'support/minitest_sqlserver'
 require 'support/test_in_memory_oltp'
 require 'cases/helper'
@@ -9,7 +10,7 @@ require 'support/load_schema_sqlserver'
 require 'support/coerceable_test_sqlserver'
 require 'support/sql_counter_sqlserver'
 require 'support/connection_reflection'
-require 'mocha/mini_test'
+require 'mocha/minitest'
 
 module ActiveRecord
   class TestCase < ActiveSupport::TestCase
@@ -23,9 +24,19 @@ module ActiveRecord
 
     let(:logger) { ActiveRecord::Base.logger }
 
+    setup :ensure_clean_rails_env
+    setup :remove_backtrace_silencers
 
     private
 
+    def ensure_clean_rails_env
+      Rails.instance_variable_set(:@_env, nil) if defined?(::Rails)
+    end
+
+    def remove_backtrace_silencers
+      Rails.backtrace_cleaner.remove_silencers!
+    end
+
     def host_windows?
       RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
     end

data/test/cases/json_test_sqlserver.rb

@@ -12,20 +12,20 @@ class JsonTestSQLServer < ActiveRecord::TestCase
   end
 
   it 'can return and save JSON data' do
-    SSTestDatatypeMigrationJson.find(@o1.id).json_col.must_equal({ 'a' => 'a', 'b' => 'b', 'c' => 'c' })
+    _(SSTestDatatypeMigrationJson.find(@o1.id).json_col).must_equal({ 'a' => 'a', 'b' => 'b', 'c' => 'c' })
     @o1.json_col = { 'a' => 'a' }
-    @o1.json_col.must_equal({ 'a' => 'a' })
+    _(@o1.json_col).must_equal({ 'a' => 'a' })
     @o1.save!
-    @o1.reload.json_col.must_equal({ 'a' => 'a' })
+    _(@o1.reload.json_col).must_equal({ 'a' => 'a' })
   end
 
   it 'can use ISJSON function' do
-    SSTestDatatypeMigrationJson.where('ISJSON(json_col) > 0').count.must_equal 4
-    SSTestDatatypeMigrationJson.where('ISJSON(json_col) IS NULL').count.must_equal 1
+    _(SSTestDatatypeMigrationJson.where('ISJSON(json_col) > 0').count).must_equal 4
+    _(SSTestDatatypeMigrationJson.where('ISJSON(json_col) IS NULL').count).must_equal 1
   end
 
   it 'can use JSON_VALUE function' do
-    SSTestDatatypeMigrationJson.where("JSON_VALUE(json_col, '$.b') = 'b'").count.must_equal 2
+    _(SSTestDatatypeMigrationJson.where("JSON_VALUE(json_col, '$.b') = 'b'").count).must_equal 2
   end
 
 end

data/test/cases/migration_test_sqlserver.rb

@@ -20,12 +20,12 @@ 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::Migrator.up(migrations_dir) }
+        quietly { ActiveRecord::MigrationContext.new(migrations_dir).up }
       rescue Exception => e
         assert_match %r|this and all later migrations canceled|, e.message
       end
-      connection.tables.wont_include @trans_test_table1
-      connection.tables.wont_include @trans_test_table2
+      _(connection.tables).wont_include @trans_test_table1
+      _(connection.tables).wont_include @trans_test_table2
     end
 
   end
@@ -41,6 +41,8 @@ class MigrationTestSQLServer < ActiveRecord::TestCase
       lock_version_column = Person.columns_hash['lock_version']
       assert_equal :string, lock_version_column.type
       assert lock_version_column.default.nil?
+      assert_nothing_raised { connection.change_column 'people', 'lock_version', :integer }
+      Person.reset_column_information
     end
 
     it 'not drop the default contraint if just renaming' do
@@ -55,6 +57,14 @@ class MigrationTestSQLServer < ActiveRecord::TestCase
       assert default_after
       assert_equal default_before['constraint_keys'], default_after['constraint_keys']
     end
+    
+    it 'change limit' do
+      assert_nothing_raised { connection.change_column :people, :lock_version, :integer, limit: 8 }
+    end
+    
+    it 'change null and default' do
+      assert_nothing_raised { connection.change_column :people, :first_name, :text, null: true, default: nil }
+    end
 
   end
 

data/test/cases/order_test_sqlserver.rb

@@ -44,13 +44,13 @@ class OrderTestSQLServer < ActiveRecord::TestCase
   it 'support quoted column' do
     order = "[title]"
     post1 = Post.create title: 'AAA Post', body: 'Test cased orders.'
-    assert_equal post1, Post.order(order).first
+    assert_equal post1, Post.order(Arel.sql(order)).first
   end
 
   it 'support quoted table and column' do
     order = "[posts].[title]"
     post1 = Post.create title: 'AAA Post', body: 'Test cased orders.'
-    assert_equal post1, Post.order(order).first
+    assert_equal post1, Post.order(Arel.sql(order)).first
   end
 
   it 'support primary: column, secondary: column' do
@@ -73,74 +73,74 @@ class OrderTestSQLServer < ActiveRecord::TestCase
     order = "(CASE WHEN [title] LIKE N'ZZZ%' THEN title ELSE '' END) DESC, body"
     post1 = Post.create title: 'ZZZ Post', body: 'Test cased orders.'
     post2 = Post.create title: 'ZZZ Post', body: 'ZZZ Test cased orders.'
-    assert_equal post1, Post.order(order).first
-    assert_equal post2, Post.order(order).second
+    assert_equal post1, Post.order(Arel.sql(order)).first
+    assert_equal post2, Post.order(Arel.sql(order)).second
   end
 
   it 'support primary: quoted table and column, secondary: case expresion' do
     order = "[posts].[body] DESC, (CASE WHEN [title] LIKE N'ZZZ%' THEN title ELSE '' END) DESC"
     post1 = Post.create title: 'ZZZ Post', body: 'ZZZ Test cased orders.'
     post2 = Post.create title: 'ZZY Post', body: 'ZZZ Test cased orders.'
-    assert_equal post1, Post.order(order).first
-    assert_equal post2, Post.order(order).second
+    assert_equal post1, Post.order(Arel.sql(order)).first
+    assert_equal post2, Post.order(Arel.sql(order)).second
   end
 
   it 'support inline function' do
     order = "LEN(title)"
     post1 = Post.create title: 'A', body: 'AAA Test cased orders.'
-    assert_equal post1, Post.order(order).first
+    assert_equal post1, Post.order(Arel.sql(order)).first
   end
 
   it 'support inline function with parameters' do
     order = "SUBSTRING(title, 1, 3)"
     post1 = Post.create title: 'AAA Post', body: 'Test cased orders.'
-    assert_equal post1, Post.order(order).first
+    assert_equal post1, Post.order(Arel.sql(order)).first
   end
 
   it 'support inline function with parameters DESC' do
     order = "SUBSTRING(title, 1, 3) DESC"
     post1 = Post.create title: 'ZZZ Post', body: 'Test cased orders.'
-    assert_equal post1, Post.order(order).first
+    assert_equal post1, Post.order(Arel.sql(order)).first
   end
 
   it 'support primary: inline function, secondary: column' do
     order = "LEN(title), body"
     post1 = Post.create title: 'A', body: 'AAA Test cased orders.'
     post2 = Post.create title: 'A', body: 'Test cased orders.'
-    assert_equal post1, Post.order(order).first
-    assert_equal post2, Post.order(order).second
+    assert_equal post1, Post.order(Arel.sql(order)).first
+    assert_equal post2, Post.order(Arel.sql(order)).second
   end
 
   it 'support primary: inline function, secondary: column with direction' do
     order = "LEN(title) ASC, body DESC"
     post1 = Post.create title: 'A', body: 'ZZZ Test cased orders.'
     post2 = Post.create title: 'A', body: 'Test cased orders.'
-    assert_equal post1, Post.order(order).first
-    assert_equal post2, Post.order(order).second
+    assert_equal post1, Post.order(Arel.sql(order)).first
+    assert_equal post2, Post.order(Arel.sql(order)).second
   end
 
   it 'support primary: column, secondary: inline function' do
     order = "body DESC, LEN(title)"
     post1 = Post.create title: 'Post', body: 'ZZZ Test cased orders.'
     post2 = Post.create title: 'Longer Post', body: 'ZZZ Test cased orders.'
-    assert_equal post1, Post.order(order).first
-    assert_equal post2, Post.order(order).second
+    assert_equal post1, Post.order(Arel.sql(order)).first
+    assert_equal post2, Post.order(Arel.sql(order)).second
   end
 
   it 'support primary: case expression, secondary: inline function' do
     order = "CASE WHEN [title] LIKE N'ZZZ%' THEN title ELSE '' END DESC, LEN(body) ASC"
     post1 = Post.create title: 'ZZZ Post', body: 'Z'
     post2 = Post.create title: 'ZZZ Post', body: 'Test cased orders.'
-    assert_equal post1, Post.order(order).first
-    assert_equal post2, Post.order(order).second
+    assert_equal post1, Post.order(Arel.sql(order)).first
+    assert_equal post2, Post.order(Arel.sql(order)).second
   end
 
   it 'support primary: inline function, secondary: case expression' do
     order = "LEN(body), CASE WHEN [title] LIKE N'ZZZ%' THEN title ELSE '' END DESC"
     post1 = Post.create title: 'ZZZ Post', body: 'Z'
     post2 = Post.create title: 'Post', body: 'Z'
-    assert_equal post1, Post.order(order).first
-    assert_equal post2, Post.order(order).second
+    assert_equal post1, Post.order(Arel.sql(order)).first
+    assert_equal post2, Post.order(Arel.sql(order)).second
   end
 
 

data/test/cases/pessimistic_locking_test_sqlserver.rb

@@ -13,7 +13,7 @@ class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
 
   it 'uses with updlock by default' do
     assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(UPDLOCK\)| do
-      Person.lock(true).to_a.must_equal Person.all.to_a
+      _(Person.lock(true).to_a).must_equal Person.all.to_a
     end
   end
 
@@ -22,7 +22,7 @@ class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
     it 'lock with simple find' do
       assert_nothing_raised do
         Person.transaction do
-          Person.lock(true).find(1).must_equal Person.find(1)
+          _(Person.lock(true).find(1)).must_equal Person.find(1)
         end
       end
     end
@@ -31,7 +31,7 @@ class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
       assert_nothing_raised do
         Person.transaction do
           Person.lock(true).scoping do
-            Person.find(1).must_equal Person.find(1)
+            _(Person.find(1)).must_equal Person.find(1)
           end
         end
       end
@@ -41,18 +41,7 @@ class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
        assert_nothing_raised do
         Person.transaction do
           person = Person.lock(true).includes(:readers).find(1)
-          person.must_equal Person.find(1)
-        end
-      end
-    end
-
-    it 'reload with lock when #lock! called' do
-      assert_nothing_raised do
-        Person.transaction do
-          person = Person.find 1
-          old, person.first_name = person.first_name, 'fooman'
-          person.lock!
-          assert_equal old, person.first_name
+          _(person).must_equal Person.find(1)
         end
       end
     end
@@ -63,6 +52,34 @@ class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
       end
     end
 
+    describe 'joining tables' do
+
+      it 'joined tables use updlock by default' do
+        assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(UPDLOCK\) INNER JOIN \[readers\] WITH\(UPDLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
+          Person.lock(true).joins(:readers).load
+        end
+      end
+
+      it 'joined tables can use custom lock directive' do
+        assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(NOLOCK\) INNER JOIN \[readers\] WITH\(NOLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
+          Person.lock('WITH(NOLOCK)').joins(:readers).load
+        end
+      end
+
+      it 'left joined tables use updlock by default' do
+        assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(UPDLOCK\) LEFT OUTER JOIN \[readers\] WITH\(UPDLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
+          Person.lock(true).left_joins(:readers).load
+        end
+      end
+
+      it 'left joined tables can use custom lock directive' do
+        assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(NOLOCK\) LEFT OUTER JOIN \[readers\] WITH\(NOLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
+          Person.lock('WITH(NOLOCK)').left_joins(:readers).load
+        end
+      end
+
+    end
+
   end
 
   describe 'For paginated finds' do
@@ -81,11 +98,11 @@ class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
       loader_sql = /SELECT.*FROM \[people\] WITH\(UPDLOCK\).*WHERE \[people\]\.\[id\] IN/
       assert_sql(eager_ids_sql, loader_sql) do
         people = Person.lock(true).limit(5).offset(10).includes(:readers).references(:readers).to_a
-        people[0].first_name.must_equal 'Thing_10'
-        people[1].first_name.must_equal 'Thing_11'
-        people[2].first_name.must_equal 'Thing_12'
-        people[3].first_name.must_equal 'Thing_13'
-        people[4].first_name.must_equal 'Thing_14'
+        _(people[0].first_name).must_equal 'Thing_10'
+        _(people[1].first_name).must_equal 'Thing_11'
+        _(people[2].first_name).must_equal 'Thing_12'
+        _(people[3].first_name).must_equal 'Thing_13'
+        _(people[4].first_name).must_equal 'Thing_14'
       end
     end
 

data/test/cases/rake_test_sqlserver.rb

@@ -43,23 +43,23 @@ class SQLServerRakeCreateTest < SQLServerRakeTest
 
   it 'establishes connection to database after create ' do
     quietly { db_tasks.create configuration }
-    connection.current_database.must_equal(new_database)
+    _(connection.current_database).must_equal(new_database)
   end
 
   it 'creates database with default collation' do
     quietly { db_tasks.create configuration }
-    connection.collation.must_equal 'SQL_Latin1_General_CP1_CI_AS'
+    _(connection.collation).must_equal 'SQL_Latin1_General_CP1_CI_AS'
   end
 
   it 'creates database with given collation' do
     quietly { db_tasks.create configuration.merge('collation' => 'Latin1_General_CI_AS') }
-    connection.collation.must_equal 'Latin1_General_CI_AS'
+    _(connection.collation).must_equal 'Latin1_General_CI_AS'
   end
 
   it 'prints error message when database exists' do
     quietly { db_tasks.create configuration }
     message = capture(:stderr) { db_tasks.create configuration }
-    message.must_match %r{activerecord_unittest_tasks.*already exists}
+    _(message).must_match %r{activerecord_unittest_tasks.*already exists}
   end
 
 end
@@ -73,12 +73,12 @@ class SQLServerRakeDropTest < SQLServerRakeTest
       db_tasks.create configuration
       db_tasks.drop configuration
     end
-    connection.current_database.must_equal 'master'
+    _(connection.current_database).must_equal 'master'
   end
 
   it 'prints error message when database does not exist' do
     message = capture(:stderr) { db_tasks.drop configuration.merge('database' => 'doesnotexist') }
-    message.must_match %r{'doesnotexist' does not exist}
+    _(message).must_match %r{'doesnotexist' does not exist}
   end
 
 end
@@ -94,11 +94,11 @@ class SQLServerRakePurgeTest < SQLServerRakeTest
   end
 
   it 'clears active connections, drops database, and recreates with established connection' do
-    connection.current_database.must_equal(new_database)
-    connection.tables.must_include 'users'
+    _(connection.current_database).must_equal(new_database)
+    _(connection.tables).must_include 'users'
     quietly { db_tasks.purge(configuration) }
-    connection.current_database.must_equal(new_database)
-    connection.tables.wont_include 'users'
+    _(connection.current_database).must_equal(new_database)
+    _(connection.tables).wont_include 'users'
   end
 
 end
@@ -110,7 +110,7 @@ class SQLServerRakeCharsetTest < SQLServerRakeTest
   end
 
   it 'retrieves charset' do
-    db_tasks.charset(configuration).must_equal 'iso_1'
+    _(db_tasks.charset(configuration)).must_equal 'iso_1'
   end
 
 end
@@ -122,7 +122,7 @@ class SQLServerRakeCollationTest < SQLServerRakeTest
   end
 
   it 'retrieves collation' do
-    db_tasks.collation(configuration).must_equal 'SQL_Latin1_General_CP1_CI_AS'
+    _(db_tasks.collation(configuration)).must_equal 'SQL_Latin1_General_CP1_CI_AS'
   end
 
 end
@@ -149,21 +149,21 @@ class SQLServerRakeStructureDumpLoadTest < SQLServerRakeTest
   it 'dumps structure and accounts for defncopy oddities' do
     skip 'debug defncopy on windows later' if host_windows?
     quietly { db_tasks.structure_dump configuration, filename }
-    filedata.wont_match %r{\AUSE.*\z}
-    filedata.wont_match %r{\AGO.*\z}
-    filedata.must_match %r{email\s+nvarchar\(4000\)}
-    filedata.must_match %r{background1\s+nvarchar\(max\)}
-    filedata.must_match %r{background2\s+text\s+}
+    _(filedata).wont_match %r{\AUSE.*\z}
+    _(filedata).wont_match %r{\AGO.*\z}
+    _(filedata).must_match %r{email\s+nvarchar\(4000\)}
+    _(filedata).must_match %r{background1\s+nvarchar\(max\)}
+    _(filedata).must_match %r{background2\s+text\s+}
   end
 
   it 'can load dumped structure' do
     skip 'debug defncopy on windows later' if host_windows?
     quietly { db_tasks.structure_dump configuration, filename }
-    filedata.must_match %r{CREATE TABLE dbo\.users}
+    _(filedata).must_match %r{CREATE TABLE dbo\.users}
     db_tasks.purge(configuration)
-    connection.tables.wont_include 'users'
+    _(connection.tables).wont_include 'users'
     db_tasks.load_schema configuration, :sql, filename
-    connection.tables.must_include 'users'
+    _(connection.tables).must_include 'users'
   end
 
 end

data/test/cases/schema_dumper_test_sqlserver.rb

@@ -34,21 +34,22 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
     if connection_dblib_73?
     assert_line :time_7,            type: 'time',         limit: nil,           precision: 7,     scale: nil,  default: "04:20:00.2883215"
     assert_line :time_2,            type: 'time',         limit: nil,           precision: 2,     scale: nil,  default: nil
+    assert_line :time_default,      type: 'time',         limit: nil,           precision: 7,     scale: nil,  default: "15:03:42.0621978"
     end
     # Character Strings
     assert_line :char_10,           type: 'char',         limit: 10,            precision: nil,   scale: nil,  default: "1234567890",           collation: nil
     assert_line :varchar_50,        type: 'varchar',      limit: 50,            precision: nil,   scale: nil,  default: "test varchar_50",      collation: nil
-    assert_line :varchar_max,       type: 'varchar_max',  limit: 2147483647,    precision: nil,   scale: nil,  default: "test varchar_max",     collation: nil
-    assert_line :text,              type: 'text_basic',   limit: 2147483647,    precision: nil,   scale: nil,  default: "test text",            collation: nil
+    assert_line :varchar_max,       type: 'varchar_max',  limit: nil,           precision: nil,   scale: nil,  default: "test varchar_max",     collation: nil
+    assert_line :text,              type: 'text_basic',   limit: nil,           precision: nil,   scale: nil,  default: "test text",            collation: nil
     # Unicode Character Strings
     assert_line :nchar_10,          type: 'nchar',        limit: 10,            precision: nil,   scale: nil,  default: "12345678åå",           collation: nil
     assert_line :nvarchar_50,       type: 'string',       limit: 50,            precision: nil,   scale: nil,  default: "test nvarchar_50 åå",  collation: nil
-    assert_line :nvarchar_max,      type: 'text',         limit: 2147483647,    precision: nil,   scale: nil,  default: "test nvarchar_max åå", collation: nil
-    assert_line :ntext,             type: 'ntext',        limit: 2147483647,    precision: nil,   scale: nil,  default: "test ntext åå",        collation: nil
+    assert_line :nvarchar_max,      type: 'text',         limit: nil,           precision: nil,   scale: nil,  default: "test nvarchar_max åå", collation: nil
+    assert_line :ntext,             type: 'ntext',        limit: nil,           precision: nil,   scale: nil,  default: "test ntext åå",        collation: nil
     # Binary Strings
     assert_line :binary_49,         type: 'binary_basic', limit: 49,            precision: nil,   scale: nil,  default: nil
     assert_line :varbinary_49,      type: 'varbinary',    limit: 49,            precision: nil,   scale: nil,  default: nil
-    assert_line :varbinary_max,     type: 'binary',       limit: 2147483647,    precision: nil,   scale: nil,  default: nil
+    assert_line :varbinary_max,     type: 'binary',       limit: nil,           precision: nil,   scale: nil,  default: nil
     # Other Data Types
     assert_line :uniqueidentifier,  type: 'uuid',         limit: nil,           precision: nil,   scale: nil,  default: -> { "newid()" }
     assert_line :timestamp,         type: 'ss_timestamp', limit: nil,           precision: nil,   scale: nil,  default: nil
@@ -58,47 +59,47 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
     columns = SSTestDatatypeMigration.columns_hash
     generate_schema_for_table 'sst_datatypes_migration'
     # Simple Rails conventions
-    columns['integer_col'].sql_type.must_equal      'int(4)'
-    columns['bigint_col'].sql_type.must_equal       'bigint(8)'
-    columns['boolean_col'].sql_type.must_equal      'bit'
-    columns['decimal_col'].sql_type.must_equal      'decimal(18,0)'
-    columns['float_col'].sql_type.must_equal        'float'
-    columns['string_col'].sql_type.must_equal       'nvarchar(4000)'
-    columns['text_col'].sql_type.must_equal         'nvarchar(max)'
-    columns['datetime_col'].sql_type.must_equal     'datetime'
-    columns['timestamp_col'].sql_type.must_equal    'datetime'
-    columns['time_col'].sql_type.must_equal         'time(7)'
-    columns['date_col'].sql_type.must_equal         'date'
-    columns['binary_col'].sql_type.must_equal       'varbinary(max)'
+    _(columns['integer_col'].sql_type).must_equal      'int(4)'
+    _(columns['bigint_col'].sql_type).must_equal       'bigint(8)'
+    _(columns['boolean_col'].sql_type).must_equal      'bit'
+    _(columns['decimal_col'].sql_type).must_equal      'decimal(18,0)'
+    _(columns['float_col'].sql_type).must_equal        'float'
+    _(columns['string_col'].sql_type).must_equal       'nvarchar(4000)'
+    _(columns['text_col'].sql_type).must_equal         'nvarchar(max)'
+    _(columns['datetime_col'].sql_type).must_equal     'datetime'
+    _(columns['timestamp_col'].sql_type).must_equal    'datetime'
+    _(columns['time_col'].sql_type).must_equal         'time(7)'
+    _(columns['date_col'].sql_type).must_equal         'date'
+    _(columns['binary_col'].sql_type).must_equal       'varbinary(max)'
     assert_line :integer_col,     type: 'integer',      limit: nil,          precision: nil,  scale: nil, default: nil
     assert_line :bigint_col,      type: 'bigint',       limit: nil,          precision: nil,  scale: nil, default: nil
     assert_line :boolean_col,     type: 'boolean',      limit: nil,          precision: nil,  scale: nil, default: nil
     assert_line :decimal_col,     type: 'decimal',      limit: nil,          precision: 18,   scale: 0,   default: nil
     assert_line :float_col,       type: 'float',        limit: nil,          precision: nil,  scale: nil, default: nil
     assert_line :string_col,      type: 'string',       limit: nil,          precision: nil,  scale: nil, default: nil
-    assert_line :text_col,        type: 'text',         limit: 2147483647,   precision: nil,  scale: nil, default: nil
+    assert_line :text_col,        type: 'text',         limit: nil,          precision: nil,  scale: nil, default: nil
     assert_line :datetime_col,    type: 'datetime',     limit: nil,          precision: nil,  scale: nil, default: nil
     assert_line :timestamp_col,   type: 'datetime',     limit: nil,          precision: nil,  scale: nil, default: nil
     assert_line :time_col,        type: 'time',         limit: nil,          precision: 7,    scale: nil, default: nil
     assert_line :date_col,        type: 'date',         limit: nil,          precision: nil,  scale: nil, default: nil
-    assert_line :binary_col,      type: 'binary',       limit: 2147483647,   precision: nil,  scale: nil, default: nil
+    assert_line :binary_col,      type: 'binary',       limit: nil,          precision: nil,  scale: nil, default: nil
     # Our type methods.
-    columns['real_col'].sql_type.must_equal         'real'
-    columns['money_col'].sql_type.must_equal        'money'
-    columns['smalldatetime_col'].sql_type.must_equal 'smalldatetime'
-    columns['datetime2_col'].sql_type.must_equal    'datetime2(7)'
-    columns['datetimeoffset'].sql_type.must_equal   'datetimeoffset(7)'
-    columns['smallmoney_col'].sql_type.must_equal   'smallmoney'
-    columns['char_col'].sql_type.must_equal         'char(1)'
-    columns['varchar_col'].sql_type.must_equal      'varchar(8000)'
-    columns['text_basic_col'].sql_type.must_equal   'text'
-    columns['nchar_col'].sql_type.must_equal        'nchar(1)'
-    columns['ntext_col'].sql_type.must_equal        'ntext'
-    columns['binary_basic_col'].sql_type.must_equal 'binary(1)'
-    columns['varbinary_col'].sql_type.must_equal    'varbinary(8000)'
-    columns['uuid_col'].sql_type.must_equal         'uniqueidentifier'
-    columns['sstimestamp_col'].sql_type.must_equal  'timestamp'
-    columns['json_col'].sql_type.must_equal         'nvarchar(max)'
+    _(columns['real_col'].sql_type).must_equal         'real'
+    _(columns['money_col'].sql_type).must_equal        'money'
+    _(columns['smalldatetime_col'].sql_type).must_equal 'smalldatetime'
+    _(columns['datetime2_col'].sql_type).must_equal    'datetime2(7)'
+    _(columns['datetimeoffset'].sql_type).must_equal   'datetimeoffset(7)'
+    _(columns['smallmoney_col'].sql_type).must_equal   'smallmoney'
+    _(columns['char_col'].sql_type).must_equal         'char(1)'
+    _(columns['varchar_col'].sql_type).must_equal      'varchar(8000)'
+    _(columns['text_basic_col'].sql_type).must_equal   'text'
+    _(columns['nchar_col'].sql_type).must_equal        'nchar(1)'
+    _(columns['ntext_col'].sql_type).must_equal        'ntext'
+    _(columns['binary_basic_col'].sql_type).must_equal 'binary(1)'
+    _(columns['varbinary_col'].sql_type).must_equal    'varbinary(8000)'
+    _(columns['uuid_col'].sql_type).must_equal         'uniqueidentifier'
+    _(columns['sstimestamp_col'].sql_type).must_equal  'timestamp'
+    _(columns['json_col'].sql_type).must_equal         'nvarchar(max)'
     assert_line :real_col,          type: 'real',           limit: nil,           precision: nil,   scale: nil,  default: nil
     assert_line :money_col,         type: 'money',          limit: nil,           precision: 19,    scale: 4,    default: nil
     assert_line :smalldatetime_col, type: 'smalldatetime',  limit: nil,           precision: nil,   scale: nil,  default: nil
@@ -107,14 +108,14 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
     assert_line :smallmoney_col,    type: 'smallmoney',     limit: nil,           precision: 10,    scale: 4,    default: nil
     assert_line :char_col,          type: 'char',           limit: 1,             precision: nil,   scale: nil,  default: nil
     assert_line :varchar_col,       type: 'varchar',        limit: nil,           precision: nil,   scale: nil,  default: nil
-    assert_line :text_basic_col,    type: 'text_basic',     limit: 2147483647,    precision: nil,   scale: nil,  default: nil
+    assert_line :text_basic_col,    type: 'text_basic',     limit: nil,           precision: nil,   scale: nil,  default: nil
     assert_line :nchar_col,         type: 'nchar',          limit: 1,             precision: nil,   scale: nil,  default: nil
-    assert_line :ntext_col,         type: 'ntext',          limit: 2147483647,    precision: nil,   scale: nil,  default: nil
+    assert_line :ntext_col,         type: 'ntext',          limit: nil,           precision: nil,   scale: nil,  default: nil
     assert_line :binary_basic_col,  type: 'binary_basic',   limit: 1,             precision: nil,   scale: nil,  default: nil
     assert_line :varbinary_col,     type: 'varbinary',      limit: nil,           precision: nil,   scale: nil,  default: nil
     assert_line :uuid_col,          type: 'uuid',           limit: nil,           precision: nil,   scale: nil,  default: nil
     assert_line :sstimestamp_col,   type: 'ss_timestamp',   limit: nil,           precision: nil,   scale: nil,  default: nil
-    assert_line :json_col,          type: 'text',           limit: 2147483647,    precision: nil,   scale: nil,  default: nil
+    assert_line :json_col,          type: 'text',           limit: nil,           precision: nil,   scale: nil,  default: nil
   end
 
   # Special Cases
@@ -129,7 +130,7 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
 
   it 'no id with model driven primary key' do
     output = generate_schema_for_table 'sst_no_pk_data'
-    output.must_match %r{create_table "sst_no_pk_data".*id:\sfalse.*do}
+    _(output).must_match %r{create_table "sst_no_pk_data".*id:\sfalse.*do}
     assert_line :name, type: 'string', limit: nil, default: nil, collation: nil
   end
 
@@ -165,15 +166,15 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
       expected = options[key]
       message  = "#{key.to_s.titleize} of #{expected.inspect} not found in:\n#{line}"
       if expected.nil?
-        actual.must_be_nil message
+        _(actual).must_be_nil message
       elsif expected.is_a?(Array)
         actual.must_include expected, message
       elsif expected.is_a?(Float)
-        actual.must_be_close_to expected, 0.001
+        _(actual).must_be_close_to expected, 0.001
       elsif expected.is_a?(Proc)
-        actual.call.must_equal(expected.call)
+        _(actual.call).must_equal(expected.call)
       else
-        actual.must_equal expected, message
+        _(actual).must_equal expected, message
       end
     end
   end