activerecord-sqlserver-adapter 4.2.18 → 5.0.0

data/test/cases/connection_test_sqlserver.rb

@@ -4,12 +4,14 @@ require 'models/topic'
 
 class ConnectionTestSQLServer < ActiveRecord::TestCase
 
-  self.use_transactional_fixtures = false
+  self.use_transactional_tests = false
 
   fixtures :topics, :accounts
 
-  before { assert connection.active? }
-  after  { connection.reconnect! }
+  before do
+    connection.reconnect!
+    assert connection.active?
+  end
 
   it 'affect rows' do
     topic_data = { 1 => { "content" => "1 updated" }, 2 => { "content" => "2 updated" } }
@@ -31,61 +33,6 @@ class ConnectionTestSQLServer < ActiveRecord::TestCase
     end
   end unless connection_sqlserver_azure?
 
-  describe 'ODBC connection management' do
-
-    it 'return finished ODBC statement handle from #execute without block' do
-      assert_all_odbc_statements_used_are_closed do
-        connection.execute('SELECT * FROM [topics]')
-      end
-    end
-
-    it 'finish ODBC statement handle from #execute with block' do
-      assert_all_odbc_statements_used_are_closed do
-        connection.execute('SELECT * FROM [topics]') { }
-      end
-    end
-
-    it 'finish connection from #raw_select' do
-      assert_all_odbc_statements_used_are_closed do
-        connection.send(:raw_select,'SELECT * FROM [topics]')
-      end
-    end
-
-    it 'execute without block closes statement' do
-      assert_all_odbc_statements_used_are_closed do
-        connection.execute("SELECT 1")
-      end
-    end
-
-    it 'execute with block closes statement' do
-      assert_all_odbc_statements_used_are_closed do
-        connection.execute("SELECT 1") do |sth|
-          assert !sth.finished?, "Statement should still be alive within block"
-        end
-      end
-    end
-
-    it 'insert with identity closes statement' do
-      assert_all_odbc_statements_used_are_closed do
-        connection.exec_insert "INSERT INTO accounts ([id],[firm_id],[credit_limit]) VALUES (999, 1, 50)", "SQL", []
-      end
-    end
-
-    it 'insert without identity closes statement' do
-      assert_all_odbc_statements_used_are_closed do
-        connection.exec_insert "INSERT INTO accounts ([firm_id],[credit_limit]) VALUES (1, 50)", "SQL", []
-      end
-    end
-
-    it 'active closes statement' do
-      assert_all_odbc_statements_used_are_closed do
-        connection.active?
-      end
-    end
-
-  end if connection_odbc?
-
-
   describe 'Connection management' do
 
     it 'set spid on connect' do
@@ -118,25 +65,7 @@ class ConnectionTestSQLServer < ActiveRecord::TestCase
     case connection_options[:mode]
     when :dblib
       connection.raw_connection.close rescue nil
-    when :odbc
-      connection.raw_connection.disconnect rescue nil
     end
   end
 
-  def assert_all_odbc_statements_used_are_closed(&block)
-    odbc = connection.raw_connection.class.parent
-    existing_handles = []
-    ObjectSpace.each_object(odbc::Statement) { |h| existing_handles << h }
-    existing_handle_ids = existing_handles.map(&:object_id)
-    assert existing_handles.all?(&:finished?), "Somewhere before the block some statements were not closed"
-    GC.disable
-    yield
-    used_handles = []
-    ObjectSpace.each_object(odbc::Statement) { |h| used_handles << h unless existing_handle_ids.include?(h.object_id) }
-    assert used_handles.size > 0, "No statements were used within given block"
-    assert used_handles.all?(&:finished?), "Statement should have been closed within given block"
-  ensure
-    GC.enable
-  end
-
 end

data/test/cases/fully_qualified_identifier_test_sqlserver.rb

