Add three new rubocop rules

Style/SpaceBeforeBlockBraces
Style/SpaceInsideBlockBraces
Style/SpaceInsideHashLiteralBraces

Fix all violations in the repository.

13 files changed, 79 insertions, 79 deletions

diff --git a/activerecord/test/cases/adapters/mysql2/active_schema_test.rb b/activerecord/test/cases/adapters/mysql2/active_schema_test.rb
index e7e37cac36..a70eb5a094 100644
--- a/activerecord/test/cases/adapters/mysql2/active_schema_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/active_schema_test.rb
@@ -30,10 +30,10 @@ class Mysql2ActiveSchemaTest < ActiveRecord::Mysql2TestCase
     assert_equal expected, add_index(:people, [:last_name, :first_name], length: 15)
 
     expected = "CREATE  INDEX `index_people_on_last_name_and_first_name`  ON `people` (`last_name`(15), `first_name`) "
-    assert_equal expected, add_index(:people, [:last_name, :first_name], length: {last_name: 15})
+    assert_equal expected, add_index(:people, [:last_name, :first_name], length: { last_name: 15 })
 
     expected = "CREATE  INDEX `index_people_on_last_name_and_first_name`  ON `people` (`last_name`(15), `first_name`(10)) "
-    assert_equal expected, add_index(:people, [:last_name, :first_name], length: {last_name: 15, first_name: 10})
+    assert_equal expected, add_index(:people, [:last_name, :first_name], length: { last_name: 15, first_name: 10 })
 
     %w(SPATIAL FULLTEXT UNIQUE).each do |type|
       expected = "CREATE #{type} INDEX `index_people_on_last_name`  ON `people` (`last_name`) "
diff --git a/activerecord/test/cases/adapters/mysql2/case_sensitivity_test.rb b/activerecord/test/cases/adapters/mysql2/case_sensitivity_test.rb
index 4d81877a9a..50ba9ab831 100644
--- a/activerecord/test/cases/adapters/mysql2/case_sensitivity_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/case_sensitivity_test.rb
@@ -30,7 +30,7 @@ class Mysql2CaseSensitivityTest < ActiveRecord::Mysql2TestCase
     CollationTest.create!(string_cs_column: "A")
     invalid = CollationTest.new(string_cs_column: "a")
     queries = assert_sql { invalid.save }
-    cs_uniqueness_query = queries.detect { |q| q.match(/string_cs_column/)}
+    cs_uniqueness_query = queries.detect { |q| q.match(/string_cs_column/) }
     assert_match(/lower/i, cs_uniqueness_query)
   end
 
diff --git a/activerecord/test/cases/adapters/mysql2/connection_test.rb b/activerecord/test/cases/adapters/mysql2/connection_test.rb
index a3f83e73a6..9ede57d395 100644
--- a/activerecord/test/cases/adapters/mysql2/connection_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/connection_test.rb
@@ -114,7 +114,7 @@ class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
 
   def test_mysql_set_session_variable
     run_without_connection do |orig_connection|
-      ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: {default_week_format: 3}))
+      ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { default_week_format: 3 }))
       session_mode = ActiveRecord::Base.connection.exec_query "SELECT @@SESSION.DEFAULT_WEEK_FORMAT"
       assert_equal 3, session_mode.rows.first.first.to_i
     end
@@ -122,7 +122,7 @@ class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
 
   def test_mysql_set_session_variable_to_default
     run_without_connection do |orig_connection|
-      ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: {default_week_format: :default}))
+      ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { default_week_format: :default }))
       global_mode = ActiveRecord::Base.connection.exec_query "SELECT @@GLOBAL.DEFAULT_WEEK_FORMAT"
       session_mode = ActiveRecord::Base.connection.exec_query "SELECT @@SESSION.DEFAULT_WEEK_FORMAT"
       assert_equal global_mode.rows, session_mode.rows
diff --git a/activerecord/test/cases/adapters/mysql2/json_test.rb b/activerecord/test/cases/adapters/mysql2/json_test.rb
index 2f7dc3f7ef..6b7d259023 100644
--- a/activerecord/test/cases/adapters/mysql2/json_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/json_test.rb
@@ -51,11 +51,11 @@ if ActiveRecord::Base.connection.supports_json?
     end
 
     def test_cast_value_on_write
