activerecord-sqlserver-adapter 5.2.0 → 6.0.1

data/test/cases/schema_test_sqlserver.rb

@@ -1,30 +1,28 @@
-require 'cases/helper_sqlserver'
+# frozen_string_literal: true
 
-class SchemaTestSQLServer < ActiveRecord::TestCase
-
-  describe 'When table is dbo schema' do
+require "cases/helper_sqlserver"
 
-    it 'find primary key for tables with odd schema' do
-      connection.primary_key('sst_natural_pk_data').must_equal 'legacy_id'
+class SchemaTestSQLServer < ActiveRecord::TestCase
+  describe "When table is dbo schema" do
+    it "find primary key for tables with odd schema" do
+      _(connection.primary_key("sst_natural_pk_data")).must_equal "legacy_id"
     end
-
   end
 
-  describe 'When table is in non-dbo schema' do
-
-    it 'work with table exists' do
-      assert connection.data_source_exists?('test.sst_schema_natural_id')
-      assert connection.data_source_exists?('[test].[sst_schema_natural_id]')
+  describe "When table is in non-dbo schema" do
+    it "work with table exists" do
+      assert connection.data_source_exists?("test.sst_schema_natural_id")
+      assert connection.data_source_exists?("[test].[sst_schema_natural_id]")
     end
 
-    it 'find primary key for tables with odd schema' do
-      connection.primary_key('test.sst_schema_natural_id').must_equal 'legacy_id'
+    it "find primary key for tables with odd schema" do
+      _(connection.primary_key("test.sst_schema_natural_id")).must_equal "legacy_id"
     end
 
     it "have only one identity column" do
       columns = connection.columns("test.sst_schema_identity")
       assert_equal 2, columns.size
-      assert_equal 1, columns.select{ |c| c.is_identity? }.size
+      assert_equal 1, columns.select { |c| c.is_identity? }.size
     end
 
     it "read only column properties for table in specific schema" do
@@ -34,21 +32,17 @@ class SchemaTestSQLServer < ActiveRecord::TestCase
       assert_equal 7, test_columns.size
       assert_equal 2, dbo_columns.size
       assert_equal 2, columns.size
-      assert_equal 1, test_columns.select{ |c| c.is_identity? }.size
-      assert_equal 1, dbo_columns.select{ |c| c.is_identity? }.size
-      assert_equal 1, columns.select{ |c| c.is_identity? }.size
+      assert_equal 1, test_columns.select { |c| c.is_identity? }.size
+      assert_equal 1, dbo_columns.select { |c| c.is_identity? }.size
+      assert_equal 1, columns.select { |c| c.is_identity? }.size
     end
 
     it "return correct varchar and nvarchar column limit length when table is in non dbo schema" do
       columns = connection.columns("test.sst_schema_columns")
-      assert_equal 255, columns.find {|c| c.name == 'name'}.limit
-      assert_equal 1000, columns.find {|c| c.name == 'description'}.limit
-      assert_equal 255, columns.find {|c| c.name == 'n_name'}.limit
-      assert_equal 1000, columns.find {|c| c.name == 'n_description'}.limit
+      assert_equal 255, columns.find { |c| c.name == "name" }.limit
+      assert_equal 1000, columns.find { |c| c.name == "description" }.limit
+      assert_equal 255, columns.find { |c| c.name == "n_name" }.limit
+      assert_equal 1000, columns.find { |c| c.name == "n_description" }.limit
     end
-
   end
-
-
 end
-

data/test/cases/scratchpad_test_sqlserver.rb

@@ -1,8 +1,8 @@
-require 'cases/helper_sqlserver'
+# frozen_string_literal: true
 
-class ScratchpadTestSQLServer < ActiveRecord::TestCase
+require "cases/helper_sqlserver"
 
-  it 'helps debug things' do
+class ScratchpadTestSQLServer < ActiveRecord::TestCase
+  it "helps debug things" do
   end
-
 end

data/test/cases/showplan_test_sqlserver.rb

@@ -1,69 +1,63 @@
-require 'cases/helper_sqlserver'
-require 'models/car'
+# frozen_string_literal: true
 
-class ShowplanTestSQLServer < ActiveRecord::TestCase
+require "cases/helper_sqlserver"
+require "models/car"
 
+class ShowplanTestSQLServer < ActiveRecord::TestCase
   fixtures :cars
 
-  describe 'Unprepare previously prepared SQL' do
-
-    it 'from simple statement' do
+  describe "Unprepare previously prepared SQL" do
+    it "from simple statement" do
       plan = Car.where(id: 1).explain
-      plan.must_include "SELECT [cars].* FROM [cars] WHERE [cars].[id] = 1"
-      plan.must_include "Clustered Index Seek", 'make sure we do not showplan the sp_executesql'
+      _(plan).must_include "SELECT [cars].* FROM [cars] WHERE [cars].[id] = 1"
+      _(plan).must_include "Clustered Index Seek", "make sure we do not showplan the sp_executesql"
     end
 
-    it 'from multiline statement' do
+    it "from multiline statement" do
       plan = Car.where("\n id = 1 \n").explain
-      plan.must_include "SELECT [cars].* FROM [cars] WHERE (\n id = 1 \n)"
-      plan.must_include "Clustered Index Seek", 'make sure we do not showplan the sp_executesql'
+      _(plan).must_include "SELECT [cars].* FROM [cars] WHERE (\n id = 1 \n)"
+      _(plan).must_include "Clustered Index Seek", "make sure we do not showplan the sp_executesql"
     end
 
