activerecord-sqlserver-adapter 5.2.1 → 6.0.0

data/test/cases/specific_schema_test_sqlserver.rb

@@ -1,71 +1,75 @@
-require 'cases/helper_sqlserver'
+# frozen_string_literal: true
 
-class SpecificSchemaTestSQLServer < ActiveRecord::TestCase
+require "cases/helper_sqlserver"
 
+class SpecificSchemaTestSQLServer < ActiveRecord::TestCase
   after { SSTestEdgeSchema.delete_all }
 
-  it 'handle dollar symbols' do
+  it "handle dollar symbols" do
     SSTestDollarTableName.create!
     SSTestDollarTableName.limit(20).offset(1)
   end
 
-  it 'models can use tinyint pk tables' do
-    obj = SSTestTinyintPk.create! name: '1'
-    _(['Fixnum', 'Integer']).must_include obj.id.class.name
+  it "models can use tinyint pk tables" do
+    obj = SSTestTinyintPk.create! name: "1"
+    _(["Fixnum", "Integer"]).must_include obj.id.class.name
     _(SSTestTinyintPk.find(obj.id)).must_equal obj
   end
 
-  it 'be able to complex count tables with no primary key' do
+  it "be able to complex count tables with no primary key" do
     SSTestNoPkData.delete_all
     10.times { |n| SSTestNoPkData.create! name: "Test#{n}" }
-    assert_equal 1, SSTestNoPkData.where(name: 'Test5').count
+    assert_equal 1, SSTestNoPkData.where(name: "Test5").count
   end
 
-  it 'quote table names properly even when they are views' do
-    obj = SSTestQuotedTable.create!
+  it "quote table names properly even when they are views" do
+    SSTestQuotedTable.create!
     assert_nothing_raised { assert SSTestQuotedTable.first }
-    obj = SSTestQuotedTableUser.create!
+
+    SSTestQuotedTableUser.create!
     assert_nothing_raised { assert SSTestQuotedTableUser.first }
-    obj = SSTestQuotedView1.create!
+
+    SSTestQuotedView1.create!
     assert_nothing_raised { assert SSTestQuotedView1.first }
-    obj = SSTestQuotedView2.create!
+
+    SSTestQuotedView2.create!
     assert_nothing_raised { assert SSTestQuotedView2.first }
   end
 
-  it 'cope with multi line defaults' do
+  it "cope with multi line defaults" do
     default = SSTestStringDefault.new
     assert_equal "Some long default with a\nnew line.", default.string_with_multiline_default
   end
 
-  it 'default strings before save' do
+  it "default strings before save" do
     default = SSTestStringDefault.new
     assert_nil default.string_with_null_default
-    assert_equal 'null', default.string_with_pretend_null_one
-    assert_equal '(null)', default.string_with_pretend_null_two
-    assert_equal 'NULL', default.string_with_pretend_null_three
-    assert_equal '(NULL)', default.string_with_pretend_null_four
-    assert_equal '(3)', default.string_with_pretend_paren_three
+    assert_equal "null", default.string_with_pretend_null_one
+    assert_equal "(null)", default.string_with_pretend_null_two
+    assert_equal "NULL", default.string_with_pretend_null_three
+    assert_equal "(NULL)", default.string_with_pretend_null_four
+    assert_equal "(3)", default.string_with_pretend_paren_three
   end
 
-  it 'default strings after save' do
+  it "default strings after save" do
     default = SSTestStringDefault.create
     assert_nil default.string_with_null_default
-    assert_equal 'null', default.string_with_pretend_null_one
-    assert_equal '(null)', default.string_with_pretend_null_two
-    assert_equal 'NULL', default.string_with_pretend_null_three
-    assert_equal '(NULL)', default.string_with_pretend_null_four
+    assert_equal "null", default.string_with_pretend_null_one
+    assert_equal "(null)", default.string_with_pretend_null_two
+    assert_equal "NULL", default.string_with_pretend_null_three
+    assert_equal "(NULL)", default.string_with_pretend_null_four
   end
 
