4 files changed, 731 insertions, 731 deletions

diff --git a/activerecord/test/cases/tasks/database_tasks_test.rb b/activerecord/test/cases/tasks/database_tasks_test.rb
index 510bb088c8..079db3fe8b 100644
--- a/activerecord/test/cases/tasks/database_tasks_test.rb
+++ b/activerecord/test/cases/tasks/database_tasks_test.rb
@@ -1,5 +1,5 @@
-require 'cases/helper'
-require 'active_record/tasks/database_tasks'
+require "cases/helper"
+require "active_record/tasks/database_tasks"
 
 module ActiveRecord
   module DatabaseTasksSetupper
@@ -64,12 +64,12 @@ module ActiveRecord
       instance.expects(:structure_dump).with("awesome-file.sql")
 
       ActiveRecord::Tasks::DatabaseTasks.register_task(/foo/, klazz)
-      ActiveRecord::Tasks::DatabaseTasks.structure_dump({'adapter' => :foo}, "awesome-file.sql")
+      ActiveRecord::Tasks::DatabaseTasks.structure_dump({ "adapter" => :foo }, "awesome-file.sql")
     end
 
     def test_unregistered_task
       assert_raise(ActiveRecord::Tasks::DatabaseNotSupported) do
-        ActiveRecord::Tasks::DatabaseTasks.structure_dump({'adapter' => :bar}, "awesome-file.sql")
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump({ "adapter" => :bar }, "awesome-file.sql")
       end
     end
   end
@@ -80,20 +80,20 @@ module ActiveRecord
     ADAPTERS_TASKS.each do |k, v|
       define_method("test_#{k}_create") do
         eval("@#{v}").expects(:create)
-        ActiveRecord::Tasks::DatabaseTasks.create 'adapter' => k
+        ActiveRecord::Tasks::DatabaseTasks.create "adapter" => k
       end
     end
   end
 
   class DatabaseTasksCreateAllTest < ActiveRecord::TestCase
     def setup
-      @configurations = {'development' => {'database' => 'my-db'}}
+      @configurations = { "development" => { "database" => "my-db" } }
 
       ActiveRecord::Base.stubs(:configurations).returns(@configurations)
     end
 
     def test_ignores_configurations_without_databases
-      @configurations['development'].merge!('database' => nil)
+      @configurations["development"].merge!("database" => nil)
 
       ActiveRecord::Tasks::DatabaseTasks.expects(:create).never
 
@@ -101,7 +101,7 @@ module ActiveRecord
     end
 
     def test_ignores_remote_databases
-      @configurations['development'].merge!('host' => 'my.server.tld')
+      @configurations["development"].merge!("host" => "my.server.tld")
       $stderr.stubs(:puts).returns(nil)
 
       ActiveRecord::Tasks::DatabaseTasks.expects(:create).never
@@ -110,15 +110,15 @@ module ActiveRecord
     end
 
     def test_warning_for_remote_databases
-      @configurations['development'].merge!('host' => 'my.server.tld')
+      @configurations["development"].merge!("host" => "my.server.tld")
 
-      $stderr.expects(:puts).with('This task only modifies local databases. my-db is on a remote host.')
+      $stderr.expects(:puts).with("This task only modifies local databases. my-db is on a remote host.")
 
       ActiveRecord::Tasks::DatabaseTasks.create_all
     end
 
     def test_creates_configurations_with_local_ip
-      @configurations['development'].merge!('host' => '127.0.0.1')
+      @configurations["development"].merge!("host" => "127.0.0.1")
 
       ActiveRecord::Tasks::DatabaseTasks.expects(:create)
 
@@ -126,7 +126,7 @@ module ActiveRecord
     end
 
     def test_creates_configurations_with_local_host
-      @configurations['development'].merge!('host' => 'localhost')
+      @configurations["development"].merge!("host" => "localhost")
 
       ActiveRecord::Tasks::DatabaseTasks.expects(:create)
 
@@ -134,7 +134,7 @@ module ActiveRecord
     end
 
     def test_creates_configurations_with_blank_hosts
-      @configurations['development'].merge!('host' => nil)
+      @configurations["development"].merge!("host" => nil)
 
       ActiveRecord::Tasks::DatabaseTasks.expects(:create)
 
@@ -145,9 +145,9 @@ module ActiveRecord
   class DatabaseTasksCreateCurrentTest < ActiveRecord::TestCase
     def setup
       @configurations = {
-        'development' => {'database' => 'dev-db'},
-        'test'        => {'database' => 'test-db'},
-        'production'  => {'database' => 'prod-db'}
+        "development" => { "database" => "dev-db" },
+        "test"        => { "database" => "test-db" },
+        "production"  => { "database" => "prod-db" }
       }
 
       ActiveRecord::Base.stubs(:configurations).returns(@configurations)
@@ -156,37 +156,37 @@ module ActiveRecord
 
     def test_creates_current_environment_database
       ActiveRecord::Tasks::DatabaseTasks.expects(:create).
-        with('database' => 'prod-db')
+        with("database" => "prod-db")
 
       ActiveRecord::Tasks::DatabaseTasks.create_current(
-        ActiveSupport::StringInquirer.new('production')
+        ActiveSupport::StringInquirer.new("production")
       )
     end
 
     def test_creates_test_and_development_databases_when_env_was_not_specified
       ActiveRecord::Tasks::DatabaseTasks.expects(:create).
-        with('database' => 'dev-db')
+        with("database" => "dev-db")
       ActiveRecord::Tasks::DatabaseTasks.expects(:create).
-        with('database' => 'test-db')
+        with("database" => "test-db")
 
       ActiveRecord::Tasks::DatabaseTasks.create_current(
-        ActiveSupport::StringInquirer.new('development')
+        ActiveSupport::StringInquirer.new("development")
       )
     end
 
     def test_creates_test_and_development_databases_when_rails_env_is_development
-      old_env = ENV['RAILS_ENV']
-      ENV['RAILS_ENV'] = 'development'
+      old_env = ENV["RAILS_ENV"]
+      ENV["RAILS_ENV"] = "development"
       ActiveRecord::Tasks::DatabaseTasks.expects(:create).
-        with('database' => 'dev-db')
+        with("database" => "dev-db")
       ActiveRecord::Tasks::DatabaseTasks.expects(:create).
-        with('database' => 'test-db')
+        with("database" => "test-db")
 
       ActiveRecord::Tasks::DatabaseTasks.create_current(
-        ActiveSupport::StringInquirer.new('development')
+        ActiveSupport::StringInquirer.new("development")
       )
     ensure
-      ENV['RAILS_ENV'] = old_env
+      ENV["RAILS_ENV"] = old_env
     end
 
     def test_establishes_connection_for_the_given_environment
@@ -195,7 +195,7 @@ module ActiveRecord
       ActiveRecord::Base.expects(:establish_connection).with(:development)
 
       ActiveRecord::Tasks::DatabaseTasks.create_current(
-        ActiveSupport::StringInquirer.new('development')
+        ActiveSupport::StringInquirer.new("development")
       )
     end
   end
@@ -206,20 +206,20 @@ module ActiveRecord
     ADAPTERS_TASKS.each do |k, v|
       define_method("test_#{k}_drop") do
         eval("@#{v}").expects(:drop)
-        ActiveRecord::Tasks::DatabaseTasks.drop 'adapter' => k
+        ActiveRecord::Tasks::DatabaseTasks.drop "adapter" => k
       end
     end
   end
 
   class DatabaseTasksDropAllTest < ActiveRecord::TestCase
     def setup
-      @configurations = {:development => {'database' => 'my-db'}}
+      @configurations = { development: { "database" => "my-db" } }
 
       ActiveRecord::Base.stubs(:configurations).returns(@configurations)
     end
 
     def test_ignores_configurations_without_databases
-      @configurations[:development].merge!('database' => nil)
+      @configurations[:development].merge!("database" => nil)
 
       ActiveRecord::Tasks::DatabaseTasks.expects(:drop).never
 
@@ -227,7 +227,7 @@ module ActiveRecord
     end
 
     def test_ignores_remote_databases
-      @configurations[:development].merge!('host' => 'my.server.tld')
+      @configurations[:development].merge!("host" => "my.server.tld")
       $stderr.stubs(:puts).returns(nil)
 
       ActiveRecord::Tasks::DatabaseTasks.expects(:drop).never
@@ -236,15 +236,15 @@ module ActiveRecord
     end
 
     def test_warning_for_remote_databases
-      @configurations[:development].merge!('host' => 'my.server.tld')
+      @configurations[:development].merge!("host" => "my.server.tld")
 
-      $stderr.expects(:puts).with('This task only modifies local databases. my-db is on a remote host.')
+      $stderr.expects(:puts).with("This task only modifies local databases. my-db is on a remote host.")
 
       ActiveRecord::Tasks::DatabaseTasks.drop_all
     end
 
     def test_drops_configurations_with_local_ip
-      @configurations[:development].merge!('host' => '127.0.0.1')
+      @configurations[:development].merge!("host" => "127.0.0.1")
 
       ActiveRecord::Tasks::DatabaseTasks.expects(:drop)
 
@@ -252,7 +252,7 @@ module ActiveRecord
     end
 
     def test_drops_configurations_with_local_host
