activerecord-sqlserver-adapter 5.2.1 → 6.0.0

data/test/cases/order_test_sqlserver.rb

@@ -1,147 +1,146 @@
-require 'cases/helper_sqlserver'
-require 'models/post'
+# frozen_string_literal: true
 
-class OrderTestSQLServer < ActiveRecord::TestCase
+require "cases/helper_sqlserver"
+require "models/post"
 
+class OrderTestSQLServer < ActiveRecord::TestCase
   fixtures :posts
 
-  it 'not mangel complex order clauses' do
+  it "not mangel complex order clauses" do
     xyz_order = "CASE WHEN [title] LIKE N'XYZ%' THEN 0 ELSE 1 END"
-    xyz_post = Post.create title: 'XYZ Post', body: 'Test cased orders.'
+    xyz_post = Post.create title: "XYZ Post", body: "Test cased orders."
     assert_equal xyz_post, Post.order(Arel.sql(xyz_order)).first
   end
 
-  it 'support column' do
+  it "support column" do
     order = "title"
-    post1 = Post.create title: 'AAA Post', body: 'Test cased orders.'
+    post1 = Post.create title: "AAA Post", body: "Test cased orders."
     assert_equal post1, Post.order(order).first
   end
 
-  it 'support column ASC' do
+  it "support column ASC" do
     order = "title ASC"
-    post1 = Post.create title: 'AAA Post', body: 'Test cased orders.'
+    post1 = Post.create title: "AAA Post", body: "Test cased orders."
     assert_equal post1, Post.order(order).first
   end
 
-  it 'support column DESC' do
+  it "support column DESC" do
     order = "title DESC"
-    post1 = Post.create title: 'ZZZ Post', body: 'Test cased orders.'
+    post1 = Post.create title: "ZZZ Post", body: "Test cased orders."
     assert_equal post1, Post.order(order).first
   end
 
-  it 'support column as symbol' do
+  it "support column as symbol" do
     order = :title
-    post1 = Post.create title: 'AAA Post', body: 'Test cased orders.'
+    post1 = Post.create title: "AAA Post", body: "Test cased orders."
     assert_equal post1, Post.order(order).first
   end
 
-  it 'support table and column' do
+  it "support table and column" do
     order = "posts.title"
-    post1 = Post.create title: 'AAA Post', body: 'Test cased orders.'
+    post1 = Post.create title: "AAA Post", body: "Test cased orders."
     assert_equal post1, Post.order(order).first
   end
 
-  it 'support quoted column' do
+  it "support quoted column" do
     order = "[title]"
-    post1 = Post.create title: 'AAA Post', body: 'Test cased orders.'
+    post1 = Post.create title: "AAA Post", body: "Test cased orders."
     assert_equal post1, Post.order(Arel.sql(order)).first
   end
 
-  it 'support quoted table and column' do
+  it "support quoted table and column" do
     order = "[posts].[title]"
-    post1 = Post.create title: 'AAA Post', body: 'Test cased orders.'
+    post1 = Post.create title: "AAA Post", body: "Test cased orders."
     assert_equal post1, Post.order(Arel.sql(order)).first
   end
 
-  it 'support primary: column, secondary: column' do
+  it "support primary: column, secondary: column" do
     order = "title DESC, body"
-    post1 = Post.create title: 'ZZZ Post', body: 'Test cased orders.'
-    post2 = Post.create title: 'ZZZ Post', body: 'ZZZ Test cased orders.'
+    post1 = Post.create title: "ZZZ Post", body: "Test cased orders."
+    post2 = Post.create title: "ZZZ Post", body: "ZZZ Test cased orders."
     assert_equal post1, Post.order(order).first
     assert_equal post2, Post.order(order).second
   end
 
-  it 'support primary: table and column, secondary: column' do
+  it "support primary: table and column, secondary: column" do
     order = "posts.title DESC, body"
-    post1 = Post.create title: 'ZZZ Post', body: 'Test cased orders.'
-    post2 = Post.create title: 'ZZZ Post', body: 'ZZZ Test cased orders.'
+    post1 = Post.create title: "ZZZ Post", body: "Test cased orders."
+    post2 = Post.create title: "ZZZ Post", body: "ZZZ Test cased orders."
     assert_equal post1, Post.order(order).first
     assert_equal post2, Post.order(order).second
   end
 
-  it 'support primary: case expression, secondary: column' do
+  it "support primary: case expression, secondary: column" do
     order = "(CASE WHEN [title] LIKE N'ZZZ%' THEN title ELSE '' END) DESC, body"