-      x = JsonDataType.new payload: {"string" => "foo", :symbol => :bar}
-      assert_equal({"string" => "foo", :symbol => :bar}, x.payload_before_type_cast)
-      assert_equal({"string" => "foo", "symbol" => "bar"}, x.payload)
+      x = JsonDataType.new payload: { "string" => "foo", :symbol => :bar }
+      assert_equal({ "string" => "foo", :symbol => :bar }, x.payload_before_type_cast)
+      assert_equal({ "string" => "foo", "symbol" => "bar" }, x.payload)
       x.save
-      assert_equal({"string" => "foo", "symbol" => "bar"}, x.reload.payload)
+      assert_equal({ "string" => "foo", "symbol" => "bar" }, x.reload.payload)
     end
 
     def test_type_cast_json
@@ -63,12 +63,12 @@ if ActiveRecord::Base.connection.supports_json?
 
       data = "{\"a_key\":\"a_value\"}"
       hash = type.deserialize(data)
-      assert_equal({"a_key" => "a_value"}, hash)
-      assert_equal({"a_key" => "a_value"}, type.deserialize(data))
+      assert_equal({ "a_key" => "a_value" }, hash)
+      assert_equal({ "a_key" => "a_value" }, type.deserialize(data))
 
       assert_equal({}, type.deserialize("{}"))
-      assert_equal({"key"=>nil}, type.deserialize('{"key": null}'))
-      assert_equal({"c"=>"}",'"a"'=>'b "a b'}, type.deserialize(%q({"c":"}", "\"a\"":"b \"a b"})))
+      assert_equal({ "key"=>nil }, type.deserialize('{"key": null}'))
+      assert_equal({ "c"=>"}",'"a"'=>'b "a b' }, type.deserialize(%q({"c":"}", "\"a\"":"b \"a b"})))
     end
 
     def test_rewrite
@@ -81,13 +81,13 @@ if ActiveRecord::Base.connection.supports_json?
     def test_select
       @connection.execute "insert into json_data_type (payload) VALUES ('{\"k\":\"v\"}')"
       x = JsonDataType.first
-      assert_equal({"k" => "v"}, x.payload)
+      assert_equal({ "k" => "v" }, x.payload)
     end
 
     def test_select_multikey
       @connection.execute %q|insert into json_data_type (payload) VALUES ('{"k1":"v1", "k2":"v2", "k3":[1,2,3]}')|
       x = JsonDataType.first
-      assert_equal({"k1" => "v1", "k2" => "v2", "k3" => [1,2,3]}, x.payload)
+      assert_equal({ "k1" => "v1", "k2" => "v2", "k3" => [1,2,3] }, x.payload)
     end
 
     def test_null_json
@@ -99,13 +99,13 @@ if ActiveRecord::Base.connection.supports_json?
     def test_select_array_json_value
       @connection.execute %q|insert into json_data_type (payload) VALUES ('["v0",{"k1":"v1"}]')|
       x = JsonDataType.first
-      assert_equal(["v0", {"k1" => "v1"}], x.payload)
+      assert_equal(["v0", { "k1" => "v1" }], x.payload)
     end
 
     def test_rewrite_array_json_value
       @connection.execute %q|insert into json_data_type (payload) VALUES ('["v0",{"k1":"v1"}]')|
       x = JsonDataType.first
-      x.payload = ["v1", {"k2" => "v2"}, "v3"]
+      x.payload = ["v1", { "k2" => "v2" }, "v3"]
       assert x.save!
     end
 
diff --git a/activerecord/test/cases/adapters/mysql2/schema_test.rb b/activerecord/test/cases/adapters/mysql2/schema_test.rb
index 3c08a4ed1f..aea930cfe6 100644
--- a/activerecord/test/cases/adapters/mysql2/schema_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/schema_test.rb
@@ -78,9 +78,9 @@ module ActiveRecord
         indexes = @connection.indexes(table).sort_by(&:name)
         assert_equal 3,indexes.size
 