-      @configurations[:development].merge!('host' => 'localhost')
+      @configurations[:development].merge!("host" => "localhost")
 
       ActiveRecord::Tasks::DatabaseTasks.expects(:drop)
 
@@ -260,7 +260,7 @@ module ActiveRecord
     end
 
     def test_drops_configurations_with_blank_hosts
-      @configurations[:development].merge!('host' => nil)
+      @configurations[:development].merge!("host" => nil)
 
       ActiveRecord::Tasks::DatabaseTasks.expects(:drop)
 
@@ -271,9 +271,9 @@ module ActiveRecord
   class DatabaseTasksDropCurrentTest < ActiveRecord::TestCase
     def setup
       @configurations = {
-        'development' => {'database' => 'dev-db'},
-        'test'        => {'database' => 'test-db'},
-        'production'  => {'database' => 'prod-db'}
+        "development" => { "database" => "dev-db" },
+        "test"        => { "database" => "test-db" },
+        "production"  => { "database" => "prod-db" }
       }
 
       ActiveRecord::Base.stubs(:configurations).returns(@configurations)
@@ -281,37 +281,37 @@ module ActiveRecord
 
     def test_drops_current_environment_database
       ActiveRecord::Tasks::DatabaseTasks.expects(:drop).
-        with('database' => 'prod-db')
+        with("database" => "prod-db")
 
       ActiveRecord::Tasks::DatabaseTasks.drop_current(
-        ActiveSupport::StringInquirer.new('production')
+        ActiveSupport::StringInquirer.new("production")
       )
     end
 
     def test_drops_test_and_development_databases_when_env_was_not_specified
       ActiveRecord::Tasks::DatabaseTasks.expects(:drop).
-        with('database' => 'dev-db')
+        with("database" => "dev-db")
       ActiveRecord::Tasks::DatabaseTasks.expects(:drop).
-        with('database' => 'test-db')
+        with("database" => "test-db")
 
       ActiveRecord::Tasks::DatabaseTasks.drop_current(
-        ActiveSupport::StringInquirer.new('development')
+        ActiveSupport::StringInquirer.new("development")
       )
     end
 
     def test_drops_testand_development_databases_when_rails_env_is_development
-      old_env = ENV['RAILS_ENV']
-      ENV['RAILS_ENV'] = 'development'
+      old_env = ENV["RAILS_ENV"]
+      ENV["RAILS_ENV"] = "development"
       ActiveRecord::Tasks::DatabaseTasks.expects(:drop).
-        with('database' => 'dev-db')
+        with("database" => "dev-db")
       ActiveRecord::Tasks::DatabaseTasks.expects(:drop).
-        with('database' => 'test-db')
+        with("database" => "test-db")
 
       ActiveRecord::Tasks::DatabaseTasks.drop_current(
-        ActiveSupport::StringInquirer.new('development')
+        ActiveSupport::StringInquirer.new("development")
       )
     ensure
-      ENV['RAILS_ENV'] = old_env
+      ENV["RAILS_ENV"] = old_env
     end
   end
 
@@ -319,7 +319,7 @@ module ActiveRecord
     self.use_transactional_tests = false
 
     def setup
-      ActiveRecord::Tasks::DatabaseTasks.migrations_paths = 'custom/path'
+      ActiveRecord::Tasks::DatabaseTasks.migrations_paths = "custom/path"
     end
 
     def teardown
@@ -327,15 +327,15 @@ module ActiveRecord
     end
 
     def test_migrate_receives_correct_env_vars
-      verbose, version = ENV['VERBOSE'], ENV['VERSION']
+      verbose, version = ENV["VERBOSE"], ENV["VERSION"]
 
-      ENV['VERBOSE'] = 'false'
-      ENV['VERSION'] = '4'
+      ENV["VERBOSE"] = "false"
+      ENV["VERSION"] = "4"
 
-      ActiveRecord::Migrator.expects(:migrate).with('custom/path', 4)
+      ActiveRecord::Migrator.expects(:migrate).with("custom/path", 4)
       ActiveRecord::Tasks::DatabaseTasks.migrate
     ensure
-      ENV['VERBOSE'], ENV['VERSION'] = verbose, version
+      ENV["VERBOSE"], ENV["VERSION"] = verbose, version
     end
 
     def test_migrate_clears_schema_cache_afterward
@@ -350,7 +350,7 @@ module ActiveRecord
     ADAPTERS_TASKS.each do |k, v|
       define_method("test_#{k}_purge") do
         eval("@#{v}").expects(:purge)
-        ActiveRecord::Tasks::DatabaseTasks.purge 'adapter' => k
+        ActiveRecord::Tasks::DatabaseTasks.purge "adapter" => k
       end
     end
   end
@@ -358,27 +358,27 @@ module ActiveRecord
   class DatabaseTasksPurgeCurrentTest < ActiveRecord::TestCase
     def test_purges_current_environment_database
       configurations = {
-        'development' => {'database' => 'dev-db'},
-        'test'        => {'database' => 'test-db'},
-        'production'  => {'database' => 'prod-db'}
+        "development" => { "database" => "dev-db" },
+        "test"        => { "database" => "test-db" },
+        "production"  => { "database" => "prod-db" }
       }
       ActiveRecord::Base.stubs(:configurations).returns(configurations)
 
       ActiveRecord::Tasks::DatabaseTasks.expects(:purge).
-        with('database' => 'prod-db')
+        with("database" => "prod-db")
       ActiveRecord::Base.expects(:establish_connection).with(:production)
 
-      ActiveRecord::Tasks::DatabaseTasks.purge_current('production')
+      ActiveRecord::Tasks::DatabaseTasks.purge_current("production")
     end
   end
 
   class DatabaseTasksPurgeAllTest < ActiveRecord::TestCase
     def test_purge_all_local_configurations
-      configurations = {:development => {'database' => 'my-db'}}
+      configurations = { development: { "database" => "my-db" } }
       ActiveRecord::Base.stubs(:configurations).returns(configurations)
 
       ActiveRecord::Tasks::DatabaseTasks.expects(:purge).
-        with('database' => 'my-db')
+        with("database" => "my-db")
 
       ActiveRecord::Tasks::DatabaseTasks.purge_all
     end
@@ -390,7 +390,7 @@ module ActiveRecord
     ADAPTERS_TASKS.each do |k, v|
       define_method("test_#{k}_charset") do
         eval("@#{v}").expects(:charset)
-        ActiveRecord::Tasks::DatabaseTasks.charset 'adapter' => k
+        ActiveRecord::Tasks::DatabaseTasks.charset "adapter" => k
       end
     end
   end
@@ -401,7 +401,7 @@ module ActiveRecord
     ADAPTERS_TASKS.each do |k, v|
       define_method("test_#{k}_collation") do
         eval("@#{v}").expects(:collation)
-        ActiveRecord::Tasks::DatabaseTasks.collation 'adapter' => k
+        ActiveRecord::Tasks::DatabaseTasks.collation "adapter" => k
       end
     end
   end
@@ -412,7 +412,7 @@ module ActiveRecord
     ADAPTERS_TASKS.each do |k, v|
       define_method("test_#{k}_structure_dump") do
         eval("@#{v}").expects(:structure_dump).with("awesome-file.sql")
-        ActiveRecord::Tasks::DatabaseTasks.structure_dump({'adapter' => k}, "awesome-file.sql")
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump({ "adapter" => k }, "awesome-file.sql")
       end
     end
   end
@@ -423,7 +423,7 @@ module ActiveRecord
     ADAPTERS_TASKS.each do |k, v|
       define_method("test_#{k}_structure_load") do
         eval("@#{v}").expects(:structure_load).with("awesome-file.sql")
-        ActiveRecord::Tasks::DatabaseTasks.structure_load({'adapter' => k}, "awesome-file.sql")
+        ActiveRecord::Tasks::DatabaseTasks.structure_load({ "adapter" => k }, "awesome-file.sql")
       end
     end
   end
@@ -437,15 +437,15 @@ module ActiveRecord
 
   class DatabaseTasksCheckSchemaFileDefaultsTest < ActiveRecord::TestCase
     def test_check_schema_file_defaults
-      ActiveRecord::Tasks::DatabaseTasks.stubs(:db_dir).returns('/tmp')
-      assert_equal '/tmp/schema.rb', ActiveRecord::Tasks::DatabaseTasks.schema_file
+      ActiveRecord::Tasks::DatabaseTasks.stubs(:db_dir).returns("/tmp")
+      assert_equal "/tmp/schema.rb", ActiveRecord::Tasks::DatabaseTasks.schema_file
     end
   end
 
   class DatabaseTasksCheckSchemaFileSpecifiedFormatsTest < ActiveRecord::TestCase
-    {ruby: 'schema.rb', sql: 'structure.sql'}.each_pair do |fmt, filename|
+    { ruby: "schema.rb", sql: "structure.sql" }.each_pair do |fmt, filename|
       define_method("test_check_schema_file_for_#{fmt}_format") do
-        ActiveRecord::Tasks::DatabaseTasks.stubs(:db_dir).returns('/tmp')
+        ActiveRecord::Tasks::DatabaseTasks.stubs(:db_dir).returns("/tmp")
         assert_equal "/tmp/#{filename}", ActiveRecord::Tasks::DatabaseTasks.schema_file(fmt)
       end
     end
