capistrano 2.8.0 → 3.19.0

data/test/configuration/actions/file_transfer_test.rb

@@ -1,61 +0,0 @@
-require "utils"
-require 'capistrano/configuration/actions/file_transfer'
-
-class ConfigurationActionsFileTransferTest < Test::Unit::TestCase
-  class MockConfig
-    include Capistrano::Configuration::Actions::FileTransfer
-    attr_accessor :sessions, :dry_run
-  end
-
-  def setup
-    @config = MockConfig.new
-    @config.stubs(:logger).returns(stub_everything)
-  end
-
-  def test_put_should_delegate_to_upload
-    @config.expects(:upload).with { |from, to, opts|
-      from.string == "some data" && to == "test.txt" && opts == { :mode => 0777 } }
-    @config.expects(:run).never
-    @config.put("some data", "test.txt", :mode => 0777)
-  end
-
-  def test_get_should_delegate_to_download_with_once
-    @config.expects(:download).with("testr.txt", "testl.txt", :foo => "bar", :once => true)
-    @config.get("testr.txt", "testl.txt", :foo => "bar")
-  end
-
-  def test_upload_should_delegate_to_transfer
-    @config.expects(:transfer).with(:up, "testl.txt", "testr.txt", :foo => "bar")
-    @config.upload("testl.txt", "testr.txt", :foo => "bar")
-  end
-
-  def test_upload_without_mode_should_not_try_to_chmod
-    @config.expects(:transfer).with(:up, "testl.txt", "testr.txt", :foo => "bar")
-    @config.expects(:run).never
-    @config.upload("testl.txt", "testr.txt", :foo => "bar")
-  end
-
-  def test_upload_with_mode_should_try_to_chmod
-    @config.expects(:transfer).with(:up, "testl.txt", "testr.txt", :foo => "bar")
-    @config.expects(:run).with("chmod 775 testr.txt", {:foo => "bar"})
-    @config.upload("testl.txt", "testr.txt", :mode => 0775, :foo => "bar")
-  end
-
-  def test_upload_with_symbolic_mode_should_try_to_chmod
-    @config.expects(:transfer).with(:up, "testl.txt", "testr.txt", :foo => "bar")
-    @config.expects(:run).with("chmod g+w testr.txt", {:foo => "bar"})
-    @config.upload("testl.txt", "testr.txt", :mode => "g+w", :foo => "bar")
-  end
-
-  def test_download_should_delegate_to_transfer
-    @config.expects(:transfer).with(:down, "testr.txt", "testl.txt", :foo => "bar")
-    @config.download("testr.txt", "testl.txt", :foo => "bar")
-  end
-
-  def test_transfer_should_invoke_transfer_on_matching_servers
-    @config.sessions = { :a => 1, :b => 2, :c => 3, :d => 4 }
-    @config.expects(:execute_on_servers).with(:foo => "bar").yields([:a, :b, :c])
-    Capistrano::Transfer.expects(:process).with(:up, "testl.txt", "testr.txt", [1,2,3], {:foo => "bar", :logger => @config.logger})
-    @config.transfer(:up, "testl.txt", "testr.txt", :foo => "bar")
-  end
-end

data/test/configuration/actions/inspect_test.rb