-    it 'from prepared statement' do
-      plan = Car.where(name: ',').limit(1).explain
-      plan.must_include " SELECT  [cars].* FROM [cars] WHERE [cars].[name]"
-      plan.must_include "TOP EXPRESSION", 'make sure we do not showplan the sp_executesql'
-      plan.must_include "Clustered Index Scan", 'make sure we do not showplan the sp_executesql'
+    it "from prepared statement" do
+      plan = Car.where(name: ",").limit(1).explain
+      _(plan).must_include "SELECT [cars].* FROM [cars] WHERE [cars].[name]"
+      _(plan).must_include "TOP EXPRESSION", "make sure we do not showplan the sp_executesql"
+      _(plan).must_include "Clustered Index Scan", "make sure we do not showplan the sp_executesql"
     end
 
-    it 'from array condition using index' do
+    it "from array condition using index" do
       plan = Car.where(id: [1, 2]).explain
-      plan.must_include " SELECT [cars].* FROM [cars] WHERE [cars].[id] IN (1, 2)"
-      plan.must_include "Clustered Index Seek", 'make sure we do not showplan the sp_executesql'
+      _(plan).must_include "SELECT [cars].* FROM [cars] WHERE [cars].[id] IN (1, 2)"
+      _(plan).must_include "Clustered Index Seek", "make sure we do not showplan the sp_executesql"
     end
 
-    it 'from array condition' do
-      plan = Car.where(name: ['honda', 'zyke']).explain
-      plan.must_include " SELECT [cars].* FROM [cars] WHERE [cars].[name] IN (N'honda', N'zyke')"
-      plan.must_include "Clustered Index Scan", 'make sure we do not showplan the sp_executesql'
+    it "from array condition" do
+      plan = Car.where(name: ["honda", "zyke"]).explain
+      _(plan).must_include " SELECT [cars].* FROM [cars] WHERE [cars].[name] IN (N'honda', N'zyke')"
+      _(plan).must_include "Clustered Index Scan", "make sure we do not showplan the sp_executesql"
     end
-
   end
 
-  describe 'With SHOWPLAN_TEXT option' do
-
-    it 'use simple table printer' do
-      with_showplan_option('SHOWPLAN_TEXT') do
+  describe "With SHOWPLAN_TEXT option" do
+    it "use simple table printer" do
+      with_showplan_option("SHOWPLAN_TEXT") do
         plan = Car.where(id: 1).explain
-        plan.must_include "SELECT [cars].* FROM [cars] WHERE [cars].[id]"
-        plan.must_include "Clustered Index Seek", 'make sure we do not showplan the sp_executesql'
+        _(plan).must_include "SELECT [cars].* FROM [cars] WHERE [cars].[id]"
+        _(plan).must_include "Clustered Index Seek", "make sure we do not showplan the sp_executesql"
       end
     end
-
   end
 
-  describe 'With SHOWPLAN_XML option' do
-
-    it 'show formatted xml' do
-      with_showplan_option('SHOWPLAN_XML') do
+  describe "With SHOWPLAN_XML option" do
+    it "show formatted xml" do
+      with_showplan_option("SHOWPLAN_XML") do
         plan = Car.where(id: 1).explain
-        plan.must_include 'ShowPlanXML'
+        _(plan).must_include "ShowPlanXML"
       end
     end
-
   end
 
-
   private
 
   def with_showplan_option(option)
@@ -73,5 +67,4 @@ class ShowplanTestSQLServer < ActiveRecord::TestCase
   ensure
     ActiveRecord::ConnectionAdapters::SQLServerAdapter.showplan_option = old_option
   end
-
 end

data/test/cases/specific_schema_test_sqlserver.rb

@@ -1,107 +1,111 @@
-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
-    SSTestTinyintPk.find(obj.id).must_equal obj
+  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'
-    obj.reload.date.must_be_instance_of Date
+  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
+    _(obj1.created_at).must_be_instance_of Time
+    _(obj1.updated_at).must_be_instance_of Time
   end
 
   # 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,58 +117,57 @@ 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!
-    o.reload.varchar_col.must_equal "O'Reilly"
+    _(o.reload.varchar_col).must_equal "O'Reilly"
     o.varchar_col = nil
     o.save!
-    o.reload.varchar_col.must_be_nil
+    _(o.reload.varchar_col).must_be_nil
   end
 
   # 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)
+    _(db_uuid).must_match(acceptable_uuid)
   end
 
   # 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,58 +1,58 @@
-# 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
+    _(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
-    in_level.must_match %r{serializable}i
-    after_level.must_match %r{read committed}i
+    _(in_level).must_match %r{serializable}i
+    _(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
-    connection.user_options_isolation_level.must_match %r{read committed}i
-    lambda {
+  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! }
-    }.must_raise(ActiveRecord::RecordInvalid)
-    connection.user_options_isolation_level.must_match %r{read committed}i
+    }).must_raise(ActiveRecord::RecordInvalid)
+    _(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,21 +63,20 @@ 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
-      connection.user_options_isolation_level.must_match "read committed snapshot"
+    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
       # "READ COMMITTED", and that no exception was raised (it's reported back
       # by SQL Server as "read committed snapshot").
-      connection.user_options_isolation_level.must_match "read committed snapshot"
+      _(connection.user_options_isolation_level).must_match "read committed snapshot"
     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