diff --git a/activerecord/test/cases/tasks/mysql_rake_test.rb b/activerecord/test/cases/tasks/mysql_rake_test.rb
index 70e406038f..dbe935808e 100644
--- a/activerecord/test/cases/tasks/mysql_rake_test.rb
+++ b/activerecord/test/cases/tasks/mysql_rake_test.rb
@@ -1,345 +1,345 @@
-require 'cases/helper'
-require 'active_record/tasks/database_tasks'
+require "cases/helper"
+require "active_record/tasks/database_tasks"
 
 if current_adapter?(:Mysql2Adapter)
-module ActiveRecord
-  class MysqlDBCreateTest < ActiveRecord::TestCase
-    def setup
-      @connection    = stub(:create_database => true)
-      @configuration = {
-        'adapter'  => 'mysql2',
-        'database' => 'my-app-db'
-      }
-
-      ActiveRecord::Base.stubs(:connection).returns(@connection)
-      ActiveRecord::Base.stubs(:establish_connection).returns(true)
-
-      $stdout, @original_stdout = StringIO.new, $stdout
-      $stderr, @original_stderr = StringIO.new, $stderr
-    end
+  module ActiveRecord
+    class MysqlDBCreateTest < ActiveRecord::TestCase
+      def setup
+        @connection    = stub(create_database: true)
+        @configuration = {
+          "adapter"  => "mysql2",
+          "database" => "my-app-db"
+        }
+
+        ActiveRecord::Base.stubs(:connection).returns(@connection)
+        ActiveRecord::Base.stubs(:establish_connection).returns(true)
+
+        $stdout, @original_stdout = StringIO.new, $stdout
+        $stderr, @original_stderr = StringIO.new, $stderr
+      end
 
-    def teardown
-      $stdout, $stderr = @original_stdout, @original_stderr
-    end
+      def teardown
+        $stdout, $stderr = @original_stdout, @original_stderr
+      end
 
-    def test_establishes_connection_without_database
-      ActiveRecord::Base.expects(:establish_connection).
-        with('adapter' => 'mysql2', 'database' => nil)
+      def test_establishes_connection_without_database
+        ActiveRecord::Base.expects(:establish_connection).
+          with("adapter" => "mysql2", "database" => nil)
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration
-    end
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration
+      end
 
-    def test_creates_database_with_no_default_options
-      @connection.expects(:create_database).
-        with('my-app-db', {})
+      def test_creates_database_with_no_default_options
+        @connection.expects(:create_database).
+          with("my-app-db", {})
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration
-    end
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration
+      end
 
-    def test_creates_database_with_given_encoding
-      @connection.expects(:create_database).
-        with('my-app-db', charset: 'latin1')
+      def test_creates_database_with_given_encoding
+        @connection.expects(:create_database).
+          with("my-app-db", charset: "latin1")
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration.merge('encoding' => 'latin1')
-    end
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration.merge("encoding" => "latin1")
+      end
 
-    def test_creates_database_with_given_collation
-      @connection.expects(:create_database).
-        with('my-app-db', collation: 'latin1_swedish_ci')
+      def test_creates_database_with_given_collation
+        @connection.expects(:create_database).
+          with("my-app-db", collation: "latin1_swedish_ci")
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration.merge('collation' => 'latin1_swedish_ci')
-    end
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration.merge("collation" => "latin1_swedish_ci")
+      end
 
-    def test_establishes_connection_to_database
-      ActiveRecord::Base.expects(:establish_connection).with(@configuration)
+      def test_establishes_connection_to_database
+        ActiveRecord::Base.expects(:establish_connection).with(@configuration)
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration
-    end
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration
+      end
 
-    def test_when_database_created_successfully_outputs_info_to_stdout
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration
+      def test_when_database_created_successfully_outputs_info_to_stdout
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration
 
-      assert_equal $stdout.string, "Created database 'my-app-db'\n"
-    end
+        assert_equal $stdout.string, "Created database 'my-app-db'\n"
+      end
 
-    def test_create_when_database_exists_outputs_info_to_stderr
-      ActiveRecord::Base.connection.stubs(:create_database).raises(
-        ActiveRecord::Tasks::DatabaseAlreadyExists
-      )
+      def test_create_when_database_exists_outputs_info_to_stderr
+        ActiveRecord::Base.connection.stubs(:create_database).raises(
+          ActiveRecord::Tasks::DatabaseAlreadyExists
+        )
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration
 
-      assert_equal $stderr.string, "Database 'my-app-db' already exists\n"
+        assert_equal $stderr.string, "Database 'my-app-db' already exists\n"
+      end
     end
-  end
 
-  class MysqlDBCreateAsRootTest < ActiveRecord::TestCase
-    def setup
-      @connection    = stub("Connection", create_database: true)
-      @error         = Mysql2::Error.new("Invalid permissions")
-      @configuration = {
-        'adapter'  => 'mysql2',
-        'database' => 'my-app-db',
-        'username' => 'pat',
-        'password' => 'wossname'
-      }
-
-      $stdin.stubs(:gets).returns("secret\n")
-      $stdout.stubs(:print).returns(nil)
-      @error.stubs(:errno).returns(1045)
-      ActiveRecord::Base.stubs(:connection).returns(@connection)
-      ActiveRecord::Base.stubs(:establish_connection).
-        raises(@error).
-        then.returns(true)
-
-      $stdout, @original_stdout = StringIO.new, $stdout
-      $stderr, @original_stderr = StringIO.new, $stderr
-    end
+    class MysqlDBCreateAsRootTest < ActiveRecord::TestCase
+      def setup
+        @connection    = stub("Connection", create_database: true)
+        @error         = Mysql2::Error.new("Invalid permissions")
+        @configuration = {
+          "adapter"  => "mysql2",
+          "database" => "my-app-db",
+          "username" => "pat",
+          "password" => "wossname"
+        }
+
+        $stdin.stubs(:gets).returns("secret\n")
+        $stdout.stubs(:print).returns(nil)
+        @error.stubs(:errno).returns(1045)
+        ActiveRecord::Base.stubs(:connection).returns(@connection)
+        ActiveRecord::Base.stubs(:establish_connection).
+          raises(@error).
+          then.returns(true)
+
+        $stdout, @original_stdout = StringIO.new, $stdout
+        $stderr, @original_stderr = StringIO.new, $stderr
+      end
 
-    def teardown
-      $stdout, $stderr = @original_stdout, @original_stderr
-    end
+      def teardown
+        $stdout, $stderr = @original_stdout, @original_stderr
+      end
 
-    def test_root_password_is_requested
-      assert_permissions_granted_for("pat")
-      $stdin.expects(:gets).returns("secret\n")
+      def test_root_password_is_requested
+        assert_permissions_granted_for("pat")
+        $stdin.expects(:gets).returns("secret\n")
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration
-    end
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration
+      end
 
-    def test_connection_established_as_root
-      assert_permissions_granted_for("pat")
-      ActiveRecord::Base.expects(:establish_connection).with(
-        'adapter'  => 'mysql2',
-        'database' => nil,
-        'username' => 'root',
-        'password' => 'secret'
-      )
+      def test_connection_established_as_root
+        assert_permissions_granted_for("pat")
+        ActiveRecord::Base.expects(:establish_connection).with(
+          "adapter"  => "mysql2",
+          "database" => nil,
+          "username" => "root",
+          "password" => "secret"
+        )
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration
-    end
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration
+      end
 
-    def test_database_created_by_root
-      assert_permissions_granted_for("pat")
-      @connection.expects(:create_database).
-        with('my-app-db', {})
+      def test_database_created_by_root
+        assert_permissions_granted_for("pat")
+        @connection.expects(:create_database).
+          with("my-app-db", {})
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration
-    end
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration
+      end
 
-    def test_grant_privileges_for_normal_user
-      assert_permissions_granted_for("pat")
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration
-    end
+      def test_grant_privileges_for_normal_user
+        assert_permissions_granted_for("pat")
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration
+      end
 
-    def test_do_not_grant_privileges_for_root_user
-      @configuration['username'] = 'root'
-      @configuration['password'] = ''
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration
-    end
+      def test_do_not_grant_privileges_for_root_user
+        @configuration["username"] = "root"
+        @configuration["password"] = ""
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration
+      end
 
-    def test_connection_established_as_normal_user
-      assert_permissions_granted_for("pat")
-      ActiveRecord::Base.expects(:establish_connection).returns do
-        ActiveRecord::Base.expects(:establish_connection).with(
-          'adapter'  => 'mysql2',
-          'database' => 'my-app-db',
-          'username' => 'pat',
-          'password' => 'secret'
-        )
+      def test_connection_established_as_normal_user
+        assert_permissions_granted_for("pat")
+        ActiveRecord::Base.expects(:establish_connection).returns do
+          ActiveRecord::Base.expects(:establish_connection).with(
+            "adapter"  => "mysql2",
+            "database" => "my-app-db",
+            "username" => "pat",
+            "password" => "secret"
+          )
 
-        raise @error
-      end
+          raise @error
+        end
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration
-    end
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration
+      end
 
-    def test_sends_output_to_stderr_when_other_errors
-      @error.stubs(:errno).returns(42)
+      def test_sends_output_to_stderr_when_other_errors
+        @error.stubs(:errno).returns(42)
 