-    post1 = Post.create title: 'ZZZ Post', body: 'Test cased orders.'
-    post2 = Post.create title: 'ZZZ Post', body: 'ZZZ Test cased orders.'
+    post1 = Post.create title: "ZZZ Post", body: "Test cased orders."
+    post2 = Post.create title: "ZZZ Post", body: "ZZZ Test cased orders."
     assert_equal post1, Post.order(Arel.sql(order)).first
     assert_equal post2, Post.order(Arel.sql(order)).second
   end
 
-  it 'support primary: quoted table and column, secondary: case expresion' do
+  it "support primary: quoted table and column, secondary: case expresion" do
     order = "[posts].[body] DESC, (CASE WHEN [title] LIKE N'ZZZ%' THEN title ELSE '' END) DESC"
-    post1 = Post.create title: 'ZZZ Post', body: 'ZZZ Test cased orders.'
-    post2 = Post.create title: 'ZZY Post', body: 'ZZZ Test cased orders.'
+    post1 = Post.create title: "ZZZ Post", body: "ZZZ Test cased orders."
+    post2 = Post.create title: "ZZY Post", body: "ZZZ Test cased orders."
     assert_equal post1, Post.order(Arel.sql(order)).first
     assert_equal post2, Post.order(Arel.sql(order)).second
   end
 
-  it 'support inline function' do
+  it "support inline function" do
     order = "LEN(title)"
-    post1 = Post.create title: 'A', body: 'AAA Test cased orders.'
+    post1 = Post.create title: "A", body: "AAA Test cased orders."
     assert_equal post1, Post.order(Arel.sql(order)).first
   end
 
-  it 'support inline function with parameters' do
+  it "support inline function with parameters" do
     order = "SUBSTRING(title, 1, 3)"
-    post1 = Post.create title: 'AAA Post', body: 'Test cased orders.'
+    post1 = Post.create title: "AAA Post", body: "Test cased orders."
     assert_equal post1, Post.order(Arel.sql(order)).first
   end
 
-  it 'support inline function with parameters DESC' do
+  it "support inline function with parameters DESC" do
     order = "SUBSTRING(title, 1, 3) DESC"
-    post1 = Post.create title: 'ZZZ Post', body: 'Test cased orders.'
+    post1 = Post.create title: "ZZZ Post", body: "Test cased orders."
     assert_equal post1, Post.order(Arel.sql(order)).first
   end
 
-  it 'support primary: inline function, secondary: column' do
+  it "support primary: inline function, secondary: column" do
     order = "LEN(title), body"
-    post1 = Post.create title: 'A', body: 'AAA Test cased orders.'
-    post2 = Post.create title: 'A', body: 'Test cased orders.'
+    post1 = Post.create title: "A", body: "AAA Test cased orders."
+    post2 = Post.create title: "A", body: "Test cased orders."
     assert_equal post1, Post.order(Arel.sql(order)).first
     assert_equal post2, Post.order(Arel.sql(order)).second
   end
 
-  it 'support primary: inline function, secondary: column with direction' do
+  it "support primary: inline function, secondary: column with direction" do
     order = "LEN(title) ASC, body DESC"
-    post1 = Post.create title: 'A', body: 'ZZZ Test cased orders.'
-    post2 = Post.create title: 'A', body: 'Test cased orders.'
+    post1 = Post.create title: "A", body: "ZZZ Test cased orders."
+    post2 = Post.create title: "A", body: "Test cased orders."
     assert_equal post1, Post.order(Arel.sql(order)).first
     assert_equal post2, Post.order(Arel.sql(order)).second
   end
 
-  it 'support primary: column, secondary: inline function' do
+  it "support primary: column, secondary: inline function" do
     order = "body DESC, LEN(title)"
-    post1 = Post.create title: 'Post', body: 'ZZZ Test cased orders.'
-    post2 = Post.create title: 'Longer Post', body: 'ZZZ Test cased orders.'
+    post1 = Post.create title: "Post", body: "ZZZ Test cased orders."
+    post2 = Post.create title: "Longer Post", body: "ZZZ Test cased orders."
     assert_equal post1, Post.order(Arel.sql(order)).first
     assert_equal post2, Post.order(Arel.sql(order)).second
   end
 
-  it 'support primary: case expression, secondary: inline function' do
+  it "support primary: case expression, secondary: inline function" do
     order = "CASE WHEN [title] LIKE N'ZZZ%' THEN title ELSE '' END DESC, LEN(body) ASC"
