activerecord-sqlserver-adapter 8.0.10 → 8.1.0

data/test/cases/connection_test_sqlserver.rb

@@ -15,7 +15,7 @@ class ConnectionTestSQLServer < ActiveRecord::TestCase
   end
 
   it "affect rows" do
-    topic_data = { 1 => { "content" => "1 updated" }, 2 => { "content" => "2 updated" } }
+    topic_data = {1 => {"content" => "1 updated"}, 2 => {"content" => "2 updated"}}
     updated = Topic.update(topic_data.keys, topic_data.values)
     assert_equal 2, updated.size
     assert_equal "1 updated", Topic.find(1).content
@@ -23,16 +23,18 @@ class ConnectionTestSQLServer < ActiveRecord::TestCase
     assert_equal 2, Topic.delete([1, 2])
   end
 
-  it "allow usage of :database connection option to remove setting from dsn" do
-    assert_equal "activerecord_unittest", connection.current_database
-    begin
-      connection.use_database("activerecord_unittest2")
-      assert_equal "activerecord_unittest2", connection.current_database
-    ensure
-      connection.use_database
-      assert_equal "activerecord_unittest", connection.current_database, "Would default back to connection options"
+  unless connection_sqlserver_azure?
+    it "allow usage of :database connection option to remove setting from dsn" do
+      assert_equal "activerecord_unittest", connection.current_database
+      begin
+        connection.use_database("activerecord_unittest2")
+        assert_equal "activerecord_unittest2", connection.current_database
+      ensure
+        connection.use_database
+        assert_equal "activerecord_unittest", connection.current_database, "Would default back to connection options"
+      end
     end
-  end unless connection_sqlserver_azure?
+  end
 
   describe "Connection management" do
     it "set spid on connect" do
@@ -60,6 +62,8 @@ class ConnectionTestSQLServer < ActiveRecord::TestCase
   private
 
   def disconnect_raw_connection!
-    connection.raw_connection.close rescue nil
+    connection.raw_connection.close
+  rescue
+    nil
   end
 end

data/test/cases/enum_test_sqlserver.rb

@@ -3,7 +3,6 @@
 require "cases/helper_sqlserver"
 
 class EnumTestSQLServer < ActiveRecord::TestCase
-
   # Check that enums are supported for all string types.
   # For each type we check: cast, serialize, and update by declaration.
   # We create a custom class for each type to test.
@@ -11,27 +10,27 @@ class EnumTestSQLServer < ActiveRecord::TestCase
     describe "support #{col_name} enums" do
       let(:klass) do
         Class.new(ActiveRecord::Base) do
-          self.table_name = 'sst_datatypes'
+          self.table_name = "sst_datatypes"
 
-          enum col_name, { alpha: "A", beta: "B" }
+          enum col_name, {alpha: "A", beta: "B"}
         end
       end
 
       it "type.cast" do
         type = klass.type_for_attribute(col_name)
 
-        assert_equal "alpha",  type.cast('A')
-        assert_equal "beta",   type.cast('B')
+        assert_equal "alpha", type.cast("A")
+        assert_equal "beta", type.cast("B")
       end
 
       it "type.serialize" do
         type = klass.type_for_attribute(col_name)
 
-        assert_equal 'A', type.serialize('A')
-        assert_equal 'B', type.serialize('B')
+        assert_equal "A", type.serialize("A")
+        assert_equal "B", type.serialize("B")
 
-        assert_equal 'A', type.serialize(:alpha)
-        assert_equal 'B', type.serialize(:beta)
+        assert_equal "A", type.serialize(:alpha)
+        assert_equal "B", type.serialize(:beta)
       end
 
       it "update by declaration" do

data/test/cases/execute_procedure_test_sqlserver.rb

@@ -49,7 +49,7 @@ class ExecuteProcedureTestSQLServer < ActiveRecord::TestCase
     end
   end
 
-  it 'test deprecation with transaction return when executing procedure' do
+  it "test deprecation with transaction return when executing procedure" do
     assert_not_deprecated(ActiveRecord.deprecator) do
       transaction_with_procedure_and_return
     end

data/test/cases/fetch_test_sqlserver.rb

@@ -49,7 +49,7 @@ class FetchTestSqlserver < ActiveRecord::TestCase
       query = Book.from(from_sql).order(:id).limit(5)
 
       assert_equal query.to_sql, "SELECT [books].* FROM (SELECT [books].* FROM [books]) [books] ORDER BY [books].[id] ASC OFFSET 0 ROWS FETCH NEXT 5 ROWS ONLY"
-      assert_equal query.to_a.count, 5
+      assert_equal query.to_a.size, 5
     end
 
     it "exception thrown if FROM subquery is provided without an order" do

data/test/cases/helper_sqlserver.rb