-        index_a = indexes.select{|i| i.name == index_a_name}[0]
-        index_b = indexes.select{|i| i.name == index_b_name}[0]
-        index_c = indexes.select{|i| i.name == index_c_name}[0]
+        index_a = indexes.select { |i| i.name == index_a_name }[0]
+        index_b = indexes.select { |i| i.name == index_b_name }[0]
+        index_c = indexes.select { |i| i.name == index_c_name }[0]
         assert_equal :btree, index_a.using
         assert_nil index_a.type
         assert_equal :btree, index_b.using
@@ -121,6 +121,6 @@ class Mysql2AnsiQuotesTest < ActiveRecord::Mysql2TestCase
   def test_foreign_keys_method_with_ansi_quotes
     fks = @connection.foreign_keys("lessons_students")
     assert_equal([["lessons_students", "students", :cascade]],
-                 fks.map {|fk| [fk.from_table, fk.to_table, fk.on_delete] })
+                 fks.map { |fk| [fk.from_table, fk.to_table, fk.on_delete] })
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/array_test.rb b/activerecord/test/cases/adapters/postgresql/array_test.rb
index e496960f21..c14745ac1f 100644
--- a/activerecord/test/cases/adapters/postgresql/array_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/array_test.rb
@@ -184,7 +184,7 @@ class PostgresqlArrayTest < ActiveRecord::PostgreSQLTestCase
 
   def test_insert_fixture
     tag_values = ["val1", "val2", "val3_with_'_multiple_quote_'_chars"]
-    @connection.insert_fixture({"tags" => tag_values}, "pg_arrays" )
+    @connection.insert_fixture({ "tags" => tag_values }, "pg_arrays" )
     assert_equal(PgArray.last.tags, tag_values)
   end
 
diff --git a/activerecord/test/cases/adapters/postgresql/connection_test.rb b/activerecord/test/cases/adapters/postgresql/connection_test.rb
index d01f601031..48c82cb7b9 100644
--- a/activerecord/test/cases/adapters/postgresql/connection_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/connection_test.rb
@@ -184,7 +184,7 @@ module ActiveRecord
 
     def test_set_session_variable_true
       run_without_connection do |orig_connection|
-        ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: {debug_print_plan: true}))
+        ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { debug_print_plan: true }))
         set_true = ActiveRecord::Base.connection.exec_query "SHOW DEBUG_PRINT_PLAN"
         assert_equal set_true.rows, [["on"]]
       end
@@ -192,7 +192,7 @@ module ActiveRecord
 
     def test_set_session_variable_false
       run_without_connection do |orig_connection|
-        ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: {debug_print_plan: false}))
+        ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { debug_print_plan: false }))
         set_false = ActiveRecord::Base.connection.exec_query "SHOW DEBUG_PRINT_PLAN"
         assert_equal set_false.rows, [["off"]]
       end
@@ -201,14 +201,14 @@ module ActiveRecord
     def test_set_session_variable_nil
       run_without_connection do |orig_connection|
         # This should be a no-op that does not raise an error
-        ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: {debug_print_plan: nil}))
+        ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { debug_print_plan: nil }))
       end
     end
 
     def test_set_session_variable_default
       run_without_connection do |orig_connection|
         # This should execute a query that does not raise an error
-        ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: {debug_print_plan: :default}))
+        ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { debug_print_plan: :default }))
       end
     end
 
@@ -224,14 +224,14 @@ module ActiveRecord
       got_lock = @connection.get_advisory_lock(lock_id)
       assert got_lock, "get_advisory_lock should have returned true but it didn't"
 
-      advisory_lock = @connection.query(list_advisory_locks).find {|l| l[1] == lock_id}
+      advisory_lock = @connection.query(list_advisory_locks).find { |l| l[1] == lock_id }
       assert advisory_lock,
         "expected to find an advisory lock with lock_id #{lock_id} but there wasn't one"
 
       released_lock = @connection.release_advisory_lock(lock_id)
       assert released_lock, "expected release_advisory_lock to return true but it didn't"
 
-      advisory_locks = @connection.query(list_advisory_locks).select {|l| l[1] == lock_id}
+      advisory_locks = @connection.query(list_advisory_locks).select { |l| l[1] == lock_id }
       assert_empty advisory_locks,
         "expected to have released advisory lock with lock_id #{lock_id} but it was still held"
     end
