activerecord-sqlserver-adapter 7.1.7 → 7.2.0

data/test/cases/disconnected_test_sqlserver.rb

@@ -7,7 +7,7 @@ class TestDisconnectedAdapter < ActiveRecord::TestCase
 
   undef_method :setup
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
   end
 
   teardown do
@@ -19,7 +19,10 @@ class TestDisconnectedAdapter < ActiveRecord::TestCase
   test "execute procedure after disconnect reconnects" do
     @connection.execute_procedure :sp_tables, "sst_datatypes"
     @connection.disconnect!
-    @connection.execute_procedure :sp_tables, "sst_datatypes"
+
+    assert_nothing_raised do
+      @connection.execute_procedure :sp_tables, "sst_datatypes"
+    end
   end
 
   test "execute query after disconnect reconnects" do
@@ -31,6 +34,9 @@ class TestDisconnectedAdapter < ActiveRecord::TestCase
 
     @connection.exec_query sql, "TEST", binds
     @connection.disconnect!
-    @connection.exec_query sql, "TEST", binds
+
+    assert_nothing_raised do
+      @connection.exec_query sql, "TEST", binds
+    end
   end
 end

data/test/cases/eager_load_too_many_ids_test_sqlserver.rb

@@ -11,7 +11,7 @@ class EagerLoadingTooManyIdsTest < ActiveRecord::TestCase
     # We Monkey patch Preloader to work with batches of 10_000 records.
     # Expect: N Books queries + Citation query
     expected_query_count = (Citation.count / in_clause_length.to_f).ceil + 1
-    assert_queries(expected_query_count) do
+    assert_queries_count(expected_query_count) do
       Citation.preload(:reference_of).to_a.size
     end
   end

data/test/cases/enum_test_sqlserver.rb

@@ -13,7 +13,7 @@ class EnumTestSQLServer < ActiveRecord::TestCase
         Class.new(ActiveRecord::Base) do
           self.table_name = 'sst_datatypes'
 
-          enum col_name => { alpha: "A", beta: "B" }
+          enum col_name, { alpha: "A", beta: "B" }
         end
       end
 

data/test/cases/execute_procedure_test_sqlserver.rb

@@ -42,12 +42,16 @@ class ExecuteProcedureTestSQLServer < ActiveRecord::TestCase
     assert_equal date_base.change(usec: 0), date_proc.change(usec: 0)
   end
 
+  def transaction_with_procedure_and_return
+    ActiveRecord::Base.transaction do
+      connection.execute_procedure("my_getutcdate")
+      return
+    end
+  end
+
   it 'test deprecation with transaction return when executing procedure' do
-    assert_deprecated(ActiveRecord.deprecator) do
-      ActiveRecord::Base.transaction do
-        connection.execute_procedure("my_getutcdate")
-        return
-      end
+    assert_not_deprecated(ActiveRecord.deprecator) do
+      transaction_with_procedure_and_return
     end
   end
 end

data/test/cases/helper_sqlserver.rb

@@ -7,21 +7,27 @@ require "pry"
 require "support/core_ext/query_cache"
 require "support/minitest_sqlserver"
 require "support/test_in_memory_oltp"
+require "support/table_definition_sqlserver"
 require "cases/helper"
 require "support/load_schema_sqlserver"
 require "support/coerceable_test_sqlserver"
-require "support/sql_counter_sqlserver"
 require "support/connection_reflection"
+require "support/query_assertions"
 require "mocha/minitest"
 
+module ActiveSupport
+  class TestCase < ::Minitest::Test
+    include ARTest::SQLServer::CoerceableTest
+  end
+end
+
 module ActiveRecord
   class TestCase < ActiveSupport::TestCase
     SQLServer = ActiveRecord::ConnectionAdapters::SQLServer
 
-    include ARTest::SQLServer::CoerceableTest,
-            ARTest::SQLServer::ConnectionReflection,
-            ARTest::SQLServer::SqlCounterSqlserver,
-            ActiveSupport::Testing::Stream
+    include ARTest::SQLServer::ConnectionReflection,
+            ActiveSupport::Testing::Stream,
+            ARTest::SQLServer::QueryAssertions
 
     let(:logger) { ActiveRecord::Base.logger }
 