@@ -5,6 +5,7 @@ require "bundler/setup"
 Bundler.require :default, :development
 require "pry"
 require "support/core_ext/query_cache"
+require "support/core_ext/backtrace_cleaner"
 require "support/minitest_sqlserver"
 require "support/test_in_memory_oltp"
 require "support/table_definition_sqlserver"
@@ -16,6 +17,9 @@ require "support/query_assertions"
 require "mocha/minitest"
 
 Minitest.after_run do
+  puts "\n\n"
+  puts "=" * 80
+  puts "Ruby Version: #{RUBY_VERSION}p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]"
   puts "\n\n"
   puts "=" * 80
   puts ActiveRecord::Base.lease_connection.send(:sqlserver_version)
@@ -33,9 +37,9 @@ module ActiveRecord
   class TestCase < ActiveSupport::TestCase
     SQLServer = ActiveRecord::ConnectionAdapters::SQLServer
 
-    include ARTest::SQLServer::ConnectionReflection,
-            ActiveSupport::Testing::Stream,
-            ARTest::SQLServer::QueryAssertions
+    include ARTest::SQLServer::QueryAssertions
+    include ActiveSupport::Testing::Stream
+    include ARTest::SQLServer::ConnectionReflection
 
     let(:logger) { ActiveRecord::Base.logger }
 

data/test/cases/index_test_sqlserver.rb

@@ -8,27 +8,29 @@ class IndexTestSQLServer < ActiveRecord::TestCase
       t.column :foo, :string, limit: 100
       t.column :bar, :string, limit: 100
       t.string :first_name
-      t.string :last_name,    limit: 100
-      t.string :key,          limit: 100
+      t.string :last_name, limit: 100
+      t.string :key, limit: 100
       t.boolean :administrator
     end
   end
 
   after do
-    connection.drop_table :testings rescue nil
+    connection.drop_table :testings
+  rescue
+    nil
   end
 
   it "add index with order" do
     assert_queries_match(/CREATE.*INDEX.*\(\[last_name\] DESC\)/i) do
-      connection.add_index "testings", ["last_name"], order: { last_name: :desc }
+      connection.add_index "testings", ["last_name"], order: {last_name: :desc}
       connection.remove_index "testings", ["last_name"]
     end
     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.add_index "testings", ["last_name", "first_name"], order: {last_name: :desc}
       connection.remove_index "testings", ["last_name", "first_name"]
     end
     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.add_index "testings", ["last_name", "first_name"], order: {last_name: :desc, first_name: :asc}
       connection.remove_index "testings", ["last_name", "first_name"]
     end
   end

data/test/cases/insert_all_test_sqlserver.rb

@@ -1,34 +1,9 @@
 # frozen_string_literal: true
 
 require "cases/helper_sqlserver"
-require "models/book"
 require "models/sqlserver/recurring_task"
 
 class InsertAllTestSQLServer < ActiveRecord::TestCase
-  # Test ported from the Rails `main` branch that is not on the `8-0-stable` branch.
-  def test_insert_all_only_applies_last_value_when_given_duplicate_identifiers
-    skip unless supports_insert_on_duplicate_skip?
-
-    Book.insert_all [
-                      { id: 111, name: "expected_new_name" },
-                      { id: 111, name: "unexpected_new_name" }
-                    ]
-    assert_equal "expected_new_name", Book.find(111).name
-  end
-
-  # Test ported from the Rails `main` branch that is not on the `8-0-stable` branch.
-  def test_upsert_all_only_applies_last_value_when_given_duplicate_identifiers
-    skip unless supports_insert_on_duplicate_update? && !current_adapter?(:PostgreSQLAdapter)
-
-    Book.create!(id: 112, name: "original_name")
-
-    Book.upsert_all [
-                      { id: 112, name: "unexpected_new_name" },
-                      { id: 112, name: "expected_new_name" }
-                    ]
-    assert_equal "expected_new_name", Book.find(112).name
-  end
-
   test "upsert_all recording of timestamps works with mixed datatypes" do
     task = RecurringTask.create!(
       key: "abcdef",
@@ -36,9 +11,9 @@ class InsertAllTestSQLServer < ActiveRecord::TestCase
     )
 
     RecurringTask.upsert_all([{
-                                id: task.id,
-                                priority: nil
-                              }])
+      id: task.id,
+      priority: nil
+    }])
 
     assert_not_equal task.updated_at, RecurringTask.find(task.id).updated_at
   end

data/test/cases/json_test_sqlserver.rb

@@ -5,19 +5,19 @@ require "cases/helper_sqlserver"
 if ActiveRecord::Base.lease_connection.supports_json?
   class JsonTestSQLServer < ActiveRecord::TestCase
     before do