-    post1 = Post.create title: 'ZZZ Post', body: 'Z'
-    post2 = Post.create title: 'ZZZ Post', body: 'Test cased orders.'
+    post1 = Post.create title: "ZZZ Post", body: "Z"
+    post2 = Post.create title: "ZZZ Post", body: "Test cased orders."
     assert_equal post1, Post.order(Arel.sql(order)).first
     assert_equal post2, Post.order(Arel.sql(order)).second
   end
 
-  it 'support primary: inline function, secondary: case expression' do
+  it "support primary: inline function, secondary: case expression" do
     order = "LEN(body), CASE WHEN [title] LIKE N'ZZZ%' THEN title ELSE '' END DESC"
-    post1 = Post.create title: 'ZZZ Post', body: 'Z'
-    post2 = Post.create title: 'Post', body: 'Z'
+    post1 = Post.create title: "ZZZ Post", body: "Z"
+    post2 = Post.create title: "Post", body: "Z"
     assert_equal post1, Post.order(Arel.sql(order)).first
     assert_equal post2, Post.order(Arel.sql(order)).second
   end
-
-
 end

data/test/cases/pessimistic_locking_test_sqlserver.rb

@@ -1,9 +1,10 @@
-require 'cases/helper_sqlserver'
-require 'models/person'
-require 'models/reader'
+# frozen_string_literal: true
 
-class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
+require "cases/helper_sqlserver"
+require "models/person"
+require "models/reader"
 
+class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
   fixtures :people, :readers
 
   before do
@@ -11,15 +12,14 @@ class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
     Reader.columns
   end
 
-  it 'uses with updlock by default' do
+  it "uses with updlock by default" do
     assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(UPDLOCK\)| do
       _(Person.lock(true).to_a).must_equal Person.all.to_a
     end
   end
 
-  describe 'For simple finds with default lock option' do
-
-    it 'lock with simple find' do
+  describe "For simple finds with default lock option" do
+    it "lock with simple find" do
       assert_nothing_raised do
         Person.transaction do
           _(Person.lock(true).find(1)).must_equal Person.find(1)
@@ -27,7 +27,7 @@ class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
       end
     end
 
-    it 'lock with scoped find' do
+    it "lock with scoped find" do
       assert_nothing_raised do
         Person.transaction do
           Person.lock(true).scoping do
@@ -37,8 +37,8 @@ class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
       end
     end
 
-    it 'lock with eager find' do
-       assert_nothing_raised do
+    it "lock with eager find" do
+      assert_nothing_raised do
         Person.transaction do
           person = Person.lock(true).includes(:readers).find(1)
           _(person).must_equal Person.find(1)
@@ -46,62 +46,56 @@ class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
       end
     end
 
-    it 'can add a custom lock directive' do
+    it "can add a custom lock directive" do
       assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(HOLDLOCK, ROWLOCK\)| do
-        Person.lock('WITH(HOLDLOCK, ROWLOCK)').load
+        Person.lock("WITH(HOLDLOCK, ROWLOCK)").load
       end
     end
 
