ibm_db 3.0.5-x86-mingw32 → 5.0.5-x86-mingw32

data/test/cases/secure_token_test.rb

@@ -0,0 +1,32 @@
+require 'cases/helper'
+require 'models/user'
+
+class SecureTokenTest < ActiveRecord::TestCase
+  setup do
+    @user = User.new
+  end
+
+  def test_token_values_are_generated_for_specified_attributes_and_persisted_on_save
+    @user.save
+    assert_not_nil @user.token
+    assert_not_nil @user.auth_token
+  end
+
+  def test_regenerating_the_secure_token
+    @user.save
+    old_token = @user.token
+    old_auth_token = @user.auth_token
+    @user.regenerate_token
+    @user.regenerate_auth_token
+
+    assert_not_equal @user.token, old_token
+    assert_not_equal @user.auth_token, old_auth_token
+  end
+
+  def test_token_value_not_overwritten_when_present
+    @user.token = "custom-secure-token"
+    @user.save
+
+    assert_equal @user.token, "custom-secure-token"
+  end
+end

data/test/cases/serialization_test.rb

@@ -8,7 +8,7 @@ require 'models/post'
 class SerializationTest < ActiveRecord::TestCase
   fixtures :books
 
-  FORMATS = [ :xml, :json ]
+  FORMATS = [ :json ]
 
   def setup
     @contact_attributes = {

data/test/cases/serialized_attribute_test.rb

@@ -22,12 +22,6 @@ class SerializedAttributeTest < ActiveRecord::TestCase
     end
   end
 
-  def test_list_of_serialized_attributes
-    assert_deprecated do
-      assert_equal %w(content), Topic.serialized_attributes.keys
-    end
-  end
-
   def test_serialized_attribute
     Topic.serialize("content", MyObject)
 
@@ -265,6 +259,12 @@ class SerializedAttributeTest < ActiveRecord::TestCase
     assert_not topic.content_changed?
   end
 
+  def test_classes_without_no_arg_constructors_are_not_supported
+    assert_raises(ArgumentError) do
+      Topic.serialize(:content, Regexp)
+    end
+  end
+
   def test_newly_emptied_serialized_hash_is_changed
     Topic.serialize(:content, Hash)
     topic = Topic.create(content: { "things" => "stuff" })
@@ -274,4 +274,91 @@ class SerializedAttributeTest < ActiveRecord::TestCase
 
     assert_equal({}, topic.content)
   end
+
+  def test_values_cast_from_nil_are_persisted_as_nil
+    # This is required to fulfil the following contract, which must be universally
+    # true in Active Record:
+    #
+    # model.attribute = value
+    # assert_equal model.attribute, model.tap(&:save).reload.attribute
+    Topic.serialize(:content, Hash)
+    topic = Topic.create!(content: {})
+    topic2 = Topic.create!(content: nil)
+
+    assert_equal [topic, topic2], Topic.where(content: nil)
+  end
+
+  def test_nil_is_always_persisted_as_null
+    Topic.serialize(:content, Hash)
+
+    topic = Topic.create!(content: { foo: "bar" })
+    topic.update_attribute :content, nil
+    assert_equal [topic], Topic.where(content: nil)
+  end
+
+  def test_mutation_detection_does_not_double_serialize
+    coder = Object.new
+    def coder.dump(value)
+      return if value.nil?
+      value + " encoded"
+    end
+    def coder.load(value)
+      return if value.nil?
+      value.gsub(" encoded", "")
+    end
+    type = Class.new(ActiveModel::Type::Value) do
+      include ActiveModel::Type::Helpers::Mutable
+
+      def serialize(value)
+        return if value.nil?
+        value + " serialized"
+      end
+
+      def deserialize(value)
+        return if value.nil?
+        value.gsub(" serialized", "")
+      end
+    end.new
+    model = Class.new(Topic) do
+      attribute :foo, type
+      serialize :foo, coder
+    end
+
+    topic = model.create!(foo: "bar")
+    topic.foo
+    refute topic.changed?
+  end
+end
+
+class ThreadedSerializedAttributeTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+  fixtures :topics
+
+  def test_serialized_attribute_works_under_concurrent_initial_access
+    model = Topic.dup
+
+    topic = model.last
+    topic.update group: "1"
+
+    model.serialize :group, JSON
+    model.reset_column_information
+
+    # This isn't strictly necessary for the test, but a little bit of
+    # knowledge of internals allows us to make failures far more likely.
+    model.define_singleton_method(:define_attribute) do |*args|
+      Thread.pass
+      super(*args)
+    end
+
+    threads = 4.times.map do
+      Thread.new do
+        topic.reload.group
+      end
+    end
+
+    # All the threads should retrieve the value knowing it is JSON, and
+    # thus decode it. If this fails, some threads will instead see the
+    # raw string ("1"), or raise an exception.
+    assert_equal [1] * threads.size, threads.map(&:value)
+  end
 end

data/test/cases/statement_cache_test.rb

@@ -94,5 +94,43 @@ module ActiveRecord
       additional_books = cache.execute([], Book, Book.connection)
       assert first_books != additional_books
     end
+
+    def test_unprepared_statements_dont_share_a_cache_with_prepared_statements
+      Book.create(name: "my book")
+      Book.create(name: "my other book")
+
+      book = Book.find_by(name: "my book")
+      other_book = Book.connection.unprepared_statement do
+        Book.find_by(name: "my other book")
+      end
+
+      refute_equal book, other_book
+    end
+
+    def test_find_by_does_not_use_statement_cache_if_table_name_is_changed
+      book = Book.create(name: "my book")
+
+      Book.find_by(name: book.name) # warming the statement cache.
+
+      # changing the table name should change the query that is not cached.
+      Book.table_name = :birds
+      assert_nil Book.find_by(name: "my book")
+    ensure
+      Book.table_name = :books
+    end
+
+    def test_find_does_not_use_statement_cache_if_table_name_is_changed
+      book = Book.create(name: "my book")
+
+      Book.find(book.id) # warming the statement cache.
+
+      # changing the table name should change the query that is not cached.
+      Book.table_name = :birds
+      assert_raise ActiveRecord::RecordNotFound do
+        Book.find(book.id)
+      end
+    ensure
+      Book.table_name = :books
+    end
   end
 end

data/test/cases/store_test.rb

@@ -104,7 +104,7 @@ class StoreTest < ActiveRecord::TestCase
     assert_equal true,      user.settings.instance_of?(ActiveSupport::HashWithIndifferentAccess)
   end
 
-  test "convert store attributes from any format other than Hash or HashWithIndifferent access losing the data" do
+  test "convert store attributes from any format other than Hash or HashWithIndifferentAccess losing the data" do
     @john.json_data = "somedata"
     @john.height = 'low'
     assert_equal true, @john.json_data.instance_of?(ActiveSupport::HashWithIndifferentAccess)
@@ -177,6 +177,7 @@ class StoreTest < ActiveRecord::TestCase
     assert_equal [:color], first_model.stored_attributes[:data]
     assert_equal [:color, :width, :height], second_model.stored_attributes[:data]
     assert_equal [:color, :area, :volume], third_model.stored_attributes[:data]
+    assert_equal [:color], first_model.stored_attributes[:data]
   end
 
   test "YAML coder initializes the store when a Nil value is given" do

data/test/cases/suppressor_test.rb

@@ -0,0 +1,63 @@
+require 'cases/helper'
+require 'models/notification'
+require 'models/user'
+
+class SuppressorTest < ActiveRecord::TestCase
+  def test_suppresses_create
+    assert_no_difference -> { Notification.count } do
+      Notification.suppress do
+        Notification.create
+        Notification.create!
+        Notification.new.save
+        Notification.new.save!
+      end
+    end
+  end
+
+  def test_suppresses_update
+    user = User.create! token: 'asdf'
+
+    User.suppress do
+      user.update token: 'ghjkl'
+      assert_equal 'asdf', user.reload.token
+
+      user.update! token: 'zxcvbnm'
+      assert_equal 'asdf', user.reload.token
+
+      user.token = 'qwerty'
+      user.save
+      assert_equal 'asdf', user.reload.token
+
+      user.token = 'uiop'
+      user.save!
+      assert_equal 'asdf', user.reload.token
+    end
+  end
+
+  def test_suppresses_create_in_callback
+    assert_difference -> { User.count } do
+      assert_no_difference -> { Notification.count } do
+        Notification.suppress { UserWithNotification.create! }
+      end
+    end
+  end
+
+  def test_resumes_saving_after_suppression_complete
+    Notification.suppress { UserWithNotification.create! }
+
+    assert_difference -> { Notification.count } do
+      Notification.create!(message: "New Comment")
+    end
+  end
+
+  def test_suppresses_validations_on_create
+    assert_no_difference -> { Notification.count } do
+      Notification.suppress do
+        User.create
+        User.create!
+        User.new.save
+        User.new.save!
+      end
+    end
+  end
+end

data/test/cases/tasks/database_tasks_test.rb

@@ -8,16 +8,50 @@ module ActiveRecord
       ActiveRecord::Tasks::MySQLDatabaseTasks.stubs(:new).returns @mysql_tasks
       ActiveRecord::Tasks::PostgreSQLDatabaseTasks.stubs(:new).returns @postgresql_tasks
       ActiveRecord::Tasks::SQLiteDatabaseTasks.stubs(:new).returns @sqlite_tasks
+
+      $stdout, @original_stdout = StringIO.new, $stdout
+      $stderr, @original_stderr = StringIO.new, $stderr
+    end
+
+    def teardown
+      $stdout, $stderr = @original_stdout, @original_stderr
     end
   end
 
   ADAPTERS_TASKS = {
-    mysql:      :mysql_tasks,
     mysql2:     :mysql_tasks,
     postgresql: :postgresql_tasks,
     sqlite3:    :sqlite_tasks
   }
 
+  class DatabaseTasksUtilsTask< ActiveRecord::TestCase
+    def test_raises_an_error_when_called_with_protected_environment
+      ActiveRecord::Migrator.stubs(:current_version).returns(1)
+
+      protected_environments = ActiveRecord::Base.protected_environments.dup
+      current_env            = ActiveRecord::Migrator.current_environment
+      assert !protected_environments.include?(current_env)
+      # Assert no error
+      ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!
+
+      ActiveRecord::Base.protected_environments << current_env
+      assert_raise(ActiveRecord::ProtectedEnvironmentError) do
+        ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!
+      end
+    ensure
+      ActiveRecord::Base.protected_environments = protected_environments
+    end
+
+    def test_raises_an_error_if_no_migrations_have_been_made
+      ActiveRecord::InternalMetadata.stubs(:table_exists?).returns(false)
+      ActiveRecord::Migrator.stubs(:current_version).returns(1)
+
+      assert_raise(ActiveRecord::NoEnvironmentInSchemaError) do
+        ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!
+      end
+    end
+  end
+
   class DatabaseTasksRegisterTask < ActiveRecord::TestCase
     def test_register_task
       klazz = Class.new do
@@ -134,21 +168,25 @@ module ActiveRecord
         with('database' => 'dev-db')
       ActiveRecord::Tasks::DatabaseTasks.expects(:create).
         with('database' => 'test-db')
-      ENV.expects(:[]).with('RAILS_ENV').returns(nil)
 
       ActiveRecord::Tasks::DatabaseTasks.create_current(
         ActiveSupport::StringInquirer.new('development')
       )
     end
 
-    def test_creates_only_development_database_when_rails_env_is_development
+    def test_creates_test_and_development_databases_when_rails_env_is_development
+      old_env = ENV['RAILS_ENV']
+      ENV['RAILS_ENV'] = 'development'
       ActiveRecord::Tasks::DatabaseTasks.expects(:create).
         with('database' => 'dev-db')
-      ENV.expects(:[]).with('RAILS_ENV').returns('development')
+      ActiveRecord::Tasks::DatabaseTasks.expects(:create).
+        with('database' => 'test-db')
 
       ActiveRecord::Tasks::DatabaseTasks.create_current(
         ActiveSupport::StringInquirer.new('development')
       )
+    ensure
+      ENV['RAILS_ENV'] = old_env
     end
 
     def test_establishes_connection_for_the_given_environment
@@ -255,38 +293,64 @@ module ActiveRecord
         with('database' => 'dev-db')
       ActiveRecord::Tasks::DatabaseTasks.expects(:drop).
         with('database' => 'test-db')
-      ENV.expects(:[]).with('RAILS_ENV').returns(nil)
 
       ActiveRecord::Tasks::DatabaseTasks.drop_current(
         ActiveSupport::StringInquirer.new('development')
       )
     end
 
-    def test_drops_only_development_database_when_rails_env_is_development
+    def test_drops_testand_development_databases_when_rails_env_is_development
+      old_env = ENV['RAILS_ENV']
+      ENV['RAILS_ENV'] = 'development'
       ActiveRecord::Tasks::DatabaseTasks.expects(:drop).
         with('database' => 'dev-db')
-      ENV.expects(:[]).with('RAILS_ENV').returns('development')
+      ActiveRecord::Tasks::DatabaseTasks.expects(:drop).
+        with('database' => 'test-db')
 
       ActiveRecord::Tasks::DatabaseTasks.drop_current(
         ActiveSupport::StringInquirer.new('development')
       )
+    ensure
+      ENV['RAILS_ENV'] = old_env
     end
   end
 
   class DatabaseTasksMigrateTest < ActiveRecord::TestCase
+    self.use_transactional_tests = false
+
+    def setup
+      ActiveRecord::Tasks::DatabaseTasks.migrations_paths = 'custom/path'
+    end
+
+    def teardown
+      ActiveRecord::Tasks::DatabaseTasks.migrations_paths = nil
+    end
+
     def test_migrate_receives_correct_env_vars
       verbose, version = ENV['VERBOSE'], ENV['VERSION']
 
-      ActiveRecord::Tasks::DatabaseTasks.migrations_paths = 'custom/path'
       ENV['VERBOSE'] = 'false'
       ENV['VERSION'] = '4'
 
       ActiveRecord::Migrator.expects(:migrate).with('custom/path', 4)
       ActiveRecord::Tasks::DatabaseTasks.migrate
     ensure
-      ActiveRecord::Tasks::DatabaseTasks.migrations_paths = nil
       ENV['VERBOSE'], ENV['VERSION'] = verbose, version
     end
+
+    def test_migrate_raise_error_on_empty_version
+      version = ENV["VERSION"]
+      ENV["VERSION"] = ""
+      e = assert_raise(RuntimeError) { ActiveRecord::Tasks::DatabaseTasks.migrate }
+      assert_equal "Empty VERSION provided", e.message
+    ensure
+      ENV["VERSION"] = version
+    end
+
+    def test_migrate_clears_schema_cache_afterward
+      ActiveRecord::Base.expects(:clear_cache!)
+      ActiveRecord::Tasks::DatabaseTasks.migrate
+    end
   end
 
   class DatabaseTasksPurgeTest < ActiveRecord::TestCase

data/test/cases/tasks/mysql_rake_test.rb

@@ -1,48 +1,49 @@
 require 'cases/helper'
+require 'active_record/tasks/database_tasks'
 
-if current_adapter?(:MysqlAdapter, :Mysql2Adapter)
+if current_adapter?(:Mysql2Adapter)
 module ActiveRecord
   class MysqlDBCreateTest < ActiveRecord::TestCase
     def setup
       @connection    = stub(:create_database => true)
       @configuration = {
-        'adapter'  => 'mysql',
+        '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 test_establishes_connection_without_database
       ActiveRecord::Base.expects(:establish_connection).
-        with('adapter' => 'mysql', 'database' => nil)
+        with('adapter' => 'mysql2', 'database' => nil)
 
       ActiveRecord::Tasks::DatabaseTasks.create @configuration
     end
 
-    def test_creates_database_with_default_encoding_and_collation
+    def test_creates_database_with_no_default_options
       @connection.expects(:create_database).
-        with('my-app-db', charset: 'utf8', collation: 'utf8_unicode_ci')
+        with('my-app-db', {})
 
       ActiveRecord::Tasks::DatabaseTasks.create @configuration
     end
 
-    def test_creates_database_with_given_encoding_and_default_collation
-      @connection.expects(:create_database).
-        with('my-app-db', charset: 'utf8', collation: 'utf8_unicode_ci')
-
-      ActiveRecord::Tasks::DatabaseTasks.create @configuration.merge('encoding' => 'utf8')
-    end
-
-    def test_creates_database_with_given_encoding_and_no_collation
+    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
 
-    def test_creates_database_with_given_collation_and_no_encoding
+    def test_creates_database_with_given_collation
       @connection.expects(:create_database).
         with('my-app-db', collation: 'latin1_swedish_ci')
 
@@ -55,108 +56,118 @@ module ActiveRecord
       ActiveRecord::Tasks::DatabaseTasks.create @configuration
     end
 
-    def test_create_when_database_exists_outputs_info_to_stderr
-      $stderr.expects(:puts).with("my-app-db already exists").once
+    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
+
+    def test_create_when_database_exists_outputs_info_to_stderr
       ActiveRecord::Base.connection.stubs(:create_database).raises(
-        ActiveRecord::StatementInvalid.new("Can't create database 'dev'; database exists:")
+        ActiveRecord::Tasks::DatabaseAlreadyExists
       )
 
       ActiveRecord::Tasks::DatabaseTasks.create @configuration
+
+      assert_equal $stderr.string, "Database 'my-app-db' already exists\n"
     end
   end
 
-  if current_adapter?(:MysqlAdapter)
-    class MysqlDBCreateAsRootTest < ActiveRecord::TestCase
-      def setup
-        @connection    = stub("Connection", create_database: true)
-        @error         = Mysql::Error.new "Invalid permissions"
-        @configuration = {
-          'adapter'  => 'mysql',
-          '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)
-      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'
+      }
 
-      if defined?(::Mysql)
-        def test_root_password_is_requested
-          assert_permissions_granted_for "pat"
-          $stdin.expects(:gets).returns("secret\n")
+      $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)
 
-          ActiveRecord::Tasks::DatabaseTasks.create @configuration
-        end
-      end
+      $stdout, @original_stdout = StringIO.new, $stdout
+      $stderr, @original_stderr = StringIO.new, $stderr
+    end
 
-      def test_connection_established_as_root
-        assert_permissions_granted_for "pat"
-        ActiveRecord::Base.expects(:establish_connection).with(
-          'adapter'  => 'mysql',
-          'database' => nil,
-          'username' => 'root',
-          'password' => 'secret'
-        )
+    def teardown
+      $stdout, $stderr = @original_stdout, @original_stderr
+    end
 
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
-      end
+    def test_root_password_is_requested
+      assert_permissions_granted_for("pat")
+      $stdin.expects(:gets).returns("secret\n")
 
-      def test_database_created_by_root
-        assert_permissions_granted_for "pat"
-        @connection.expects(:create_database).
-          with('my-app-db', :charset => 'utf8', :collation => 'utf8_unicode_ci')
+      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_grant_privileges_for_normal_user
-        assert_permissions_granted_for "pat"
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
-      end
+      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_database_created_by_root
+      assert_permissions_granted_for("pat")
+      @connection.expects(:create_database).
+        with('my-app-db', {})
+
+      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'  => 'mysql',
-            'database' => 'my-app-db',
-            'username' => 'pat',
-            'password' => 'secret'
-          )
+    def test_grant_privileges_for_normal_user
+      assert_permissions_granted_for("pat")
+      ActiveRecord::Tasks::DatabaseTasks.create @configuration
+    end
 
