activerecord-sqlserver-adapter 6.0.0.rc1 → 6.0.0.rc2

data/test/cases/connection_test_sqlserver.rb

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
-require 'cases/helper_sqlserver'
-require 'models/reply'
-require 'models/topic'
+require "cases/helper_sqlserver"
+require "models/reply"
+require "models/topic"
 
 class ConnectionTestSQLServer < ActiveRecord::TestCase
-
   self.use_transactional_tests = false
 
   fixtures :topics, :accounts
@@ -15,7 +14,7 @@ class ConnectionTestSQLServer < ActiveRecord::TestCase
     assert connection.active?
   end
 
-  it 'affect rows' do
+  it "affect rows" do
     topic_data = { 1 => { "content" => "1 updated" }, 2 => { "content" => "2 updated" } }
     updated = Topic.update(topic_data.keys, topic_data.values)
     assert_equal 2, updated.size
@@ -24,43 +23,40 @@ 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
+  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
+      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'
+      assert_equal "activerecord_unittest", connection.current_database, "Would default back to connection options"
     end
   end unless connection_sqlserver_azure?
 
-  describe 'Connection management' do
-
-    it 'set spid on connect' do
-      _(['Fixnum', 'Integer']).must_include connection.spid.class.name
+  describe "Connection management" do
+    it "set spid on connect" do
+      _(["Fixnum", "Integer"]).must_include connection.spid.class.name
     end
 
-    it 'reset spid on disconnect!' do
+    it "reset spid on disconnect!" do
       connection.disconnect!
       assert connection.spid.nil?
     end
 
-    it 'reset the connection' do
+    it "reset the connection" do
       connection.disconnect!
       _(connection.raw_connection).must_be_nil
     end
 
-    it 'be able to disconnect and reconnect at will' do
+    it "be able to disconnect and reconnect at will" do
       disconnect_raw_connection!
       assert !connection.active?
       connection.reconnect!
       assert connection.active?
     end
-
   end
 
-
   private
 
   def disconnect_raw_connection!
@@ -69,5 +65,4 @@ class ConnectionTestSQLServer < ActiveRecord::TestCase
       connection.raw_connection.close rescue nil
     end
   end
-
 end

data/test/cases/execute_procedure_test_sqlserver.rb

@@ -1,46 +1,44 @@
 # frozen_string_literal: true
 
-require 'cases/helper_sqlserver'
+require "cases/helper_sqlserver"
 
 class ExecuteProcedureTestSQLServer < ActiveRecord::TestCase
-
-  it 'execute a simple procedure' do
+  it "execute a simple procedure" do
     tables = ActiveRecord::Base.execute_procedure :sp_tables
     assert_instance_of Array, tables
     assert tables.first.respond_to?(:keys)
   end
 
-  it 'take parameter arguments' do
-    tables = ActiveRecord::Base.execute_procedure :sp_tables, 'sst_datatypes'
+  it "take parameter arguments" do
+    tables = ActiveRecord::Base.execute_procedure :sp_tables, "sst_datatypes"
     table_info = tables.first
     assert_equal 1, tables.size
-    assert_equal (ENV['ARUNIT_DB_NAME'] || 'activerecord_unittest'), table_info['TABLE_QUALIFIER'], "Table Info: #{table_info.inspect}"
-    assert_equal 'TABLE', table_info['TABLE_TYPE'], "Table Info: #{table_info.inspect}"
+    assert_equal (ENV["ARUNIT_DB_NAME"] || "activerecord_unittest"), table_info["TABLE_QUALIFIER"], "Table Info: #{table_info.inspect}"
+    assert_equal "TABLE", table_info["TABLE_TYPE"], "Table Info: #{table_info.inspect}"
   end
 
-  it 'allow multiple result sets to be returned' do
-    results1, results2 = ActiveRecord::Base.execute_procedure('sp_helpconstraint','accounts')
+  it "allow multiple result sets to be returned" do
+    results1, results2 = ActiveRecord::Base.execute_procedure("sp_helpconstraint", "accounts")
     assert_instance_of Array, results1
     assert results1.first.respond_to?(:keys)
-    assert results1.first['Object Name']
+    assert results1.first["Object Name"]
     assert_instance_of Array, results2
     assert results2.first.respond_to?(:keys)