-      $stderr.expects(:puts).at_least_once.returns(nil)
+        $stderr.expects(:puts).at_least_once.returns(nil)
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration
-    end
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration
+      end
 
-    private
+      private
 
-    def assert_permissions_granted_for(db_user)
-      db_name = @configuration['database']
-      db_password = @configuration['password']
-      @connection.expects(:execute).with("GRANT ALL PRIVILEGES ON #{db_name}.* TO '#{db_user}'@'localhost' IDENTIFIED BY '#{db_password}' WITH GRANT OPTION;")
+        def assert_permissions_granted_for(db_user)
+          db_name = @configuration["database"]
+          db_password = @configuration["password"]
+          @connection.expects(:execute).with("GRANT ALL PRIVILEGES ON #{db_name}.* TO '#{db_user}'@'localhost' IDENTIFIED BY '#{db_password}' WITH GRANT OPTION;")
+        end
     end
-  end
 
-  class MySQLDBDropTest < ActiveRecord::TestCase
-    def setup
-      @connection    = stub(:drop_database => true)
-      @configuration = {
-        'adapter'  => 'mysql2',
-        'database' => 'my-app-db'
-      }
+    class MySQLDBDropTest < ActiveRecord::TestCase
+      def setup
+        @connection    = stub(drop_database: true)
+        @configuration = {
+          "adapter"  => "mysql2",
+          "database" => "my-app-db"
+        }
 
-      ActiveRecord::Base.stubs(:connection).returns(@connection)
-      ActiveRecord::Base.stubs(:establish_connection).returns(true)
+        ActiveRecord::Base.stubs(:connection).returns(@connection)
+        ActiveRecord::Base.stubs(:establish_connection).returns(true)
 
-      $stdout, @original_stdout = StringIO.new, $stdout
-      $stderr, @original_stderr = StringIO.new, $stderr
-    end
+        $stdout, @original_stdout = StringIO.new, $stdout
+        $stderr, @original_stderr = StringIO.new, $stderr
+      end
 
-    def teardown
-      $stdout, $stderr = @original_stdout, @original_stderr
-    end
+      def teardown
+        $stdout, $stderr = @original_stdout, @original_stderr
+      end
 
-    def test_establishes_connection_to_mysql_database
-      ActiveRecord::Base.expects(:establish_connection).with @configuration
+      def test_establishes_connection_to_mysql_database
+        ActiveRecord::Base.expects(:establish_connection).with @configuration
 
-      ActiveRecord::Tasks::DatabaseTasks.drop @configuration
-    end
+        ActiveRecord::Tasks::DatabaseTasks.drop @configuration
+      end
 
-    def test_drops_database
-      @connection.expects(:drop_database).with('my-app-db')
+      def test_drops_database
+        @connection.expects(:drop_database).with("my-app-db")
 
-      ActiveRecord::Tasks::DatabaseTasks.drop @configuration
-    end
+        ActiveRecord::Tasks::DatabaseTasks.drop @configuration
+      end
 
-    def test_when_database_dropped_successfully_outputs_info_to_stdout
-      ActiveRecord::Tasks::DatabaseTasks.drop @configuration
+      def test_when_database_dropped_successfully_outputs_info_to_stdout
+        ActiveRecord::Tasks::DatabaseTasks.drop @configuration
 
-      assert_equal $stdout.string, "Dropped database 'my-app-db'\n"
+        assert_equal $stdout.string, "Dropped database 'my-app-db'\n"
+      end
     end
-  end
 
-  class MySQLPurgeTest < ActiveRecord::TestCase
-    def setup
-      @connection    = stub(:recreate_database => true)
-      @configuration = {
-        'adapter'  => 'mysql2',
-        'database' => 'test-db'
-      }
+    class MySQLPurgeTest < ActiveRecord::TestCase
+      def setup
+        @connection    = stub(recreate_database: true)
+        @configuration = {
+          "adapter"  => "mysql2",
+          "database" => "test-db"
+        }
 
-      ActiveRecord::Base.stubs(:connection).returns(@connection)
-      ActiveRecord::Base.stubs(:establish_connection).returns(true)
-    end
+        ActiveRecord::Base.stubs(:connection).returns(@connection)
+        ActiveRecord::Base.stubs(:establish_connection).returns(true)
+      end
 
-    def test_establishes_connection_to_the_appropriate_database
-      ActiveRecord::Base.expects(:establish_connection).with(@configuration)
+      def test_establishes_connection_to_the_appropriate_database
+        ActiveRecord::Base.expects(:establish_connection).with(@configuration)
 
-      ActiveRecord::Tasks::DatabaseTasks.purge @configuration
-    end
+        ActiveRecord::Tasks::DatabaseTasks.purge @configuration
+      end
 
-    def test_recreates_database_with_no_default_options
-      @connection.expects(:recreate_database).
-        with('test-db', {})
+      def test_recreates_database_with_no_default_options
+        @connection.expects(:recreate_database).
+          with("test-db", {})
 
-      ActiveRecord::Tasks::DatabaseTasks.purge @configuration
-    end
+        ActiveRecord::Tasks::DatabaseTasks.purge @configuration
+      end
 
-    def test_recreates_database_with_the_given_options
-      @connection.expects(:recreate_database).
-        with('test-db', charset: 'latin', collation: 'latin1_swedish_ci')
+      def test_recreates_database_with_the_given_options
+        @connection.expects(:recreate_database).
+          with("test-db", charset: "latin", collation: "latin1_swedish_ci")
 
-      ActiveRecord::Tasks::DatabaseTasks.purge @configuration.merge(
-        'encoding' => 'latin', 'collation' => 'latin1_swedish_ci')
+        ActiveRecord::Tasks::DatabaseTasks.purge @configuration.merge(
+          "encoding" => "latin", "collation" => "latin1_swedish_ci")
+      end
     end
-  end
 
-  class MysqlDBCharsetTest < ActiveRecord::TestCase
-    def setup
-      @connection    = stub(:create_database => true)
-      @configuration = {
-        'adapter'  => 'mysql2',
-        'database' => 'my-app-db'
-      }
+    class MysqlDBCharsetTest < ActiveRecord::TestCase
+      def setup
+        @connection    = stub(create_database: true)
+        @configuration = {
+          "adapter"  => "mysql2",
+          "database" => "my-app-db"
+        }
 
-      ActiveRecord::Base.stubs(:connection).returns(@connection)
-      ActiveRecord::Base.stubs(:establish_connection).returns(true)
-    end
+        ActiveRecord::Base.stubs(:connection).returns(@connection)
+        ActiveRecord::Base.stubs(:establish_connection).returns(true)
+      end
 
-    def test_db_retrieves_charset
-      @connection.expects(:charset)
-      ActiveRecord::Tasks::DatabaseTasks.charset @configuration
+      def test_db_retrieves_charset
+        @connection.expects(:charset)
+        ActiveRecord::Tasks::DatabaseTasks.charset @configuration
+      end
     end
-  end
 
-  class MysqlDBCollationTest < ActiveRecord::TestCase
-    def setup
-      @connection    = stub(:create_database => true)
-      @configuration = {
-        'adapter'  => 'mysql2',
-        'database' => 'my-app-db'
-      }
+    class MysqlDBCollationTest < ActiveRecord::TestCase
+      def setup
+        @connection    = stub(create_database: true)
+        @configuration = {
+          "adapter"  => "mysql2",
+          "database" => "my-app-db"
+        }
 
-      ActiveRecord::Base.stubs(:connection).returns(@connection)
-      ActiveRecord::Base.stubs(:establish_connection).returns(true)
-    end
+        ActiveRecord::Base.stubs(:connection).returns(@connection)
+        ActiveRecord::Base.stubs(:establish_connection).returns(true)
+      end
 
-    def test_db_retrieves_collation
-      @connection.expects(:collation)
-      ActiveRecord::Tasks::DatabaseTasks.collation @configuration
+      def test_db_retrieves_collation
+        @connection.expects(:collation)
+        ActiveRecord::Tasks::DatabaseTasks.collation @configuration
+      end
     end
-  end
 
-  class MySQLStructureDumpTest < ActiveRecord::TestCase
-    def setup
-      @configuration = {
-        'adapter'  => 'mysql2',
-        'database' => 'test-db'
-      }
-    end
+    class MySQLStructureDumpTest < ActiveRecord::TestCase
+      def setup
+        @configuration = {
+          "adapter"  => "mysql2",
+          "database" => "test-db"
+        }
+      end
 