@@ -37,7 +37,7 @@ class FullyQualifiedIdentifierTestSQLServer < ActiveRecord::TestCase
     it 'should not use fully qualified table name in where clause' do
       table = Arel::Table.new(:table)
       expected_sql = "SELECT * FROM [my.server].[db].[schema].[table] WHERE [table].[id] = 42"
-      assert_equal expected_sql, table.project(Arel.star).where(table[:id].eq(42)).to_sql
+      quietly { assert_equal expected_sql, table.project(Arel.star).where(table[:id].eq(42)).to_sql }
     end
 
     it 'should not use fully qualified table name in order clause' do
@@ -47,28 +47,28 @@ class FullyQualifiedIdentifierTestSQLServer < ActiveRecord::TestCase
     end
 
     it 'should use fully qualified table name in insert statement' do
-      manager = Arel::InsertManager.new(Arel::Table.engine)
+      manager = Arel::InsertManager.new
       manager.into Arel::Table.new(:table)
       manager.values = manager.create_values [Arel.sql('*')], %w{ a }
       expected_sql = "INSERT INTO [my.server].[db].[schema].[table] VALUES (*)"
-      assert_equal expected_sql, manager.to_sql
+      quietly { assert_equal expected_sql, manager.to_sql }
     end
 
     it 'should use fully qualified table name in update statement' do
       table = Arel::Table.new(:table)
-      manager = Arel::UpdateManager.new(Arel::Table.engine)
+      manager = Arel::UpdateManager.new
       manager.table(table).where(table[:id].eq(42))
       manager.set([[table[:name], "Bob"]])
       expected_sql = "UPDATE [my.server].[db].[schema].[table] SET [name] = N'Bob' WHERE [table].[id] = 42"
-      assert_equal expected_sql, manager.to_sql
+      quietly { assert_equal expected_sql, manager.to_sql }
     end
 
     it 'should use fully qualified table name in delete statement' do
       table = Arel::Table.new(:table)
-      manager = Arel::DeleteManager.new(Arel::Table.engine)
+      manager = Arel::DeleteManager.new
       manager.from(table).where(table[:id].eq(42))
       expected_sql = "DELETE FROM [my.server].[db].[schema].[table] WHERE [table].[id] = 42"
-      assert_equal expected_sql, manager.to_sql
+      quietly { assert_equal expected_sql, manager.to_sql }
     end
 
   end

data/test/cases/helper_sqlserver.rb

@@ -1,6 +1,7 @@
 require 'support/paths_sqlserver'
 require 'bundler/setup'
 Bundler.require :default, :development
+require 'pry'
 require 'support/minitest_sqlserver'
 require 'cases/helper'
 require 'support/load_schema_sqlserver'
@@ -15,7 +16,9 @@ module ActiveRecord
     SQLServer = ActiveRecord::ConnectionAdapters::SQLServer
 
     include ARTest::SQLServer::CoerceableTest,
-            ARTest::SQLServer::ConnectionReflection
+            ARTest::SQLServer::ConnectionReflection,
+            ARTest::SQLServer::SqlCounterSqlserver,
+            ActiveSupport::Testing::Stream
 
     let(:logger) { ActiveRecord::Base.logger }
 
@@ -34,20 +37,6 @@ module ActiveRecord
       klass.use_output_inserted = true
     end
 
-    def silence_stream(stream)
-      old_stream = stream.dup
-      stream.reopen(RbConfig::CONFIG['host_os'] =~ /mswin|mingw/ ? 'NUL:' : '/dev/null')
-      stream.sync = true
-      yield
-    ensure
-      stream.reopen(old_stream)
-      old_stream.close
-    end
-
-    def quietly
-      silence_stream(STDOUT) { silence_stream(STDERR) { yield } }
-    end
-
   end
 end
 

data/test/cases/pessimistic_locking_test_sqlserver.rb

@@ -73,7 +73,7 @@ class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
     end
 
     it 'copes with eager loading un-locked paginated' do
