capistrano 2.15.11 → 3.0.0.pre

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,76 +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)
-    @config.stubs(:sudo).returns('sudo')
-  end
-
-  def test_stream_should_pass_options_through_to_run
-    @config.expects(:invoke_command).with("tail -f foo.log", :once => true, :eof => true)
-    @config.stream("tail -f foo.log", :once => true)
-  end
-
-  def test_stream_with_sudo_should_avoid_closing_stdin
-    @config.expects(:invoke_command).with("sudo tail -f foo.log", :once => true, :eof => false)
-    @config.stream("sudo 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, :eof => true)
-    @config.capture("hostname", :foo => "bar")
-  end
-
-  def test_capture_with_sudo_should_avoid_closing_stdin
-    @config.expects(:invoke_command).with("sudo hostname", :foo => "bar", :once => true, :eof => false)
-    @config.capture("sudo 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,306 +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
-    attr_accessor :roles
-
-    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 filter_servers(options = {})
-      [nil, @servers]
-    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", :eof => true)
-    @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(:execute_on_servers).never
-    ::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_keep_input_stream_open
-    @config.expects(:execute_on_servers).with(:foo => "bar")
-    @config.sudo "ls", :foo => "bar"
-  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
-
-  def test_parallel_command_execution_with_no_match
-    assert_block("should not raise argument error") do
-      begin
-        @config.parallel do |session|
-          session.when("in?(:app)", "ls") {|ch,stream,data| puts "noop"}
-          session.when("in?(:db)", "pwd") {|ch,stream,data| puts "noop"}
-        end
-        true
-      rescue
-        false
-      end
-    end
-  end
-
-  def test_parallel_command_execution_with_matching_servers
-    @config.expects(:execute_on_servers)
-
-    logger = mock('logger')
-    logger.stubs(:debug).with("executing multiple commands in parallel").once
-    logger.stubs(:trace).twice
-    @config.stubs(:logger).returns(logger)
-
-    assert_block("should not raise Argument error") do
-      begin
-        @config.servers = [:app, :db]
-        @config.roles = {:app => [:app], :db => [:db] }
-        @config.parallel do |session|
-          session.when("in?(:app)", "ls") {|ch,stream,data| puts "noop"}
-          session.when("in?(:db)", "pwd") {|ch,stream,data| puts "noop"}
-        end
-        true
-      rescue
-        false
-      end
-    end
-  end
-
-  def test_run_only_logs_once
-    @config.servers = [:app, :db]
-
-    logger = mock('logger')
-    logger.stubs(:debug).with("executing \"ls\"")
-    @config.stubs(:logger).returns(logger)
-
-    @config.expects(:execute_on_servers)
-
-    @config.run("ls")
-  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/alias_task_test.rb

@@ -1,118 +0,0 @@
-require 'utils'
-require 'capistrano/configuration/alias_task'
-require 'capistrano/configuration/execution'
-require 'capistrano/configuration/namespaces'
-require 'capistrano/task_definition'
-
-class AliasTaskTest < Test::Unit::TestCase
-  class MockConfig
-    attr_reader :options
-    attr_accessor :logger
-
-    def initialize(options={})
-      @options = {}
-      @logger = options.delete(:logger)
-    end
-
-    include Capistrano::Configuration::AliasTask
-    include Capistrano::Configuration::Execution
-    include Capistrano::Configuration::Namespaces
-  end
-
-  def setup
-    @config = MockConfig.new( :logger => stub(:debug => nil, :info => nil, :important => nil) )
-  end
-
-  def test_makes_a_copy_of_the_task
-    @config.task(:foo) { 42 }
-    @config.alias_task 'new_foo', 'foo'
-
-    assert @config.tasks.key?(:new_foo)
-  end
-
-  def test_original_task_remain_with_same_name
-    @config.task(:foo) { 42 }
-    @config.alias_task 'new_foo', 'foo'
-
-    assert_equal :foo, @config.tasks[:foo].name
-    assert_equal :new_foo, @config.tasks[:new_foo].name
-  end
-
-  def test_aliased_task_do_the_same
-    @config.task(:foo) { 42 }
-    @config.alias_task 'new_foo', 'foo'
-
-    assert_equal 42, @config.find_and_execute_task('new_foo')
-  end
-
-  def test_aliased_task_should_preserve_description
-    @config.task(:foo, :desc => "the Ultimate Question of Life, the Universe, and Everything" ) { 42 }
-    @config.alias_task 'new_foo', 'foo'
-
-    task = @config.find_task('foo')
-    new_task = @config.find_task('new_foo')
-
-    assert_equal task.description, new_task.description
-  end
-
-  def test_aliased_task_should_preserve_on_error
-    @config.task(:foo, :on_error => :continue) { 42 }
-    @config.alias_task 'new_foo', 'foo'
-
-    task = @config.find_task('foo')
-    new_task = @config.find_task('new_foo')
-
-    assert_equal task.on_error, new_task.on_error
-  end
-
-  def test_aliased_task_should_preserve_max_hosts
-    @config.task(:foo, :max_hosts => 5) { 42 }
-    @config.alias_task 'new_foo', 'foo'
-
-    task = @config.find_task('foo')
-    new_task = @config.find_task('new_foo')
-
-    assert_equal task.max_hosts, new_task.max_hosts
-  end
-
-  def test_raise_exception_when_task_doesnt_exist
-    assert_raises(Capistrano::NoSuchTaskError) { @config.alias_task 'non_existant_task', 'fail_miserably' }
-  end
-
-  def test_convert_task_names_using_to_str
-    @config.task(:foo, :role => :app) { 42 }
-
-    @config.alias_task 'one', 'foo'
-    @config.alias_task :two, 'foo'
-    @config.alias_task 'three', :foo
-    @config.alias_task :four, :foo
-
-    assert @config.tasks.key?(:one)
-    assert @config.tasks.key?(:two)
-    assert @config.tasks.key?(:three)
-    assert @config.tasks.key?(:four)
-  end
-
-  def test_raise_an_exception_when_task_names_can_not_be_converted
-    @config.task(:foo, :role => :app) { 42 }
-
-    assert_raises(ArgumentError) { @config.alias_task mock('x'), :foo }
-  end
-
-  def test_should_include_namespace
-    @config.namespace(:outer) do
-      task(:foo) { 42 }
-      alias_task 'new_foo', 'foo'
-
-      namespace(:inner) do
-        task(:foo) { 43 }
-        alias_task 'new_foo', 'foo'
-      end
-    end
-
-    assert_equal 42, @config.find_and_execute_task('outer:new_foo')
-    assert_equal 42, @config.find_and_execute_task('outer:foo')
-    assert_equal 43, @config.find_and_execute_task('outer:inner:new_foo')
-    assert_equal 43, @config.find_and_execute_task('outer:inner:foo')
-  end
-end