activerecord-sqlserver-adapter 6.0.0.rc1 → 6.1.0.0.rc1

data/test/cases/pessimistic_locking_test_sqlserver.rb

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
-require 'cases/helper_sqlserver'
-require 'models/person'
-require 'models/reader'
+require "cases/helper_sqlserver"
+require "models/person"
+require "models/reader"
 
 class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
-
   fixtures :people, :readers
 
   before do
@@ -13,15 +12,14 @@ class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
     Reader.columns
   end
 
-  it 'uses with updlock by default' do
+  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
     end
   end
 
-  describe 'For simple finds with default lock option' do
-
-    it 'lock with simple find' do
+  describe "For simple finds with default lock option" do
+    it "lock with simple find" do
       assert_nothing_raised do
         Person.transaction do
           _(Person.lock(true).find(1)).must_equal Person.find(1)
@@ -29,7 +27,7 @@ class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
       end
     end
 
-    it 'lock with scoped find' do
+    it "lock with scoped find" do
       assert_nothing_raised do
         Person.transaction do
           Person.lock(true).scoping do
@@ -39,8 +37,8 @@ class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
       end
     end
 
-    it 'lock with eager find' do
-       assert_nothing_raised do
+    it "lock with eager find" do
+      assert_nothing_raised do
         Person.transaction do
           person = Person.lock(true).includes(:readers).find(1)
           _(person).must_equal Person.find(1)
@@ -48,62 +46,56 @@ class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
       end
     end
 
-    it 'can add a custom lock directive' do
+    it "can add a custom lock directive" do
       assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(HOLDLOCK, ROWLOCK\)| do
-        Person.lock('WITH(HOLDLOCK, ROWLOCK)').load
+        Person.lock("WITH(HOLDLOCK, ROWLOCK)").load
       end
     end
 
-    describe 'joining tables' do
-
-      it 'joined tables use updlock by default' do
+    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
+      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
+          Person.lock("WITH(NOLOCK)").joins(:readers).load
         end
       end
 
-      it 'left joined tables use updlock by default' do
+      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
+      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
+          Person.lock("WITH(NOLOCK)").left_joins(:readers).load
         end
       end
-
     end
-
   end
 
-  describe 'For paginated finds' do
-
+  describe "For paginated finds" do
     before do
       Person.delete_all
       20.times { |n| Person.create!(first_name: "Thing_#{n}") }
     end
 