-    describe 'joining tables' do
-
-      it 'joined tables use updlock by default' do
+    describe "joining tables" do
+      it "joined tables use updlock by default" do
         assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(UPDLOCK\) INNER JOIN \[readers\] WITH\(UPDLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
           Person.lock(true).joins(:readers).load
         end
       end
 
-      it 'joined tables can use custom lock directive' do
+      it "joined tables can use custom lock directive" do
         assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(NOLOCK\) INNER JOIN \[readers\] WITH\(NOLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
-          Person.lock('WITH(NOLOCK)').joins(:readers).load
+          Person.lock("WITH(NOLOCK)").joins(:readers).load
         end
       end
 
-      it 'left joined tables use updlock by default' do
+      it "left joined tables use updlock by default" do
         assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(UPDLOCK\) LEFT OUTER JOIN \[readers\] WITH\(UPDLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
           Person.lock(true).left_joins(:readers).load
         end
       end
 
-      it 'left joined tables can use custom lock directive' do
+      it "left joined tables can use custom lock directive" do
         assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(NOLOCK\) LEFT OUTER JOIN \[readers\] WITH\(NOLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
-          Person.lock('WITH(NOLOCK)').left_joins(:readers).load
+          Person.lock("WITH(NOLOCK)").left_joins(:readers).load
         end
       end
-
     end
-
   end
 
-  describe 'For paginated finds' do
-
+  describe "For paginated finds" do
     before do
       Person.delete_all
       20.times { |n| Person.create!(first_name: "Thing_#{n}") }
     end
 
-    it 'copes with eager loading un-locked paginated' do
+    it "copes with eager loading un-locked paginated" do
       eager_ids_sql = /SELECT\s+DISTINCT \[people\].\[id\] FROM \[people\] WITH\(UPDLOCK\) LEFT OUTER JOIN \[readers\] WITH\(UPDLOCK\)\s+ON \[readers\].\[person_id\] = \[people\].\[id\]\s+ORDER BY \[people\].\[id\] ASC OFFSET @0 ROWS FETCH NEXT @1 ROWS ONLY/
       loader_sql = /SELECT.*FROM \[people\] WITH\(UPDLOCK\).*WHERE \[people\]\.\[id\] IN/
       assert_sql(eager_ids_sql, loader_sql) do
         people = Person.lock(true).limit(5).offset(10).includes(:readers).references(:readers).to_a
-        _(people[0].first_name).must_equal 'Thing_10'
-        _(people[1].first_name).must_equal 'Thing_11'
-        _(people[2].first_name).must_equal 'Thing_12'
-        _(people[3].first_name).must_equal 'Thing_13'
-        _(people[4].first_name).must_equal 'Thing_14'
+        _(people[0].first_name).must_equal "Thing_10"
+        _(people[1].first_name).must_equal "Thing_11"
+        _(people[2].first_name).must_equal "Thing_12"
+        _(people[3].first_name).must_equal "Thing_13"
+        _(people[4].first_name).must_equal "Thing_14"
       end
     end
-
   end
-
 end

data/test/cases/rake_test_sqlserver.rb

@@ -1,18 +1,19 @@
-require 'cases/helper_sqlserver'
+# frozen_string_literal: true
 
-class SQLServerRakeTest < ActiveRecord::TestCase
+require "cases/helper_sqlserver"
 
+class SQLServerRakeTest < ActiveRecord::TestCase
   self.use_transactional_tests = false
 
   cattr_accessor :azure_skip
   self.azure_skip = connection_sqlserver_azure?
 
   let(:db_tasks)              { ActiveRecord::Tasks::DatabaseTasks }
-  let(:new_database)          { 'activerecord_unittest_tasks' }
-  let(:default_configuration) { ARTest.connection_config['arunit'] }
-  let(:configuration)         { default_configuration.merge('database' => new_database) }
+  let(:new_database)          { "activerecord_unittest_tasks" }
+  let(:default_configuration) { ARTest.connection_config["arunit"] }
+  let(:configuration)         { default_configuration.merge("database" => new_database) }
 
-  before { skip 'on azure' if azure_skip }
+  before { skip "on azure" if azure_skip }
   before { disconnect! unless azure_skip }
   after  { reconnect unless azure_skip }
 
@@ -25,7 +26,7 @@ class SQLServerRakeTest < ActiveRecord::TestCase
   def reconnect
     config = default_configuration
     if connection_sqlserver_azure?
-      ActiveRecord::Base.establish_connection(config.merge('database' => 'master'))
+      ActiveRecord::Base.establish_connection(config.merge("database" => "master"))
       connection.drop_database(new_database) rescue nil
       disconnect!
       ActiveRecord::Base.establish_connection(config)
@@ -34,57 +35,51 @@ class SQLServerRakeTest < ActiveRecord::TestCase
       connection.drop_database(new_database) rescue nil
     end
   end
-
 end
 
 class SQLServerRakeCreateTest < SQLServerRakeTest
-
   self.azure_skip = false
 
-  it 'establishes connection to database after create ' do
+  it "establishes connection to database after create " do
     quietly { db_tasks.create configuration }
     _(connection.current_database).must_equal(new_database)
   end
 
-  it 'creates database with default collation' do
+  it "creates database with default collation" do
     quietly { db_tasks.create configuration }
-    _(connection.collation).must_equal 'SQL_Latin1_General_CP1_CI_AS'
+    _(connection.collation).must_equal "SQL_Latin1_General_CP1_CI_AS"
   end
 
-  it 'creates database with given collation' do
-    quietly { db_tasks.create configuration.merge('collation' => 'Latin1_General_CI_AS') }
-    _(connection.collation).must_equal 'Latin1_General_CI_AS'
+  it "creates database with given collation" do
+    quietly { db_tasks.create configuration.merge("collation" => "Latin1_General_CI_AS") }
+    _(connection.collation).must_equal "Latin1_General_CI_AS"
   end
 
-  it 'prints error message when database exists' do
+  it "prints error message when database exists" do
     quietly { db_tasks.create configuration }
     message = capture(:stderr) { db_tasks.create configuration }
     _(message).must_match %r{activerecord_unittest_tasks.*already exists}
   end
-
 end
 
 class SQLServerRakeDropTest < SQLServerRakeTest
-
   self.azure_skip = false
 
-  it 'drops database and uses master' do
+  it "drops database and uses master" do
     quietly do
       db_tasks.create configuration
       db_tasks.drop configuration
     end
-    _(connection.current_database).must_equal 'master'
+    _(connection.current_database).must_equal "master"
   end
 
-  it 'prints error message when database does not exist' do
-    message = capture(:stderr) { db_tasks.drop configuration.merge('database' => 'doesnotexist') }
+  it "prints error message when database does not exist" do
+    message = capture(:stderr) { db_tasks.drop configuration.merge("database" => "doesnotexist") }
     _(message).must_match %r{'doesnotexist' does not exist}
   end
-
 end
 
 class SQLServerRakePurgeTest < SQLServerRakeTest
-
   before do
     quietly { db_tasks.create(configuration) }
     connection.create_table :users, force: true do |t|
@@ -93,43 +88,37 @@ class SQLServerRakePurgeTest < SQLServerRakeTest
     end
   end
 
-  it 'clears active connections, drops database, and recreates with established connection' do
+  it "clears active connections, drops database, and recreates with established connection" do
     _(connection.current_database).must_equal(new_database)
-    _(connection.tables).must_include 'users'
+    _(connection.tables).must_include "users"
     quietly { db_tasks.purge(configuration) }
     _(connection.current_database).must_equal(new_database)
-    _(connection.tables).wont_include 'users'
+    _(connection.tables).wont_include "users"
   end
-
 end
 
 class SQLServerRakeCharsetTest < SQLServerRakeTest
-
   before do
     quietly { db_tasks.create(configuration) }
   end
 
-  it 'retrieves charset' do
-    _(db_tasks.charset(configuration)).must_equal 'iso_1'
+  it "retrieves charset" do
+    _(db_tasks.charset(configuration)).must_equal "iso_1"
   end
-
 end
 
 class SQLServerRakeCollationTest < SQLServerRakeTest
-
   before do
     quietly { db_tasks.create(configuration) }
   end
 
-  it 'retrieves collation' do
-    _(db_tasks.collation(configuration)).must_equal 'SQL_Latin1_General_CP1_CI_AS'
+  it "retrieves collation" do
+    _(db_tasks.collation(configuration)).must_equal "SQL_Latin1_General_CP1_CI_AS"
   end
-
 end
 
 class SQLServerRakeStructureDumpLoadTest < SQLServerRakeTest
-
-  let(:filename) { File.join ARTest::SQLServer.migrations_root, 'structure.sql' }
+  let(:filename) { File.join ARTest::SQLServer.migrations_root, "structure.sql" }
   let(:filedata) { File.read(filename) }
 
   before do
@@ -146,8 +135,8 @@ class SQLServerRakeStructureDumpLoadTest < SQLServerRakeTest
     FileUtils.rm_rf(filename)
   end
 
-  it 'dumps structure and accounts for defncopy oddities' do
-    skip 'debug defncopy on windows later' if host_windows?
+  it "dumps structure and accounts for defncopy oddities" do
+    skip "debug defncopy on windows later" if host_windows?
     quietly { db_tasks.structure_dump configuration, filename }
     _(filedata).wont_match %r{\AUSE.*\z}
     _(filedata).wont_match %r{\AGO.*\z}
@@ -156,14 +145,13 @@ class SQLServerRakeStructureDumpLoadTest < SQLServerRakeTest
     _(filedata).must_match %r{background2\s+text\s+}
   end
 
-  it 'can load dumped structure' do
-    skip 'debug defncopy on windows later' if host_windows?
+  it "can load dumped structure" do
+    skip "debug defncopy on windows later" if host_windows?
     quietly { db_tasks.structure_dump configuration, filename }
     _(filedata).must_match %r{CREATE TABLE dbo\.users}
     db_tasks.purge(configuration)
-    _(connection.tables).wont_include 'users'
+    _(connection.tables).wont_include "users"
     db_tasks.load_schema configuration, :sql, filename
-    _(connection.tables).must_include 'users'
+    _(connection.tables).must_include "users"
   end
-
 end