-          raise @error
-        end
+    def test_do_not_grant_privileges_for_root_user
+      @configuration['username'] = 'root'
+      @configuration['password'] = ''
+      ActiveRecord::Tasks::DatabaseTasks.create @configuration
+    end
 
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
+    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
 
-      def test_sends_output_to_stderr_when_other_errors
-        @error.stubs(:errno).returns(42)
+      ActiveRecord::Tasks::DatabaseTasks.create @configuration
+    end
 
-        $stderr.expects(:puts).at_least_once.returns(nil)
+    def test_sends_output_to_stderr_when_other_errors
+      @error.stubs(:errno).returns(42)
 
-        ActiveRecord::Tasks::DatabaseTasks.create @configuration
-      end
+      $stderr.expects(:puts).at_least_once.returns(nil)
 
-      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;")
-        end
+      ActiveRecord::Tasks::DatabaseTasks.create @configuration
+    end
+
+    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;")
     end
   end
 
@@ -164,12 +175,19 @@ module ActiveRecord
     def setup
       @connection    = stub(:drop_database => true)
       @configuration = {
-        'adapter'  => 'mysql',
+        '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 test_establishes_connection_to_mysql_database
@@ -183,13 +201,19 @@ module ActiveRecord
 
       ActiveRecord::Tasks::DatabaseTasks.drop @configuration
     end
+
+    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"
+    end
   end
 
   class MySQLPurgeTest < ActiveRecord::TestCase
     def setup
       @connection    = stub(:recreate_database => true)
       @configuration = {
-        'adapter'  => 'mysql',
+        'adapter'  => 'mysql2',
         'database' => 'test-db'
       }
 
@@ -203,9 +227,9 @@ module ActiveRecord
       ActiveRecord::Tasks::DatabaseTasks.purge @configuration
     end
 
-    def test_recreates_database_with_the_default_options
+    def test_recreates_database_with_no_default_options
       @connection.expects(:recreate_database).
-        with('test-db', charset: 'utf8', collation: 'utf8_unicode_ci')
+        with('test-db', {})
 
       ActiveRecord::Tasks::DatabaseTasks.purge @configuration
     end
@@ -223,7 +247,7 @@ module ActiveRecord
     def setup
       @connection    = stub(:create_database => true)
       @configuration = {
-        'adapter'  => 'mysql',
+        'adapter'  => 'mysql2',
         'database' => 'my-app-db'
       }
 
@@ -241,7 +265,7 @@ module ActiveRecord
     def setup
       @connection    = stub(:create_database => true)
       @configuration = {
-        'adapter'  => 'mysql',
+        'adapter'  => 'mysql2',
         'database' => 'my-app-db'
       }
 
@@ -258,55 +282,53 @@ module ActiveRecord
   class MySQLStructureDumpTest < ActiveRecord::TestCase
     def setup
       @configuration = {
-        'adapter'  => 'mysql',
+        'adapter'  => 'mysql2',
         'database' => 'test-db'
       }
     end
 
     def test_structure_dump
       filename = "awesome-file.sql"
-      Kernel.expects(:system).with("mysqldump", "--result-file", filename, "--no-data", "test-db").returns(true)
+      Kernel.expects(:system).with("mysqldump", "--result-file", filename, "--no-data", "--routines", "test-db").returns(true)
 
       ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
     end
 
-    def test_warn_when_external_structure_dump_fails
-      filename = "awesome-file.sql"
-      Kernel.expects(:system).with("mysqldump", "--result-file", filename, "--no-data", "test-db").returns(false)
-
-      # There doesn't seem to be a good way to get a handle on a Process::Status object without actually
-      # creating a child process, hence this to populate $?
-      system("not_a_real_program_#{SecureRandom.hex}")
-      assert_raise(RuntimeError) {
-        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", "test-db")
-        .returns(nil)
+        .with("mysqldump", "--result-file", filename, "--no-data", "--routines", "test-db")
+        .returns(false)
 
-      assert_raise(RuntimeError) {
+      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", "test-db").returns(true)
+      Kernel.expects(:system).with("mysqldump", "--port=10000", "--result-file", filename, "--no-data", "--routines", "test-db").returns(true)
 
       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", "test-db").returns(true)
+
+      ActiveRecord::Tasks::DatabaseTasks.structure_dump(
+        @configuration.merge("sslca" => "ca.crt"),
+        filename)
+    end
   end
 
   class MySQLStructureLoadTest < ActiveRecord::TestCase
     def setup
       @configuration = {
-        'adapter'  => 'mysql',
+        'adapter'  => 'mysql2',
         'database' => 'test-db'
       }
     end
@@ -319,6 +341,5 @@ module ActiveRecord
       ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
     end
   end
-
 end
 end