-    assert results2.first['constraint_name']
-    assert results2.first['constraint_type']
+    assert results2.first["constraint_name"]
+    assert results2.first["constraint_type"]
   end
 
-  it 'take named parameter arguments' do
-    tables = ActiveRecord::Base.execute_procedure :sp_tables, table_name: 'tables', table_owner: 'sys'
+  it "take named parameter arguments" do
+    tables = ActiveRecord::Base.execute_procedure :sp_tables, table_name: "tables", table_owner: "sys"
     table_info = tables.first
     assert_equal 1, tables.size
-    assert_equal (ENV['ARUNIT_DB_NAME'] || 'activerecord_unittest'), table_info['TABLE_QUALIFIER'], "Table Info: #{table_info.inspect}"
-    assert_equal 'VIEW', table_info['TABLE_TYPE'], "Table Info: #{table_info.inspect}"
+    assert_equal (ENV["ARUNIT_DB_NAME"] || "activerecord_unittest"), table_info["TABLE_QUALIFIER"], "Table Info: #{table_info.inspect}"
+    assert_equal "VIEW", table_info["TABLE_TYPE"], "Table Info: #{table_info.inspect}"
   end
 
-  it 'uses the proper timezone' do
-    date_proc = connection.execute_procedure('my_getutcdate').first['utcdate']
-    date_base = connection.select_value('select GETUTCDATE()')
+  it "uses the proper timezone" do
+    date_proc = connection.execute_procedure("my_getutcdate").first["utcdate"]
+    date_base = connection.select_value("select GETUTCDATE()")
     assert_equal date_base.change(usec: 0), date_proc.change(usec: 0)
   end
-
 end

data/test/cases/fetch_test_sqlserver.rb

@@ -1,22 +1,20 @@
 # frozen_string_literal: true
 
-require 'cases/helper_sqlserver'
-require 'models/book'
+require "cases/helper_sqlserver"
+require "models/book"
 
 class FetchTestSqlserver < ActiveRecord::TestCase
-
   let(:books) { @books }
 
   before { create_10_books }
 
-  it 'work with fully qualified table and columns in select' do
-    books = Book.select('books.id, books.name').limit(3).offset(5)
-    assert_equal Book.all[5,3].map(&:id), books.map(&:id)
+  it "work with fully qualified table and columns in select" do
+    books = Book.select("books.id, books.name").limit(3).offset(5)
+    assert_equal Book.all[5, 3].map(&:id), books.map(&:id)
   end
 
-  describe 'count' do
-
-    it 'gauntlet' do
+  describe "count" do
+    it "gauntlet" do
       books[0].destroy
       books[1].destroy
       books[2].destroy
@@ -31,29 +29,23 @@ class FetchTestSqlserver < ActiveRecord::TestCase
       assert_equal 0, Book.limit(3).offset(7).count
       assert_equal 0, Book.limit(3).offset(8).count
     end
-
   end
 
-  describe 'order' do
-
-    it 'gauntlet' do
-      Book.where(name:'Name-10').delete_all
-      _(Book.order(:name).limit(1).offset(1).map(&:name)).must_equal ['Name-2']
-      _(Book.order(:name).limit(2).offset(2).map(&:name)).must_equal ['Name-3', 'Name-4']
-      _(Book.order(:name).limit(2).offset(7).map(&:name)).must_equal ['Name-8', 'Name-9']
-      _(Book.order(:name).limit(3).offset(7).map(&:name)).must_equal ['Name-8', 'Name-9']
+  describe "order" do
+    it "gauntlet" do
+      Book.where(name: "Name-10").delete_all
+      _(Book.order(:name).limit(1).offset(1).map(&:name)).must_equal ["Name-2"]
+      _(Book.order(:name).limit(2).offset(2).map(&:name)).must_equal ["Name-3", "Name-4"]
+      _(Book.order(:name).limit(2).offset(7).map(&:name)).must_equal ["Name-8", "Name-9"]
+      _(Book.order(:name).limit(3).offset(7).map(&:name)).must_equal ["Name-8", "Name-9"]
       _(Book.order(:name).limit(3).offset(9).map(&:name)).must_equal []
     end
-
   end
 
-
   protected
 
   def create_10_books
     Book.delete_all
     @books = (1..10).map { |i| Book.create! name: "Name-#{i}" }
   end
-
 end
-

data/test/cases/fully_qualified_identifier_test_sqlserver.rb

