capistrano 1.4.2 → 2.0.0

data/test/cli/options_test.rb

@@ -0,0 +1,226 @@
+require "#{File.dirname(__FILE__)}/../utils"
+require 'capistrano/cli/options'
+
+class CLIOptionsTest < Test::Unit::TestCase
+  class ExitException < Exception; end
+
+  class MockCLI
+    def initialize
+      @args = []
+    end
+
+    attr_reader :args
+
+    include Capistrano::CLI::Options
+  end
+
+  def setup
+    @cli = MockCLI.new
+  end
+
+  def test_parse_options_should_require_non_empty_args_list
+    @cli.stubs(:warn)
+    @cli.expects(:exit).raises(ExitException)
+    assert_raises(ExitException) { @cli.parse_options! }
+  end
+  
+  def test_parse_options_with_e_should_set_explain_option
+    @cli.args << "-e" << "sample"
+    @cli.parse_options!
+    assert_equal "sample", @cli.options[:explain]
+  end
+
+  def test_parse_options_with_f_should_add_recipe_file
+    @cli.args << "-f" << "deploy"
+    @cli.parse_options!
+    assert_equal %w(deploy), @cli.options[:recipes]
+  end
+
+  def test_parse_options_with_multiple_f_should_add_each_as_recipe_file
+    @cli.args << "-f" << "deploy" << "-f" << "monitor"
+    @cli.parse_options!
+    assert_equal %w(deploy monitor), @cli.options[:recipes]
+  end
+
+  def test_parse_options_with_H_should_show_verbose_help_and_exit
+    @cli.expects(:exit).raises(ExitException)
+    @cli.expects(:long_help)
+    @cli.args << "-H"
+    assert_raises(ExitException) { @cli.parse_options! }
+  end
+
+  def test_parse_options_with_h_should_show_options_and_exit
+    @cli.expects(:puts).with(@cli.option_parser)
+    @cli.expects(:exit).raises(ExitException)
+    @cli.args << "-h"
+    assert_raises(ExitException) { @cli.parse_options! }
+  end
+
+  def test_parse_options_with_p_should_prompt_for_password
+    MockCLI.expects(:password_prompt).returns(:the_password)
+    @cli.args << "-p"
+    @cli.parse_options!
+    assert_equal :the_password, @cli.options[:password]
+  end
+
+  def test_parse_options_without_p_should_set_proc_for_password
+    @cli.args << "-e" << "sample"
+    @cli.parse_options!
+    assert_instance_of Proc, @cli.options[:password]
+  end
+
+  def test_parse_options_with_q_should_set_verbose_to_0
+    @cli.args << "-q"
+    @cli.parse_options!
+    assert_equal 0, @cli.options[:verbose]
+  end
+
+  def test_parse_options_with_S_should_set_pre_vars
+    @cli.args << "-S" << "foo=bar"
+    @cli.parse_options!
+    assert_equal "bar", @cli.options[:pre_vars][:foo]
+  end
+
+  def test_parse_options_with_s_should_set_vars
+    @cli.args << "-s" << "foo=bar"
+    @cli.parse_options!
+    assert_equal "bar", @cli.options[:vars][:foo]
+  end
+
+  def test_parse_options_with_T_should_set_tasks_option_and_set_verbose_off
+    @cli.args << "-T"
+    @cli.parse_options!
+    assert @cli.options[:tasks]
+    assert_equal 0, @cli.options[:verbose]
+  end
+
+  def test_parse_options_with_V_should_show_version_and_exit
+    @cli.args << "-V"
+    @cli.expects(:puts).with { |s| s.include?(Capistrano::Version::STRING) }
+    @cli.expects(:exit).raises(ExitException)
+    assert_raises(ExitException) { @cli.parse_options! }
+  end
+
+  def test_parse_options_with_v_should_set_verbose_to_1
+    @cli.args << "-v"
+    @cli.parse_options!
+    assert_equal 1, @cli.options[:verbose]
+  end
+
+  def test_parse_options_with_multiple_v_should_set_verbose_accordingly
+    @cli.args << "-vvvvvvv"
+    @cli.parse_options!
+    assert_equal 7, @cli.options[:verbose]
+  end
+
+  def test_parse_options_without_X_should_set_sysconf
+    @cli.args << "-v"
+    @cli.parse_options!
+    assert @cli.options.key?(:sysconf)
+  end
+
+  def test_parse_options_with_X_should_unset_sysconf
+    @cli.args << "-X"
+    @cli.parse_options!
+    assert !@cli.options.key?(:sysconf)
+  end
+
+  def test_parse_options_without_x_should_set_dotfile
+    @cli.args << "-v"
+    @cli.parse_options!
+    assert @cli.options.key?(:dotfile)
+  end
+
+  def test_parse_options_with_x_should_unset_dotfile
+    @cli.args << "-x"
+    @cli.parse_options!
+    assert !@cli.options.key?(:dotfile)
+  end
+
+  def test_parse_options_without_q_or_v_should_set_verbose_to_3
+    @cli.args << "-x"
+    @cli.parse_options!
+    assert_equal 3, @cli.options[:verbose]
+  end
+
+  def test_should_search_for_default_recipes_if_f_not_given
+    @cli.expects(:look_for_default_recipe_file!)
+    @cli.args << "-v"
+    @cli.parse_options!
+  end
+
+  def test_should_not_search_for_default_recipes_if_f_given
+    @cli.expects(:look_for_default_recipe_file!).never
+    @cli.args << "-f" << "hello"
+    @cli.parse_options!
+  end
+
+  def test_F_should_search_for_default_recipes_even_if_f_is_given
+    @cli.expects(:look_for_default_recipe_file!)
+    @cli.args << "-Ff" << "hello"
+    @cli.parse_options!
+  end
+
+  def test_should_extract_env_vars_from_command_line
+    assert_nil ENV["HELLO"]
+    assert_nil ENV["ANOTHER"]
+
+    @cli.args << "HELLO=world" << "hello" << "ANOTHER=value"
+    @cli.parse_options!
+
+    assert_equal "world", ENV["HELLO"]
+    assert_equal "value", ENV["ANOTHER"]
+  ensure
+    ENV["HELLO"] = ENV["ANOTHER"] = nil
+  end
+
+  def test_remaining_args_should_be_added_to_actions_list
+    @cli.args << "-v" << "HELLO=world" << "-f" << "foo" << "something" << "else"
+    @cli.parse_options!
+    assert_equal %w(something else), @cli.args
+  ensure
+    ENV["HELLO"] = nil
+  end
+
+  def test_search_for_default_recipe_file_should_look_for_Capfile
+    File.stubs(:file?).returns(false)
+    File.expects(:file?).with("Capfile").returns(true)
+    @cli.args << "-v"
+    @cli.parse_options!
+    assert_equal %w(Capfile), @cli.options[:recipes]
+  end
+
+  def test_search_for_default_recipe_file_should_look_for_capfile
+    File.stubs(:file?).returns(false)
+    File.expects(:file?).with("capfile").returns(true)
+    @cli.args << "-v"
+    @cli.parse_options!
+    assert_equal %w(capfile), @cli.options[:recipes]
+  end
+
+  def test_search_for_default_recipe_should_hike_up_the_directory_tree_until_it_finds_default_recipe
+    File.stubs(:file?).returns(false)
+    File.expects(:file?).with("capfile").times(2).returns(false,true)
+    Dir.expects(:pwd).times(3).returns(*%w(/bar/baz /bar/baz /bar))
+    Dir.expects(:chdir).with("..")
+    @cli.args << "-v"
+    @cli.parse_options!
+    assert_equal %w(capfile), @cli.options[:recipes]
+  end
+
+  def test_search_for_default_recipe_should_halt_at_root_directory
+    File.stubs(:file?).returns(false)
+    Dir.expects(:pwd).times(7).returns(*%w(/bar/baz /bar/baz /bar /bar / / /))
+    Dir.expects(:chdir).with("..").times(3)
+    Dir.expects(:chdir).with("/bar/baz")
+    @cli.args << "-v"
+    @cli.parse_options!
+    assert @cli.options[:recipes].empty?
+  end
+
+  def test_parse_should_instantiate_new_cli_and_call_parse_options
+    cli = mock("cli", :parse_options! => nil)
+    MockCLI.expects(:new).with(%w(a b c)).returns(cli)
+    assert_equal cli, MockCLI.parse(%w(a b c))
+  end
+end