-      @o1 = SSTestDatatypeMigrationJson.create! json_col: { "a" => "a", "b" => "b", "c" => "c" }
-      @o2 = SSTestDatatypeMigrationJson.create! json_col: { "a" => nil, "b" => "b", "c" => "c" }
-      @o3 = SSTestDatatypeMigrationJson.create! json_col: { "x" => 1, "y" => 2, "z" => 3 }
-      @o4 = SSTestDatatypeMigrationJson.create! json_col: { "array" => [1, 2, 3] }
+      @o1 = SSTestDatatypeMigrationJson.create! json_col: {"a" => "a", "b" => "b", "c" => "c"}
+      @o2 = SSTestDatatypeMigrationJson.create! json_col: {"a" => nil, "b" => "b", "c" => "c"}
+      @o3 = SSTestDatatypeMigrationJson.create! json_col: {"x" => 1, "y" => 2, "z" => 3}
+      @o4 = SSTestDatatypeMigrationJson.create! json_col: {"array" => [1, 2, 3]}
       @o5 = SSTestDatatypeMigrationJson.create! json_col: nil
     end
 
     it "can return and save JSON data" do
-      _(SSTestDatatypeMigrationJson.find(@o1.id).json_col).must_equal({ "a" => "a", "b" => "b", "c" => "c" })
-      @o1.json_col = { "a" => "a" }
-      _(@o1.json_col).must_equal({ "a" => "a" })
+      _(SSTestDatatypeMigrationJson.find(@o1.id).json_col).must_equal({"a" => "a", "b" => "b", "c" => "c"})
+      @o1.json_col = {"a" => "a"}
+      _(@o1.json_col).must_equal({"a" => "a"})
       @o1.save!
-      _(@o1.reload.json_col).must_equal({ "a" => "a" })
+      _(@o1.reload.json_col).must_equal({"a" => "a"})
     end
 
     it "can use ISJSON function" do

data/test/cases/lateral_test_sqlserver.rb

@@ -7,7 +7,7 @@ require "models/author"
 class LateralTestSQLServer < ActiveRecord::TestCase
   fixtures :posts, :authors
 
-  it 'uses OUTER APPLY for OUTER JOIN LATERAL' do
+  it "uses OUTER APPLY for OUTER JOIN LATERAL" do
     post = Arel::Table.new(:posts)
     author = Arel::Table.new(:authors)
     subselect = post.project(Arel.star).take(1).where(post[:author_id].eq(author[:id])).where(post[:id].eq(42))
@@ -21,7 +21,7 @@ class LateralTestSQLServer < ActiveRecord::TestCase
     assert_equal results.length, 1
   end
 
-  it 'uses CROSS APPLY for INNER JOIN LATERAL' do
+  it "uses CROSS APPLY for INNER JOIN LATERAL" do
     post = Arel::Table.new(:posts)
     author = Arel::Table.new(:authors)
     subselect = post.project(Arel.star).take(1).where(post[:author_id].eq(author[:id])).where(post[:id].eq(42))

data/test/cases/migration_test_sqlserver.rb

@@ -21,8 +21,8 @@ class MigrationTestSQLServer < ActiveRecord::TestCase
       begin
         migrations_dir = File.join ARTest::SQLServer.migrations_root, "transaction_table"
         quietly { ActiveRecord::MigrationContext.new(migrations_dir).up }
-      rescue Exception => e
-        assert_match %r|this and all later migrations canceled|, e.message
+      rescue => e
+        assert_match %r{this and all later migrations canceled}, e.message
       end
       _(connection.tables).wont_include @trans_test_table1
       _(connection.tables).wont_include @trans_test_table2
@@ -45,9 +45,9 @@ class MigrationTestSQLServer < ActiveRecord::TestCase
 
     it "not drop the default constraint if just renaming" do
       find_default = lambda do
-        connection.execute_procedure(:sp_helpconstraint, "sst_string_defaults", "nomsg").select do |row|
+        connection.execute_procedure(:sp_helpconstraint, "sst_string_defaults", "nomsg").reverse.find do |row|
           row["constraint_type"] == "DEFAULT on column string_with_pretend_paren_three"
-        end.last
+        end
       end
       default_before = find_default.call
       connection.change_column :sst_string_defaults, :string_with_pretend_paren_three, :string, limit: 255
@@ -68,7 +68,7 @@ class MigrationTestSQLServer < ActiveRecord::TestCase
       assert_nothing_raised { connection.change_column :sst_string_collation, :string_with_collation, :varchar, collation: :SQL_Latin1_General_CP437_BIN }
 
       SstStringCollation.reset_column_information
-      assert_equal "SQL_Latin1_General_CP437_BIN", SstStringCollation.columns_hash['string_with_collation'].collation
+      assert_equal "SQL_Latin1_General_CP437_BIN", SstStringCollation.columns_hash["string_with_collation"].collation
     end
   end
 