@@ -1,65 +0,0 @@
-require "utils"
-require 'capistrano/configuration/actions/inspect'
-
-class ConfigurationActionsInspectTest < Test::Unit::TestCase
-  class MockConfig
-    include Capistrano::Configuration::Actions::Inspect
-  end
-
-  def setup
-    @config = MockConfig.new
-    @config.stubs(:logger).returns(stub_everything)
-  end
-
-  def test_stream_should_pass_options_through_to_run
-    @config.expects(:invoke_command).with("tail -f foo.log", :once => true)
-    @config.stream("tail -f foo.log", :once => true)
-  end
-
-  def test_stream_should_emit_stdout_via_puts
-    @config.expects(:invoke_command).yields(mock("channel"), :out, "something streamed")
-    @config.expects(:puts).with("something streamed")
-    @config.expects(:warn).never
-    @config.stream("tail -f foo.log")
-  end
-
-  def test_stream_should_emit_stderr_via_warn
-    ch = mock("channel")
-    ch.expects(:[]).with(:server).returns(server("capistrano"))
-    @config.expects(:invoke_command).yields(ch, :err, "something streamed")
-    @config.expects(:puts).never
-    @config.expects(:warn).with("[err :: capistrano] something streamed")
-    @config.stream("tail -f foo.log")
-  end
-
-  def test_capture_should_pass_options_merged_with_once_to_run
-    @config.expects(:invoke_command).with("hostname", :foo => "bar", :once => true)
-    @config.capture("hostname", :foo => "bar")
-  end
-
-  def test_capture_with_stderr_should_emit_stderr_via_warn
-    ch = mock("channel")
-    ch.expects(:[]).with(:server).returns(server("capistrano"))
-    @config.expects(:invoke_command).yields(ch, :err, "boom")
-    @config.expects(:warn).with("[err :: capistrano] boom")
-    @config.capture("hostname")
-  end
-
-  def test_capture_with_stdout_should_aggregate_and_return_stdout
-    config_expects_invoke_command_to_loop_with(mock("channel"), "foo", "bar", "baz")
-    assert_equal "foobarbaz", @config.capture("hostname")
-  end
-
-  private
-
-    def config_expects_invoke_command_to_loop_with(channel, *output)
-      class <<@config
-        attr_accessor :script, :channel
-        def invoke_command(*args)
-          script.each { |item| yield channel, :out, item }
-        end
-      end
-      @config.channel = channel
-      @config.script = output
-    end
-end

data/test/configuration/actions/invocation_test.rb