-  it 'default objects work' do
-    obj = SSTestObjectDefault.create! name: 'MetaSkills'
-    _(obj.date).must_be_nil 'since this is set on insert'
+  it "default objects work" do
+    obj = SSTestObjectDefault.create! name: "MetaSkills"
+    _(obj.date).must_be_nil "since this is set on insert"
     _(obj.reload.date).must_be_instance_of Date
   end
 
-  it 'allows datetime2 as timestamps' do
-    _(SSTestBooking.columns_hash['created_at'].sql_type).must_equal 'datetime2(7)'
-    _(SSTestBooking.columns_hash['updated_at'].sql_type).must_equal 'datetime2(7)'
-    obj1 = SSTestBooking.new name: 'test1'
+  it "allows datetime2 as timestamps" do
+    _(SSTestBooking.columns_hash["created_at"].sql_type).must_equal "datetime2(7)"
+    _(SSTestBooking.columns_hash["updated_at"].sql_type).must_equal "datetime2(7)"
+    obj1 = SSTestBooking.new name: "test1"
     obj1.save!
     _(obj1.created_at).must_be_instance_of Time
     _(obj1.updated_at).must_be_instance_of Time
@@ -73,35 +77,35 @@ class SpecificSchemaTestSQLServer < ActiveRecord::TestCase
 
   # Natural primary keys.
 
-  it 'work with identity inserts' do
-    record = SSTestNaturalPkData.new name: 'Test', description: 'Natural identity inserts.'
-    record.id = '12345ABCDE'
+  it "work with identity inserts" do
+    record = SSTestNaturalPkData.new name: "Test", description: "Natural identity inserts."
+    record.id = "12345ABCDE"
     assert record.save
-    assert_equal '12345ABCDE', record.reload.id
+    assert_equal "12345ABCDE", record.reload.id
   end
 
-  it 'work with identity inserts when the key is an int' do
-    record = SSTestNaturalPkIntData.new name: 'Test', description: 'Natural identity inserts.'
+  it "work with identity inserts when the key is an int" do
+    record = SSTestNaturalPkIntData.new name: "Test", description: "Natural identity inserts."
     record.id = 12
     assert record.save
     assert_equal 12, record.reload.id
   end
 
-  it 'use primary key for row table order in pagination sql' do
+  it "use primary key for row table order in pagination sql" do
     sql = /ORDER BY \[sst_natural_pk_data\]\.\[legacy_id\] ASC OFFSET @0 ROWS FETCH NEXT @1 ROWS ONLY/
     assert_sql(sql) { SSTestNaturalPkData.limit(5).offset(5).load }
   end
 
   # Special quoted column
 
-  it 'work as normal' do
+  it "work as normal" do
     SSTestEdgeSchema.delete_all
-    r = SSTestEdgeSchema.create! 'crazy]]quote' => 'crazyqoute'
-    assert SSTestEdgeSchema.columns_hash['crazy]]quote']
-    assert_equal r, SSTestEdgeSchema.where('crazy]]quote' => 'crazyqoute').first
+    r = SSTestEdgeSchema.create! "crazy]]quote" => "crazyqoute"
+    assert SSTestEdgeSchema.columns_hash["crazy]]quote"]
+    assert_equal r, SSTestEdgeSchema.where("crazy]]quote" => "crazyqoute").first
   end
 
-  it 'various methods to bypass national quoted columns for any column, but primarily useful for char/varchar' do
+  it "various methods to bypass national quoted columns for any column, but primarily useful for char/varchar" do
     value = Class.new do
       def quoted_id
         "'T'"
@@ -113,14 +117,14 @@ class SpecificSchemaTestSQLServer < ActiveRecord::TestCase
     # Using our custom char type data.
     type = ActiveRecord::Type::SQLServer::Char
     data = ActiveRecord::Type::SQLServer::Data