data/test/cases/index_test_sqlserver.rb

@@ -19,29 +19,31 @@ class IndexTestSQLServer < ActiveRecord::TestCase
   end
 
   it "add index with order" do
-    assert_sql(/CREATE.*INDEX.*\(\[last_name\] DESC\)/i) do
+    assert_queries_match(/CREATE.*INDEX.*\(\[last_name\] DESC\)/i) do
       connection.add_index "testings", ["last_name"], order: { last_name: :desc }
       connection.remove_index "testings", ["last_name"]
     end
-    assert_sql(/CREATE.*INDEX.*\(\[last_name\] DESC, \[first_name\]\)/i) do
+    assert_queries_match(/CREATE.*INDEX.*\(\[last_name\] DESC, \[first_name\]\)/i) do
       connection.add_index "testings", ["last_name", "first_name"], order: { last_name: :desc }
       connection.remove_index "testings", ["last_name", "first_name"]
     end
-    assert_sql(/CREATE.*INDEX.*\(\[last_name\] DESC, \[first_name\] ASC\)/i) do
+    assert_queries_match(/CREATE.*INDEX.*\(\[last_name\] DESC, \[first_name\] ASC\)/i) do
       connection.add_index "testings", ["last_name", "first_name"], order: { last_name: :desc, first_name: :asc }
       connection.remove_index "testings", ["last_name", "first_name"]
     end
   end
 
   it "add index with where" do
-    assert_sql(/CREATE.*INDEX.*\(\[last_name\]\) WHERE \[first_name\] = N'john doe'/i) do
+    assert_queries_match(/CREATE.*INDEX.*\(\[last_name\]\) WHERE \[first_name\] = N'john doe'/i) do
       connection.add_index "testings", "last_name", where: "[first_name] = N'john doe'"
       connection.remove_index "testings", "last_name"
     end
   end
 
   it "add index with expression" do
-    connection.execute "ALTER TABLE [testings] ADD [first_name_upper] AS UPPER([first_name])"
-    connection.add_index "testings", "first_name_upper"
+    assert_nothing_raised do
+      connection.execute "ALTER TABLE [testings] ADD [first_name_upper] AS UPPER([first_name])"
+      connection.add_index "testings", "first_name_upper"
+    end
   end
 end

data/test/cases/json_test_sqlserver.rb

@@ -2,7 +2,7 @@
 
 require "cases/helper_sqlserver"
 
-if ActiveRecord::Base.connection.supports_json?
+if ActiveRecord::Base.lease_connection.supports_json?
   class JsonTestSQLServer < ActiveRecord::TestCase
     before do
       @o1 = SSTestDatatypeMigrationJson.create! json_col: { "a" => "a", "b" => "b", "c" => "c" }

data/test/cases/lateral_test_sqlserver.rb

@@ -16,7 +16,7 @@ class LateralTestSQLServer < ActiveRecord::TestCase
     eq = Arel::Nodes::Equality.new(one, one)
 
     sql = author.project(Arel.star).where(author[:name].matches("David")).outer_join(subselect.lateral.as("bar")).on(eq).to_sql
-    results = ActiveRecord::Base.connection.exec_query sql
+    results = ActiveRecord::Base.lease_connection.exec_query sql
     assert_equal sql, "SELECT * FROM [authors] OUTER APPLY (SELECT * FROM [posts] WHERE [posts].[author_id] = [authors].[id] AND [posts].[id] = 42 ORDER BY [posts].[id] ASC OFFSET 0 ROWS FETCH NEXT 1 ROWS ONLY) AS bar WHERE [authors].[name] LIKE N'David'"
     assert_equal results.length, 1
   end
@@ -27,7 +27,7 @@ class LateralTestSQLServer < ActiveRecord::TestCase
     subselect = post.project(Arel.star).take(1).where(post[:author_id].eq(author[:id])).where(post[:id].eq(42))
 
     sql = author.project(Arel.star).where(author[:name].matches("David")).join(subselect.lateral.as("bar")).to_sql