-      eager_ids_sql = /SELECT\s+DISTINCT \[people\].\[id\] FROM \[people\] WITH\(UPDLOCK\) LEFT OUTER JOIN \[readers\] WITH\(UPDLOCK\)\s+ON \[readers\].\[person_id\] = \[people\].\[id\]\s+ORDER BY \[people\].\[id\] ASC OFFSET 10 ROWS FETCH NEXT 5 ROWS ONLY/
+      eager_ids_sql = /SELECT\s+DISTINCT \[people\].\[id\] FROM \[people\] WITH\(UPDLOCK\) LEFT OUTER JOIN \[readers\] WITH\(UPDLOCK\)\s+ON \[readers\].\[person_id\] = \[people\].\[id\]\s+ORDER BY \[people\].\[id\] ASC OFFSET @0 ROWS FETCH NEXT @1 ROWS ONLY/
       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

data/test/cases/rake_test_sqlserver.rb

@@ -2,7 +2,7 @@ require 'cases/helper_sqlserver'
 
 class SQLServerRakeTest < ActiveRecord::TestCase
 
-  self.use_transactional_fixtures = false
+  self.use_transactional_tests = false
 
   cattr_accessor :azure_skip
   self.azure_skip = connection_sqlserver_azure?
@@ -42,24 +42,24 @@ class SQLServerRakeCreateTest < SQLServerRakeTest
   self.azure_skip = false
 
   it 'establishes connection to database after create ' do
-    db_tasks.create configuration
+    quietly { db_tasks.create configuration }
     connection.current_database.must_equal(new_database)
   end
 
   it 'creates database with default collation' do
-    db_tasks.create configuration
+    quietly { db_tasks.create configuration }
     connection.collation.must_equal 'SQL_Latin1_General_CP1_CI_AS'
   end
 
   it 'creates database with given collation' do
-    db_tasks.create configuration.merge('collation' => 'Latin1_General_CI_AS')
+    quietly { db_tasks.create configuration.merge('collation' => 'Latin1_General_CI_AS') }
     connection.collation.must_equal 'Latin1_General_CI_AS'
   end
 
   it 'prints error message when database exists' do
-    db_tasks.create configuration
+    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
@@ -69,8 +69,10 @@ class SQLServerRakeDropTest < SQLServerRakeTest
   self.azure_skip = false
 
   it 'drops database and uses master' do
-    db_tasks.create configuration
-    db_tasks.drop configuration
+    quietly do
+      db_tasks.create configuration
+      db_tasks.drop configuration
+    end
     connection.current_database.must_equal 'master'
   end
 
@@ -84,7 +86,7 @@ end
 class SQLServerRakePurgeTest < SQLServerRakeTest
 
   before do
-    db_tasks.create(configuration)
+    quietly { db_tasks.create(configuration) }
     connection.create_table :users, force: true do |t|
       t.string :name, :email
       t.timestamps null: false
@@ -94,7 +96,7 @@ class SQLServerRakePurgeTest < SQLServerRakeTest
   it 'clears active connections, drops database, and recreates with established connection' do
     connection.current_database.must_equal(new_database)
     connection.tables.must_include 'users'
-    db_tasks.purge(configuration)
+    quietly { db_tasks.purge(configuration) }
     connection.current_database.must_equal(new_database)
     connection.tables.wont_include 'users'
   end
@@ -103,7 +105,9 @@ end
 
 class SQLServerRakeCharsetTest < SQLServerRakeTest
 
-  before { db_tasks.create(configuration) }
+  before do
+    quietly { db_tasks.create(configuration) }
+  end
 
   it 'retrieves charset' do
     db_tasks.charset(configuration).must_equal 'iso_1'
@@ -113,7 +117,9 @@ end
 
 class SQLServerRakeCollationTest < SQLServerRakeTest
 
-  before { db_tasks.create(configuration) }
+  before do
+    quietly { db_tasks.create(configuration) }
+  end
 
   it 'retrieves collation' do
     db_tasks.collation(configuration).must_equal 'SQL_Latin1_General_CP1_CI_AS'