-    assert_sql(/@0 = 'T'/) { SSTestDatatypeMigration.where(char_col: data.new('T', type.new)).first }
-    assert_sql(/@0 = 'T'/) { SSTestDatatypeMigration.where(varchar_col: data.new('T', type.new)).first }
+    assert_sql(/@0 = 'T'/) { SSTestDatatypeMigration.where(char_col: data.new("T", type.new)).first }
+    assert_sql(/@0 = 'T'/) { SSTestDatatypeMigration.where(varchar_col: data.new("T", type.new)).first }
     # Taking care of everything.
-    assert_sql(/@0 = 'T'/) { SSTestDatatypeMigration.where(char_col: 'T').first }
-    assert_sql(/@0 = 'T'/) { SSTestDatatypeMigration.where(varchar_col: 'T').first }
+    assert_sql(/@0 = 'T'/) { SSTestDatatypeMigration.where(char_col: "T").first }
+    assert_sql(/@0 = 'T'/) { SSTestDatatypeMigration.where(varchar_col: "T").first }
   end
 
-  it 'can update and hence properly quoted non-national char/varchar columns' do
+  it "can update and hence properly quoted non-national char/varchar columns" do
     o = SSTestDatatypeMigration.create!
     o.varchar_col = "O'Reilly"
     o.save!
@@ -132,28 +136,28 @@ class SpecificSchemaTestSQLServer < ActiveRecord::TestCase
 
   # With column names that have spaces
 
-  it 'create record using a custom attribute reader and be able to load it back in' do
-    value = 'Saved value into a column that has a space in the name.'
+  it "create record using a custom attribute reader and be able to load it back in" do
+    value = "Saved value into a column that has a space in the name."
     record = SSTestEdgeSchema.create! with_spaces: value
     assert_equal value, SSTestEdgeSchema.find(record.id).with_spaces
   end
 
   # With description column
 
-  it 'allow all sorts of ordering without adapter munging it up with special description column' do
-    SSTestEdgeSchema.create! description: 'A'
-    SSTestEdgeSchema.create! description: 'B'
-    SSTestEdgeSchema.create! description: 'C'
-    assert_equal ['A','B','C'], SSTestEdgeSchema.order('description').map(&:description)
-    assert_equal ['A','B','C'], SSTestEdgeSchema.order('description asc').map(&:description)
-    assert_equal ['A','B','C'], SSTestEdgeSchema.order('description ASC').map(&:description)
-    assert_equal ['C','B','A'], SSTestEdgeSchema.order('description desc').map(&:description)
-    assert_equal ['C','B','A'], SSTestEdgeSchema.order('description DESC').map(&:description)
+  it "allow all sorts of ordering without adapter munging it up with special description column" do
+    SSTestEdgeSchema.create! description: "A"
+    SSTestEdgeSchema.create! description: "B"
+    SSTestEdgeSchema.create! description: "C"
+    assert_equal ["A", "B", "C"], SSTestEdgeSchema.order("description").map(&:description)
+    assert_equal ["A", "B", "C"], SSTestEdgeSchema.order("description asc").map(&:description)
+    assert_equal ["A", "B", "C"], SSTestEdgeSchema.order("description ASC").map(&:description)
+    assert_equal ["C", "B", "A"], SSTestEdgeSchema.order("description desc").map(&:description)
+    assert_equal ["C", "B", "A"], SSTestEdgeSchema.order("description DESC").map(&:description)
   end
 
   # For uniqueidentifier model helpers
 
-  it 'returns a new id via connection newid_function' do
+  it "returns a new id via connection newid_function" do
     acceptable_uuid = ActiveRecord::ConnectionAdapters::SQLServer::Type::Uuid::ACCEPTABLE_UUID
     db_uuid = ActiveRecord::Base.connection.newid_function
     _(db_uuid).must_match(acceptable_uuid)