@@ -1,21 +1,17 @@
 # frozen_string_literal: true
 
-require 'cases/helper_sqlserver'
+require "cases/helper_sqlserver"
 
 class FullyQualifiedIdentifierTestSQLServer < ActiveRecord::TestCase
-
-  describe 'local server' do
-
-    it 'should use table name in select projections' do
+  describe "local server" do
+    it "should use table name in select projections" do
       table = Arel::Table.new(:table)
       expected_sql = "SELECT [table].[name] FROM [table]"
       assert_equal expected_sql, table.project(table[:name]).to_sql
     end
-
   end
 
-  describe 'remote server' do
-
+  describe "remote server" do
     before do
       connection_options[:database_prefix] = "[my.server].db.schema."
     end
@@ -24,39 +20,39 @@ class FullyQualifiedIdentifierTestSQLServer < ActiveRecord::TestCase
       connection_options.delete :database_prefix
     end
 
-    it 'should use fully qualified table name in select from clause' do
+    it "should use fully qualified table name in select from clause" do
       table = Arel::Table.new(:table)
       expected_sql = "SELECT * FROM [my.server].[db].[schema].[table]"
       assert_equal expected_sql, table.project(Arel.star).to_sql
     end
 
-    it 'should not use fully qualified table name in select projections' do
+    it "should not use fully qualified table name in select projections" do
       table = Arel::Table.new(:table)
       expected_sql = "SELECT [table].[name] FROM [my.server].[db].[schema].[table]"
       assert_equal expected_sql, table.project(table[:name]).to_sql
     end
 
-    it 'should not use fully qualified table name in where clause' do
+    it "should not use fully qualified table name in where clause" do
       table = Arel::Table.new(:table)
       expected_sql = "SELECT * FROM [my.server].[db].[schema].[table] WHERE [table].[id] = 42"
       quietly { assert_equal expected_sql, table.project(Arel.star).where(table[:id].eq(42)).to_sql }
     end
 
-    it 'should not use fully qualified table name in order clause' do
+    it "should not use fully qualified table name in order clause" do
       table = Arel::Table.new(:table)
       expected_sql = "SELECT * FROM [my.server].[db].[schema].[table] ORDER BY [table].[name]"
       assert_equal expected_sql, table.project(Arel.star).order(table[:name]).to_sql
     end
 
-    it 'should use fully qualified table name in insert statement' do
+    it "should use fully qualified table name in insert statement" do
       manager = Arel::InsertManager.new
       manager.into Arel::Table.new(:table)
-      manager.values = manager.create_values [Arel.sql('*')]
+      manager.values = manager.create_values [Arel.sql("*")]
       expected_sql = "INSERT INTO [my.server].[db].[schema].[table] VALUES (*)"
       quietly { assert_equal expected_sql, manager.to_sql }
     end
 
-    it 'should use fully qualified table name in update statement' do
+    it "should use fully qualified table name in update statement" do
       table = Arel::Table.new(:table)
       manager = Arel::UpdateManager.new
       manager.table(table).where(table[:id].eq(42))
@@ -65,14 +61,12 @@ class FullyQualifiedIdentifierTestSQLServer < ActiveRecord::TestCase
       quietly { assert_equal expected_sql, manager.to_sql }
     end
 
-    it 'should use fully qualified table name in delete statement' do
+    it "should use fully qualified table name in delete statement" do
       table = Arel::Table.new(:table)
       manager = Arel::DeleteManager.new
       manager.from(table).where(table[:id].eq(42))
       expected_sql = "DELETE FROM [my.server].[db].[schema].[table] WHERE [table].[id] = 42"
       quietly { assert_equal expected_sql, manager.to_sql }
     end
-
   end
-
 end

data/test/cases/helper_sqlserver.rb

@@ -1,22 +1,21 @@
 # frozen_string_literal: true
 
-require 'support/paths_sqlserver'
-require 'bundler/setup'
+require "support/paths_sqlserver"
+require "bundler/setup"
 Bundler.require :default, :development
