activerecord-sqlserver-adapter 5.2.1 → 7.0.0.0

data/test/cases/connection_test_sqlserver.rb

@@ -1,9 +1,10 @@
-require 'cases/helper_sqlserver'
-require 'models/reply'
-require 'models/topic'
+# frozen_string_literal: true
 
-class ConnectionTestSQLServer < ActiveRecord::TestCase
+require "cases/helper_sqlserver"
+require "models/reply"
+require "models/topic"
 
+class ConnectionTestSQLServer < ActiveRecord::TestCase
   self.use_transactional_tests = false
 
   fixtures :topics, :accounts
@@ -13,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
@@ -22,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!
@@ -67,5 +65,4 @@ class ConnectionTestSQLServer < ActiveRecord::TestCase
       connection.raw_connection.close rescue nil
     end
   end
-
 end

data/test/cases/disconnected_test_sqlserver.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+
+class TestDisconnectedAdapter < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+  end
+
+  teardown do
+    return if in_memory_db?
+    db_config = ActiveRecord::Base.connection_db_config
+    ActiveRecord::Base.establish_connection(db_config)
+  end
+
+  test "can't execute procedures while disconnected" do
+    @connection.execute_procedure :sp_tables, "sst_datatypes"
+    @connection.disconnect!
+    assert_raises(ActiveRecord::ConnectionNotEstablished, 'SQL Server client is not connected') do
+      @connection.execute_procedure :sp_tables, "sst_datatypes"
+    end
+  end
+
+  test "can't execute query while disconnected" do
+    sql = "SELECT count(*) from products WHERE id IN(@0, @1)"
+    binds = [
+      ActiveRecord::Relation::QueryAttribute.new("id", 2, ActiveRecord::Type::BigInteger.new),
+      ActiveRecord::Relation::QueryAttribute.new("id", 2, ActiveRecord::Type::BigInteger.new)
+    ]
+
+    @connection.exec_query sql, "TEST", binds
+    @connection.disconnect!
+    assert_raises(ActiveRecord::ConnectionNotEstablished, 'SQL Server client is not connected') do
+      @connection.exec_query sql, "TEST", binds
+    end
+  end
+end

data/test/cases/eager_load_too_many_ids_test_sqlserver.rb

@@ -0,0 +1,18 @@
+require "cases/helper_sqlserver"
+require "models/citation"
+require "models/book"
+
+class EagerLoadingTooManyIdsTest < ActiveRecord::TestCase
+  fixtures :citations
+
+  def test_batch_preloading_too_many_ids
+    in_clause_length = 10_000
+
+    # 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
+      Citation.preload(:reference_of).to_a.size
+    end
+  end
+end

data/test/cases/execute_procedure_test_sqlserver.rb

@@ -1,44 +1,53 @@
-require 'cases/helper_sqlserver'
+# frozen_string_literal: true
 
-class ExecuteProcedureTestSQLServer < ActiveRecord::TestCase
+require "cases/helper_sqlserver"
 
-  it 'execute a simple procedure' do
+class ExecuteProcedureTestSQLServer < ActiveRecord::TestCase
+  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
 
+  it 'test deprecation with transaction return when executing procedure' do
+    assert_deprecated do
+      ActiveRecord::Base.transaction do
+        connection.execute_procedure("my_getutcdate")
+        return
+      end
+    end
+  end
 end

data/test/cases/fetch_test_sqlserver.rb

@@ -1,20 +1,20 @@
-require 'cases/helper_sqlserver'
-require 'models/book'
+# frozen_string_literal: true
 
-class FetchTestSqlserver < ActiveRecord::TestCase
+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
@@ -29,29 +29,41 @@ 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
 