diff --git a/activerecord/test/cases/adapters/postgresql/hstore_test.rb b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
index 817dfbf705..3a8fcf388a 100644
--- a/activerecord/test/cases/adapters/postgresql/hstore_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
@@ -64,8 +64,8 @@ if ActiveRecord::Base.connection.supports_extensions?
       @connection.add_column "hstores", "permissions", :hstore, default: '"users"=>"read", "articles"=>"write"'
       Hstore.reset_column_information
 
-      assert_equal({"users"=>"read", "articles"=>"write"}, Hstore.column_defaults["permissions"])
-      assert_equal({"users"=>"read", "articles"=>"write"}, Hstore.new.permissions)
+      assert_equal({ "users"=>"read", "articles"=>"write" }, Hstore.column_defaults["permissions"])
+      assert_equal({ "users"=>"read", "articles"=>"write" }, Hstore.new.permissions)
     ensure
       Hstore.reset_column_information
     end
@@ -103,18 +103,18 @@ if ActiveRecord::Base.connection.supports_extensions?
     end
 
     def test_cast_value_on_write
-      x = Hstore.new tags: {"bool" => true, "number" => 5}
-      assert_equal({"bool" => true, "number" => 5}, x.tags_before_type_cast)
-      assert_equal({"bool" => "true", "number" => "5"}, x.tags)
+      x = Hstore.new tags: { "bool" => true, "number" => 5 }
+      assert_equal({ "bool" => true, "number" => 5 }, x.tags_before_type_cast)
+      assert_equal({ "bool" => "true", "number" => "5" }, x.tags)
       x.save
-      assert_equal({"bool" => "true", "number" => "5"}, x.reload.tags)
+      assert_equal({ "bool" => "true", "number" => "5" }, x.reload.tags)
     end
 
     def test_type_cast_hstore
-      assert_equal({"1" => "2"}, @type.deserialize("\"1\"=>\"2\""))
+      assert_equal({ "1" => "2" }, @type.deserialize("\"1\"=>\"2\""))
       assert_equal({}, @type.deserialize(""))
-      assert_equal({"key"=>nil}, @type.deserialize("key => NULL"))
-      assert_equal({"c"=>"}",'"a"'=>'b "a b'}, @type.deserialize(%q(c=>"}", "\"a\""=>"b \"a b")))
+      assert_equal({ "key"=>nil }, @type.deserialize("key => NULL"))
+      assert_equal({ "c"=>"}",'"a"'=>'b "a b' }, @type.deserialize(%q(c=>"}", "\"a\""=>"b \"a b")))
     end
 
     def test_with_store_accessors
@@ -182,31 +182,31 @@ if ActiveRecord::Base.connection.supports_extensions?
     end
 
     def test_parse1
-      assert_equal({"a"=>nil,"b"=>nil,"c"=>"NuLl","null"=>"c"}, @type.deserialize('a=>null,b=>NuLl,c=>"NuLl",null=>c'))
+      assert_equal({ "a"=>nil,"b"=>nil,"c"=>"NuLl","null"=>"c" }, @type.deserialize('a=>null,b=>NuLl,c=>"NuLl",null=>c'))
     end
 
     def test_parse2
-      assert_equal({" " => " "},  @type.deserialize("\\ =>\\ "))
+      assert_equal({ " " => " " },  @type.deserialize("\\ =>\\ "))
     end
 
     def test_parse3
-      assert_equal({"=" => ">"},  @type.deserialize("==>>"))
+      assert_equal({ "=" => ">" },  @type.deserialize("==>>"))
     end
 
     def test_parse4
-      assert_equal({"=a"=>"q=w"},   @type.deserialize('\=a=>q=w'))
+      assert_equal({ "=a"=>"q=w" },   @type.deserialize('\=a=>q=w'))
     end
 
     def test_parse5
-      assert_equal({"=a"=>"q=w"},   @type.deserialize('"=a"=>q\=w'))
+      assert_equal({ "=a"=>"q=w" },   @type.deserialize('"=a"=>q\=w'))
     end
 
     def test_parse6
-      assert_equal({"\"a"=>"q>w"},  @type.deserialize('"\"a"=>q>w'))
+      assert_equal({ "\"a"=>"q>w" },  @type.deserialize('"\"a"=>q>w'))
     end
 
     def test_parse7