@@ -1,247 +0,0 @@
-require "utils"
-require 'capistrano/configuration/actions/invocation'
-require 'capistrano/configuration/actions/file_transfer'
-
-class ConfigurationActionsInvocationTest < Test::Unit::TestCase
-  class MockConfig
-    attr_reader :options
-    attr_accessor :debug
-    attr_accessor :dry_run
-		attr_accessor :preserve_roles
-    attr_accessor :servers
-
-    def initialize
-      @options = {}
-      @servers = []
-    end
-
-    def [](*args)
-      @options[*args]
-    end
-
-    def set(name, value)
-      @options[name] = value
-    end
-
-    def fetch(*args)
-      @options.fetch(*args)
-    end
-
-    def execute_on_servers(options = {})
-      yield @servers
-    end
-
-    include Capistrano::Configuration::Actions::Invocation
-    include Capistrano::Configuration::Actions::FileTransfer
-  end
-
-  def setup
-    @config = make_config
-    @original_io_proc = MockConfig.default_io_proc
-  end
-
-  def teardown
-    MockConfig.default_io_proc = @original_io_proc
-  end
-
-  def test_run_options_should_be_passed_to_execute_on_servers
-    @config.expects(:execute_on_servers).with(:foo => "bar")
-    @config.run "ls", :foo => "bar"
-  end
-
-  def test_run_will_return_if_dry_run
-    @config.expects(:dry_run).returns(true)
-    @config.expects(:execute_on_servers).never
-    @config.run "ls", :foo => "bar"
-  end
-
-  def test_put_wont_transfer_if_dry_run
-    config = make_config
-    config.dry_run = true
-    config.servers = %w[ foo ]
-    config.expects(:sessions).returns({ 'foo-server' => 'bar' })
-    ::Capistrano::Transfer.expects(:process).never
-    config.put "foo", "bar", :mode => 0644
-  end
-
-  def test_add_default_command_options_should_return_bare_options_if_there_is_no_env_or_shell_specified
-    assert_equal({:foo => "bar"}, @config.add_default_command_options(:foo => "bar"))
-  end
-
-  def test_add_default_command_options_should_merge_default_environment_as_env
-    @config[:default_environment][:bang] = "baz"
-    assert_equal({:foo => "bar", :env => { :bang => "baz" }}, @config.add_default_command_options(:foo => "bar"))
-  end
-
-  def test_add_default_command_options_should_merge_env_with_default_environment
-    @config[:default_environment][:bang] = "baz"
-    @config[:default_environment][:bacon] = "crunchy"
-    assert_equal({:foo => "bar", :env => { :bang => "baz", :bacon => "chunky", :flip => "flop" }}, @config.add_default_command_options(:foo => "bar", :env => {:bacon => "chunky", :flip => "flop"}))
-  end
-
-  def test_add_default_command_options_should_use_default_shell_if_present
-    @config.set :default_shell, "/bin/bash"
-    assert_equal({:foo => "bar", :shell => "/bin/bash"}, @config.add_default_command_options(:foo => "bar"))
-  end
-
-  def test_add_default_command_options_should_use_default_shell_of_false_if_present
-    @config.set :default_shell, false
-    assert_equal({:foo => "bar", :shell => false}, @config.add_default_command_options(:foo => "bar"))
-  end
-
-  def test_add_default_command_options_should_use_shell_in_preference_of_default_shell
-    @config.set :default_shell, "/bin/bash"
-    assert_equal({:foo => "bar", :shell => "/bin/sh"}, @config.add_default_command_options(:foo => "bar", :shell => "/bin/sh"))
-  end
-
-  def test_default_io_proc_should_log_stdout_arguments_as_info
-    ch = { :host => "capistrano",
-           :server => server("capistrano"),
-           :options => { :logger => mock("logger") } }
-    ch[:options][:logger].expects(:info).with("data stuff", "out :: capistrano")
-    MockConfig.default_io_proc[ch, :out, "data stuff"]
-  end
-
-  def test_default_io_proc_should_log_stderr_arguments_as_important
-    ch = { :host => "capistrano",
-           :server => server("capistrano"),
-           :options => { :logger => mock("logger") } }
-    ch[:options][:logger].expects(:important).with("data stuff", "err :: capistrano")
-    MockConfig.default_io_proc[ch, :err, "data stuff"]
-  end
-
-  def test_sudo_should_default_to_sudo
-    @config.expects(:run).with("sudo -p 'sudo password: ' ls", {})
-    @config.sudo "ls"
-  end
-
-  def test_sudo_should_use_sudo_variable_definition
-    @config.expects(:run).with("/opt/local/bin/sudo -p 'sudo password: ' ls", {})
-    @config.options[:sudo] = "/opt/local/bin/sudo"
-    @config.sudo "ls"
-  end
-
-  def test_sudo_should_interpret_as_option_as_user
-    @config.expects(:run).with("sudo -p 'sudo password: ' -u app ls", {})
-    @config.sudo "ls", :as => "app"
-  end
-
-  def test_sudo_should_pass_options_through_to_run
-    @config.expects(:run).with("sudo -p 'sudo password: ' ls", :foo => "bar")
-    @config.sudo "ls", :foo => "bar"
-  end
-
-  def test_sudo_should_avoid_minus_p_when_sudo_prompt_is_empty
-    @config.set :sudo_prompt, ""
-    @config.expects(:run).with("sudo ls", {})
-    @config.sudo "ls"
-  end
-
-  def test_sudo_should_interpret_sudo_prompt_variable_as_custom_prompt
-    @config.set :sudo_prompt, "give it to me: "
-    @config.expects(:run).with("sudo -p 'give it to me: ' ls", {})
-    @config.sudo "ls"
-  end
-
-  def test_sudo_behavior_callback_should_send_password_when_prompted_with_default_sudo_prompt
-    ch = mock("channel")
-    ch.expects(:send_data).with("g00b3r\n")
-    @config.options[:password] = "g00b3r"
-    @config.sudo_behavior_callback(nil)[ch, nil, "sudo password: "]
-  end
-
-  def test_sudo_behavior_callback_should_send_password_when_prompted_with_custom_sudo_prompt
-    ch = mock("channel")
-    ch.expects(:send_data).with("g00b3r\n")
-    @config.set :sudo_prompt, "give it to me: "
-    @config.options[:password] = "g00b3r"
-    @config.sudo_behavior_callback(nil)[ch, nil, "give it to me: "]
-  end
-
-  def test_sudo_behavior_callback_with_incorrect_password_on_first_prompt
-    ch = mock("channel")
-    ch.stubs(:[]).with(:host).returns("capistrano")
-    ch.stubs(:[]).with(:server).returns(server("capistrano"))
-    @config.expects(:reset!).with(:password)
-    @config.sudo_behavior_callback(nil)[ch, nil, "Sorry, try again."]
-  end
-
-  def test_sudo_behavior_callback_with_incorrect_password_on_subsequent_prompts
-    callback = @config.sudo_behavior_callback(nil)
-
-    ch = mock("channel")
-    ch.stubs(:[]).with(:host).returns("capistrano")
-    ch.stubs(:[]).with(:server).returns(server("capistrano"))
-    ch2 = mock("channel")
-    ch2.stubs(:[]).with(:host).returns("cap2")
-    ch2.stubs(:[]).with(:server).returns(server("cap2"))
-
-    @config.expects(:reset!).with(:password).times(2)
-
-    callback[ch, nil, "Sorry, try again."]
-    callback[ch2, nil, "Sorry, try again."] # shouldn't call reset!
-    callback[ch, nil, "Sorry, try again."]
-  end
-
-  def test_sudo_behavior_callback_should_reset_password_and_prompt_again_if_output_includes_both_cues
-    ch = mock("channel")
-    ch.stubs(:[]).with(:host).returns("capistrano")
-    ch.stubs(:[]).with(:server).returns(server("capistrano"))
-    ch.expects(:send_data, "password!\n").times(2)
-
-    @config.set(:password, "password!")
-    @config.expects(:reset!).with(:password)
-
-    callback = @config.sudo_behavior_callback(nil)
-    callback[ch, :out, "sudo password: "]
-    callback[ch, :out, "Sorry, try again.\nsudo password: "]
-  end
-
-  def test_sudo_behavior_callback_should_defer_to_fallback_for_other_output
-    callback = @config.sudo_behavior_callback(inspectable_proc)
-
-    a = mock("channel", :called => true)
-    b = mock("stream", :called => true)
-    c = mock("data", :called => true)
-  
-    callback[a, b, c]
-  end
-
-  def test_invoke_command_should_default_to_run
-    @config.expects(:run).with("ls", :once => true)
-    @config.invoke_command("ls", :once => true)
-  end
-
-  def test_invoke_command_should_delegate_to_method_identified_by_via
-    @config.expects(:foobar).with("ls", :once => true)
-    @config.invoke_command("ls", :once => true, :via => :foobar)
-  end
-
-  private
-
-    def make_config
-      config = MockConfig.new
-      config.stubs(:logger).returns(stub_everything)
-      config
-    end
-
-    def inspectable_proc
-      Proc.new do |ch, stream, data|
-        ch.called
-        stream.called
-        data.called
-      end
-    end
-
-    def prepare_command(command, sessions, options)
-      a = mock("channel", :called => true)
-      b = mock("stream", :called => true)
-      c = mock("data", :called => true)
-
-      compare_args = Proc.new do |tree, sess, opts|
-        tree.fallback.command == command && sess == sessions && opts == options
-      end
-
-      Capistrano::Command.expects(:process).with(&compare_args)
-    end
-end