+class DeterministicFetchWithCompositePkTestSQLServer < ActiveRecord::TestCase
+  it "orders by the identity column if table has one" do
+    SSCompositePkWithIdentity.delete_all
+    SSCompositePkWithIdentity.create(pk_col_two: 2)
+    SSCompositePkWithIdentity.create(pk_col_two: 1)
+
+    _(SSCompositePkWithIdentity.take(1).map(&:pk_col_two)).must_equal [2]
+  end
+
+  it "orders by the first column if table has no identity column" do
+    SSCompositePkWithoutIdentity.delete_all
+    SSCompositePkWithoutIdentity.create(pk_col_one: 2, pk_col_two: 2)
+    SSCompositePkWithoutIdentity.create(pk_col_one: 1, pk_col_two: 1)
+
+    _(SSCompositePkWithoutIdentity.take(1).map(&:pk_col_two)).must_equal [1]
+  end
+end

data/test/cases/fully_qualified_identifier_test_sqlserver.rb

@@ -1,19 +1,17 @@
-require 'cases/helper_sqlserver'
+# frozen_string_literal: true
 
-class FullyQualifiedIdentifierTestSQLServer < ActiveRecord::TestCase
-
-  describe 'local server' do
+require "cases/helper_sqlserver"
 
-    it 'should use table name in select projections' do
+class FullyQualifiedIdentifierTestSQLServer < ActiveRecord::TestCase
+  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
@@ -22,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]"
+      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('*')], %w{ a }
+      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))
@@ -63,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,20 +1,21 @@
-require 'support/paths_sqlserver'
-require 'bundler/setup'
+# frozen_string_literal: true
+
+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,
@@ -38,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
@@ -48,7 +49,6 @@ module ActiveRecord
     ensure
       klass.use_output_inserted = true
     end
-
   end
 end
 

data/test/cases/in_clause_test_sqlserver.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+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)
+    posts = Post.where(author: authors_subquery)
+
+    assert_includes authors_subquery.to_sql, "ORDER BY [authors].[name]"
+    assert_not_includes posts.to_sql, "ORDER BY [authors].[name]"
+    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)
+    posts = Post.where(author: authors_subquery)
+
+    assert_includes authors_subquery.to_sql, "ORDER BY [authors].[name]"
+    assert_includes posts.to_sql, "ORDER BY [authors].[name]"
+    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)
+    posts = Post.where(author: authors_subquery)
+
+    assert_includes authors_subquery.to_sql, "ORDER BY [authors].[name]"
+    assert_includes posts.to_sql, "ORDER BY [authors].[name]"
+    assert_equal 8, posts.length
+  end
+
+  it "removes ordering from 'not' subqueries" do
+    authors_subquery = Author.where.not(name: ["Mary", "Bob"]).order(:name)
+    posts = Post.where(author: authors_subquery)
+
+    assert_includes authors_subquery.to_sql, "ORDER BY [authors].[name]"
+    assert_not_includes posts.to_sql, "ORDER BY [authors].[name]"
+    assert_equal 5, posts.length
+  end
+
+  it "does not remove ordering from 'not' subquery that includes a limit" do
+    authors_subquery = Author.where.not(name: ["Ronan", "Mary", "Bob"]).order(:name).limit(2)
+    posts = Post.where(author: authors_subquery)
+
+    assert_includes authors_subquery.to_sql, "ORDER BY [authors].[name]"
+    assert_includes posts.to_sql, "ORDER BY [authors].[name]"
+    assert_equal 5, posts.length
+  end
+
+  it "does not remove ordering from 'not' subquery that includes an offset" do
+    authors_subquery = Author.where.not(name: ["David", "Ronan", "Cian"]).order(:name).offset(1)
+    posts = Post.where(author: authors_subquery)
+
+    assert_includes authors_subquery.to_sql, "ORDER BY [authors].[name]"
+    assert_includes posts.to_sql, "ORDER BY [authors].[name]"
+    assert_equal 3, posts.length
+  end
+end

data/test/cases/index_test_sqlserver.rb

@@ -1,7 +1,8 @@
-require 'cases/helper_sqlserver'
+# frozen_string_literal: true
 
-class IndexTestSQLServer < ActiveRecord::TestCase
+require "cases/helper_sqlserver"
 
+class IndexTestSQLServer < ActiveRecord::TestCase
   before do
     connection.create_table(:testings) do |t|
       t.column :foo, :string, limit: 100
@@ -17,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

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