3 files changed, 254 insertions, 87 deletions

diff --git a/railties/test/commands/console_test.rb b/railties/test/commands/console_test.rb
index 9e449856f4..4aea3e980f 100644
--- a/railties/test/commands/console_test.rb
+++ b/railties/test/commands/console_test.rb
@@ -6,7 +6,13 @@ class Rails::ConsoleTest < ActiveSupport::TestCase
   include EnvHelpers
 
   class FakeConsole
-    def self.start; end
+    def self.started?
+      @started
+    end
+
+    def self.start
+      @started = true
+    end
   end
 
   def test_sandbox_option
@@ -19,37 +25,47 @@ class Rails::ConsoleTest < ActiveSupport::TestCase
     assert console.sandbox?
   end
 
-  def test_debugger_option
-    console = Rails::Console.new(app, parse_arguments(["--debugger"]))
-    assert console.debugger?
-  end
-
   def test_no_options
     console = Rails::Console.new(app, parse_arguments([]))
-    assert !console.debugger?
     assert !console.sandbox?
   end
 
   def test_start
-    FakeConsole.expects(:start)
     start
+
+    assert app.console.started?
     assert_match(/Loading \w+ environment \(Rails/, output)
   end
 
-  def test_start_with_debugger
-    rails_console = Rails::Console.new(app, parse_arguments(["--debugger"]))
-    rails_console.expects(:require_debugger).returns(nil)
+  def test_start_with_sandbox
+    start ["--sandbox"]
 
-    silence_stream(STDOUT) { rails_console.start }
+
+    assert app.console.started?
+    assert app.sandbox
+    assert_match(/Loading \w+ environment in sandbox \(Rails/, output)
   end
 
-  def test_start_with_sandbox
-    app.expects(:sandbox=).with(true)
-    FakeConsole.expects(:start)
+  if RUBY_VERSION < '2.0.0'
+    def test_debugger_option
+      console = Rails::Console.new(app, parse_arguments(["--debugger"]))
+      assert console.debugger?
+    end
 
-    start ["--sandbox"]
+    def test_no_options_does_not_set_debugger_flag
+      console = Rails::Console.new(app, parse_arguments([]))
+      assert !console.debugger?
+    end
 
-    assert_match(/Loading \w+ environment in sandbox \(Rails/, output)
+    def test_start_with_debugger
+      stubbed_console = Class.new(Rails::Console) do
+        def require_debugger
+        end
+      end
+
+      rails_console = stubbed_console.new(app, parse_arguments(["--debugger"]))
+      silence_stream(STDOUT) { rails_console.start }
+    end
   end
 
   def test_console_with_environment
@@ -58,10 +74,7 @@ class Rails::ConsoleTest < ActiveSupport::TestCase
   end
 
   def test_console_defaults_to_IRB
-    config = mock("config", console: nil)
-    app = mock("app", config: config)
-    app.expects(:load_console).returns(nil)
-
+    app = build_app(nil)
     assert_equal IRB, Rails::Console.new(app).console
   end
 
@@ -111,9 +124,20 @@ class Rails::ConsoleTest < ActiveSupport::TestCase
     assert_match(/\sdevelopment\s/, output)
   end
 
-  private
+  def test_rails_env_is_dev_when_argument_is_dev_and_dev_env_is_present
+    stubbed_console = Class.new(Rails::Console) do
+      def available_environments
+        ['dev']
+      end
+    end
+    options = stubbed_console.parse_arguments(['dev'])
+    assert_match('dev', options[:environment])
+  end
 
   attr_reader :output
+  private :output
+
+  private
 
   def start(argv = [])
     rails_console = Rails::Console.new(app, parse_arguments(argv))
@@ -121,13 +145,29 @@ class Rails::ConsoleTest < ActiveSupport::TestCase
   end
 
   def app
-    @app ||= begin
-      config = mock("config", console: FakeConsole)
-      app = mock("app", config: config)
-      app.stubs(:sandbox=).returns(nil)
-      app.expects(:load_console)
-      app
+    @app ||= build_app(FakeConsole)
+  end
+
+  def build_app(console)
+    mocked_console = Class.new do
+      attr_reader :sandbox, :console
+
+      def initialize(console)
+        @console = console
+      end
+
+      def config
+        self
+      end
+
+      def sandbox=(arg)
+        @sandbox = arg
+      end
+
+      def load_console
+      end
     end
+    mocked_console.new(console)
   end
 
   def parse_arguments(args)
diff --git a/railties/test/commands/dbconsole_test.rb b/railties/test/commands/dbconsole_test.rb
index 6316584825..a3cd1eb0ed 100644
--- a/railties/test/commands/dbconsole_test.rb
+++ b/railties/test/commands/dbconsole_test.rb
@@ -1,78 +1,149 @@
 require 'abstract_unit'
+require 'minitest/mock'
 require 'rails/commands/dbconsole'
 
 class Rails::DBConsoleTest < ActiveSupport::TestCase
-  def teardown
-    %w[PGUSER PGHOST PGPORT PGPASSWORD].each{|key| ENV.delete(key)}
-  end
 
-  def test_config
-    Rails::DBConsole.const_set(:APP_PATH, "erb")
 
-    app_config({})
-    capture_abort { Rails::DBConsole.new.config }
-    assert aborted
-    assert_match(/No database is configured for the environment '\w+'/, output)
+  def setup
+    Rails::DBConsole.const_set('APP_PATH', 'rails/all')
+  end
+
+  def teardown
+    Rails::DBConsole.send(:remove_const, 'APP_PATH')
+    %w[PGUSER PGHOST PGPORT PGPASSWORD DATABASE_URL].each{|key| ENV.delete(key)}
+  end
 
-    app_config(test: "with_init")
-    assert_equal Rails::DBConsole.new.config, "with_init"
+  def test_config_with_db_config_only
+    config_sample = {
+      "test"=> {
+        "adapter"=> "sqlite3",
+        "host"=> "localhost",
+        "port"=> "9000",
+        "database"=> "foo_test",
+        "user"=> "foo",
+        "password"=> "bar",
+        "pool"=> "5",
+        "timeout"=> "3000"
+      }
+    }
+    app_db_config(config_sample) do
+      assert_equal config_sample["test"], Rails::DBConsole.new.config
+    end
+  end
 
-    app_db_file("test:\n  without_init")
-    assert_equal Rails::DBConsole.new.config, "without_init"
+  def test_config_with_no_db_config
+    app_db_config(nil) do
+      assert_raise(ActiveRecord::AdapterNotSpecified) {
+        Rails::DBConsole.new.config
+      }
+    end
+  end
 
-    app_db_file("test:\n  <%= Rails.something_app_specific %>")
-    assert_equal Rails::DBConsole.new.config, "with_init"
+  def test_config_with_database_url_only
+    ENV['DATABASE_URL'] = 'postgresql://foo:bar@localhost:9000/foo_test?pool=5&timeout=3000'
+    expected = {
+      "adapter"  => "postgresql",
+      "host"     => "localhost",
+      "port"     => 9000,
+      "database" => "foo_test",
+      "username" => "foo",
+      "password" => "bar",
+      "pool"     => "5",
+      "timeout"  => "3000"
+    }.sort
+
+    app_db_config(nil) do
+      assert_equal expected, Rails::DBConsole.new.config.sort
+    end
+  end
 
-    app_db_file("test:\n\ninvalid")
-    assert_equal Rails::DBConsole.new.config, "with_init"
+  def test_config_choose_database_url_if_exists
+    host = "database-url-host.com"
+    ENV['DATABASE_URL'] = "postgresql://foo:bar@#{host}:9000/foo_test?pool=5&timeout=3000"
+    sample_config = {
+      "test" => {
+        "adapter"  => "postgresql",
+        "host"     => "not-the-#{host}",
+        "port"     => 9000,
+        "database" => "foo_test",
+        "username" => "foo",
+        "password" => "bar",
+        "pool"     => "5",
+        "timeout"  => "3000"
+      }
+    }
+    app_db_config(sample_config) do
+      assert_equal host, Rails::DBConsole.new.config["host"]
+    end
   end
 
   def test_env
-    assert_equal Rails::DBConsole.new.environment, "test"
+    assert_equal "test", Rails::DBConsole.new.environment
 
     ENV['RAILS_ENV'] = nil
     ENV['RACK_ENV'] = nil
 
-    Rails.stubs(:respond_to?).with(:env).returns(false)
-    assert_equal Rails::DBConsole.new.environment, "development"
+    Rails.stub(:respond_to?, false) do
+      assert_equal "development", Rails::DBConsole.new.environment
 
-    ENV['RACK_ENV'] = "rack_env"
-    assert_equal Rails::DBConsole.new.environment, "rack_env"
+      ENV['RACK_ENV'] = "rack_env"
+      assert_equal "rack_env", Rails::DBConsole.new.environment
 
-    ENV['RAILS_ENV'] = "rails_env"
-    assert_equal Rails::DBConsole.new.environment, "rails_env"
+      ENV['RAILS_ENV'] = "rails_env"
+      assert_equal "rails_env", Rails::DBConsole.new.environment
+    end
   ensure
     ENV['RAILS_ENV'] = "test"
+    ENV['RACK_ENV'] = nil
+  end
+
+  def test_rails_env_is_development_when_argument_is_dev
+    dbconsole = Rails::DBConsole.new
+
+    dbconsole.stub(:available_environments, ['development', 'test']) do
+      options = dbconsole.send(:parse_arguments, ['dev'])
+      assert_match('development', options[:environment])
+    end
+  end
+
+  def test_rails_env_is_dev_when_argument_is_dev_and_dev_env_is_present
+    dbconsole = Rails::DBConsole.new
+
+    dbconsole.stub(:available_environments, ['dev']) do
+      options = dbconsole.send(:parse_arguments, ['dev'])
+      assert_match('dev', options[:environment])
+    end
   end
 
   def test_mysql
-    dbconsole.expects(:find_cmd_and_exec).with(%w[mysql mysql5], 'db')
     start(adapter: 'mysql', database: 'db')
     assert !aborted
+    assert_equal [%w[mysql mysql5], 'db'], dbconsole.find_cmd_and_exec_args
   end
 
   def test_mysql_full
-    dbconsole.expects(:find_cmd_and_exec).with(%w[mysql mysql5], '--host=locahost', '--port=1234', '--socket=socket', '--user=user', '--default-character-set=UTF-8', '-p', 'db')
     start(adapter: 'mysql', database: 'db', host: 'locahost', port: 1234, socket: 'socket', username: 'user', password: 'qwerty', encoding: 'UTF-8')
     assert !aborted
+    assert_equal [%w[mysql mysql5], '--host=locahost', '--port=1234', '--socket=socket', '--user=user', '--default-character-set=UTF-8', '-p', 'db'], dbconsole.find_cmd_and_exec_args
   end
 
   def test_mysql_include_password
-    dbconsole.expects(:find_cmd_and_exec).with(%w[mysql mysql5], '--user=user', '--password=qwerty', 'db')
     start({adapter: 'mysql', database: 'db', username: 'user', password: 'qwerty'}, ['-p'])
     assert !aborted
+    assert_equal [%w[mysql mysql5], '--user=user', '--password=qwerty', 'db'], dbconsole.find_cmd_and_exec_args
   end
 
   def test_postgresql
-    dbconsole.expects(:find_cmd_and_exec).with('psql', 'db')
     start(adapter: 'postgresql', database: 'db')
     assert !aborted
+    assert_equal ['psql', 'db'], dbconsole.find_cmd_and_exec_args
   end
 
   def test_postgresql_full
-    dbconsole.expects(:find_cmd_and_exec).with('psql', 'db')
     start(adapter: 'postgresql', database: 'db', username: 'user', password: 'q1w2e3', host: 'host', port: 5432)
     assert !aborted
+    assert_equal ['psql', 'db'], dbconsole.find_cmd_and_exec_args
     assert_equal 'user', ENV['PGUSER']
     assert_equal 'host', ENV['PGHOST']
     assert_equal '5432', ENV['PGPORT']
@@ -80,60 +151,60 @@ class Rails::DBConsoleTest < ActiveSupport::TestCase
   end
 
   def test_postgresql_include_password
-    dbconsole.expects(:find_cmd_and_exec).with('psql', 'db')
     start({adapter: 'postgresql', database: 'db', username: 'user', password: 'q1w2e3'}, ['-p'])
     assert !aborted
+    assert_equal ['psql', 'db'], dbconsole.find_cmd_and_exec_args
     assert_equal 'user', ENV['PGUSER']
     assert_equal 'q1w2e3', ENV['PGPASSWORD']
   end
 
   def test_sqlite
-    dbconsole.expects(:find_cmd_and_exec).with('sqlite', 'db')
     start(adapter: 'sqlite', database: 'db')
     assert !aborted
+    assert_equal ['sqlite', 'db'], dbconsole.find_cmd_and_exec_args
   end
 
   def test_sqlite3
-    dbconsole.expects(:find_cmd_and_exec).with('sqlite3', Rails.root.join('db.sqlite3').to_s)
     start(adapter: 'sqlite3', database: 'db.sqlite3')
     assert !aborted
+    assert_equal ['sqlite3', Rails.root.join('db.sqlite3').to_s], dbconsole.find_cmd_and_exec_args
   end
 
   def test_sqlite3_mode
-    dbconsole.expects(:find_cmd_and_exec).with('sqlite3', '-html', Rails.root.join('db.sqlite3').to_s)
     start({adapter: 'sqlite3', database: 'db.sqlite3'}, ['--mode', 'html'])
     assert !aborted
+    assert_equal ['sqlite3', '-html', Rails.root.join('db.sqlite3').to_s], dbconsole.find_cmd_and_exec_args
   end
 
   def test_sqlite3_header
-    dbconsole.expects(:find_cmd_and_exec).with('sqlite3', '-header', Rails.root.join('db.sqlite3').to_s)
     start({adapter: 'sqlite3', database: 'db.sqlite3'}, ['--header'])
+    assert_equal ['sqlite3', '-header', Rails.root.join('db.sqlite3').to_s], dbconsole.find_cmd_and_exec_args
   end
 
   def test_sqlite3_db_absolute_path
-    dbconsole.expects(:find_cmd_and_exec).with('sqlite3', '/tmp/db.sqlite3')
     start(adapter: 'sqlite3', database: '/tmp/db.sqlite3')
     assert !aborted
+    assert_equal ['sqlite3', '/tmp/db.sqlite3'], dbconsole.find_cmd_and_exec_args
   end
 
   def test_sqlite3_db_without_defined_rails_root
-    Rails.stubs(:respond_to?)
-    Rails.expects(:respond_to?).with(:root).once.returns(false)
-    dbconsole.expects(:find_cmd_and_exec).with('sqlite3', Rails.root.join('../config/db.sqlite3').to_s)
-    start(adapter: 'sqlite3', database: 'config/db.sqlite3')
-    assert !aborted
+    Rails.stub(:respond_to?, false) do
+      start(adapter: 'sqlite3', database: 'config/db.sqlite3')
+      assert !aborted
+      assert_equal ['sqlite3', Rails.root.join('../config/db.sqlite3').to_s], dbconsole.find_cmd_and_exec_args
+    end
   end
 
   def test_oracle
-    dbconsole.expects(:find_cmd_and_exec).with('sqlplus', 'user@db')
     start(adapter: 'oracle', database: 'db', username: 'user', password: 'secret')
     assert !aborted
+    assert_equal ['sqlplus', 'user@db'], dbconsole.find_cmd_and_exec_args
   end
 
   def test_oracle_include_password
-    dbconsole.expects(:find_cmd_and_exec).with('sqlplus', 'user/secret@db')
     start({adapter: 'oracle', database: 'db', username: 'user', password: 'secret'}, ['-p'])
     assert !aborted
+    assert_equal ['sqlplus', 'user/secret@db'], dbconsole.find_cmd_and_exec_args
   end
 
   def test_unknown_command_line_client
@@ -160,16 +231,33 @@ class Rails::DBConsoleTest < ActiveSupport::TestCase
     assert_match(/Usage:.*dbconsole/, stdout)
   end
 
-  private
   attr_reader :aborted, :output
+  private :aborted, :output
+
+  private
+
+  def app_db_config(results)
+    Rails.application.config.stub(:database_configuration, results || {}) do
+      yield
+    end
+  end
 
   def dbconsole
-    @dbconsole ||= Rails::DBConsole.new(nil)
+    @dbconsole ||= Class.new(Rails::DBConsole) do
+      attr_reader :find_cmd_and_exec_args
+
+      def find_cmd_and_exec(*args)
+        @find_cmd_and_exec_args = args
+      end
+    end.new(nil)
   end
 
   def start(config = {}, argv = [])
-    dbconsole.stubs(config: config.stringify_keys, arguments: argv)
-    capture_abort { dbconsole.start }
+    dbconsole.stub(:config, config.stringify_keys) do
+      dbconsole.stub(:arguments, argv) do
+        capture_abort { dbconsole.start }
+      end
+    end
   end
 
   def capture_abort
@@ -183,11 +271,4 @@ class Rails::DBConsoleTest < ActiveSupport::TestCase
     end
   end
 
-  def app_db_file(result)
-    IO.stubs(:read).with("config/database.yml").returns(result)
-  end
-
-  def app_config(result)
-    Rails.application.config.stubs(:database_configuration).returns(result.stringify_keys)
-  end
 end
diff --git a/railties/test/commands/server_test.rb b/railties/test/commands/server_test.rb
index cb57b3c0cd..ba688f1e9e 100644
--- a/railties/test/commands/server_test.rb
+++ b/railties/test/commands/server_test.rb
@@ -27,16 +27,62 @@ class Rails::ServerTest < ActiveSupport::TestCase
   end
 
   def test_environment_with_rails_env
-    with_rails_env 'production' do
-      server = Rails::Server.new
-      assert_equal 'production', server.options[:environment]
+    with_rack_env nil do
+      with_rails_env 'production' do
+        server = Rails::Server.new
+        assert_equal 'production', server.options[:environment]
+      end
     end
   end
 
   def test_environment_with_rack_env
-    with_rack_env 'production' do
-      server = Rails::Server.new
-      assert_equal 'production', server.options[:environment]
+    with_rails_env nil do
+      with_rack_env 'production' do
+        server = Rails::Server.new
+        assert_equal 'production', server.options[:environment]
+      end
+    end
+  end
+
+  def test_log_stdout
+    with_rack_env nil do
+      with_rails_env nil do
+        args    = []
+        options = Rails::Server::Options.new.parse!(args)
+        assert_equal true, options[:log_stdout]
+
+        args    = ["-e", "development"]
+        options = Rails::Server::Options.new.parse!(args)
+        assert_equal true, options[:log_stdout]
+
+        args    = ["-e", "production"]
+        options = Rails::Server::Options.new.parse!(args)
+        assert_equal false, options[:log_stdout]
+
+        with_rack_env 'development' do
+          args    = []
+          options = Rails::Server::Options.new.parse!(args)
+          assert_equal true, options[:log_stdout]
+        end
+
+        with_rack_env 'production' do
+          args    = []
+          options = Rails::Server::Options.new.parse!(args)
+          assert_equal false, options[:log_stdout]
+        end
+
+        with_rails_env 'development' do
+          args    = []
+          options = Rails::Server::Options.new.parse!(args)
+          assert_equal true, options[:log_stdout]
+        end
+
+        with_rails_env 'production' do
+          args    = []
+          options = Rails::Server::Options.new.parse!(args)
+          assert_equal false, options[:log_stdout]
+        end
+      end
     end
   end
 end