-      assert_equal({"\"a"=>"q\"w"}, @type.deserialize('\"a=>q"w'))
+      assert_equal({ "\"a"=>"q\"w" }, @type.deserialize('\"a=>q"w'))
     end
 
     def test_rewrite
@@ -219,19 +219,19 @@ if ActiveRecord::Base.connection.supports_extensions?
     def test_select
       @connection.execute "insert into hstores (tags) VALUES ('1=>2')"
       x = Hstore.first
-      assert_equal({"1" => "2"}, x.tags)
+      assert_equal({ "1" => "2" }, x.tags)
     end
 
     def test_array_cycle
-      assert_array_cycle([{"AA" => "BB", "CC" => "DD"}, {"AA" => nil}])
+      assert_array_cycle([{ "AA" => "BB", "CC" => "DD" }, { "AA" => nil }])
     end
 
     def test_array_strings_with_quotes
-      assert_array_cycle([{"this has" => 'some "s that need to be escaped"'}])
+      assert_array_cycle([{ "this has" => 'some "s that need to be escaped"' }])
     end
 
     def test_array_strings_with_commas
-      assert_array_cycle([{"this,has" => "many,values"}])
+      assert_array_cycle([{ "this,has" => "many,values" }])
     end
 
     def test_array_strings_with_array_delimiters
@@ -239,17 +239,17 @@ if ActiveRecord::Base.connection.supports_extensions?
     end
 
     def test_array_strings_with_null_strings
-      assert_array_cycle([{"NULL" => "NULL"}])
+      assert_array_cycle([{ "NULL" => "NULL" }])
     end
 
     def test_contains_nils
-      assert_array_cycle([{"NULL" => nil}])
+      assert_array_cycle([{ "NULL" => nil }])
     end
 
     def test_select_multikey
       @connection.execute "insert into hstores (tags) VALUES ('1=>2,2=>3')"
       x = Hstore.first
-      assert_equal({"1" => "2", "2" => "3"}, x.tags)
+      assert_equal({ "1" => "2", "2" => "3" }, x.tags)
     end
 
     def test_create
@@ -303,17 +303,17 @@ if ActiveRecord::Base.connection.supports_extensions?
       HstoreWithSerialize.create! tags: TagCollection.new("one" => "two")
       record = HstoreWithSerialize.first
       assert_instance_of TagCollection, record.tags
-      assert_equal({"one" => "two"}, record.tags.to_hash)
+      assert_equal({ "one" => "two" }, record.tags.to_hash)
       record.tags = TagCollection.new("three" => "four")
       record.save!
-      assert_equal({"three" => "four"}, HstoreWithSerialize.first.tags.to_hash)
+      assert_equal({ "three" => "four" }, HstoreWithSerialize.first.tags.to_hash)
     end
 
     def test_clone_hstore_with_serialized_attributes
       HstoreWithSerialize.create! tags: TagCollection.new("one" => "two")
       record = HstoreWithSerialize.first
       dupe = record.dup
-      assert_equal({"one" => "two"}, dupe.tags.to_hash)
+      assert_equal({ "one" => "two" }, dupe.tags.to_hash)
     end
 
     def test_schema_dump_with_shorthand
diff --git a/activerecord/test/cases/adapters/postgresql/json_test.rb b/activerecord/test/cases/adapters/postgresql/json_test.rb
index d0e206ae80..c74f70f251 100644
--- a/activerecord/test/cases/adapters/postgresql/json_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/json_test.rb
@@ -38,11 +38,11 @@ module PostgresqlJSONSharedTestCases
   end
 
   def test_default
-    @connection.add_column "json_data_type", "permissions", column_type, default: {"users": "read", "posts": ["read", "write"]}
+    @connection.add_column "json_data_type", "permissions", column_type, default: { "users": "read", "posts": ["read", "write"] }
     JsonDataType.reset_column_information
 
-    assert_equal({"users"=>"read", "posts"=>["read", "write"]}, JsonDataType.column_defaults["permissions"])
-    assert_equal({"users"=>"read", "posts"=>["read", "write"]}, JsonDataType.new.permissions)
+    assert_equal({ "users"=>"read", "posts"=>["read", "write"] }, JsonDataType.column_defaults["permissions"])
+    assert_equal({ "users"=>"read", "posts"=>["read", "write"] }, JsonDataType.new.permissions)
   ensure
     JsonDataType.reset_column_information
   end