-    results = ActiveRecord::Base.connection.exec_query sql
+    results = ActiveRecord::Base.lease_connection.exec_query sql
 
     assert_equal sql, "SELECT * FROM [authors] CROSS APPLY (SELECT * FROM [posts] WHERE [posts].[author_id] = [authors].[id] AND [posts].[id] = 42 ORDER BY [posts].[id] ASC OFFSET 0 ROWS FETCH NEXT 1 ROWS ONLY) AS bar WHERE [authors].[name] LIKE N'David'"
     assert_equal results.length, 0

data/test/cases/migration_test_sqlserver.rb

@@ -20,7 +20,7 @@ class MigrationTestSQLServer < ActiveRecord::TestCase
     it "not create a tables if error in migrations" do
       begin
         migrations_dir = File.join ARTest::SQLServer.migrations_root, "transaction_table"
-        quietly { ActiveRecord::MigrationContext.new(migrations_dir, ActiveRecord::SchemaMigration).up }
+        quietly { ActiveRecord::MigrationContext.new(migrations_dir).up }
       rescue Exception => e
         assert_match %r|this and all later migrations canceled|, e.message
       end

data/test/cases/optimizer_hints_test_sqlserver.rb

@@ -7,29 +7,29 @@ class OptimizerHitsTestSQLServer < ActiveRecord::TestCase
   fixtures :companies
 
   it "apply optimizations" do
-    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
+    assert_queries_match(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
       companies = Company.optimizer_hints("HASH GROUP")
       companies = companies.distinct.select("firm_id")
-      assert_includes companies.explain, "| Hash Match | Aggregate  |"
+      assert_includes companies.explain.inspect, "| Hash Match | Aggregate  |"
     end
 
-    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(ORDER GROUP\)\z}) do
+    assert_queries_match(%r{\ASELECT .+ FROM .+ OPTION \(ORDER GROUP\)\z}) do
       companies = Company.optimizer_hints("ORDER GROUP")
       companies = companies.distinct.select("firm_id")
-      assert_includes companies.explain, "| Stream Aggregate | Aggregate  |"
+      assert_includes companies.explain.inspect, "| Stream Aggregate | Aggregate  |"
     end
   end
 
   it "apply multiple optimizations" do
-    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP, FAST 1\)\z}) do
+    assert_queries_match(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP, FAST 1\)\z}) do
       companies = Company.optimizer_hints("HASH GROUP", "FAST 1")
       companies = companies.distinct.select("firm_id")
-      assert_includes companies.explain, "| Hash Match | Flow Distinct |"
+      assert_includes companies.explain.inspect, "| Hash Match | Flow Distinct |"
     end
   end
 
   it "support subqueries" do
-    assert_sql(%r{.*'SELECT COUNT\(count_column\) FROM \(SELECT .*\) subquery_for_count OPTION \(MAXDOP 2\)'.*}) do
+    assert_queries_match(%r{.*'SELECT COUNT\(count_column\) FROM \(SELECT .*\) subquery_for_count OPTION \(MAXDOP 2\)'.*}) do
       companies = Company.optimizer_hints("MAXDOP 2")
       companies = companies.select(:id).where(firm_id: [0, 1]).limit(3)
       assert_equal 3, companies.count
@@ -37,25 +37,25 @@ class OptimizerHitsTestSQLServer < ActiveRecord::TestCase
   end
 
   it "sanitize values" do
-    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
+    assert_queries_match(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
       companies = Company.optimizer_hints("OPTION (HASH GROUP)")
       companies = companies.distinct.select("firm_id")
       companies.to_a
     end
 
-    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
+    assert_queries_match(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
       companies = Company.optimizer_hints("OPTION(HASH GROUP)")
       companies = companies.distinct.select("firm_id")
       companies.to_a
     end
 
-    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(TABLE HINT \(\[companies\], INDEX\(1\)\)\)\z}) do
+    assert_queries_match(%r{\ASELECT .+ FROM .+ OPTION \(TABLE HINT \(\[companies\], INDEX\(1\)\)\)\z}) do
       companies = Company.optimizer_hints("OPTION(TABLE HINT ([companies], INDEX(1)))")
       companies = companies.distinct.select("firm_id")
       companies.to_a
     end
 