@@ -127,7 +133,7 @@ class SQLServerRakeStructureDumpLoadTest < SQLServerRakeTest
   let(:filedata) { File.read(filename) }
 
   before do
-    db_tasks.create(configuration)
+    quietly { db_tasks.create(configuration) }
     connection.create_table :users, force: true do |t|
       t.string :name, :email
       t.text :background1
@@ -156,7 +162,7 @@ class SQLServerRakeStructureDumpLoadTest < SQLServerRakeTest
     filedata.must_match %r{CREATE TABLE dbo\.users}
     db_tasks.purge(configuration)
     connection.tables.wont_include 'users'
-    db_tasks.load_schema_for configuration, :sql, filename
+    db_tasks.load_schema configuration, :sql, filename
     connection.tables.must_include 'users'
   end
 

data/test/cases/schema_dumper_test_sqlserver.rb

@@ -9,49 +9,48 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
 
   it 'sst_datatypes' do
     generate_schema_for_table 'sst_datatypes'
-    # Exact Numerics
-    assert_line :bigint,            type: 'bigint',       limit: '8',           precision: nil,   scale: nil,  default: '42'
-    assert_line :int,               type: 'integer',      limit: '4',           precision: nil,   scale: nil,  default: '42'
-    assert_line :smallint,          type: 'integer',      limit: '2',           precision: nil,   scale: nil,  default: '42'
-    assert_line :tinyint,           type: 'integer',      limit: '1',           precision: nil,   scale: nil,  default: '42'
-    assert_line :bit,               type: 'boolean',      limit: nil,           precision: nil,   scale: nil,  default: 'true'
-    assert_line :decimal_9_2,       type: 'decimal',      limit: nil,           precision: '9',   scale: '2',  default: '12345.01'
-    assert_line :numeric_18_0,      type: 'decimal',      limit: nil,           precision: '18',  scale: '0',  default: '191.0'
-    assert_line :numeric_36_2,      type: 'decimal',      limit: nil,           precision: '36',  scale: '2',  default: '12345678901234567890.01'
-    assert_line :money,             type: 'money',        limit: nil,           precision: '19',  scale: '4',  default: '4.2'
-    assert_line :smallmoney,        type: 'smallmoney',   limit: nil,           precision: '10',  scale: '4',  default: '4.2'
+    assert_line :bigint,            type: 'bigint',       limit: nil,           precision: nil,   scale: nil,  default: 42
+    assert_line :int,               type: 'integer',      limit: nil,           precision: nil,   scale: nil,  default: 42
+    assert_line :smallint,          type: 'integer',      limit: 2,             precision: nil,   scale: nil,  default: 42
+    assert_line :tinyint,           type: 'integer',      limit: 1,             precision: nil,   scale: nil,  default: 42
+    assert_line :bit,               type: 'boolean',      limit: nil,           precision: nil,   scale: nil,  default: true
+    assert_line :decimal_9_2,       type: 'decimal',      limit: nil,           precision: 9,     scale: 2,    default: 12345.01
+    assert_line :numeric_18_0,      type: 'decimal',      limit: nil,           precision: 18,    scale: 0,    default: 191.0
+    assert_line :numeric_36_2,      type: 'decimal',      limit: nil,           precision: 36,    scale: 2,    default: 12345678901234567890.01
+    assert_line :money,             type: 'money',        limit: nil,           precision: 19,    scale: 4,    default: 4.2
+    assert_line :smallmoney,        type: 'smallmoney',   limit: nil,           precision: 10,    scale: 4,    default: 4.2
     # Approximate Numerics