data/test/configuration/callbacks_test.rb

@@ -1,220 +0,0 @@
-require "utils"
-require 'capistrano/configuration/callbacks'
-
-class ConfigurationCallbacksTest < Test::Unit::TestCase
-  class MockConfig
-    attr_reader :original_initialize_called
-    attr_reader :called
-
-    def initialize
-      @original_initialize_called = true
-      @called = []
-    end
-
-    def execute_task(task)
-      invoke_task_directly(task)
-    end
-
-    protected
-
-      def invoke_task_directly(task)
-        @called << task
-      end
-
-    include Capistrano::Configuration::Callbacks
-  end
-
-  def setup
-    @config = MockConfig.new
-    @config.stubs(:logger).returns(stub_everything("logger"))
-  end
-
-  def test_initialize_should_initialize_callbacks_collection
-    assert @config.original_initialize_called
-    assert @config.callbacks.empty?
-  end
-
-  def test_before_should_delegate_to_on
-    @config.expects(:on).with(:before, :foo, "bing:blang", {:only => :bar, :zip => :zing})
-    @config.before :bar, :foo, "bing:blang", :zip => :zing
-  end
-
-  def test_after_should_delegate_to_on
-    @config.expects(:on).with(:after, :foo, "bing:blang", {:only => :bar, :zip => :zing})
-    @config.after :bar, :foo, "bing:blang", :zip => :zing
-  end
-
-  def test_on_with_single_reference_should_add_task_callback
-    @config.on :before, :a_test
-    assert_equal 1, @config.callbacks[:before].length
-    assert_equal :a_test, @config.callbacks[:before][0].source
-    @config.expects(:find_and_execute_task).with(:a_test)
-    @config.callbacks[:before][0].call
-  end
-
-  def test_on_with_multi_reference_should_add_all_as_task_callback
-    @config.on :before, :first, :second, :third
-    assert_equal 3, @config.callbacks[:before].length
-    assert_equal %w(first second third), @config.callbacks[:before].map { |c| c.source.to_s }
-  end
-
-  def test_on_with_block_should_add_block_as_proc_callback
-    called = false
-    @config.on(:before) { called = true }
-    assert_equal 1, @config.callbacks[:before].length
-    assert_instance_of Proc, @config.callbacks[:before][0].source
-    @config.callbacks[:before][0].call
-    assert called
-  end
-
-  def test_on_with_single_only_should_set_only_as_string_array_on_all_references
-    @config.on :before, :first, "second:third", :only => :primary
-    assert_equal 2, @config.callbacks[:before].length
-    assert @config.callbacks[:before].all? { |c| c.only == %w(primary) }
-  end
-
-  def test_on_with_multi_only_should_set_only_as_string_array_on_all_references
-    @config.on :before, :first, "second:third", :only => [:primary, "other:one"]
-    assert_equal 2, @config.callbacks[:before].length
-    assert @config.callbacks[:before].all? { |c| c.only == %w(primary other:one) }
-  end
-
-  def test_on_with_single_except_should_set_except_as_string_array_on_all_references
-    @config.on :before, :first, "second:third", :except => :primary
-    assert_equal 2, @config.callbacks[:before].length
-    assert @config.callbacks[:before].all? { |c| c.except == %w(primary) }
-  end
-
-  def test_on_with_multi_except_should_set_except_as_string_array_on_all_references
-    @config.on :before, :first, "second:third", :except => [:primary, "other:one"]
-    assert_equal 2, @config.callbacks[:before].length
-    assert @config.callbacks[:before].all? { |c| c.except == %w(primary other:one) }
-  end
-
-  def test_on_with_only_and_block_should_set_only_as_string_array
-    @config.on(:before, :only => :primary) { blah }
-    assert_equal 1, @config.callbacks[:before].length
-    assert_equal %w(primary), @config.callbacks[:before].first.only
-  end
-
-  def test_on_with_except_and_block_should_set_except_as_string_array
-    @config.on(:before, :except => :primary) { blah }
-    assert_equal 1, @config.callbacks[:before].length
-    assert_equal %w(primary), @config.callbacks[:before].first.except
-  end
-  
-  def test_on_without_tasks_or_block_should_raise_error
-    assert_raises(ArgumentError) { @config.on(:before) }
-  end
-
-  def test_on_with_both_tasks_and_block_should_raise_error
-    assert_raises(ArgumentError) { @config.on(:before, :first) { blah } }
-  end
-
-  def test_trigger_without_constraints_should_invoke_all_callbacks
-    task = stub(:fully_qualified_name => "any:old:thing")
-    @config.on(:before, :first, "second:third")
-    @config.on(:after, :another, "and:another")
-    @config.expects(:find_and_execute_task).with(:first)
-    @config.expects(:find_and_execute_task).with("second:third")
-    @config.expects(:find_and_execute_task).with(:another).never
-    @config.expects(:find_and_execute_task).with("and:another").never
-    @config.trigger(:before, task)
-  end
-
-  def test_trigger_with_only_constraint_should_invoke_only_matching_callbacks
-    task = stub(:fully_qualified_name => "any:old:thing")
-    @config.on(:before, :first)
-    @config.on(:before, "second:third", :only => "any:old:thing")
-    @config.on(:before, "this:too", :only => "any:other:thing")
-    @config.on(:after, :another, "and:another")
-    @config.expects(:find_and_execute_task).with(:first)
-    @config.expects(:find_and_execute_task).with("second:third")
-    @config.expects(:find_and_execute_task).with("this:too").never
-    @config.expects(:find_and_execute_task).with(:another).never
-    @config.expects(:find_and_execute_task).with("and:another").never
-    @config.trigger(:before, task)
-  end
-
-  def test_trigger_with_except_constraint_should_invoke_anything_but_matching_callbacks
-    task = stub(:fully_qualified_name => "any:old:thing")
-    @config.on(:before, :first)
-    @config.on(:before, "second:third", :except => "any:old:thing")
-    @config.on(:before, "this:too", :except => "any:other:thing")
-    @config.on(:after, :another, "and:another")
-    @config.expects(:find_and_execute_task).with(:first)
-    @config.expects(:find_and_execute_task).with("second:third").never
-    @config.expects(:find_and_execute_task).with("this:too")
-    @config.expects(:find_and_execute_task).with(:another).never
-    @config.expects(:find_and_execute_task).with("and:another").never
-    @config.trigger(:before, task)
-  end
-
-  def test_trigger_without_task_should_invoke_all_callbacks_for_that_event
-    task = stub(:fully_qualified_name => "any:old:thing")
-    @config.on(:before, :first)
-    @config.on(:before, "second:third", :except => "any:old:thing")
-    @config.on(:before, "this:too", :except => "any:other:thing")
-    @config.on(:after, :another, "and:another")
-    @config.expects(:find_and_execute_task).with(:first)
-    @config.expects(:find_and_execute_task).with("second:third")
-    @config.expects(:find_and_execute_task).with("this:too")
-    @config.expects(:find_and_execute_task).with(:another).never
-    @config.expects(:find_and_execute_task).with("and:another").never
-    @config.trigger(:before)
-  end
-
-  def test_execute_task_without_named_hooks_should_just_call_task
-    ns = stub("namespace", :default_task => nil, :name => "old", :fully_qualified_name => "any:old")
-    task = stub(:fully_qualified_name => "any:old:thing", :name => "thing", :namespace => ns)
-
-    ns.stubs(:search_task).returns(nil)
-
-    @config.execute_task(task)
-    assert_equal [task], @config.called
-  end
-
-  def test_execute_task_with_named_before_hook_should_call_named_before_hook
-    ns = stub("namespace", :default_task => nil, :name => "old", :fully_qualified_name => "any:old")
-    task = stub(:fully_qualified_name => "any:old:thing", :name => "thing", :namespace => ns)
-    before_task = stub(:fully_qualified_name => "any:old:before_thing", :name => "before_thing", :namespace => ns)
-
-    ns.stubs(:search_task).returns(nil)
-    ns.expects(:search_task).with("before_thing").returns(before_task)
-
-    @config.execute_task(task)
-    assert_equal [before_task, task], @config.called
-  end
-
-  def test_execute_task_with_named_after_hook_should_call_named_after_hook
-    ns = stub("namespace", :default_task => nil, :name => "old", :fully_qualified_name => "any:old")
-    task = stub(:fully_qualified_name => "any:old:thing", :name => "thing", :namespace => ns)
-    after_task = stub(:fully_qualified_name => "any:old:after_thing", :name => "after_thing", :namespace => ns)
-
-    ns.stubs(:search_task).returns(nil)
-    ns.expects(:search_task).with("after_thing").returns(after_task)
-
-    @config.execute_task(task)
-    assert_equal [task, after_task], @config.called
-  end
-
-  def test_execute_task_with_on_hooks_should_trigger_hooks_around_task
-    ns = stub("namespace", :default_task => nil, :name => "old", :fully_qualified_name => "any:old")
-    task = stub(:fully_qualified_name => "any:old:thing", :name => "thing", :namespace => ns)
-    before_task = stub(:fully_qualified_name => "any:old:before_thing", :name => "before_thing", :namespace => ns)
-    after_task = stub(:fully_qualified_name => "any:old:after_thing", :name => "after_thing", :namespace => ns)
-
-    ns.stubs(:search_task).returns(nil)
-    ns.expects(:search_task).with("before_thing").returns(before_task)
-    ns.expects(:search_task).with("after_thing").returns(after_task)
-
-    @config.before("any:old:thing", :first_this, :then_this)
-    @config.after("any:old:thing", :and_then_this, :lastly_this)
-
-    [:first_this, :then_this, :and_then_this, :lastly_this].each do |t|
-      @config.expects(:find_and_execute_task).with(t)
-    end
-
-    @config.execute_task(task)
-  end
-end