-    def test_structure_dump
-      filename = "awesome-file.sql"
-      Kernel.expects(:system).with("mysqldump", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db").returns(true)
+      def test_structure_dump
+        filename = "awesome-file.sql"
+        Kernel.expects(:system).with("mysqldump", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db").returns(true)
 
-      ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
-    end
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+      end
 
-    def test_warn_when_external_structure_dump_command_execution_fails
-      filename = "awesome-file.sql"
-      Kernel.expects(:system)
-        .with("mysqldump", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db")
-        .returns(false)
+      def test_warn_when_external_structure_dump_command_execution_fails
+        filename = "awesome-file.sql"
+        Kernel.expects(:system)
+          .with("mysqldump", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db")
+          .returns(false)
 
-      e = assert_raise(RuntimeError) {
-        ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
-      }
-      assert_match(/^failed to execute: `mysqldump`$/, e.message)
-    end
+        e = assert_raise(RuntimeError) {
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+        }
+        assert_match(/^failed to execute: `mysqldump`$/, e.message)
+      end
 
-    def test_structure_dump_with_port_number
-      filename = "awesome-file.sql"
-      Kernel.expects(:system).with("mysqldump", "--port=10000", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db").returns(true)
+      def test_structure_dump_with_port_number
+        filename = "awesome-file.sql"
+        Kernel.expects(:system).with("mysqldump", "--port=10000", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db").returns(true)
 
-      ActiveRecord::Tasks::DatabaseTasks.structure_dump(
-        @configuration.merge('port' => 10000),
-        filename)
-    end
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump(
+          @configuration.merge("port" => 10000),
+          filename)
+      end
 
-    def test_structure_dump_with_ssl
-      filename = "awesome-file.sql"
-      Kernel.expects(:system).with("mysqldump", "--ssl-ca=ca.crt", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db").returns(true)
+      def test_structure_dump_with_ssl
+        filename = "awesome-file.sql"
+        Kernel.expects(:system).with("mysqldump", "--ssl-ca=ca.crt", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db").returns(true)
 
-      ActiveRecord::Tasks::DatabaseTasks.structure_dump(
-        @configuration.merge("sslca" => "ca.crt"),
-        filename)
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump(
+          @configuration.merge("sslca" => "ca.crt"),
+          filename)
+      end
     end
-  end
 
-  class MySQLStructureLoadTest < ActiveRecord::TestCase
-    def setup
-      @configuration = {
-        'adapter'  => 'mysql2',
-        'database' => 'test-db'
-      }
-    end
+    class MySQLStructureLoadTest < ActiveRecord::TestCase
+      def setup
+        @configuration = {
+          "adapter"  => "mysql2",
+          "database" => "test-db"
+        }
+      end
 
-    def test_structure_load
-      filename = "awesome-file.sql"
-      Kernel.expects(:system).with('mysql', '--execute', %{SET FOREIGN_KEY_CHECKS = 0; SOURCE #{filename}; SET FOREIGN_KEY_CHECKS = 1}, "--database", "test-db")
-        .returns(true)
+      def test_structure_load
+        filename = "awesome-file.sql"
+        Kernel.expects(:system).with("mysql", "--execute", %{SET FOREIGN_KEY_CHECKS = 0; SOURCE #{filename}; SET FOREIGN_KEY_CHECKS = 1}, "--database", "test-db")
+          .returns(true)
 
-      ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
+        ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
+      end
     end
   end
 end
-end
diff --git a/activerecord/test/cases/tasks/postgresql_rake_test.rb b/activerecord/test/cases/tasks/postgresql_rake_test.rb
index 99d73e91a4..b8c8ec88f0 100644
--- a/activerecord/test/cases/tasks/postgresql_rake_test.rb
+++ b/activerecord/test/cases/tasks/postgresql_rake_test.rb
@@ -1,304 +1,304 @@
-require 'cases/helper'
-require 'active_record/tasks/database_tasks'
+require "cases/helper"
+require "active_record/tasks/database_tasks"
 
 if current_adapter?(:PostgreSQLAdapter)
-module ActiveRecord
-  class PostgreSQLDBCreateTest < ActiveRecord::TestCase
-    def setup
-      @connection    = stub(:create_database => true)
-      @configuration = {
-        'adapter'  => 'postgresql',
-        'database' => 'my-app-db'
-      }
-
-      ActiveRecord::Base.stubs(:connection).returns(@connection)
-      ActiveRecord::Base.stubs(:establish_connection).returns(true)
-
-      $stdout, @original_stdout = StringIO.new, $stdout
-      $stderr, @original_stderr = StringIO.new, $stderr
-    end
+  module ActiveRecord
+    class PostgreSQLDBCreateTest < ActiveRecord::TestCase
+      def setup
+        @connection    = stub(create_database: true)
+        @configuration = {
+          "adapter"  => "postgresql",
+          "database" => "my-app-db"
+        }
+
+        ActiveRecord::Base.stubs(:connection).returns(@connection)
+        ActiveRecord::Base.stubs(:establish_connection).returns(true)
+
+        $stdout, @original_stdout = StringIO.new, $stdout
+        $stderr, @original_stderr = StringIO.new, $stderr
+      end
 
-    def teardown
-      $stdout, $stderr = @original_stdout, @original_stderr
-    end
+      def teardown
+        $stdout, $stderr = @original_stdout, @original_stderr
+      end
 
-    def test_establishes_connection_to_postgresql_database
-      ActiveRecord::Base.expects(:establish_connection).with(
-        'adapter'            => 'postgresql',
-        'database'           => 'postgres',
-        'schema_search_path' => 'public'
-      )
+      def test_establishes_connection_to_postgresql_database
+        ActiveRecord::Base.expects(:establish_connection).with(
+          "adapter"            => "postgresql",
+          "database"           => "postgres",
+          "schema_search_path" => "public"
+        )
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration
-    end
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration
+      end
 
-    def test_creates_database_with_default_encoding
-      @connection.expects(:create_database).
-        with('my-app-db', @configuration.merge('encoding' => 'utf8'))
+      def test_creates_database_with_default_encoding
+        @connection.expects(:create_database).
+          with("my-app-db", @configuration.merge("encoding" => "utf8"))
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration
-    end
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration
+      end
 
-    def test_creates_database_with_given_encoding
-      @connection.expects(:create_database).
-        with('my-app-db', @configuration.merge('encoding' => 'latin'))
+      def test_creates_database_with_given_encoding
+        @connection.expects(:create_database).
+          with("my-app-db", @configuration.merge("encoding" => "latin"))
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration.
-        merge('encoding' => 'latin')
-    end
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration.
+          merge("encoding" => "latin")
+      end
 
-    def test_creates_database_with_given_collation_and_ctype
-      @connection.expects(:create_database).
-        with('my-app-db', @configuration.merge('encoding' => 'utf8', 'collation' => 'ja_JP.UTF8', 'ctype' => 'ja_JP.UTF8'))
+      def test_creates_database_with_given_collation_and_ctype
+        @connection.expects(:create_database).
+          with("my-app-db", @configuration.merge("encoding" => "utf8", "collation" => "ja_JP.UTF8", "ctype" => "ja_JP.UTF8"))
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration.
-        merge('collation' => 'ja_JP.UTF8', 'ctype' => 'ja_JP.UTF8')
-    end
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration.
+          merge("collation" => "ja_JP.UTF8", "ctype" => "ja_JP.UTF8")
+      end
 
-    def test_establishes_connection_to_new_database
-      ActiveRecord::Base.expects(:establish_connection).with(@configuration)
+      def test_establishes_connection_to_new_database
+        ActiveRecord::Base.expects(:establish_connection).with(@configuration)
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration
-    end
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration
+      end
 
-    def test_db_create_with_error_prints_message
-      ActiveRecord::Base.stubs(:establish_connection).raises(Exception)
+      def test_db_create_with_error_prints_message
+        ActiveRecord::Base.stubs(:establish_connection).raises(Exception)
 
-      $stderr.stubs(:puts).returns(true)
-      $stderr.expects(:puts).
-        with("Couldn't create database for #{@configuration.inspect}")
+        $stderr.stubs(:puts).returns(true)
+        $stderr.expects(:puts).
+          with("Couldn't create database for #{@configuration.inspect}")
 
-      assert_raises(Exception) { ActiveRecord::Tasks::DatabaseTasks.create @configuration }
-    end
+        assert_raises(Exception) { ActiveRecord::Tasks::DatabaseTasks.create @configuration }
+      end
 
-    def test_when_database_created_successfully_outputs_info_to_stdout
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration
+      def test_when_database_created_successfully_outputs_info_to_stdout
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration
 
-      assert_equal $stdout.string, "Created database 'my-app-db'\n"
-    end
+        assert_equal $stdout.string, "Created database 'my-app-db'\n"
+      end
 
-    def test_create_when_database_exists_outputs_info_to_stderr
-      ActiveRecord::Base.connection.stubs(:create_database).raises(
-        ActiveRecord::Tasks::DatabaseAlreadyExists
-      )
+      def test_create_when_database_exists_outputs_info_to_stderr
+        ActiveRecord::Base.connection.stubs(:create_database).raises(
+          ActiveRecord::Tasks::DatabaseAlreadyExists
+        )
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration
 
-      assert_equal $stderr.string, "Database 'my-app-db' already exists\n"
+        assert_equal $stderr.string, "Database 'my-app-db' already exists\n"
+      end
     end
-  end
 
-  class PostgreSQLDBDropTest < ActiveRecord::TestCase
-    def setup
-      @connection    = stub(:drop_database => true)
-      @configuration = {
-        'adapter'  => 'postgresql',
-        'database' => 'my-app-db'
-      }
+    class PostgreSQLDBDropTest < ActiveRecord::TestCase
+      def setup
+        @connection    = stub(drop_database: true)
+        @configuration = {
+          "adapter"  => "postgresql",
+          "database" => "my-app-db"
+        }
 
-      ActiveRecord::Base.stubs(:connection).returns(@connection)
-      ActiveRecord::Base.stubs(:establish_connection).returns(true)
+        ActiveRecord::Base.stubs(:connection).returns(@connection)
+        ActiveRecord::Base.stubs(:establish_connection).returns(true)
 
-      $stdout, @original_stdout = StringIO.new, $stdout
-      $stderr, @original_stderr = StringIO.new, $stderr
-    end
+        $stdout, @original_stdout = StringIO.new, $stdout
+        $stderr, @original_stderr = StringIO.new, $stderr
+      end
 
-    def teardown
-      $stdout, $stderr = @original_stdout, @original_stderr
-    end
+      def teardown
+        $stdout, $stderr = @original_stdout, @original_stderr
+      end
 
-    def test_establishes_connection_to_postgresql_database
-      ActiveRecord::Base.expects(:establish_connection).with(
-        'adapter'            => 'postgresql',
-        'database'           => 'postgres',
-        'schema_search_path' => 'public'
-      )
+      def test_establishes_connection_to_postgresql_database
+        ActiveRecord::Base.expects(:establish_connection).with(
+          "adapter"            => "postgresql",
+          "database"           => "postgres",
+          "schema_search_path" => "public"
+        )
 
-      ActiveRecord::Tasks::DatabaseTasks.drop @configuration
-    end
+        ActiveRecord::Tasks::DatabaseTasks.drop @configuration
+      end
 
-    def test_drops_database
-      @connection.expects(:drop_database).with('my-app-db')
+      def test_drops_database
+        @connection.expects(:drop_database).with("my-app-db")
 
-      ActiveRecord::Tasks::DatabaseTasks.drop @configuration
-    end
+        ActiveRecord::Tasks::DatabaseTasks.drop @configuration
+      end
 
-    def test_when_database_dropped_successfully_outputs_info_to_stdout
-      ActiveRecord::Tasks::DatabaseTasks.drop @configuration
+      def test_when_database_dropped_successfully_outputs_info_to_stdout
+        ActiveRecord::Tasks::DatabaseTasks.drop @configuration
 
-      assert_equal $stdout.string, "Dropped database 'my-app-db'\n"
+        assert_equal $stdout.string, "Dropped database 'my-app-db'\n"
+      end
     end
-  end
 
-  class PostgreSQLPurgeTest < ActiveRecord::TestCase
-    def setup
-      @connection    = stub(:create_database => true, :drop_database => true)
-      @configuration = {
-        'adapter'  => 'postgresql',
-        'database' => 'my-app-db'
-      }
-
-      ActiveRecord::Base.stubs(:connection).returns(@connection)
-      ActiveRecord::Base.stubs(:clear_active_connections!).returns(true)
-      ActiveRecord::Base.stubs(:establish_connection).returns(true)
-    end
+    class PostgreSQLPurgeTest < ActiveRecord::TestCase
+      def setup
+        @connection    = stub(create_database: true, drop_database: true)
+        @configuration = {
+          "adapter"  => "postgresql",
+          "database" => "my-app-db"
+        }
 
-    def test_clears_active_connections
-      ActiveRecord::Base.expects(:clear_active_connections!)
+        ActiveRecord::Base.stubs(:connection).returns(@connection)
+        ActiveRecord::Base.stubs(:clear_active_connections!).returns(true)
+        ActiveRecord::Base.stubs(:establish_connection).returns(true)
+      end
 
-      ActiveRecord::Tasks::DatabaseTasks.purge @configuration
-    end
+      def test_clears_active_connections
+        ActiveRecord::Base.expects(:clear_active_connections!)
+
+        ActiveRecord::Tasks::DatabaseTasks.purge @configuration
+      end
 
-    def test_establishes_connection_to_postgresql_database
-      ActiveRecord::Base.expects(:establish_connection).with(
-        'adapter'            => 'postgresql',
-        'database'           => 'postgres',
-        'schema_search_path' => 'public'
-      )
+      def test_establishes_connection_to_postgresql_database
+        ActiveRecord::Base.expects(:establish_connection).with(
+          "adapter"            => "postgresql",
+          "database"           => "postgres",
+          "schema_search_path" => "public"
+        )
 
-      ActiveRecord::Tasks::DatabaseTasks.purge @configuration
-    end
+        ActiveRecord::Tasks::DatabaseTasks.purge @configuration
+      end
 
-    def test_drops_database
-      @connection.expects(:drop_database).with('my-app-db')
+      def test_drops_database
+        @connection.expects(:drop_database).with("my-app-db")
 
-      ActiveRecord::Tasks::DatabaseTasks.purge @configuration
-    end
+        ActiveRecord::Tasks::DatabaseTasks.purge @configuration
+      end
 
-    def test_creates_database
-      @connection.expects(:create_database).
-        with('my-app-db', @configuration.merge('encoding' => 'utf8'))
+      def test_creates_database
+        @connection.expects(:create_database).
+          with("my-app-db", @configuration.merge("encoding" => "utf8"))
 
-      ActiveRecord::Tasks::DatabaseTasks.purge @configuration
-    end
+        ActiveRecord::Tasks::DatabaseTasks.purge @configuration
+      end
 
-    def test_establishes_connection
-      ActiveRecord::Base.expects(:establish_connection).with(@configuration)
+      def test_establishes_connection
+        ActiveRecord::Base.expects(:establish_connection).with(@configuration)
 
-      ActiveRecord::Tasks::DatabaseTasks.purge @configuration
+        ActiveRecord::Tasks::DatabaseTasks.purge @configuration
+      end
     end
-  end
 
-  class PostgreSQLDBCharsetTest < ActiveRecord::TestCase
-    def setup
-      @connection    = stub(:create_database => true)
-      @configuration = {
-        'adapter'  => 'postgresql',
-        'database' => 'my-app-db'
-      }
+    class PostgreSQLDBCharsetTest < ActiveRecord::TestCase
+      def setup
+        @connection    = stub(create_database: true)
+        @configuration = {
+          "adapter"  => "postgresql",
+          "database" => "my-app-db"
+        }
 
-      ActiveRecord::Base.stubs(:connection).returns(@connection)
-      ActiveRecord::Base.stubs(:establish_connection).returns(true)
-    end
+        ActiveRecord::Base.stubs(:connection).returns(@connection)
+        ActiveRecord::Base.stubs(:establish_connection).returns(true)
+      end
 
-    def test_db_retrieves_charset
-      @connection.expects(:encoding)
-      ActiveRecord::Tasks::DatabaseTasks.charset @configuration
+      def test_db_retrieves_charset
+        @connection.expects(:encoding)
+        ActiveRecord::Tasks::DatabaseTasks.charset @configuration
+      end
     end
-  end
 
-  class PostgreSQLDBCollationTest < ActiveRecord::TestCase
-    def setup
-      @connection    = stub(:create_database => true)
-      @configuration = {
-        'adapter'  => 'postgresql',
-        'database' => 'my-app-db'
-      }
+    class PostgreSQLDBCollationTest < ActiveRecord::TestCase
+      def setup
+        @connection    = stub(create_database: true)
+        @configuration = {
+          "adapter"  => "postgresql",
+          "database" => "my-app-db"
+        }
 
-      ActiveRecord::Base.stubs(:connection).returns(@connection)
-      ActiveRecord::Base.stubs(:establish_connection).returns(true)
-    end
+        ActiveRecord::Base.stubs(:connection).returns(@connection)
+        ActiveRecord::Base.stubs(:establish_connection).returns(true)
+      end
 
-    def test_db_retrieves_collation
-      @connection.expects(:collation)
-      ActiveRecord::Tasks::DatabaseTasks.collation @configuration
+      def test_db_retrieves_collation
+        @connection.expects(:collation)
+        ActiveRecord::Tasks::DatabaseTasks.collation @configuration
+      end
     end
-  end
 
-  class PostgreSQLStructureDumpTest < ActiveRecord::TestCase
-    def setup
-      @connection    = stub(:structure_dump => true)
-      @configuration = {
-        'adapter'  => 'postgresql',
-        'database' => 'my-app-db'
-      }
-      @filename = "awesome-file.sql"
-
-      ActiveRecord::Base.stubs(:connection).returns(@connection)
-      ActiveRecord::Base.stubs(:establish_connection).returns(true)
-      Kernel.stubs(:system)
-      File.stubs(:open)
-    end
+    class PostgreSQLStructureDumpTest < ActiveRecord::TestCase
+      def setup
+        @connection    = stub(structure_dump: true)
+        @configuration = {
+          "adapter"  => "postgresql",
+          "database" => "my-app-db"
+        }
+        @filename = "awesome-file.sql"
 
-    def test_structure_dump
-      Kernel.expects(:system).with('pg_dump', '-s', '-x', '-O', '-f', @filename, 'my-app-db').returns(true)
+        ActiveRecord::Base.stubs(:connection).returns(@connection)
+        ActiveRecord::Base.stubs(:establish_connection).returns(true)
+        Kernel.stubs(:system)
+        File.stubs(:open)
+      end
 
-      ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, @filename)
-    end
+      def test_structure_dump
+        Kernel.expects(:system).with("pg_dump", "-s", "-x", "-O", "-f", @filename, "my-app-db").returns(true)
 
-    def test_structure_dump_with_schema_search_path
-      @configuration['schema_search_path'] = 'foo,bar'
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, @filename)
+      end
 
-      Kernel.expects(:system).with('pg_dump', '-s', '-x', '-O', '-f', @filename, '--schema=foo', '--schema=bar', 'my-app-db').returns(true)
+      def test_structure_dump_with_schema_search_path
+        @configuration["schema_search_path"] = "foo,bar"
 
-      ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, @filename)
-    end
+        Kernel.expects(:system).with("pg_dump", "-s", "-x", "-O", "-f", @filename, "--schema=foo", "--schema=bar", "my-app-db").returns(true)
 
-    def test_structure_dump_with_schema_search_path_and_dump_schemas_all
-      @configuration['schema_search_path'] = 'foo,bar'
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, @filename)
+      end
 
-      Kernel.expects(:system).with("pg_dump", '-s', '-x', '-O', '-f', @filename,  'my-app-db').returns(true)
+      def test_structure_dump_with_schema_search_path_and_dump_schemas_all
+        @configuration["schema_search_path"] = "foo,bar"
 
-      with_dump_schemas(:all) do
-        ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, @filename)
+        Kernel.expects(:system).with("pg_dump", "-s", "-x", "-O", "-f", @filename,  "my-app-db").returns(true)
+
+        with_dump_schemas(:all) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, @filename)
+        end
       end
-    end
 
-    def test_structure_dump_with_dump_schemas_string
-      Kernel.expects(:system).with("pg_dump", '-s', '-x', '-O', '-f', @filename, '--schema=foo', '--schema=bar', "my-app-db").returns(true)
+      def test_structure_dump_with_dump_schemas_string
+        Kernel.expects(:system).with("pg_dump", "-s", "-x", "-O", "-f", @filename, "--schema=foo", "--schema=bar", "my-app-db").returns(true)
 
-      with_dump_schemas('foo,bar') do
-        ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, @filename)
+        with_dump_schemas("foo,bar") do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, @filename)
+        end
       end
-    end
 
-    private
+      private
 
-    def with_dump_schemas(value, &block)
-      old_dump_schemas = ActiveRecord::Base.dump_schemas
-      ActiveRecord::Base.dump_schemas = value
-      yield
-    ensure
-      ActiveRecord::Base.dump_schemas = old_dump_schemas
+        def with_dump_schemas(value, &block)
+          old_dump_schemas = ActiveRecord::Base.dump_schemas
+          ActiveRecord::Base.dump_schemas = value
+          yield
+        ensure
+          ActiveRecord::Base.dump_schemas = old_dump_schemas
+        end
     end
-  end
 
-  class PostgreSQLStructureLoadTest < ActiveRecord::TestCase
-    def setup
-      @connection    = stub
-      @configuration = {
-        'adapter'  => 'postgresql',
-        'database' => 'my-app-db'
-      }
-
-      ActiveRecord::Base.stubs(:connection).returns(@connection)
-      ActiveRecord::Base.stubs(:establish_connection).returns(true)
-      Kernel.stubs(:system)
-    end
+    class PostgreSQLStructureLoadTest < ActiveRecord::TestCase
+      def setup
+        @connection    = stub
+        @configuration = {
+          "adapter"  => "postgresql",
+          "database" => "my-app-db"
+        }
 
-    def test_structure_load
-      filename = "awesome-file.sql"
-      Kernel.expects(:system).with('psql', '-v', 'ON_ERROR_STOP=1', '-q', '-f', filename, @configuration['database']).returns(true)
+        ActiveRecord::Base.stubs(:connection).returns(@connection)
+        ActiveRecord::Base.stubs(:establish_connection).returns(true)
+        Kernel.stubs(:system)
+      end
 
-      ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
-    end
+      def test_structure_load
+        filename = "awesome-file.sql"
+        Kernel.expects(:system).with("psql", "-v", "ON_ERROR_STOP=1", "-q", "-f", filename, @configuration["database"]).returns(true)
 
-    def test_structure_load_accepts_path_with_spaces
-      filename = "awesome file.sql"
-      Kernel.expects(:system).with('psql', '-v', 'ON_ERROR_STOP=1', '-q', '-f', filename, @configuration['database']).returns(true)
+        ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
+      end
+
+      def test_structure_load_accepts_path_with_spaces
+        filename = "awesome file.sql"
+        Kernel.expects(:system).with("psql", "-v", "ON_ERROR_STOP=1", "-q", "-f", filename, @configuration["database"]).returns(true)
 
-      ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
+        ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
+      end
     end
   end
 end
-end
diff --git a/activerecord/test/cases/tasks/sqlite_rake_test.rb b/activerecord/test/cases/tasks/sqlite_rake_test.rb
index 4be03c7f61..141048bfe7 100644
--- a/activerecord/test/cases/tasks/sqlite_rake_test.rb
+++ b/activerecord/test/cases/tasks/sqlite_rake_test.rb
@@ -1,220 +1,220 @@
-require 'cases/helper'
-require 'active_record/tasks/database_tasks'
-require 'pathname'
+require "cases/helper"
+require "active_record/tasks/database_tasks"
+require "pathname"
 
 if current_adapter?(:SQLite3Adapter)
-module ActiveRecord
-  class SqliteDBCreateTest < ActiveRecord::TestCase
-    def setup
-      @database      = 'db_create.sqlite3'
-      @connection    = stub :connection
-      @configuration = {
-        'adapter'  => 'sqlite3',
-        'database' => @database
-      }
-
-      File.stubs(:exist?).returns(false)
-      ActiveRecord::Base.stubs(:connection).returns(@connection)
-      ActiveRecord::Base.stubs(:establish_connection).returns(true)
-
-      $stdout, @original_stdout = StringIO.new, $stdout
-      $stderr, @original_stderr = StringIO.new, $stderr
-    end
+  module ActiveRecord
+    class SqliteDBCreateTest < ActiveRecord::TestCase
+      def setup
+        @database      = "db_create.sqlite3"
+        @connection    = stub :connection
+        @configuration = {
+          "adapter"  => "sqlite3",
+          "database" => @database
+        }
+
+        File.stubs(:exist?).returns(false)
+        ActiveRecord::Base.stubs(:connection).returns(@connection)
+        ActiveRecord::Base.stubs(:establish_connection).returns(true)
+
+        $stdout, @original_stdout = StringIO.new, $stdout
+        $stderr, @original_stderr = StringIO.new, $stderr
+      end
 
-    def teardown
-      $stdout, $stderr = @original_stdout, @original_stderr
-    end
+      def teardown
+        $stdout, $stderr = @original_stdout, @original_stderr
+      end
 
-    def test_db_checks_database_exists
-      File.expects(:exist?).with(@database).returns(false)
+      def test_db_checks_database_exists
+        File.expects(:exist?).with(@database).returns(false)
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration, '/rails/root'
-    end
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
+      end
 
-    def test_when_db_created_successfully_outputs_info_to_stdout
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration, '/rails/root'
+      def test_when_db_created_successfully_outputs_info_to_stdout
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
 
-      assert_equal $stdout.string, "Created database '#{@database}'\n"
-    end
+        assert_equal $stdout.string, "Created database '#{@database}'\n"
+      end
 
-    def test_db_create_when_file_exists
-      File.stubs(:exist?).returns(true)
+      def test_db_create_when_file_exists
+        File.stubs(:exist?).returns(true)
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration, '/rails/root'
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
 
-      assert_equal $stderr.string, "Database '#{@database}' already exists\n"
-    end
+        assert_equal $stderr.string, "Database '#{@database}' already exists\n"
+      end
 
-    def test_db_create_with_file_does_nothing
-      File.stubs(:exist?).returns(true)
-      $stderr.stubs(:puts).returns(nil)
+      def test_db_create_with_file_does_nothing
+        File.stubs(:exist?).returns(true)
+        $stderr.stubs(:puts).returns(nil)
 
-      ActiveRecord::Base.expects(:establish_connection).never
+        ActiveRecord::Base.expects(:establish_connection).never
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration, '/rails/root'
-    end
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
+      end
 
-    def test_db_create_establishes_a_connection
-      ActiveRecord::Base.expects(:establish_connection).with(@configuration)
+      def test_db_create_establishes_a_connection
+        ActiveRecord::Base.expects(:establish_connection).with(@configuration)
 
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration, '/rails/root'
-    end
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
+      end
 
-    def test_db_create_with_error_prints_message
-      ActiveRecord::Base.stubs(:establish_connection).raises(Exception)
+      def test_db_create_with_error_prints_message
+        ActiveRecord::Base.stubs(:establish_connection).raises(Exception)
 
-      $stderr.stubs(:puts).returns(true)
-      $stderr.expects(:puts).
-        with("Couldn't create database for #{@configuration.inspect}")
+        $stderr.stubs(:puts).returns(true)
+        $stderr.expects(:puts).
+          with("Couldn't create database for #{@configuration.inspect}")
 
-      assert_raises(Exception) { ActiveRecord::Tasks::DatabaseTasks.create @configuration, '/rails/root' }
+        assert_raises(Exception) { ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root" }
+      end
     end
-  end
 
-  class SqliteDBDropTest < ActiveRecord::TestCase
-    def setup
-      @database      = "db_create.sqlite3"
-      @path          = stub(:to_s => '/absolute/path', :absolute? => true)
-      @configuration = {
-        'adapter'  => 'sqlite3',
-        'database' => @database
-      }
-
-      Pathname.stubs(:new).returns(@path)
-      File.stubs(:join).returns('/former/relative/path')
-      FileUtils.stubs(:rm).returns(true)
-
-      $stdout, @original_stdout = StringIO.new, $stdout
-      $stderr, @original_stderr = StringIO.new, $stderr
-    end
+    class SqliteDBDropTest < ActiveRecord::TestCase
+      def setup
+        @database      = "db_create.sqlite3"
+        @path          = stub(to_s: "/absolute/path", absolute?: true)
+        @configuration = {
+          "adapter"  => "sqlite3",
+          "database" => @database
+        }
 
-    def teardown
-      $stdout, $stderr = @original_stdout, @original_stderr
-    end
+        Pathname.stubs(:new).returns(@path)
+        File.stubs(:join).returns("/former/relative/path")
+        FileUtils.stubs(:rm).returns(true)
 
-    def test_creates_path_from_database
-      Pathname.expects(:new).with(@database).returns(@path)
+        $stdout, @original_stdout = StringIO.new, $stdout
+        $stderr, @original_stderr = StringIO.new, $stderr
+      end
 
-      ActiveRecord::Tasks::DatabaseTasks.drop @configuration, '/rails/root'
-    end
+      def teardown
+        $stdout, $stderr = @original_stdout, @original_stderr
+      end
 
-    def test_removes_file_with_absolute_path
-      File.stubs(:exist?).returns(true)
-      @path.stubs(:absolute?).returns(true)
+      def test_creates_path_from_database
+        Pathname.expects(:new).with(@database).returns(@path)
 
-      FileUtils.expects(:rm).with('/absolute/path')
+        ActiveRecord::Tasks::DatabaseTasks.drop @configuration, "/rails/root"
+      end
 
-      ActiveRecord::Tasks::DatabaseTasks.drop @configuration, '/rails/root'
-    end
+      def test_removes_file_with_absolute_path
+        File.stubs(:exist?).returns(true)
+        @path.stubs(:absolute?).returns(true)
 
-    def test_generates_absolute_path_with_given_root
-      @path.stubs(:absolute?).returns(false)
+        FileUtils.expects(:rm).with("/absolute/path")
 
-      File.expects(:join).with('/rails/root', @path).
-        returns('/former/relative/path')
+        ActiveRecord::Tasks::DatabaseTasks.drop @configuration, "/rails/root"
+      end
 
-      ActiveRecord::Tasks::DatabaseTasks.drop @configuration, '/rails/root'
-    end
+      def test_generates_absolute_path_with_given_root
+        @path.stubs(:absolute?).returns(false)
 
-    def test_removes_file_with_relative_path
-      File.stubs(:exist?).returns(true)
-      @path.stubs(:absolute?).returns(false)
+        File.expects(:join).with("/rails/root", @path).
+          returns("/former/relative/path")
 
-      FileUtils.expects(:rm).with('/former/relative/path')
+        ActiveRecord::Tasks::DatabaseTasks.drop @configuration, "/rails/root"
+      end
 
-      ActiveRecord::Tasks::DatabaseTasks.drop @configuration, '/rails/root'
-    end
+      def test_removes_file_with_relative_path
+        File.stubs(:exist?).returns(true)
+        @path.stubs(:absolute?).returns(false)
 
-    def test_when_db_dropped_successfully_outputs_info_to_stdout
-      ActiveRecord::Tasks::DatabaseTasks.drop @configuration, '/rails/root'
+        FileUtils.expects(:rm).with("/former/relative/path")
 
-      assert_equal $stdout.string, "Dropped database '#{@database}'\n"
-    end
-  end
+        ActiveRecord::Tasks::DatabaseTasks.drop @configuration, "/rails/root"
+      end
 
-  class SqliteDBCharsetTest < ActiveRecord::TestCase
-    def setup
-      @database      = 'db_create.sqlite3'
-      @connection    = stub :connection
-      @configuration = {
-        'adapter'  => 'sqlite3',
-        'database' => @database
-      }
-
-      File.stubs(:exist?).returns(false)
-      ActiveRecord::Base.stubs(:connection).returns(@connection)
-      ActiveRecord::Base.stubs(:establish_connection).returns(true)
-    end
+      def test_when_db_dropped_successfully_outputs_info_to_stdout
+        ActiveRecord::Tasks::DatabaseTasks.drop @configuration, "/rails/root"
 
-    def test_db_retrieves_charset
-      @connection.expects(:encoding)
-      ActiveRecord::Tasks::DatabaseTasks.charset @configuration, '/rails/root'
+        assert_equal $stdout.string, "Dropped database '#{@database}'\n"
+      end
     end
-  end
 
-  class SqliteDBCollationTest < ActiveRecord::TestCase
-    def setup
-      @database      = 'db_create.sqlite3'
-      @connection    = stub :connection
-      @configuration = {
-        'adapter'  => 'sqlite3',
-        'database' => @database
-      }
-
-      File.stubs(:exist?).returns(false)
-      ActiveRecord::Base.stubs(:connection).returns(@connection)
-      ActiveRecord::Base.stubs(:establish_connection).returns(true)
-    end
+    class SqliteDBCharsetTest < ActiveRecord::TestCase
+      def setup
+        @database      = "db_create.sqlite3"
+        @connection    = stub :connection
+        @configuration = {
+          "adapter"  => "sqlite3",
+          "database" => @database
+        }
 
-    def test_db_retrieves_collation
-      assert_raise NoMethodError do
-        ActiveRecord::Tasks::DatabaseTasks.collation @configuration, '/rails/root'
+        File.stubs(:exist?).returns(false)
+        ActiveRecord::Base.stubs(:connection).returns(@connection)
+        ActiveRecord::Base.stubs(:establish_connection).returns(true)
       end
-    end
-  end
 
-  class SqliteStructureDumpTest < ActiveRecord::TestCase
-    def setup
-      @database      = "db_create.sqlite3"
-      @configuration = {
-        'adapter'  => 'sqlite3',
-        'database' => @database
-      }
+      def test_db_retrieves_charset
+        @connection.expects(:encoding)
+        ActiveRecord::Tasks::DatabaseTasks.charset @configuration, "/rails/root"
+      end
     end
 
-    def test_structure_dump
-      dbfile   = @database
-      filename = "awesome-file.sql"
+    class SqliteDBCollationTest < ActiveRecord::TestCase
+      def setup
+        @database      = "db_create.sqlite3"
+        @connection    = stub :connection
+        @configuration = {
+          "adapter"  => "sqlite3",
+          "database" => @database
+        }
 
-      ActiveRecord::Tasks::DatabaseTasks.structure_dump @configuration, filename, '/rails/root'
-      assert File.exist?(dbfile)
-      assert File.exist?(filename)
-    ensure
-      FileUtils.rm_f(filename)
-      FileUtils.rm_f(dbfile)
+        File.stubs(:exist?).returns(false)
+        ActiveRecord::Base.stubs(:connection).returns(@connection)
+        ActiveRecord::Base.stubs(:establish_connection).returns(true)
+      end
+
+      def test_db_retrieves_collation
+        assert_raise NoMethodError do
+          ActiveRecord::Tasks::DatabaseTasks.collation @configuration, "/rails/root"
+        end
+      end
     end
-  end
 
-  class SqliteStructureLoadTest < ActiveRecord::TestCase
-    def setup
-      @database      = "db_create.sqlite3"
-      @configuration = {
-        'adapter'  => 'sqlite3',
-        'database' => @database
-      }
+    class SqliteStructureDumpTest < ActiveRecord::TestCase
+      def setup
+        @database      = "db_create.sqlite3"
+        @configuration = {
+          "adapter"  => "sqlite3",
+          "database" => @database
+        }
+      end
+
+      def test_structure_dump
+        dbfile   = @database
+        filename = "awesome-file.sql"
+
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump @configuration, filename, "/rails/root"
+        assert File.exist?(dbfile)
+        assert File.exist?(filename)
+      ensure
+        FileUtils.rm_f(filename)
+        FileUtils.rm_f(dbfile)
+      end
     end
 
-    def test_structure_load
-      dbfile   = @database
-      filename = "awesome-file.sql"
+    class SqliteStructureLoadTest < ActiveRecord::TestCase
+      def setup
+        @database      = "db_create.sqlite3"
+        @configuration = {
+          "adapter"  => "sqlite3",
+          "database" => @database
+        }
+      end
+
+      def test_structure_load
+        dbfile   = @database
+        filename = "awesome-file.sql"
 
-      open(filename, 'w') { |f| f.puts("select datetime('now', 'localtime');") }
-      ActiveRecord::Tasks::DatabaseTasks.structure_load @configuration, filename, '/rails/root'
-      assert File.exist?(dbfile)
-    ensure
-      FileUtils.rm_f(filename)
-      FileUtils.rm_f(dbfile)
+        open(filename, "w") { |f| f.puts("select datetime('now', 'localtime');") }
+        ActiveRecord::Tasks::DatabaseTasks.structure_load @configuration, filename, "/rails/root"
+        assert File.exist?(dbfile)
+      ensure
+        FileUtils.rm_f(filename)
+        FileUtils.rm_f(dbfile)
+      end
     end
   end
 end
-end