@@ -68,11 +68,11 @@ module PostgresqlJSONSharedTestCases
   end
 
   def test_cast_value_on_write
-    x = JsonDataType.new payload: {"string" => "foo", :symbol => :bar}
-    assert_equal({"string" => "foo", :symbol => :bar}, x.payload_before_type_cast)
-    assert_equal({"string" => "foo", "symbol" => "bar"}, x.payload)
+    x = JsonDataType.new payload: { "string" => "foo", :symbol => :bar }
+    assert_equal({ "string" => "foo", :symbol => :bar }, x.payload_before_type_cast)
+    assert_equal({ "string" => "foo", "symbol" => "bar" }, x.payload)
     x.save
-    assert_equal({"string" => "foo", "symbol" => "bar"}, x.reload.payload)
+    assert_equal({ "string" => "foo", "symbol" => "bar" }, x.reload.payload)
   end
 
   def test_type_cast_json
@@ -80,12 +80,12 @@ module PostgresqlJSONSharedTestCases
 
     data = "{\"a_key\":\"a_value\"}"
     hash = type.deserialize(data)
-    assert_equal({"a_key" => "a_value"}, hash)
-    assert_equal({"a_key" => "a_value"}, type.deserialize(data))
+    assert_equal({ "a_key" => "a_value" }, hash)
+    assert_equal({ "a_key" => "a_value" }, type.deserialize(data))
 
     assert_equal({}, type.deserialize("{}"))
-    assert_equal({"key"=>nil}, type.deserialize('{"key": null}'))
-    assert_equal({"c"=>"}",'"a"'=>'b "a b'}, type.deserialize(%q({"c":"}", "\"a\"":"b \"a b"})))
+    assert_equal({ "key"=>nil }, type.deserialize('{"key": null}'))
+    assert_equal({ "c"=>"}",'"a"'=>'b "a b' }, type.deserialize(%q({"c":"}", "\"a\"":"b \"a b"})))
   end
 
   def test_rewrite
@@ -98,13 +98,13 @@ module PostgresqlJSONSharedTestCases
   def test_select
     @connection.execute "insert into json_data_type (payload) VALUES ('{\"k\":\"v\"}')"
     x = JsonDataType.first
-    assert_equal({"k" => "v"}, x.payload)
+    assert_equal({ "k" => "v" }, x.payload)
   end
 
   def test_select_multikey
     @connection.execute %q|insert into json_data_type (payload) VALUES ('{"k1":"v1", "k2":"v2", "k3":[1,2,3]}')|
     x = JsonDataType.first
-    assert_equal({"k1" => "v1", "k2" => "v2", "k3" => [1,2,3]}, x.payload)
+    assert_equal({ "k1" => "v1", "k2" => "v2", "k3" => [1,2,3] }, x.payload)
   end
 
   def test_null_json
@@ -116,13 +116,13 @@ module PostgresqlJSONSharedTestCases
   def test_select_array_json_value
     @connection.execute %q|insert into json_data_type (payload) VALUES ('["v0",{"k1":"v1"}]')|
     x = JsonDataType.first
-    assert_equal(["v0", {"k1" => "v1"}], x.payload)
+    assert_equal(["v0", { "k1" => "v1" }], x.payload)
   end
 
   def test_rewrite_array_json_value
     @connection.execute %q|insert into json_data_type (payload) VALUES ('["v0",{"k1":"v1"}]')|
     x = JsonDataType.first
-    x.payload = ["v1", {"k2" => "v2"}, "v3"]
+    x.payload = ["v1", { "k2" => "v2" }, "v3"]
     assert x.save!
   end
 
diff --git a/activerecord/test/cases/adapters/postgresql/schema_test.rb b/activerecord/test/cases/adapters/postgresql/schema_test.rb
index d821cbafdf..b0be25de0c 100644
--- a/activerecord/test/cases/adapters/postgresql/schema_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/schema_test.rb
@@ -332,7 +332,7 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
     @connection.execute "CREATE INDEX \"things_Index\" ON #{SCHEMA_NAME}.things (name)"
 
     with_schema_search_path SCHEMA_NAME do
-      assert_nothing_raised { @connection.remove_index "things", name: "things_Index"}
+      assert_nothing_raised { @connection.remove_index "things", name: "things_Index" }
     end
   end
 