-    it 'copes with eager loading un-locked paginated' do
+    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 @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
-        _(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
-
   end
-
 end

data/test/cases/primary_keys_test_sqlserver.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+require "support/schema_dumping_helper"
+
+class PrimaryKeyUuidTypeTest < ActiveRecord::TestCase
+  include SchemaDumpingHelper
+
+  self.use_transactional_tests = false
+
+  class Barcode < ActiveRecord::Base
+  end
+
+  setup do
+    @connection = ActiveRecord::Base.connection
+    @connection.create_table(:barcodes, primary_key: "code", id: :uuid, force: true)
+  end
+
+  teardown do
+    @connection.drop_table(:barcodes, if_exists: true)
+  end
+
+  def test_any_type_primary_key
+    assert_equal "code", Barcode.primary_key
+
+    column = Barcode.column_for_attribute(Barcode.primary_key)
+    assert_not column.null
+    assert_equal :uuid, column.type
+    assert_not_predicate column, :is_identity?
+    assert_predicate column, :is_primary?
+  ensure
+    Barcode.reset_column_information
+  end
+
+  test "schema dump primary key includes default" do
+    schema = dump_table_schema "barcodes"
+    assert_match %r/create_table "barcodes", primary_key: "code", id: :uuid, default: -> { "newid\(\)" }/, schema
+  end
+end
+
+class PrimaryKeyIntegerTest < ActiveRecord::TestCase
+  include SchemaDumpingHelper
+
+  self.use_transactional_tests = false
+
+  class Barcode < ActiveRecord::Base
+  end
+
+  class Widget < ActiveRecord::Base
+  end
+
+  setup do
+    @connection = ActiveRecord::Base.connection
+  end
+
+  teardown do
+    @connection.drop_table :barcodes, if_exists: true
+    @connection.drop_table :widgets, if_exists: true
+  end
+
+  test "integer primary key without default" do
+    @connection.create_table(:widgets, id: :integer, force: true)
+    column = @connection.columns(:widgets).find { |c| c.name == "id" }
+    assert_predicate column, :is_primary?
+    assert_predicate column, :is_identity?
+    assert_equal :integer, column.type
+    assert_not_predicate column, :bigint?
+
+    schema = dump_table_schema "widgets"
+    assert_match %r/create_table "widgets", id: :integer, force: :cascade do/, schema
+  end
+
+  test "bigint primary key without default" do
+    @connection.create_table(:widgets, id: :bigint, force: true)
+    column = @connection.columns(:widgets).find { |c| c.name == "id" }
+    assert_predicate column, :is_primary?
+    assert_predicate column, :is_identity?
+    assert_equal :integer, column.type
+    assert_predicate column, :bigint?
+
+    schema = dump_table_schema "widgets"
+    assert_match %r/create_table "widgets", force: :cascade do/, schema
+  end
+
+  test "don't set identity to integer and bigint when there is a default" do
+    @connection.create_table(:barcodes, id: :integer, default: nil, force: true)
+    @connection.create_table(:widgets, id: :bigint, default: nil, force: true)
+
+    column = @connection.columns(:widgets).find { |c| c.name == "id" }
+    assert_predicate column, :is_primary?
+    assert_not_predicate column, :is_identity?
+
+    schema = dump_table_schema "widgets"
+    assert_match %r/create_table "widgets", id: :bigint, default: nil, force: :cascade do/, schema
+
+    column = @connection.columns(:barcodes).find { |c| c.name == "id" }
+    assert_predicate column, :is_primary?
+    assert_not_predicate column, :is_identity?
+
+    schema = dump_table_schema "barcodes"
+    assert_match %r/create_table "barcodes", id: :integer, default: nil, force: :cascade do/, schema
+  end
+end

data/test/cases/rake_test_sqlserver.rb

@@ -1,20 +1,20 @@
 # frozen_string_literal: true
 
-require 'cases/helper_sqlserver'
+require "cases/helper_sqlserver"
 
 class SQLServerRakeTest < ActiveRecord::TestCase
-
   self.use_transactional_tests = false
 
   cattr_accessor :azure_skip
   self.azure_skip = connection_sqlserver_azure?
 
   let(:db_tasks)              { ActiveRecord::Tasks::DatabaseTasks }
-  let(:new_database)          { 'activerecord_unittest_tasks' }
-  let(:default_configuration) { ARTest.connection_config['arunit'] }
-  let(:configuration)         { default_configuration.merge('database' => new_database) }
+  let(:new_database)          { "activerecord_unittest_tasks" }
+  let(:default_configuration) { ARTest.test_configuration_hashes["arunit"] }
+  let(:configuration)         { default_configuration.merge("database" => new_database) }
+  let(:db_config)             { ActiveRecord::Base.configurations.resolve(configuration) }
 
-  before { skip 'on azure' if azure_skip }
+  before { skip "on azure" if azure_skip }
   before { disconnect! unless azure_skip }
   after  { reconnect unless azure_skip }
 
@@ -27,7 +27,7 @@ class SQLServerRakeTest < ActiveRecord::TestCase
   def reconnect
     config = default_configuration
     if connection_sqlserver_azure?
-      ActiveRecord::Base.establish_connection(config.merge('database' => 'master'))
+      ActiveRecord::Base.establish_connection(config.merge("database" => "master"))
       connection.drop_database(new_database) rescue nil
       disconnect!
       ActiveRecord::Base.establish_connection(config)
@@ -36,57 +36,51 @@ class SQLServerRakeTest < ActiveRecord::TestCase
       connection.drop_database(new_database) rescue nil
     end
   end
-
 end
 
 class SQLServerRakeCreateTest < SQLServerRakeTest
-
   self.azure_skip = false
 
-  it 'establishes connection to database after create ' do
+  it "establishes connection to database after create " do
     quietly { db_tasks.create configuration }
     _(connection.current_database).must_equal(new_database)
   end
 
-  it 'creates database with default collation' do
+  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'
+  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"
   end
 
-  it 'prints error message when database exists' do
+  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}
   end