-require 'pry'
-require 'support/core_ext/query_cache'
-require 'support/minitest_sqlserver'
-require 'support/test_in_memory_oltp'
-require 'cases/helper'
-require 'support/load_schema_sqlserver'
-require 'support/coerceable_test_sqlserver'
-require 'support/sql_counter_sqlserver'
-require 'support/connection_reflection'
-require 'mocha/minitest'
+require "pry"
+require "support/core_ext/query_cache"
+require "support/minitest_sqlserver"
+require "support/test_in_memory_oltp"
+require "cases/helper"
+require "support/load_schema_sqlserver"
+require "support/coerceable_test_sqlserver"
+require "support/sql_counter_sqlserver"
+require "support/connection_reflection"
+require "mocha/minitest"
 
 module ActiveRecord
   class TestCase < ActiveSupport::TestCase
-
     SQLServer = ActiveRecord::ConnectionAdapters::SQLServer
 
     include ARTest::SQLServer::CoerceableTest,
@@ -40,7 +39,7 @@ module ActiveRecord
     end
 
     def host_windows?
-      RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+      RbConfig::CONFIG["host_os"] =~ /mswin|mingw/
     end
 
     def with_use_output_inserted_disabled
@@ -50,7 +49,6 @@ module ActiveRecord
     ensure
       klass.use_output_inserted = true
     end
-
   end
 end
 

data/test/cases/in_clause_test_sqlserver.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require 'cases/helper_sqlserver'
-require 'models/post'
-require 'models/author'
+require "cases/helper_sqlserver"
+require "models/post"
+require "models/author"
 
 class InClauseTestSQLServer < ActiveRecord::TestCase
   fixtures :posts, :authors
 
-  it 'removes ordering from subqueries' do
-    authors_subquery = Author.where(name: ['David', 'Mary', 'Bob']).order(:name)
+  it "removes ordering from subqueries" do
+    authors_subquery = Author.where(name: ["David", "Mary", "Bob"]).order(:name)
     posts = Post.where(author: authors_subquery)
 
     assert_includes authors_subquery.to_sql, "ORDER BY [authors].[name]"
@@ -16,8 +16,8 @@ class InClauseTestSQLServer < ActiveRecord::TestCase
     assert_equal 10, posts.length
   end
 
-  it 'does not remove ordering from subquery that includes a limit' do
-    authors_subquery = Author.where(name: ['David', 'Mary', 'Bob']).order(:name).limit(2)
+  it "does not remove ordering from subquery that includes a limit" do
+    authors_subquery = Author.where(name: ["David", "Mary", "Bob"]).order(:name).limit(2)
     posts = Post.where(author: authors_subquery)
 
     assert_includes authors_subquery.to_sql, "ORDER BY [authors].[name]"
@@ -25,8 +25,8 @@ class InClauseTestSQLServer < ActiveRecord::TestCase
     assert_equal 7, posts.length
   end
 
-  it 'does not remove ordering from subquery that includes an offset' do
-    authors_subquery = Author.where(name: ['David', 'Mary', 'Bob']).order(:name).offset(1)
+  it "does not remove ordering from subquery that includes an offset" do
+    authors_subquery = Author.where(name: ["David", "Mary", "Bob"]).order(:name).offset(1)
     posts = Post.where(author: authors_subquery)
 
     assert_includes authors_subquery.to_sql, "ORDER BY [authors].[name]"

data/test/cases/index_test_sqlserver.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
-require 'cases/helper_sqlserver'
+require "cases/helper_sqlserver"
 
 class IndexTestSQLServer < ActiveRecord::TestCase
-
   before do
     connection.create_table(:testings) do |t|
       t.column :foo, :string, limit: 100
@@ -19,31 +18,30 @@ class IndexTestSQLServer < ActiveRecord::TestCase
     connection.drop_table :testings rescue nil
   end
 
-  it 'add index with order' do
+  it "add index with order" do
     assert_sql(/CREATE.*INDEX.*\(\[last_name\] DESC\)/i) do
-      connection.add_index 'testings', ['last_name'], order: { last_name: :desc }
-      connection.remove_index 'testings', ['last_name']
+      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
-      connection.add_index 'testings', ['last_name', 'first_name'], order: { last_name: :desc }
-      connection.remove_index 'testings', ['last_name', 'first_name']
+      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
-      connection.add_index 'testings', ['last_name', 'first_name'], order: { last_name: :desc, first_name: :asc }
-      connection.remove_index 'testings', ['last_name', 'first_name']
+      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
+  it "add index with where" do
     assert_sql(/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'
+      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
+  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'
+    connection.add_index "testings", "first_name_upper"
   end
-
 end