-    assert_line :float,             type: 'float',        limit: nil,          precision: nil,   scale: nil,  default: '123.00000001'
-    assert_line :real,              type: 'real',         limit: nil,          precision: nil,   scale: nil,  default: %r{123.4[45]}
+    assert_line :float,             type: 'float',        limit: nil,           precision: nil,   scale: nil,  default: 123.00000001
+    assert_line :real,              type: 'real',         limit: nil,           precision: nil,   scale: nil,  default: 123.45
     # Date and Time
-    assert_line :date,              type: 'date',         limit: nil,           precision: nil,   scale: nil,  default: "\"01-01-0001\""
-    assert_line :datetime,          type: 'datetime',     limit: nil,           precision: nil,   scale: nil,  default: "\"01-01-1753 00:00:00.123\""
+    assert_line :date,              type: 'date',         limit: nil,           precision: nil,   scale: nil,  default: "01-01-0001"
+    assert_line :datetime,          type: 'datetime',     limit: nil,           precision: nil,   scale: nil,  default: "01-01-1753 00:00:00.123"
     if connection_dblib_73?
-    assert_line :datetime2_7,       type: 'datetime2',    limit: nil,           precision: '7',   scale: nil,  default: "\"12-31-9999 23:59:59.9999999\""
-    assert_line :datetime2_3,       type: 'datetime2',    limit: nil,           precision: '3',   scale: nil,  default: nil
-    assert_line :datetime2_1,       type: 'datetime2',    limit: nil,           precision: '1',   scale: nil,  default: nil
+    assert_line :datetime2_7,       type: 'datetime',     limit: nil,           precision: 7,     scale: nil,  default: "12-31-9999 23:59:59.9999999"
+    assert_line :datetime2_3,       type: 'datetime',     limit: nil,           precision: 3,     scale: nil,  default: nil
+    assert_line :datetime2_1,       type: 'datetime',     limit: nil,           precision: 1,     scale: nil,  default: nil
     end
-    assert_line :smalldatetime,     type: 'smalldatetime',limit: nil,           precision: nil,   scale: nil,  default: "\"01-01-1901 15:45:00\""
+    assert_line :smalldatetime,     type: 'smalldatetime',limit: nil,           precision: nil,   scale: nil,  default: "01-01-1901 15:45:00.0"
     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_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
     end
     # Character Strings
-    assert_line :char_10,           type: 'char',         limit: '10',          precision: nil,   scale: nil,  default: "\"1234567890\""
-    assert_line :varchar_50,        type: 'varchar',      limit: '50',          precision: nil,   scale: nil,  default: "\"test varchar_50\""
-    assert_line :varchar_max,       type: 'varchar_max',  limit: '2147483647',  precision: nil,   scale: nil,  default: "\"test varchar_max\""
-    assert_line :text,              type: 'text_basic',   limit: '2147483647',  precision: nil,   scale: nil,  default: "\"test text\""
+    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
     # Unicode Character Strings
-    assert_line :nchar_10,          type: 'nchar',        limit: '10',          precision: nil,   scale: nil,  default: "\"12345678åå\""
-    assert_line :nvarchar_50,       type: 'string',       limit: '50',          precision: nil,   scale: nil,  default: "\"test nvarchar_50 åå\""
-    assert_line :nvarchar_max,      type: 'text',         limit: '2147483647',  precision: nil,   scale: nil,  default: "\"test nvarchar_max åå\""
-    assert_line :ntext,             type: 'ntext',        limit: '2147483647',  precision: nil,   scale: nil,  default: "\"test ntext åå\""
+    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
     # 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 :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
     # Other Data Types
-    assert_line :uniqueidentifier,  type: 'uuid',         limit: nil,           precision: nil,   scale: nil,  default: nil
+    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
   end
 
@@ -71,18 +70,18 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
     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: '4',          precision: nil,  scale: nil, default: nil