-
 end
 
 class SQLServerRakeDropTest < SQLServerRakeTest
-
   self.azure_skip = false
 
-  it 'drops database and uses master' do
+  it "drops database and uses master" do
     quietly do
       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') }
+  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}
   end
-
 end
 
 class SQLServerRakePurgeTest < SQLServerRakeTest
-
   before do
     quietly { db_tasks.create(configuration) }
     connection.create_table :users, force: true do |t|
@@ -95,43 +89,37 @@ class SQLServerRakePurgeTest < SQLServerRakeTest
     end
   end
 
-  it 'clears active connections, drops database, and recreates with established connection' do
+  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.tables).must_include "users"
     quietly { db_tasks.purge(configuration) }
     _(connection.current_database).must_equal(new_database)
-    _(connection.tables).wont_include 'users'
+    _(connection.tables).wont_include "users"
   end
-
 end
 
 class SQLServerRakeCharsetTest < SQLServerRakeTest
-
   before do
     quietly { db_tasks.create(configuration) }
   end
 
-  it 'retrieves charset' do
-    _(db_tasks.charset(configuration)).must_equal 'iso_1'
+  it "retrieves charset" do
+    _(db_tasks.charset(configuration)).must_equal "iso_1"
   end
-
 end
 
 class SQLServerRakeCollationTest < SQLServerRakeTest
-
   before do
     quietly { db_tasks.create(configuration) }
   end
 
-  it 'retrieves collation' do
-    _(db_tasks.collation(configuration)).must_equal 'SQL_Latin1_General_CP1_CI_AS'
+  it "retrieves collation" do
+    _(db_tasks.collation(configuration)).must_equal "SQL_Latin1_General_CP1_CI_AS"
   end
-
 end
 
 class SQLServerRakeStructureDumpLoadTest < SQLServerRakeTest
-
-  let(:filename) { File.join ARTest::SQLServer.migrations_root, 'structure.sql' }
+  let(:filename) { File.join ARTest::SQLServer.migrations_root, "structure.sql" }
   let(:filedata) { File.read(filename) }
 
   before do
@@ -148,8 +136,8 @@ class SQLServerRakeStructureDumpLoadTest < SQLServerRakeTest
     FileUtils.rm_rf(filename)
   end
 
-  it 'dumps structure and accounts for defncopy oddities' do
-    skip 'debug defncopy on windows later' if host_windows?
+  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}
@@ -158,14 +146,13 @@ class SQLServerRakeStructureDumpLoadTest < SQLServerRakeTest
     _(filedata).must_match %r{background2\s+text\s+}
   end
 
-  it 'can load dumped structure' do
-    skip 'debug defncopy on windows later' if host_windows?
+  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}
     db_tasks.purge(configuration)
-    _(connection.tables).wont_include 'users'
-    db_tasks.load_schema configuration, :sql, filename
-    _(connection.tables).must_include 'users'
+    _(connection.tables).wont_include "users"
+    db_tasks.load_schema db_config, :sql, filename
+    _(connection.tables).must_include "users"
   end
-
 end

data/test/cases/schema_dumper_test_sqlserver.rb

@@ -1,146 +1,159 @@
 # frozen_string_literal: true
 
-require 'cases/helper_sqlserver'
+require "cases/helper_sqlserver"
 
 class SchemaDumperTestSQLServer < ActiveRecord::TestCase
-
   before { all_tables }
 
   let(:all_tables)   { ActiveRecord::Base.connection.tables }
   let(:schema)       { @generated_schema }
 