@@ -161,10 +165,9 @@ class SpecificSchemaTestSQLServer < ActiveRecord::TestCase
 
   # with similar table definition in two schemas
 
-  it 'returns the correct primary columns' do
+  it "returns the correct primary columns" do
     connection = ActiveRecord::Base.connection
-    assert_equal 'field_1', connection.columns('test.sst_schema_test_mulitple_schema').detect(&:is_primary?).name
-    assert_equal 'field_2', connection.columns('test2.sst_schema_test_mulitple_schema').detect(&:is_primary?).name
+    assert_equal "field_1", connection.columns("test.sst_schema_test_mulitple_schema").detect(&:is_primary?).name
+    assert_equal "field_2", connection.columns("test2.sst_schema_test_mulitple_schema").detect(&:is_primary?).name
   end
-
 end

data/test/cases/transaction_test_sqlserver.rb

@@ -1,42 +1,42 @@
-# encoding: UTF-8
-require 'cases/helper_sqlserver'
-require 'models/ship'
-require 'models/developer'
+# frozen_string_literal: true
 
-class TransactionTestSQLServer < ActiveRecord::TestCase
+require "cases/helper_sqlserver"
+require "models/ship"
+require "models/developer"
 
+class TransactionTestSQLServer < ActiveRecord::TestCase
   self.use_transactional_tests = false
 
   before { delete_ships }
 
-  it 'allow ActiveRecord::Rollback to work in 1 transaction block' do
+  it "allow ActiveRecord::Rollback to work in 1 transaction block" do
     Ship.transaction do
-      Ship.create! name: 'Black Pearl'
+      Ship.create! name: "Black Pearl"
       raise ActiveRecord::Rollback
     end
     assert_no_ships
   end
 
-  it 'allow nested transactions to totally rollback' do
+  it "allow nested transactions to totally rollback" do
     begin
       Ship.transaction do
-        Ship.create! name: 'Black Pearl'
+        Ship.create! name: "Black Pearl"
         Ship.transaction do
-          Ship.create! name: 'Flying Dutchman'
-          raise 'HELL'
+          Ship.create! name: "Flying Dutchman"
+          raise "HELL"
         end
       end
-    rescue Exception => e
+    rescue Exception
       assert_no_ships
     end
   end
 
-  it 'can use an isolation level and reverts back to starting isolation level' do
+  it "can use an isolation level and reverts back to starting isolation level" do
     in_level = nil
     begin_level = connection.user_options_isolation_level
     _(begin_level).must_match %r{read committed}i
     Ship.transaction(isolation: :serializable) do
-      Ship.create! name: 'Black Pearl'
+      Ship.create! name: "Black Pearl"
       in_level = connection.user_options_isolation_level
     end
     after_level = connection.user_options_isolation_level
@@ -44,7 +44,7 @@ class TransactionTestSQLServer < ActiveRecord::TestCase
     _(after_level).must_match %r{read committed}i
   end
 