diff --git a/activerecord/test/cases/adapters/postgresql/utils_test.rb b/activerecord/test/cases/adapters/postgresql/utils_test.rb
index 70f72dd929..01c597beae 100644
--- a/activerecord/test/cases/adapters/postgresql/utils_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/utils_test.rb
@@ -54,7 +54,7 @@ class PostgreSQLNameTest < ActiveRecord::PostgreSQLTestCase
   end
 
   test "can be used as hash key" do
-    hash = {Name.new("schema", "article_seq") => "success"}
+    hash = { Name.new("schema", "article_seq") => "success" }
     assert_equal "success", hash[Name.new("schema", "article_seq")]
     assert_equal nil, hash[Name.new("schema", "articles")]
     assert_equal nil, hash[Name.new("public", "article_seq")]
diff --git a/activerecord/test/cases/adapters/sqlite3/copy_table_test.rb b/activerecord/test/cases/adapters/sqlite3/copy_table_test.rb
index 70e2f0fec1..8342b05870 100644
--- a/activerecord/test/cases/adapters/sqlite3/copy_table_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/copy_table_test.rb
@@ -11,7 +11,7 @@ class CopyTableTest < ActiveRecord::SQLite3TestCase
   end
 
   def test_copy_table(from = "customers", to = "customers2", options = {})
-    assert_nothing_raised {copy_table(from, to, options)}
+    assert_nothing_raised { copy_table(from, to, options) }
     assert_equal row_count(from), row_count(to)
 
     if block_given?
@@ -25,7 +25,7 @@ class CopyTableTest < ActiveRecord::SQLite3TestCase
 
   def test_copy_table_renaming_column
     test_copy_table("customers", "customers2",
-        rename: {"name" => "person_name"}) do |from, to, options|
+        rename: { "name" => "person_name" }) do |from, to, options|
       expected = column_values(from, "name")
       assert_equal expected, column_values(to, "person_name")
       assert expected.any?, "No values in table: #{expected.inspect}"
@@ -55,8 +55,8 @@ class CopyTableTest < ActiveRecord::SQLite3TestCase
 
   def test_copy_table_with_id_col_that_is_not_primary_key
     test_copy_table("goofy_string_id", "goofy_string_id2") do
-      original_id = @connection.columns("goofy_string_id").detect{|col| col.name == "id" }
-      copied_id = @connection.columns("goofy_string_id2").detect{|col| col.name == "id" }
+      original_id = @connection.columns("goofy_string_id").detect { |col| col.name == "id" }
+      copied_id = @connection.columns("goofy_string_id2").detect { |col| col.name == "id" }
       assert_equal original_id.type, copied_id.type
       assert_equal original_id.sql_type, copied_id.sql_type
       assert_equal original_id.limit, copied_id.limit
@@ -77,15 +77,15 @@ class CopyTableTest < ActiveRecord::SQLite3TestCase
 
 protected
   def copy_table(from, to, options = {})
-    @connection.copy_table(from, to, {temporary: true}.merge(options))
+    @connection.copy_table(from, to, { temporary: true }.merge(options))
   end
 
   def column_names(table)
-    @connection.table_structure(table).map {|column| column["name"]}
+    @connection.table_structure(table).map { |column| column["name"] }
   end
 
   def column_values(table, column)
-    @connection.select_all("SELECT #{column} FROM #{table} ORDER BY id").map {|row| row[column]}
+    @connection.select_all("SELECT #{column} FROM #{table} ORDER BY id").map { |row| row[column] }
   end
 
   def table_indexes_without_name(table)
diff --git a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
index 4800d3d7d5..d2f0710cb2 100644
--- a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
@@ -405,7 +405,7 @@ module ActiveRecord
                                    configurations["arunit"]["database"])
         statement = ::SQLite3::Statement.new(db,
                                            "CREATE TABLE statement_test (number integer not null)")
-        statement.stub(:step, ->{ raise ::SQLite3::BusyException.new("busy") }) do
+        statement.stub(:step, -> { raise ::SQLite3::BusyException.new("busy") }) do
           assert_called(statement, :columns, returns: []) do
             assert_called(statement, :close) do
               ::SQLite3::Statement.stub(:new, statement) do