-  it 'sst_datatypes' do
-    generate_schema_for_table 'sst_datatypes'
-    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
+  it "sst_datatypes" do
+    generate_schema_for_table "sst_datatypes"
+    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: nil,  default: 191
+    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: 123.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: '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
+      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.0"
+    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_default,      type: 'time',         limit: nil,           precision: 7,     scale: nil,  default: "15:03:42.0621978"
+      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: 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
+    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: 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: 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
+    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: 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: nil,           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: 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
+    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
 
-  it 'sst_datatypes_migration' do
+  it "sst_datatypes_migration" do
     columns = SSTestDatatypeMigration.columns_hash
-    generate_schema_for_table 'sst_datatypes_migration'
+    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)'
-    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: 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: nil,          precision: nil,  scale: nil, default: nil
+    _(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: nil, 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: 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: 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)'
-    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
-    assert_line :datetime2_col,     type: 'datetime',       limit: nil,           precision: 7,     scale: nil,  default: nil
-    assert_line :datetimeoffset,    type: 'datetimeoffset', 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: 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: 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: nil,           precision: nil,   scale: nil,  default: nil
+    _(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
+    assert_line :datetime2_col,     type: "datetime",       limit: nil,           precision: 7,     scale: nil,  default: nil
+    assert_line :datetimeoffset,    type: "datetimeoffset", 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: 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: 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: nil,           precision: nil,   scale: nil,  default: nil
+  end
+
+  it "dump column collation" do
+    generate_schema_for_table('sst_string_collation')
+
+    assert_line :string_without_collation, type: "string", limit: nil, default: nil, collation: nil
+    assert_line :string_default_collation, type: "varchar", limit: nil, default: nil, collation: nil
+    assert_line :string_with_collation, type: "varchar", limit: nil, default: nil, collation: "SQL_Latin1_General_CP1_CS_AS"
+    assert_line :varchar_with_collation, type: "varchar", limit: nil, default: nil, collation: "SQL_Latin1_General_CP1_CS_AS"
   end
 
   # Special Cases
 
-  it 'honor nonstandard primary keys' do
-    generate_schema_for_table('movies') do |output|
+  it "honor nonstandard primary keys" do
+    generate_schema_for_table("movies") do |output|
       match = output.match(%r{create_table "movies"(.*)do})
       assert_not_nil(match, "nonstandardpk table not found")
       assert_match %r(primary_key: "movieid"), match[1], "non-standard primary key not preserved"
     end
   end
 
-  it 'no id with model driven primary key' do
-    output = generate_schema_for_table 'sst_no_pk_data'
+  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: nil, default: nil, collation: nil
+    assert_line :name, type: "string", limit: nil, default: nil, collation: nil
   end
 
+  it "dumps field with unique key constraints only once" do
+    output = generate_schema_for_table "unique_key_dumped_table"
+
+    _(output.scan('t.integer "unique_field"').length).must_equal(1)
+  end
 
   private
 
   def generate_schema_for_table(*table_names)
-    require 'stringio'
+    require "stringio"
     stream = StringIO.new
     ActiveRecord::SchemaDumper.ignore_tables = all_tables - table_names
     ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
@@ -150,6 +163,7 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
     type_matcher = /\A\s+t\.\w+\s+"(.*?)"[,\n]/
     @generated_schema.each_line do |line|
       next unless line =~ type_matcher
+
       @schema_lines[Regexp.last_match[1]] = SchemaLine.new(line)
     end
     @generated_schema
@@ -159,14 +173,17 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
     @schema_lines[column_name.to_s]
   end
 
-  def assert_line(column_name, options={})
+  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}"
+    assert line, "Could not find line with column name: #{column_name.inspect} in schema:\n#{schema}"
+
     [: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?(Array)
@@ -182,7 +199,6 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
   end
 
   class SchemaLine
-
     LINE_PARSER = %r{t\.(\w+)\s+"(.*?)"[,\s+](.*)}
 
     attr_reader :line,
@@ -230,8 +246,5 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
     rescue SyntaxError
       {}
     end
-
   end
-
 end
-