-  it 'can use an isolation level and reverts back to starting isolation level under exceptions' do
+  it "can use an isolation level and reverts back to starting isolation level under exceptions" do
     _(connection.user_options_isolation_level).must_match %r{read committed}i
     _(lambda {
       Ship.transaction(isolation: :serializable) { Ship.create! }
@@ -52,7 +52,7 @@ class TransactionTestSQLServer < ActiveRecord::TestCase
     _(connection.user_options_isolation_level).must_match %r{read committed}i
   end
 
-  describe 'when READ_COMMITTED_SNAPSHOT is set' do
+  describe "when READ_COMMITTED_SNAPSHOT is set" do
     before do
       connection.execute "ALTER DATABASE [#{connection.current_database}] SET ALLOW_SNAPSHOT_ISOLATION ON"
       connection.execute "ALTER DATABASE [#{connection.current_database}] SET READ_COMMITTED_SNAPSHOT ON WITH ROLLBACK IMMEDIATE"
@@ -63,11 +63,11 @@ class TransactionTestSQLServer < ActiveRecord::TestCase
       connection.execute "ALTER DATABASE [#{connection.current_database}] SET READ_COMMITTED_SNAPSHOT OFF WITH ROLLBACK IMMEDIATE"
     end
 
-    it 'should use READ COMMITTED as an isolation level' do
+    it "should use READ COMMITTED as an isolation level" do
       _(connection.user_options_isolation_level).must_match "read committed snapshot"
 
       Ship.transaction(isolation: :serializable) do
-        Ship.create! name: 'Black Pearl'
+        Ship.create! name: "Black Pearl"
       end
 
       # We're actually testing that the isolation level was correctly reset to
@@ -77,7 +77,6 @@ class TransactionTestSQLServer < ActiveRecord::TestCase
     end
   end
 
-
   protected
 
   def delete_ships
@@ -87,5 +86,4 @@ class TransactionTestSQLServer < ActiveRecord::TestCase
   def assert_no_ships
     assert Ship.count.zero?, "Expected Ship to have no models but it did have:\n#{Ship.all.inspect}"
   end
-
 end

data/test/cases/trigger_test_sqlserver.rb

@@ -1,29 +1,30 @@
-# encoding: UTF-8
-require 'cases/helper_sqlserver'
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
 
 class SQLServerTriggerTest < ActiveRecord::TestCase
-  after  { exclude_output_inserted_table_names.clear }
+  after { exclude_output_inserted_table_names.clear }
 
   let(:exclude_output_inserted_table_names) do
     ActiveRecord::ConnectionAdapters::SQLServerAdapter.exclude_output_inserted_table_names
   end
 
-  it 'can insert into a table with output inserted - with a true setting for table name' do
-    exclude_output_inserted_table_names['sst_table_with_trigger'] = true
+  it "can insert into a table with output inserted - with a true setting for table name" do
+    exclude_output_inserted_table_names["sst_table_with_trigger"] = true
     assert SSTestTriggerHistory.all.empty?
-    obj = SSTestTrigger.create! event_name: 'test trigger'
-    _(['Fixnum', 'Integer']).must_include obj.id.class.name
-    _(obj.event_name).must_equal 'test trigger'
+    obj = SSTestTrigger.create! event_name: "test trigger"
+    _(["Fixnum", "Integer"]).must_include obj.id.class.name
+    _(obj.event_name).must_equal "test trigger"
     _(obj.id).must_be :present?
     _(obj.id.to_s).must_equal SSTestTriggerHistory.first.id_source
   end
 
-  it 'can insert into a table with output inserted - with a uniqueidentifier value' do
-    exclude_output_inserted_table_names['sst_table_with_uuid_trigger'] = 'uniqueidentifier'
+  it "can insert into a table with output inserted - with a uniqueidentifier value" do
+    exclude_output_inserted_table_names["sst_table_with_uuid_trigger"] = "uniqueidentifier"
     assert SSTestTriggerHistory.all.empty?
-    obj = SSTestTriggerUuid.create! event_name: 'test uuid trigger'
-    _(obj.id.class.name).must_equal 'String'
-    _(obj.event_name).must_equal 'test uuid trigger'
+    obj = SSTestTriggerUuid.create! event_name: "test uuid trigger"
+    _(obj.id.class.name).must_equal "String"
+    _(obj.event_name).must_equal "test uuid trigger"
     _(obj.id).must_be :present?
     _(obj.id.to_s).must_equal SSTestTriggerHistory.first.id_source
   end

data/test/cases/utils_test_sqlserver.rb

@@ -1,59 +1,62 @@
-require 'cases/helper_sqlserver'
+# frozen_string_literal: true
 
-class UtilsTestSQLServer < ActiveRecord::TestCase
+require "cases/helper_sqlserver"
 
-  it '.quote_string' do
+class UtilsTestSQLServer < ActiveRecord::TestCase
+  it ".quote_string" do
     _(SQLServer::Utils.quote_string("I'll store this in C:\\Users")).must_equal "I''ll store this in C:\\Users"
   end
 
-  it '.unquote_string' do
+  it ".unquote_string" do
     _(SQLServer::Utils.unquote_string("I''ll store this in C:\\Users")).must_equal "I'll store this in C:\\Users"
   end
 
-  it '.quoted_raw' do
+  it ".quoted_raw" do
     _(SQLServer::Utils.quoted_raw("some.Name")).must_equal "[some.Name]"
   end
 
-  describe '.extract_identifiers constructor and thus SQLServer::Utils::Name value object' do
-
+  describe ".extract_identifiers constructor and thus SQLServer::Utils::Name value object" do
     let(:valid_names) { valid_names_unquoted + valid_names_quoted }
 
-    let(:valid_names_unquoted) {[
-      'server.database.schema.object',
-      'server.database..object',
-      'server..schema.object',
-      'server...object',
-      'database.schema.object',
-      'database..object',
-      'schema.object',
-      'object'
-    ]}
-
-    let(:valid_names_quoted) {[
-      '[server].[database].[schema].[object]',
-      '[server].[database]..[object]',
-      '[server]..[schema].[object]',
-      '[server]...[object]',
-      '[database].[schema].[object]',
-      '[database]..[object]',
-      '[schema].[object]',
-      '[object]'
-    ]}
+    let(:valid_names_unquoted) {
+      [
+        "server.database.schema.object",
+        "server.database..object",
+        "server..schema.object",
+        "server...object",
+        "database.schema.object",
+        "database..object",
+        "schema.object",
+        "object"
+      ]
+    }
+
+    let(:valid_names_quoted) {
+      [
+        "[server].[database].[schema].[object]",
+        "[server].[database]..[object]",
+        "[server]..[schema].[object]",
+        "[server]...[object]",
+        "[database].[schema].[object]",
+        "[database]..[object]",
+        "[schema].[object]",
+        "[object]"
+      ]
+    }
 
     let(:server_names)   { valid_names.partition { |name| name =~ /server/ } }
     let(:database_names) { valid_names.partition { |name| name =~ /database/ } }
     let(:schema_names)   { valid_names.partition { |name| name =~ /schema/ } }
 
-    it 'extracts and returns #object identifier unquoted by default or quoted as needed' do
+    it "extracts and returns #object identifier unquoted by default or quoted as needed" do
       valid_names.each do |n|
         name = extract_identifiers(n)
-        _(name.object).must_equal 'object', "With #{n.inspect} for #object"
-        _(name.object_quoted).must_equal '[object]', "With #{n.inspect} for #object_quoted"
+        _(name.object).must_equal "object", "With #{n.inspect} for #object"
+        _(name.object_quoted).must_equal "[object]", "With #{n.inspect} for #object_quoted"
       end
     end
 
     [:schema, :database, :server].each do |part|
-
       it "extracts and returns #{part} identifier unquoted by default or quoted as needed" do
         present, blank = send(:"#{part}_names")
         present.each do |n|
@@ -67,57 +70,55 @@ class UtilsTestSQLServer < ActiveRecord::TestCase
           _(name.send(:"#{part}_quoted")).must_be_nil "With #{n.inspect} for ##{part}_quoted method"
         end
       end
-
     end
 
-    it 'does not blow up on nil or blank string name' do
+    it "does not blow up on nil or blank string name" do
       _(extract_identifiers(nil).object).must_be_nil
-      _(extract_identifiers(' ').object).must_be_nil
+      _(extract_identifiers(" ").object).must_be_nil
     end
 
-    it 'has a #quoted that returns a fully quoted name with all identifiers as orginially passed in' do
-      _(extract_identifiers('object').quoted).must_equal '[object]'
-      _(extract_identifiers('server.database..object').quoted).must_equal '[server].[database]..[object]'
-      _(extract_identifiers('[server]...[object]').quoted).must_equal '[server]...[object]'
+    it "has a #quoted that returns a fully quoted name with all identifiers as orginially passed in" do
+      _(extract_identifiers("object").quoted).must_equal "[object]"
+      _(extract_identifiers("server.database..object").quoted).must_equal "[server].[database]..[object]"
+      _(extract_identifiers("[server]...[object]").quoted).must_equal "[server]...[object]"
     end
 
-    it 'can take a symbol argument' do
-      _(extract_identifiers(:object).object).must_equal 'object'
+    it "can take a symbol argument" do
+      _(extract_identifiers(:object).object).must_equal "object"
     end
 
-    it 'allows identifiers with periods to work' do
-      _(extract_identifiers('[obj.name]').quoted).must_equal '[obj.name]'
-      _(extract_identifiers('[obj.name].[foo]').quoted).must_equal '[obj.name].[foo]'
+    it "allows identifiers with periods to work" do
+      _(extract_identifiers("[obj.name]").quoted).must_equal "[obj.name]"
+      _(extract_identifiers("[obj.name].[foo]").quoted).must_equal "[obj.name].[foo]"
     end
 
-    it 'should indicate if a name is fully qualitified' do
-      _(extract_identifiers('object').fully_qualified?).must_equal false
-      _(extract_identifiers('schema.object').fully_qualified?).must_equal false
-      _(extract_identifiers('database.schema.object').fully_qualified?).must_equal false
-      _(extract_identifiers('database.object').fully_qualified?).must_equal false
-      _(extract_identifiers('server...object').fully_qualified?).must_equal false
-      _(extract_identifiers('server.database..object').fully_qualified?).must_equal false
-      _(extract_identifiers('server.database.schema.object').fully_qualified?).must_equal true
-      _(extract_identifiers('server.database.schema.').fully_qualified?).must_equal true
-      _(extract_identifiers('[obj.name]').fully_qualified?).must_equal false
-      _(extract_identifiers('[schema].[obj.name]').fully_qualified?).must_equal false
-      _(extract_identifiers('[database].[schema].[obj.name]').fully_qualified?).must_equal false
-      _(extract_identifiers('[database].[obj.name]').fully_qualified?).must_equal false
-      _(extract_identifiers('[server.name]...[obj.name]').fully_qualified?).must_equal false
-      _(extract_identifiers('[server.name].[database]..[obj.name]').fully_qualified?).must_equal false
-      _(extract_identifiers('[server.name].[database].[schema].[obj.name]').fully_qualified?).must_equal true
-      _(extract_identifiers('[server.name].[database].[schema].').fully_qualified?).must_equal true
+    it "should indicate if a name is fully qualitified" do
+      _(extract_identifiers("object").fully_qualified?).must_equal false
+      _(extract_identifiers("schema.object").fully_qualified?).must_equal false
+      _(extract_identifiers("database.schema.object").fully_qualified?).must_equal false
+      _(extract_identifiers("database.object").fully_qualified?).must_equal false
+      _(extract_identifiers("server...object").fully_qualified?).must_equal false
+      _(extract_identifiers("server.database..object").fully_qualified?).must_equal false
+      _(extract_identifiers("server.database.schema.object").fully_qualified?).must_equal true
+      _(extract_identifiers("server.database.schema.").fully_qualified?).must_equal true
+      _(extract_identifiers("[obj.name]").fully_qualified?).must_equal false
+      _(extract_identifiers("[schema].[obj.name]").fully_qualified?).must_equal false
+      _(extract_identifiers("[database].[schema].[obj.name]").fully_qualified?).must_equal false
+      _(extract_identifiers("[database].[obj.name]").fully_qualified?).must_equal false
+      _(extract_identifiers("[server.name]...[obj.name]").fully_qualified?).must_equal false
+      _(extract_identifiers("[server.name].[database]..[obj.name]").fully_qualified?).must_equal false
+      _(extract_identifiers("[server.name].[database].[schema].[obj.name]").fully_qualified?).must_equal true
+      _(extract_identifiers("[server.name].[database].[schema].").fully_qualified?).must_equal true
     end
 
-    it 'can return fully qualified quoted table name' do
-      name = extract_identifiers('[my.server].db.schema.')
-      _(name.fully_qualified_database_quoted).must_equal '[my.server].[db]'
-      name = extract_identifiers('[server.name].[database].[schema].[object]')
-      _(name.fully_qualified_database_quoted).must_equal '[server.name].[database]'
-      name = extract_identifiers('server.database.schema.object')
-      _(name.fully_qualified_database_quoted).must_equal '[server].[database]'
+    it "can return fully qualified quoted table name" do
+      name = extract_identifiers("[my.server].db.schema.")
+      _(name.fully_qualified_database_quoted).must_equal "[my.server].[db]"
+      name = extract_identifiers("[server.name].[database].[schema].[object]")
+      _(name.fully_qualified_database_quoted).must_equal "[server.name].[database]"
+      name = extract_identifiers("server.database.schema.object")
+      _(name.fully_qualified_database_quoted).must_equal "[server].[database]"
     end
-
   end
 
   private
@@ -125,5 +126,4 @@ class UtilsTestSQLServer < ActiveRecord::TestCase
   def extract_identifiers(name)
     SQLServer::Utils.extract_identifiers(name)
   end
-
 end

data/test/cases/uuid_test_sqlserver.rb

@@ -1,47 +1,46 @@
-# encoding: UTF-8
-require 'cases/helper_sqlserver'
+# frozen_string_literal: true
 
-class SQLServerUuidTest < ActiveRecord::TestCase
+require "cases/helper_sqlserver"
 
+class SQLServerUuidTest < ActiveRecord::TestCase
   let(:acceptable_uuid) { ActiveRecord::ConnectionAdapters::SQLServer::Type::Uuid::ACCEPTABLE_UUID }
 
-  it 'has a uuid primary key' do
-    _(SSTestUuid.columns_hash['id'].type).must_equal :uuid
+  it "has a uuid primary key" do
+    _(SSTestUuid.columns_hash["id"].type).must_equal :uuid
     assert SSTestUuid.primary_key
   end
 
-  it 'can create with a new pk' do
+  it "can create with a new pk" do
     obj = SSTestUuid.create!
     _(obj.id).must_be :present?
     _(obj.id).must_match acceptable_uuid
   end
 
-  it 'can create other uuid column on reload' do
+  it "can create other uuid column on reload" do
     obj = SSTestUuid.create!
     obj.reload
     _(obj.other_uuid).must_match acceptable_uuid
   end
 
-  it 'can find uuid pk via connection' do
-    _(connection.primary_key(SSTestUuid.table_name)).must_equal 'id'
+  it "can find uuid pk via connection" do
+    _(connection.primary_key(SSTestUuid.table_name)).must_equal "id"
   end
 
-  it 'changing column default' do
+  it "changing column default" do
     table_name = SSTestUuid.table_name
     connection.add_column table_name, :thingy, :uuid, null: false, default: "NEWSEQUENTIALID()"
     SSTestUuid.reset_column_information
-    column = SSTestUuid.columns_hash['thingy']
+    column = SSTestUuid.columns_hash["thingy"]
     _(column.default_function).must_equal "newsequentialid()"
     # Now to a different function.
     connection.change_column table_name, :thingy, :uuid, null: false, default: "NEWID()"
     SSTestUuid.reset_column_information
-    column = SSTestUuid.columns_hash['thingy']
+    column = SSTestUuid.columns_hash["thingy"]
     _(column.default_function).must_equal "newid()"
   end
 
-  it 'can insert even when use_output_inserted to false ' do
+  it "can insert even when use_output_inserted to false " do
     obj = with_use_output_inserted_disabled { SSTestUuid.create!(name: "😢") }
     _(obj.id).must_be :nil?
   end
-
 end