@@ -78,7 +78,7 @@ class MigrationTestSQLServer < ActiveRecord::TestCase
 
       schemas = connection.exec_query("select name from sys.schemas").to_a
 
-      assert_includes schemas, { "name" => "some schema" }
+      assert_includes schemas, {"name" => "some schema"}
     end
 
     it "creates a new schema with an owner" do
@@ -86,7 +86,7 @@ class MigrationTestSQLServer < ActiveRecord::TestCase
 
       schemas = connection.exec_query("select name, principal_id from sys.schemas").to_a
 
-      assert_includes schemas, { "name" => "some schema", "principal_id" => 2 }
+      assert_includes schemas, {"name" => "some schema", "principal_id" => 2}
     end
   end
 
@@ -106,18 +106,18 @@ class MigrationTestSQLServer < ActiveRecord::TestCase
     it "drops a schema" do
       schemas = connection.exec_query("select name from sys.schemas").to_a
 
-      assert_includes schemas, { "name" => "some schema" }
+      assert_includes schemas, {"name" => "some schema"}
 
       connection.drop_schema("some schema")
 
       schemas = connection.exec_query("select name from sys.schemas").to_a
 
-      refute_includes schemas, { "name" => "some schema" }
+      refute_includes schemas, {"name" => "some schema"}
     end
   end
 
-  describe 'creating stored procedure' do
-    it 'stored procedure contains inserts are created successfully' do
+  describe "creating stored procedure" do
+    it "stored procedure contains inserts are created successfully" do
       sql = <<-SQL
           CREATE OR ALTER PROCEDURE do_some_task
           AS
@@ -126,7 +126,7 @@ class MigrationTestSQLServer < ActiveRecord::TestCase
             CREATE TABLE SomeTableName (SomeNum int PRIMARY KEY CLUSTERED);
             INSERT INTO SomeTableName(SomeNum) VALUES(1);
           END
-        SQL
+      SQL
 
       assert_nothing_raised { connection.execute(sql) }
     ensure

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_queries_match %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_queries_match %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_queries_match %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_queries_match %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_queries_match %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_queries_match %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

data/test/cases/primary_keys_test_sqlserver.rb

@@ -67,7 +67,7 @@ class PrimaryKeyIntegerTest < ActiveRecord::TestCase
     assert_not_predicate column, :bigint?
 
     schema = dump_table_schema "widgets"
-    assert_match %r/create_table "widgets", id: :integer, force: :cascade do/, schema
+    assert_match %r{create_table "widgets", id: :integer, force: :cascade do}, schema
   end
 
   test "bigint primary key without default" do
@@ -79,7 +79,7 @@ class PrimaryKeyIntegerTest < ActiveRecord::TestCase
     assert_predicate column, :bigint?
 
     schema = dump_table_schema "widgets"
-    assert_match %r/create_table "widgets", force: :cascade do/, schema
+    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
@@ -91,13 +91,13 @@ class PrimaryKeyIntegerTest < ActiveRecord::TestCase
     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
+    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
+    assert_match %r{create_table "barcodes", id: :integer, default: nil, force: :cascade do}, schema
   end
 end

data/test/cases/rake_test_sqlserver.rb

@@ -8,15 +8,15 @@ class SQLServerRakeTest < ActiveRecord::TestCase
   cattr_accessor :azure_skip
   self.azure_skip = connection_sqlserver_azure?
 
-  let(:db_tasks)              { ActiveRecord::Tasks::DatabaseTasks }
-  let(:new_database)          { "activerecord_unittest_tasks" }
+  let(:db_tasks) { ActiveRecord::Tasks::DatabaseTasks }
+  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) }
+  let(:configuration) { default_configuration.merge("database" => new_database) }
+  let(:db_config) { ActiveRecord::Base.configurations.resolve(configuration) }
 
   before { skip "on azure" if azure_skip }
   before { disconnect! unless azure_skip }
-  after  { reconnect unless azure_skip }
+  after { reconnect unless azure_skip }
 
   private
 
@@ -28,12 +28,20 @@ class SQLServerRakeTest < ActiveRecord::TestCase
     config = default_configuration
     if connection_sqlserver_azure?
       ActiveRecord::Base.establish_connection(config.merge("database" => "master"))
-      connection.drop_database(new_database) rescue nil
+      begin
+        connection.drop_database(new_database)
+      rescue
+        nil
+      end
       disconnect!
       ActiveRecord::Base.establish_connection(config)
     else
       ActiveRecord::Base.establish_connection(config)
-      connection.drop_database(new_database) rescue nil
+      begin
+        connection.drop_database(new_database)
+      rescue
+        nil
+      end
     end
   end
 end