data/test/cli/ui_test.rb

@@ -0,0 +1,28 @@
+require "#{File.dirname(__FILE__)}/../utils"
+require 'capistrano/cli/ui'
+
+class CLIUITest < Test::Unit::TestCase
+  class MockCLI
+    include Capistrano::CLI::UI
+  end
+
+  def test_ui_should_return_highline_instance
+    assert_instance_of HighLine, MockCLI.ui
+  end
+
+  def test_password_prompt_should_have_default_prompt_and_set_echo_false
+    q = mock("question")
+    q.expects(:echo=).with(false)
+    ui = mock("ui")
+    ui.expects(:ask).with("Password: ").yields(q).returns("sayuncle")
+    MockCLI.expects(:ui).returns(ui)
+    assert_equal "sayuncle", MockCLI.password_prompt
+  end
+
+  def test_password_prompt_with_custom_prompt_should_use_custom_prompt
+    ui = mock("ui")
+    ui.expects(:ask).with("Give the passphrase: ").returns("sayuncle")
+    MockCLI.expects(:ui).returns(ui)
+    assert_equal "sayuncle", MockCLI.password_prompt("Give the passphrase: ")
+  end
+end

data/test/cli_test.rb

@@ -0,0 +1,17 @@
+require "#{File.dirname(__FILE__)}/utils"
+require 'capistrano/cli'
+
+class CLI_Test < Test::Unit::TestCase
+  def test_options_ui_and_help_modules_should_integrate_successfully_with_configuration
+    cli = Capistrano::CLI.parse(%w(-T))
+    cli.expects(:puts).at_least_once
+    cli.execute!
+  end
+
+  def test_options_and_execute_modules_should_integrate_successfully_with_configuration
+    path = "#{File.dirname(__FILE__)}/fixtures/cli_integration.rb"
+    cli = Capistrano::CLI.parse(%W(-q -f #{path} testing))
+    config = cli.execute!
+    assert config[:testing_occurred]
+  end
+end

data/test/command_test.rb

@@ -1,43 +1,302 @@
-$:.unshift File.dirname(__FILE__) + "/../lib"
-
-require 'stringio'
-require 'test/unit'
+require "#{File.dirname(__FILE__)}/utils"
 require 'capistrano/command'
 
 class CommandTest < Test::Unit::TestCase
-  class MockSession
-    def open_channel
-      { :closed => true, :status => 0 }
+  def test_command_should_open_channels_on_all_sessions
+    s1 = mock(:open_channel => nil)
+    s2 = mock(:open_channel => nil)
+    s3 = mock(:open_channel => nil)
+    assert_equal "ls", Capistrano::Command.new("ls", [s1, s2, s3]).command
+  end
+
+  def test_command_with_newlines_should_be_properly_escaped
+    cmd = Capistrano::Command.new("ls\necho", [mock(:open_channel => nil)])
+    assert_equal "ls\\\necho", cmd.command
+  end
+
+  def test_command_with_windows_newlines_should_be_properly_escaped
+    cmd = Capistrano::Command.new("ls\r\necho", [mock(:open_channel => nil)])
+    assert_equal "ls\\\necho", cmd.command
+  end
+
+  def test_command_with_env_key_should_have_environment_constructed_and_prepended
+    session = setup_for_extracting_channel_action(:on_success) do |ch|
+      ch.expects(:exec).with(%(env FOO=bar sh -c "ls"))
+    end
+    Capistrano::Command.new("ls", [session], :env => { "FOO" => "bar" })
+  end
+
+  def test_env_with_symbolic_key_should_be_accepted_as_a_string
+    session = setup_for_extracting_channel_action(:on_success) do |ch|
+      ch.expects(:exec).with(%(env FOO=bar sh -c "ls"))
+    end
+    Capistrano::Command.new("ls", [session], :env => { :FOO => "bar" })
+  end
+
+  def test_env_as_string_should_be_substituted_in_directly
+    session = setup_for_extracting_channel_action(:on_success) do |ch|
+      ch.expects(:exec).with(%(env HOWDY=there sh -c "ls"))
+    end
+    Capistrano::Command.new("ls", [session], :env => "HOWDY=there")
+  end
+
+  def test_env_with_symbolic_value_should_be_accepted_as_string
+    session = setup_for_extracting_channel_action(:on_success) do |ch|
+      ch.expects(:exec).with(%(env FOO=bar sh -c "ls"))
+    end
+    Capistrano::Command.new("ls", [session], :env => { "FOO" => :bar })
+  end
+
+  def test_env_value_should_be_escaped
+    session = setup_for_extracting_channel_action(:on_success) do |ch|
+      ch.expects(:exec).with(%(env FOO=(\\ \\\"bar\\\"\\ ) sh -c "ls"))
+    end
+    Capistrano::Command.new("ls", [session], :env => { "FOO" => '( "bar" )' })
+  end
+
+  def test_env_with_multiple_keys_should_chain_the_entries_together
+    session = setup_for_extracting_channel_action(:on_success) do |ch|
+      ch.expects(:exec).with do |command|
+        command =~ /^env / &&
+        command =~ /\ba=b\b/ &&
+        command =~ /\bc=d\b/ &&
+        command =~ /\be=f\b/ &&
+        command =~ / sh -c "ls"$/
+      end
     end
+    Capistrano::Command.new("ls", [session], :env => { :a => :b, :c => :d, :e => :f })
+  end
+
+  def test_open_channel_should_set_host_key_on_channel
+    session = mock(:xserver => server("capistrano"))
+    channel = stub_everything
+
+    session.expects(:open_channel).yields(channel)
+    channel.expects(:[]=).with(:host, "capistrano")
+
+    Capistrano::Command.new("ls", [session])
   end
 
-  class MockActor
-    attr_reader :sessions
+  def test_open_channel_should_set_options_key_on_channel
+    session = mock(:xserver => server("capistrano"))
+    channel = stub_everything
+
+    session.expects(:open_channel).yields(channel)
+    channel.expects(:[]=).with(:options, {:data => "here we go"})
 
-    def initialize
-      @sessions = Hash.new { |h,k| h[k] = MockSession.new }
+    Capistrano::Command.new("ls", [session], :data => "here we go")
+  end
+
+  def test_open_channel_should_request_pty
+    session = mock(:xserver => server("capistrano"))
+    channel = stub_everything
+
+    session.expects(:open_channel).yields(channel)
+    channel.expects(:request_pty).with(:want_reply => true)
+
+    Capistrano::Command.new("ls", [session])
+  end
+
+  def test_successful_channel_should_send_command
+    session = setup_for_extracting_channel_action(:on_success) do |ch|
+      ch.expects(:exec).with(%(sh -c "ls"))
     end
+    Capistrano::Command.new("ls", [session])
   end
 
-  def setup
-    @actor = MockActor.new
+  def test_successful_channel_with_shell_option_should_send_command_via_specified_shell
+    session = setup_for_extracting_channel_action(:on_success) do |ch|
+      ch.expects(:exec).with(%(/bin/bash -c "ls"))
+    end
+    Capistrano::Command.new("ls", [session], :shell => "/bin/bash")
+  end
+
+  def test_successful_channel_should_send_data_if_data_key_is_present
+    session = setup_for_extracting_channel_action(:on_success) do |ch|
+      ch.expects(:exec).with(%(sh -c "ls"))
+      ch.expects(:send_data).with("here we go")
+    end
+    Capistrano::Command.new("ls", [session], :data => "here we go")
   end
 
-  def test_command_executes_on_all_servers
-    command = Capistrano::Command.new(%w(server1 server2 server3),
-      "hello", nil, {}, @actor)
-    assert_equal %w(server1 server2 server3), @actor.sessions.keys.sort
+  def test_unsuccessful_channel_should_close_channel
+    session = setup_for_extracting_channel_action(:on_failure) do |ch|
+      ch.expects(:close)
+    end
+    Capistrano::Command.new("ls", [session])
   end
 
-  def test_command_with_newlines
-    command = Capistrano::Command.new(%w(server1), "hello\nworld", nil, {},
-      @actor)
-    assert_equal "hello\\\nworld", command.command
+  def test_on_data_should_invoke_callback_as_stdout
+    session = setup_for_extracting_channel_action(:on_data, "hello")
+    called = false
+    Capistrano::Command.new("ls", [session]) do |ch, stream, data|
+      called = true
+      assert_equal :out, stream
+      assert_equal "hello", data
+    end
+    assert called
   end
 
-  def test_command_with_windows_newlines
-    command = Capistrano::Command.new(%w(server1), "hello\r\nworld", nil, {},
-      @actor)
-    assert_equal "hello\\\nworld", command.command
+  def test_on_extended_data_should_invoke_callback_as_stderr
+    session = setup_for_extracting_channel_action(:on_extended_data, 2, "hello")
+    called = false
+    Capistrano::Command.new("ls", [session]) do |ch, stream, data|
+      called = true
+      assert_equal :err, stream
+      assert_equal "hello", data
+    end
+    assert called
   end
+
+  def test_on_request_should_record_exit_status
+    data = mock(:read_long => 5)
+    session = setup_for_extracting_channel_action(:on_request, "exit-status", nil, data) do |ch|
+      ch.expects(:[]=).with(:status, 5)
+    end
+    Capistrano::Command.new("ls", [session])
+  end
+
+  def test_on_close_should_set_channel_closed
+    session = setup_for_extracting_channel_action(:on_close) do |ch|
+      ch.expects(:[]=).with(:closed, true)
+    end
+    Capistrano::Command.new("ls", [session])
+  end
+
+  def test_stop_should_close_all_open_channels
+    sessions = [mock("session", :open_channel => new_channel(false)),
+                mock("session", :open_channel => new_channel(true)),
+                mock("session", :open_channel => new_channel(false))]
+
+    cmd = Capistrano::Command.new("ls", sessions)
+    cmd.stop!
+  end
+
+  def test_process_should_return_cleanly_if_all_channels_have_zero_exit_status
+    sessions = [mock("session", :open_channel => new_channel(true, 0)),
+                mock("session", :open_channel => new_channel(true, 0)),
+                mock("session", :open_channel => new_channel(true, 0))]
+    cmd = Capistrano::Command.new("ls", sessions)
+    assert_nothing_raised { cmd.process! }
+  end
+
+  def test_process_should_raise_error_if_any_channel_has_non_zero_exit_status
+    sessions = [mock("session", :open_channel => new_channel(true, 0)),
+                mock("session", :open_channel => new_channel(true, 0)),
+                mock("session", :open_channel => new_channel(true, 1))]
+    cmd = Capistrano::Command.new("ls", sessions)
+    assert_raises(Capistrano::CommandError) { cmd.process! }
+  end
+
+  def test_command_error_should_include_accessor_with_host_array
+    sessions = [mock("session", :open_channel => new_channel(true, 0)),
+                mock("session", :open_channel => new_channel(true, 0)),
+                mock("session", :open_channel => new_channel(true, 1))]
+    cmd = Capistrano::Command.new("ls", sessions)
+
+    begin
+      cmd.process!
+      flunk "expected an exception to be raised"
+    rescue Capistrano::CommandError => e
+      assert e.respond_to?(:hosts)
+      assert_equal %w(capistrano), e.hosts.map { |h| h.to_s }
+    end
+  end
+
+  def test_process_should_loop_until_all_channels_are_closed
+    new_channel = Proc.new do |times|
+      ch = mock("channel")
+      returns = [false] * (times-1)
+      ch.stubs(:[]).with(:closed).returns(*(returns + [true]))
+      con = mock("connection")
+      con.expects(:process).with(true).times(times-1)
+      ch.expects(:connection).times(times-1).returns(con)
+      ch.expects(:[]).with(:status).returns(0)
+      ch
+    end
+
+    sessions = [mock("session", :open_channel => new_channel[5]),
+                mock("session", :open_channel => new_channel[10]),
+                mock("session", :open_channel => new_channel[7])]
+    cmd = Capistrano::Command.new("ls", sessions)
+    assert_nothing_raised { cmd.process! }
+  end
+
+  def test_process_should_ping_all_connections_each_second
+    now = Time.now
+
+    new_channel = Proc.new do
+      ch = mock("channel")
+      ch.stubs(:now => now)
+      def ch.[](key)
+        case key
+        when :status then 0
+        when :closed then Time.now - now < 1.1 ? false : true
+        else raise "unknown key: #{key}"
+        end
+      end
+      con = mock("connection")
+      con.stubs(:process)
+      con.expects(:ping!)
+      ch.stubs(:connection).returns(con)
+      ch
+    end
+
+    sessions = [mock("session", :open_channel => new_channel[]),
+                mock("session", :open_channel => new_channel[]),
+                mock("session", :open_channel => new_channel[])]
+    cmd = Capistrano::Command.new("ls", sessions)
+    assert_nothing_raised { cmd.process! }
+  end
+
+  def test_process_should_instantiate_command_and_process!
+    cmd = mock("command", :process! => nil)
+    Capistrano::Command.expects(:new).with("ls -l", %w(a b c), {:foo => "bar"}).yields(:command).returns(cmd)
+    parameter = nil
+    Capistrano::Command.process("ls -l", %w(a b c), :foo => "bar") { |cmd| parameter = cmd }
+    assert_equal :command, parameter
+  end
+
+  def test_process_with_host_placeholder_should_substitute_placeholder_with_each_host
+    session = setup_for_extracting_channel_action(:on_success) do |ch|
+      ch.expects(:exec).with(%(sh -c "echo capistrano"))
+    end
+    Capistrano::Command.new("echo $CAPISTRANO:HOST$", [session])
+  end
+
+  def test_process_with_unknown_placeholder_should_not_replace_placeholder
+    session = setup_for_extracting_channel_action(:on_success) do |ch|
+      ch.expects(:exec).with(%(sh -c "echo \\$CAPISTRANO:OTHER\\$"))
+    end
+    Capistrano::Command.new("echo $CAPISTRANO:OTHER$", [session])
+  end
+
+  private
+
+    def new_channel(closed, status=nil)
+      ch = mock("channel")
+      ch.expects(:[]).with(:closed).returns(closed)
+      ch.expects(:[]).with(:status).returns(status) if status
+      ch.expects(:close) unless closed
+      ch.stubs(:[]).with(:host).returns("capistrano")
+      ch.stubs(:[]).with(:server).returns(server("capistrano"))
+      ch
+    end
+
+    def setup_for_extracting_channel_action(action, *args)
+      s = server("capistrano")
+      session = mock("session", :xserver => s)
+
+      channel = stub_everything
+      session.expects(:open_channel).yields(channel)
+
+      ch = mock
+      ch.stubs(:[]).with(:server).returns(s)
+      ch.stubs(:[]).with(:host).returns(s.host)
+      channel.expects(action).yields(ch, *args)
+
+      yield ch if block_given?
+
+      session
+    end
 end