-    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
+    assert_queries_match(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
       companies = Company.optimizer_hints("Option(HASH GROUP)")
       companies = companies.distinct.select("firm_id")
       companies.to_a
@@ -63,7 +63,7 @@ class OptimizerHitsTestSQLServer < ActiveRecord::TestCase
   end
 
   it "skip optimization after unscope" do
-    assert_sql("SELECT DISTINCT [companies].[firm_id] FROM [companies]") do
+    assert_queries_match("SELECT DISTINCT [companies].[firm_id] FROM [companies]") do
       companies = Company.optimizer_hints("HASH GROUP")
       companies = companies.distinct.select("firm_id")
       companies.unscope(:optimizer_hints).load

data/test/cases/pessimistic_locking_test_sqlserver.rb

@@ -13,7 +13,7 @@ class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
   end
 
   it "uses with updlock by default" do
-    assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(UPDLOCK\)| do
+    assert_queries_match %r|SELECT \[people\]\.\* FROM \[people\] WITH\(UPDLOCK\)| do
       _(Person.lock(true).to_a).must_equal Person.all.to_a
     end
   end
@@ -47,32 +47,32 @@ class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
     end
 
     it "can add a custom lock directive" do
-      assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(HOLDLOCK, ROWLOCK\)| do
+      assert_queries_match %r|SELECT \[people\]\.\* FROM \[people\] WITH\(HOLDLOCK, ROWLOCK\)| do
         Person.lock("WITH(HOLDLOCK, ROWLOCK)").load
       end
     end
 
     describe "joining tables" do
       it "joined tables use updlock by default" do
-        assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(UPDLOCK\) INNER JOIN \[readers\] WITH\(UPDLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
+        assert_queries_match %r|SELECT \[people\]\.\* FROM \[people\] WITH\(UPDLOCK\) INNER JOIN \[readers\] WITH\(UPDLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
           Person.lock(true).joins(:readers).load
         end
       end
 
       it "joined tables can use custom lock directive" do
-        assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(NOLOCK\) INNER JOIN \[readers\] WITH\(NOLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
+        assert_queries_match %r|SELECT \[people\]\.\* FROM \[people\] WITH\(NOLOCK\) INNER JOIN \[readers\] WITH\(NOLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
           Person.lock("WITH(NOLOCK)").joins(:readers).load
         end
       end
 
       it "left joined tables use updlock by default" do
-        assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(UPDLOCK\) LEFT OUTER JOIN \[readers\] WITH\(UPDLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
+        assert_queries_match %r|SELECT \[people\]\.\* FROM \[people\] WITH\(UPDLOCK\) LEFT OUTER JOIN \[readers\] WITH\(UPDLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
           Person.lock(true).left_joins(:readers).load
         end
       end
 
       it "left joined tables can use custom lock directive" do
-        assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(NOLOCK\) LEFT OUTER JOIN \[readers\] WITH\(NOLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
+        assert_queries_match %r|SELECT \[people\]\.\* FROM \[people\] WITH\(NOLOCK\) LEFT OUTER JOIN \[readers\] WITH\(NOLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
           Person.lock("WITH(NOLOCK)").left_joins(:readers).load
         end
       end
@@ -88,7 +88,8 @@ class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
     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
+
+      assert_queries_match(/#{eager_ids_sql}|#{loader_sql}/, count: 2) 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"

data/test/cases/primary_keys_test_sqlserver.rb

@@ -12,7 +12,7 @@ class PrimaryKeyUuidTypeTest < ActiveRecord::TestCase
   end
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table(:barcodes, primary_key: "code", id: :uuid, force: true)
   end
 
@@ -50,7 +50,7 @@ class PrimaryKeyIntegerTest < ActiveRecord::TestCase
   end
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
   end
 
   teardown do

data/test/cases/rake_test_sqlserver.rb

@@ -138,18 +138,22 @@ class SQLServerRakeStructureDumpLoadTest < SQLServerRakeTest
 
   it "dumps structure and accounts for defncopy oddities" do
     skip "debug defncopy on windows later" if host_windows?
+
     quietly { db_tasks.structure_dump configuration, filename }
+
     _(filedata).wont_match %r{\AUSE.*\z}
     _(filedata).wont_match %r{\AGO.*\z}
-    _(filedata).must_match %r{email\s+nvarchar\(4000\)}
-    _(filedata).must_match %r{background1\s+nvarchar\(max\)}
-    _(filedata).must_match %r{background2\s+text\s+}
+    _(filedata).must_match %r{\[email\]\s+nvarchar\(4000\)}
+    _(filedata).must_match %r{\[background1\]\s+nvarchar\(max\)}
+    _(filedata).must_match %r{\[background2\]\s+text\s+}
   end
 
   it "can load dumped structure" do
     skip "debug defncopy on windows later" if host_windows?
+
     quietly { db_tasks.structure_dump configuration, filename }
-    _(filedata).must_match %r{CREATE TABLE dbo\.users}
+
+    _(filedata).must_match %r{CREATE TABLE \[dbo\]\.\[users\]}
     db_tasks.purge(configuration)
     _(connection.tables).wont_include "users"
     db_tasks.load_schema db_config, :sql, filename

data/test/cases/schema_dumper_test_sqlserver.rb

@@ -6,7 +6,7 @@ require "stringio"
 class SchemaDumperTestSQLServer < ActiveRecord::TestCase
   before { all_tables }
 
-  let(:all_tables)   { ActiveRecord::Base.connection.tables }
+  let(:all_tables)   { ActiveRecord::Base.lease_connection.tables }
   let(:schema)       { @generated_schema }
 
   it "sst_datatypes" do
@@ -162,7 +162,7 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
 
   it "schemas are dumped and tables names only include non-default schema" do
     stream = StringIO.new
-    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection_pool, stream)
     generated_schema = stream.string
 
     # Only generate non-default schemas. Default schema is 'dbo'.
@@ -177,7 +177,7 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
     # Only non-default schemas should be included in table names. Default schema is 'dbo'.
     assert_includes generated_schema, 'create_table "accounts"'
     assert_includes generated_schema, 'create_table "test.aliens"'
-    assert_includes generated_schema, 'create_table "test2.sst_schema_test_mulitple_schema"'
+    assert_includes generated_schema, 'create_table "test2.sst_schema_test_multiple_schema"'
   end
 
   private
@@ -187,8 +187,7 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
     ActiveRecord::SchemaDumper.ignore_tables = all_tables - table_names
 
     stream = StringIO.new
-    ActiveRecord::SchemaDumper.ignore_tables = all_tables - table_names
-    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection_pool, stream)
 
     @generated_schema = stream.string
     yield @generated_schema if block_given?

data/test/cases/showplan_test_sqlserver.rb

@@ -8,32 +8,32 @@ class ShowplanTestSQLServer < ActiveRecord::TestCase
 
   describe "Unprepare previously prepared SQL" do
     it "from simple statement" do
-      plan = Car.where(id: 1).explain
+      plan = Car.where(id: 1).explain.inspect
       _(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
-      plan = Car.where("\n id = 1 \n").explain
+      plan = Car.where("\n id = 1 \n").explain.inspect
       _(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 = Car.where(name: ",").limit(1).explain.inspect
       _(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
-      plan = Car.where(id: [1, 2]).explain
+      plan = Car.where(id: [1, 2]).explain.inspect
       _(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 = Car.where(name: ["honda", "zyke"]).explain.inspect
       _(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
@@ -42,7 +42,7 @@ class ShowplanTestSQLServer < ActiveRecord::TestCase
   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 = Car.where(id: 1).explain.inspect
         _(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
@@ -52,7 +52,7 @@ class ShowplanTestSQLServer < ActiveRecord::TestCase
   describe "With SHOWPLAN_XML option" do
     it "show formatted xml" do
       with_showplan_option("SHOWPLAN_XML") do
-        plan = Car.where(id: 1).explain
+        plan = Car.where(id: 1).explain.inspect
         _(plan).must_include "ShowPlanXML"
       end
     end

data/test/cases/specific_schema_test_sqlserver.rb

@@ -6,8 +6,12 @@ class SpecificSchemaTestSQLServer < ActiveRecord::TestCase
   after { SSTestEdgeSchema.delete_all }
 
   it "handle dollar symbols" do
-    SSTestDollarTableName.create!
-    SSTestDollarTableName.limit(20).offset(1)
+    assert_difference("SSTestDollarTableName.count", 1) do
+      SSTestDollarTableName.create!
+    end
+    assert_nothing_raised do
+      SSTestDollarTableName.limit(20).offset(1)
+    end
   end
 
   it "models can use tinyint pk tables" do
@@ -93,7 +97,7 @@ class SpecificSchemaTestSQLServer < ActiveRecord::TestCase
 
   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 }
+    assert_queries_match(sql) { SSTestNaturalPkData.limit(5).offset(5).load }
   end
 
   # Special quoted column
@@ -112,16 +116,16 @@ class SpecificSchemaTestSQLServer < ActiveRecord::TestCase
       end
     end
     # Using ActiveRecord's quoted_id feature for objects.
-    assert_sql(/@0 = 'T'/) { SSTestDatatypeMigration.where(char_col: value.new).first }
-    assert_sql(/@0 = 'T'/) { SSTestDatatypeMigration.where(varchar_col: value.new).first }
+    assert_queries_match(/@0 = 'T'/) { SSTestDatatypeMigration.where(char_col: value.new).first }
+    assert_queries_match(/@0 = 'T'/) { SSTestDatatypeMigration.where(varchar_col: value.new).first }
     # 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_queries_match(/@0 = 'T'/) { SSTestDatatypeMigration.where(char_col: data.new("T", type.new)).first }
+    assert_queries_match(/@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_queries_match(/@0 = 'T'/) { SSTestDatatypeMigration.where(char_col: "T").first }
+    assert_queries_match(/@0 = 'T'/) { SSTestDatatypeMigration.where(varchar_col: "T").first }
   end
 
   it "can update and hence properly quoted non-national char/varchar columns" do
@@ -159,15 +163,15 @@ class SpecificSchemaTestSQLServer < ActiveRecord::TestCase
 
   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 = ActiveRecord::Base.lease_connection.newid_function
     _(db_uuid).must_match(acceptable_uuid)
   end
 
   # with similar table definition in two schemas
 
   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
+    connection = ActiveRecord::Base.lease_connection
+    assert_equal "field_1", connection.columns("test.sst_schema_test_multiple_schema").detect(&:is_primary?).name
+    assert_equal "field_2", connection.columns("test2.sst_schema_test_multiple_schema").detect(&:is_primary?).name
   end
 end

data/test/cases/view_test_sqlserver.rb

@@ -3,7 +3,7 @@
 require "cases/helper_sqlserver"
 
 class ViewTestSQLServer < ActiveRecord::TestCase
-  let(:connection) { ActiveRecord::Base.connection }
+  let(:connection) { ActiveRecord::Base.lease_connection }
 
   describe 'view with default values' do
     before do

data/test/schema/sqlserver_specific_schema.rb

@@ -308,17 +308,17 @@ ActiveRecord::Schema.define do
     )
   NATURALPKTABLESQLINOTHERSCHEMA
 
-  execute "IF EXISTS(SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'sst_schema_test_mulitple_schema' and TABLE_SCHEMA = 'test') DROP TABLE test.sst_schema_test_mulitple_schema"
+  execute "IF EXISTS(SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'sst_schema_test_multiple_schema' and TABLE_SCHEMA = 'test') DROP TABLE test.sst_schema_test_multiple_schema"
   execute <<-SCHEMATESTMULTIPLESCHEMA
-    CREATE TABLE test.sst_schema_test_mulitple_schema(
+    CREATE TABLE test.sst_schema_test_multiple_schema(
       field_1 int NOT NULL PRIMARY KEY,
       field_2 int,
     )
   SCHEMATESTMULTIPLESCHEMA
   execute "IF NOT EXISTS(SELECT * FROM sys.schemas WHERE name = 'test2') EXEC sp_executesql N'CREATE SCHEMA test2'"
-  execute "IF EXISTS(SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'sst_schema_test_mulitple_schema' and TABLE_SCHEMA = 'test2') DROP TABLE test2.sst_schema_test_mulitple_schema"
+  execute "IF EXISTS(SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'sst_schema_test_multiple_schema' and TABLE_SCHEMA = 'test2') DROP TABLE test2.sst_schema_test_multiple_schema"
   execute <<-SCHEMATESTMULTIPLESCHEMA
-    CREATE TABLE test2.sst_schema_test_mulitple_schema(
+    CREATE TABLE test2.sst_schema_test_multiple_schema(
       field_1 int,
       field_2 int NOT NULL PRIMARY KEY,
     )

data/test/support/connection_reflection.rb

@@ -8,7 +8,7 @@ module ARTest
       included { extend ConnectionReflection }
 
       def connection
-        ActiveRecord::Base.connection
+        ActiveRecord::Base.lease_connection
       end
 
       def connection_options

data/test/support/core_ext/query_cache.rb

@@ -22,8 +22,8 @@ module SqlIgnoredCache
   # compromising cache outside tests.
   def cache_sql(sql, name, binds)
     result = super
-    
-    @query_cache.delete_if do |cache_key, _v|
+
+    @query_cache.instance_variable_get(:@map).delete_if do |cache_key, _v|
       # Query cache key generated by `sql` or `[sql, binds]`, so need to retrieve `sql` for both cases.
       cache_key_sql = Array(cache_key).first
       Regexp.union(IGNORED_SQL).match?(cache_key_sql)

data/test/support/query_assertions.rb

@@ -0,0 +1,49 @@
+module ARTest
+  module SQLServer
+    module QueryAssertions
+      def assert_queries_count(count = nil, include_schema: false, &block)
+        ActiveRecord::Base.lease_connection.materialize_transactions
+
+        counter = ActiveRecord::Assertions::QueryAssertions::SQLCounter.new
+        ActiveSupport::Notifications.subscribed(counter, "sql.active_record") do
+          result = _assert_nothing_raised_or_warn("assert_queries_count", &block)
+          queries = include_schema ? counter.log_all : counter.log
+
+          # Start of monkey-patch
+          queries = include_release_savepoint_placeholder_queries(queries)
+          # End of monkey-patch
+
+          if count
+            assert_equal count, queries.size, "#{queries.size} instead of #{count} queries were executed. Queries: #{queries.join("\n\n")}"
+          else
+            assert_operator queries.size, :>=, 1, "1 or more queries expected, but none were executed.#{queries.empty? ? '' : "\nQueries:\n#{queries.join("\n")}"}"
+          end
+          result
+        end
+      end
+
+      private
+
+      # Rails tests expect a save-point to be created and released. SQL Server does not release
+      # save-points and so the number of queries will be off. This monkey patch adds a placeholder queries
+      # to replace the missing save-point releases.
+      def include_release_savepoint_placeholder_queries(queries)
+        grouped_queries = [[]]
+
+        queries.each do |query|
+          if query =~ /SAVE TRANSACTION \S+/
+            grouped_queries << [query]
+          else
+            grouped_queries.last << query
+          end
+        end
+
+        grouped_queries.each do |group|
+          group.append "/* release savepoint placeholder for testing */" if group.first =~ /SAVE TRANSACTION \S+/
+        end
+
+        grouped_queries.flatten
+      end
+    end
+  end
+end