activerecord-sqlserver-adapter 5.2.0 → 6.0.1

data/test/cases/json_test_sqlserver.rb

@@ -1,32 +1,32 @@
-require 'cases/helper_sqlserver'
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
 
 if ActiveRecord::Base.connection.supports_json?
-class JsonTestSQLServer < ActiveRecord::TestCase
+  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] }
+      @o5 = SSTestDatatypeMigrationJson.create! json_col: nil
+    end
 
-  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] }
-    @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" })
+      @o1.save!
+      _(@o1.reload.json_col).must_equal({ "a" => "a" })
+    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' })
-    @o1.save!
-    @o1.reload.json_col.must_equal({ 'a' => 'a' })
-  end
+    it "can use ISJSON function" do
+      _(SSTestDatatypeMigrationJson.where("ISJSON(json_col) > 0").count).must_equal 4
+      _(SSTestDatatypeMigrationJson.where("ISJSON(json_col) IS NULL").count).must_equal 1
+    end
 
-  it 'can use ISJSON function' do
-    SSTestDatatypeMigrationJson.where('ISJSON(json_col) > 0').count.must_equal 4
-    SSTestDatatypeMigrationJson.where('ISJSON(json_col) IS NULL').count.must_equal 1
+    it "can use JSON_VALUE function" do
+      _(SSTestDatatypeMigrationJson.where("JSON_VALUE(json_col, '$.b') = 'b'").count).must_equal 2
+    end
   end
-
-  it 'can use JSON_VALUE function' do
-    SSTestDatatypeMigrationJson.where("JSON_VALUE(json_col, '$.b') = 'b'").count.must_equal 2
-  end
-
-end
 end

data/test/cases/migration_test_sqlserver.rb

@@ -1,14 +1,14 @@
-require 'cases/helper_sqlserver'
-require 'models/person'
+# frozen_string_literal: true
 
-class MigrationTestSQLServer < ActiveRecord::TestCase
-
-  describe 'For transactions' do
+require "cases/helper_sqlserver"
+require "models/person"
 
+class MigrationTestSQLServer < ActiveRecord::TestCase
+  describe "For transactions" do
     before do
-      @trans_test_table1 = 'sqlserver_trans_table1'
-      @trans_test_table2 = 'sqlserver_trans_table2'
-      @trans_tables = [@trans_test_table1,@trans_test_table2]
+      @trans_test_table1 = "sqlserver_trans_table1"
+      @trans_test_table2 = "sqlserver_trans_table2"
+      @trans_tables = [@trans_test_table1, @trans_test_table2]
     end
 
     after do
@@ -17,47 +17,51 @@ class MigrationTestSQLServer < ActiveRecord::TestCase
       end
     end
 
-    it 'not create a tables if error in migrations' do
+    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).up }
+        migrations_dir = File.join ARTest::SQLServer.migrations_root, "transaction_table"
+        quietly { ActiveRecord::MigrationContext.new(migrations_dir, ActiveRecord::SchemaMigration).up }
       rescue Exception => 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
+      _(connection.tables).wont_include @trans_test_table1
+      _(connection.tables).wont_include @trans_test_table2
     end
-
   end
 
-  describe 'For changing column' do
-
-    it 'not raise exception when column contains default constraint' do
-      lock_version_column = Person.columns_hash['lock_version']
+  describe "For changing column" do
+    it "not raise exception when column contains default constraint" do
+      lock_version_column = Person.columns_hash["lock_version"]
       assert_equal :integer, lock_version_column.type
       assert lock_version_column.default.present?
-      assert_nothing_raised { connection.change_column 'people', 'lock_version', :string }
+      assert_nothing_raised { connection.change_column "people", "lock_version", :string }
       Person.reset_column_information
-      lock_version_column = Person.columns_hash['lock_version']
+      lock_version_column = Person.columns_hash["lock_version"]
       assert_equal :string, lock_version_column.type
       assert lock_version_column.default.nil?
-      assert_nothing_raised { connection.change_column 'people', 'lock_version', :integer }
+      assert_nothing_raised { connection.change_column "people", "lock_version", :integer }
       Person.reset_column_information
     end
 
-    it 'not drop the default contraint if just renaming' do
+    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|
-          row['constraint_type'] == "DEFAULT on column string_with_pretend_paren_three"
+        connection.execute_procedure(:sp_helpconstraint, "sst_string_defaults", "nomsg").select do |row|
+          row["constraint_type"] == "DEFAULT on column string_with_pretend_paren_three"
         end.last
       end
       default_before = find_default.call
       connection.change_column :sst_string_defaults, :string_with_pretend_paren_three, :string, limit: 255
       default_after = find_default.call
       assert default_after
-      assert_equal default_before['constraint_keys'], default_after['constraint_keys']
+      assert_equal default_before["constraint_keys"], default_after["constraint_keys"]
     end
 
-  end
+    it "change limit" do
+      assert_nothing_raised { connection.change_column :people, :lock_version, :integer, limit: 8 }
+    end
 
+    it "change null and default" do
+      assert_nothing_raised { connection.change_column :people, :first_name, :text, null: true, default: nil }
+    end
+  end
 end

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,97 +12,90 @@ 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
+      _(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)
+          _(Person.lock(true).find(1)).must_equal Person.find(1)
         end
       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
-            Person.find(1).must_equal Person.find(1)
+            _(Person.find(1)).must_equal Person.find(1)
           end
         end
       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)
+          _(person).must_equal Person.find(1)
         end
       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