-    assert_line :bigint_col,      type: 'bigint',       limit: '8',          precision: nil,  scale: nil, default: nil
+    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 :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: '4000',       precision: nil,  scale: nil, default: nil
-    assert_line :text_col,        type: 'text',         limit: '2147483647', 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 :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 :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: 2147483647,   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'
@@ -99,16 +98,16 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
     columns['uuid_col'].sql_type.must_equal         'uniqueidentifier'
     columns['sstimestamp_col'].sql_type.must_equal  'timestamp'
     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 :datetime2_col,     type: 'datetime2',    limit: nil,           precision: '7',   scale: nil,  default: nil
-    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: '8000',        precision: nil,   scale: nil,  default: nil
-    assert_line :text_basic_col,    type: 'text_basic',   limit: '2147483647',  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 :binary_basic_col,  type: 'binary_basic', limit: '1',           precision: nil,   scale: nil,  default: nil
-    assert_line :varbinary_col,     type: 'varbinary',    limit: '8000',        precision: nil,   scale: nil,  default: nil
+    assert_line :money_col,         type: 'money',        limit: nil,           precision: 19,    scale: 4,    default: nil
+    assert_line :datetime2_col,     type: 'datetime',     limit: nil,           precision: 7,     scale: nil,  default: nil
+    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 :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 :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
   end
@@ -126,7 +125,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}
-    assert_line :name, type: 'string', limit: '4000'
+    assert_line :name, type: 'string', limit: nil, default: nil, collation: nil
   end
 
 
@@ -155,15 +154,19 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
   def assert_line(column_name, options={})
     line = line(column_name)
     assert line, "Count not find line with column name: #{column_name.inspect} in schema:\n#{schema}"
-    [:type, :limit, :precision, :scale, :default].each do |key|
+    [:type, :limit, :precision, :scale, :collation, :default].each do |key|
       next unless options.key?(key)
       actual   = key == :type ? line.send(:type_method) : line.send(key)
       expected = options[key]
       message  = "#{key.to_s.titleize} of #{expected.inspect} not found in:\n#{line}"
       if expected.nil?
         actual.must_be_nil message
-      elsif expected.is_a?(Regexp)
-        actual.must_match expected, message
+      elsif expected.is_a?(Array)
+        actual.must_include expected, message
+      elsif expected.is_a?(Float)
+        actual.must_be_close_to expected, 0.001
+      elsif expected.is_a?(Proc)
+        actual.call.must_equal(expected.call)
       else
         actual.must_equal expected, message
       end
@@ -172,24 +175,52 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
 
   class SchemaLine
 
-    attr_reader :line
+    LINE_PARSER = %r{t\.(\w+)\s+"(.*?)"[,\s+](.*)}
 
-    def self.match(method_name, pattern)
-      define_method(method_name) { line.match(pattern).try :[], 1 }
+    attr_reader :line,
+                :type_method,
+                :col_name,
+                :options
+
+    def self.option(method_name)
+      define_method(method_name) { options.present? ? options[method_name.to_sym] : nil }
     end
 
     def initialize(line)
       @line = line
+      @type_method, @col_name, @options = parse_line
     end
 
-    match :type_method,   %r{\A\s+t\.(.*?)\s}
-    match :limit,         %r{\slimit:\s(.*?)[,\s]}
-    match :default,       %r{\sdefault:\s(.*)\n}
-    match :precision,     %r{\sprecision:\s(.*?)[,\s]}
-    match :scale,         %r{\sscale:\s(.*?)[,\s]}
+    option :limit
+    option :precision
+    option :scale
+    option :default
+    option :collation
 
     def to_s
-      line
+      line.squish
+    end
+
+    def inspect
+      "#<SchemaLine col_name=#{col_name.inspect}, options=#{options.inspect}>"
+    end
+
+    private
+
+    def parse_line
+      _all, type_method, col_name, options = @line.match(LINE_PARSER).to_a
+      options = parse_options(options)
+      [type_method, col_name, options]
+    end
+
+    def parse_options(opts)
+      if opts.present?
+        eval "{#{opts}}"
+      else
+        {}
+      end
+    rescue SyntaxError
+      {}
     end
 
   end