sshkit 1.7.1 → 1.8.0

data/test/unit/formatters/test_simple_text.rb

@@ -0,0 +1,83 @@
+require 'helper'
+
+module SSHKit
+  class TestSimpleText < UnitTest
+
+    def setup
+      super
+      SSHKit.config.output_verbosity = Logger::DEBUG
+    end
+
+    def output
+      @output ||= String.new
+    end
+
+    def simple
+      @simple ||= SSHKit::Formatter::SimpleText.new(output)
+    end
+
+    %w(fatal error warn info debug).each do |level|
+      define_method("test_#{level}_output") do
+        simple.send(level, 'Test')
+        assert_log_output "Test\n"
+      end
+    end
+
+    def test_logging_message_with_leading_and_trailing_space
+      simple.log("       some spaces\n\n  \t")
+      assert_log_output "some spaces\n"
+    end
+
+    def test_can_log_non_strings
+      simple.log(Pathname.new('/var/log/my.log'))
+      assert_log_output "/var/log/my.log\n"
+    end
+
+    def test_command_lifecycle_logging
+      command = SSHKit::Command.new(:a_cmd, 'some args', host: Host.new('user@localhost'))
+      command.stubs(:uuid).returns('aaaaaa')
+      command.stubs(:runtime).returns(1)
+
+      simple.log_command_start(command)
+      command.started = true
+      command.on_stdout(nil, 'stdout message')
+      simple.log_command_data(command, :stdout, 'stdout message')
+      command.on_stderr(nil, 'stderr message')
+      simple.log_command_data(command, :stderr, 'stderr message')
+      command.exit_status = 0
+      simple.log_command_exit(command)
+
+      expected_log_lines = [
+        'Running /usr/bin/env a_cmd some args as user@localhost',
+        'Command: /usr/bin/env a_cmd some args',
+        "\tstdout message",
+        "\tstderr message",
+        'Finished in 1.000 seconds with exit status 0 (successful).'
+      ]
+      assert_equal expected_log_lines, output.split("\n")
+    end
+
+    def test_unsupported_class
+      raised_error = assert_raises RuntimeError do
+        simple << Pathname.new('/tmp')
+      end
+      assert_equal('write only supports formatting SSHKit::LogMessage, called with Pathname: #<Pathname:/tmp>', raised_error.message)
+    end
+
+    def test_does_not_log_when_verbosity_is_too_low
+      SSHKit.config.output_verbosity = Logger::WARN
+      simple.info('Some info')
+      assert_log_output('')
+
+      SSHKit.config.output_verbosity = Logger::INFO
+      simple.info('Some other info')
+      assert_log_output("Some other info\n")
+    end
+
+    private
+
+    def assert_log_output(expected_output)
+      assert_equal expected_output, output
+    end
+  end
+end

data/test/unit/test_color.rb

@@ -4,13 +4,77 @@ require 'sshkit'
 module SSHKit
   class TestColor < UnitTest
 
-    def test_responds_to_colorize?
-      assert Color.respond_to?(:colorize?)
+    def test_colorize_when_tty_available
+      color = SSHKit::Color.new(stub(tty?: true), {})
+      assert_equal "\e[1;32;49mhi\e[0m", color.colorize('hi', :green, :bold)
     end
 
-    def test_not_fails_on_bold_mode
-      Color.stubs(:colorize?).returns true
-      assert_equal Color.bold("test"), 'test'.bold
+    def test_colorize_when_SSHKIT_COLOR_present
+      color = SSHKit::Color.new(stub(tty?: false), {'SSHKIT_COLOR' => 'a'})
+      assert_equal "\e[0;31;49mhi\e[0m", color.colorize('hi', :red)
+    end
+
+    def test_does_not_colorize_when_no_tty_and_SSHKIT_COLOR_not_present
+      color = SSHKit::Color.new(stub(tty?: false), {})
+      assert_equal 'hi', color.colorize('hi', :red)
+    end
+
+    # The output parameter may not define the tty method eg if it is a Logger.
+    # In this case we assume showing colors would not be supported
+    # https://github.com/capistrano/sshkit/pull/246#issuecomment-100358122
+    def test_does_not_colorize_when_tty_method_not_defined_and_SSHKIT_COLOR_not_present
+      color = SSHKit::Color.new(stub(), {})
+      assert_equal 'hi', color.colorize('hi', :red)
+    end
+
+    def test_colorize_colors
+      color = SSHKit::Color.new(stub(tty?: true), {})
+      assert_equal "\e[0;30;49mhi\e[0m", color.colorize('hi', :black)
+      assert_equal "\e[0;31;49mhi\e[0m", color.colorize('hi', :red)
+      assert_equal "\e[0;32;49mhi\e[0m", color.colorize('hi', :green)
+      assert_equal "\e[0;33;49mhi\e[0m", color.colorize('hi', :yellow)
+      assert_equal "\e[0;34;49mhi\e[0m", color.colorize('hi', :blue)
+      assert_equal "\e[0;35;49mhi\e[0m", color.colorize('hi', :magenta)
+      assert_equal "\e[0;36;49mhi\e[0m", color.colorize('hi', :cyan)
+      assert_equal "\e[0;37;49mhi\e[0m", color.colorize('hi', :white)
+      assert_equal "\e[0;90;49mhi\e[0m", color.colorize('hi', :light_black)
+      assert_equal "\e[0;91;49mhi\e[0m", color.colorize('hi', :light_red)
+      assert_equal "\e[0;92;49mhi\e[0m", color.colorize('hi', :light_green)
+      assert_equal "\e[0;93;49mhi\e[0m", color.colorize('hi', :light_yellow)
+      assert_equal "\e[0;94;49mhi\e[0m", color.colorize('hi', :light_blue)
+      assert_equal "\e[0;95;49mhi\e[0m", color.colorize('hi', :light_magenta)
+      assert_equal "\e[0;96;49mhi\e[0m", color.colorize('hi', :light_cyan)
+      assert_equal "\e[0;97;49mhi\e[0m", color.colorize('hi', :light_white)
+    end
+
+    def test_colorize_bold_colors
+      color = SSHKit::Color.new(stub(tty?: true), {})
+      assert_equal "\e[1;30;49mhi\e[0m", color.colorize('hi', :black, :bold)
+      assert_equal "\e[1;31;49mhi\e[0m", color.colorize('hi', :red, :bold)
+      assert_equal "\e[1;32;49mhi\e[0m", color.colorize('hi', :green, :bold)
+      assert_equal "\e[1;33;49mhi\e[0m", color.colorize('hi', :yellow, :bold)
+      assert_equal "\e[1;34;49mhi\e[0m", color.colorize('hi', :blue, :bold)
+      assert_equal "\e[1;35;49mhi\e[0m", color.colorize('hi', :magenta, :bold)
+      assert_equal "\e[1;36;49mhi\e[0m", color.colorize('hi', :cyan, :bold)
+      assert_equal "\e[1;37;49mhi\e[0m", color.colorize('hi', :white, :bold)
+      assert_equal "\e[1;90;49mhi\e[0m", color.colorize('hi', :light_black, :bold)
+      assert_equal "\e[1;91;49mhi\e[0m", color.colorize('hi', :light_red, :bold)
+      assert_equal "\e[1;92;49mhi\e[0m", color.colorize('hi', :light_green, :bold)
+      assert_equal "\e[1;93;49mhi\e[0m", color.colorize('hi', :light_yellow, :bold)
+      assert_equal "\e[1;94;49mhi\e[0m", color.colorize('hi', :light_blue, :bold)
+      assert_equal "\e[1;95;49mhi\e[0m", color.colorize('hi', :light_magenta, :bold)
+      assert_equal "\e[1;96;49mhi\e[0m", color.colorize('hi', :light_cyan, :bold)
+      assert_equal "\e[1;97;49mhi\e[0m", color.colorize('hi', :light_white, :bold)
+    end
+
+    def test_ignores_unrecognized_color
+      color = SSHKit::Color.new(stub(tty?: true), {})
+      assert_equal 'hi', color.colorize('hi', :tangerine)
+    end
+
+    def test_ignores_unrecognized_mode
+      color = SSHKit::Color.new(stub(tty?: true), {})
+      assert_equal "\e[0;31;49mhi\e[0m", color.colorize('hi', :red, :underline)
     end
   end
 end

data/test/unit/test_command.rb

@@ -4,10 +4,6 @@ require 'sshkit'
 module SSHKit
   class TestCommand < UnitTest
 
-    def setup
-      SSHKit.reset_configuration!
-    end
-
     def test_maps_a_command
       c = Command.new('example')
       assert_equal '/usr/bin/env example', c.to_command
@@ -32,38 +28,44 @@ module SSHKit
     def test_including_the_env
       SSHKit.config = nil
       c = Command.new(:rails, 'server', env: {rails_env: :production})
-      assert_equal "( RAILS_ENV=production /usr/bin/env rails server )", c.to_command
+      assert_equal %{( export RAILS_ENV="production" ; /usr/bin/env rails server )}, c.to_command
     end
 
     def test_including_the_env_with_multiple_keys
       SSHKit.config = nil
       c = Command.new(:rails, 'server', env: {rails_env: :production, foo: 'bar'})
-      assert_equal "( RAILS_ENV=production FOO=bar /usr/bin/env rails server )", c.to_command
+      assert_equal %{( export RAILS_ENV="production" FOO="bar" ; /usr/bin/env rails server )}, c.to_command
     end
 
     def test_including_the_env_with_string_keys
       SSHKit.config = nil
       c = Command.new(:rails, 'server', env: {'FACTER_env' => :production, foo: 'bar'})
-      assert_equal "( FACTER_env=production FOO=bar /usr/bin/env rails server )", c.to_command
+      assert_equal %{( export FACTER_env="production" FOO="bar" ; /usr/bin/env rails server )}, c.to_command
+    end
+
+    def test_double_quotes_are_escaped_in_env
+      SSHKit.config = nil
+      c = Command.new(:rails, 'server', env: {foo: 'asdf"hjkl'})
+      assert_equal %{( export FOO="asdf\\\"hjkl" ; /usr/bin/env rails server )}, c.to_command
     end
 
     def test_including_the_env_doesnt_addressively_escape
       SSHKit.config = nil
       c = Command.new(:rails, 'server', env: {path: '/example:$PATH'})
-      assert_equal "( PATH=/example:$PATH /usr/bin/env rails server )", c.to_command
+      assert_equal %{( export PATH="/example:$PATH" ; /usr/bin/env rails server )}, c.to_command
     end
 
     def test_global_env
       SSHKit.config = nil
       SSHKit.config.default_env = { default: 'env' }
       c = Command.new(:rails, 'server', env: {})
-      assert_equal "( DEFAULT=env /usr/bin/env rails server )", c.to_command
+      assert_equal %{( export DEFAULT="env" ; /usr/bin/env rails server )}, c.to_command
     end
 
     def test_default_env_is_overwritten_with_locally_defined
       SSHKit.config.default_env = { foo: 'bar', over: 'under' }
       c = Command.new(:rails, 'server', env: { over: 'write'})
-      assert_equal "( FOO=bar OVER=write /usr/bin/env rails server )", c.to_command
+      assert_equal %{( export FOO="bar" OVER="write" ; /usr/bin/env rails server )}, c.to_command
     end
 
     def test_working_in_a_given_directory
@@ -73,7 +75,7 @@ module SSHKit
 
     def test_working_in_a_given_directory_with_env
       c = Command.new(:ls, '-l', in: "/opt/sites", env: {a: :b})
-      assert_equal "cd /opt/sites && ( A=b /usr/bin/env ls -l )", c.to_command
+      assert_equal %{cd /opt/sites && ( export A="b" ; /usr/bin/env ls -l )}, c.to_command
     end
 
     def test_having_a_host_passed
@@ -118,7 +120,7 @@ module SSHKit
     def test_umask_with_env_and_working_directory_and_user
       SSHKit.config.umask = '007'
       c = Command.new(:touch, 'somefile', user: 'bob', env: {a: 'b'}, in: '/var')
-      assert_equal "cd /var && umask 007 && ( A=b sudo -u bob A=b -- sh -c '/usr/bin/env touch somefile' )", c.to_command
+      assert_equal %{cd /var && umask 007 && ( export A="b" ; sudo -u bob A="b" -- sh -c '/usr/bin/env touch somefile' )}, c.to_command
     end
 
     def test_verbosity_defaults_to_logger_info
@@ -163,16 +165,49 @@ module SSHKit
       assert c.failed?
     end
 
-    def test_appending_stdout
+    def test_on_stdout
       c = Command.new(:whoami)
-      assert c.stdout += "test\n"
-      assert_equal "test\n", c.stdout
+      c.on_stdout(nil, "test\n")
+      c.on_stdout(nil, 'test2')
+      c.on_stdout(nil, 'test3')
+      assert_equal "test\ntest2test3", c.full_stdout
     end
 
-    def test_appending_stderr
+    def test_on_stderr
+      c = Command.new(:whoami)
+      c.on_stderr(nil, 'test')
+      assert_equal 'test', c.full_stderr
+    end
+
+    def test_deprecated_stdtream_accessors
+      deprecation_out = ''
+      SSHKit.config.deprecation_output = deprecation_out
+
       c = Command.new(:whoami)
-      assert c.stderr += "test\n"
-      assert_equal "test\n", c.stderr
+      c.stdout='a test'
+      assert_equal('a test', c.stdout)
+      c.stderr='another test'
+      assert_equal('another test', c.stderr)
+      deprecation_lines = deprecation_out.lines.to_a
+
+      assert_equal 8, deprecation_lines.size
+      assert_equal(
+        '[Deprecated] The stdout= method on Command is deprecated. ' +
+        "The @stdout attribute will be removed in a future release.\n",
+        deprecation_lines[0])
+      assert_equal(
+        '[Deprecated] The stdout method on Command is deprecated. ' +
+        "The @stdout attribute will be removed in a future release. Use full_stdout() instead.\n",
+        deprecation_lines[2])
+
+      assert_equal(
+        '[Deprecated] The stderr= method on Command is deprecated. ' +
+        "The @stderr attribute will be removed in a future release.\n",
+        deprecation_lines[4])
+      assert_equal(
+        '[Deprecated] The stderr method on Command is deprecated. ' +
+        "The @stderr attribute will be removed in a future release. Use full_stderr() instead.\n",
+        deprecation_lines[6])
     end
 
     def test_setting_exit_status

data/test/unit/test_command_map.rb

@@ -4,10 +4,6 @@ require 'sshkit'
 module SSHKit
   class TestCommandMap < UnitTest
 
-    def setup
-      SSHKit.reset_configuration!
-    end
-
     def test_defaults
       map = CommandMap.new
       assert_equal map[:rake], "/usr/bin/env rake"

data/test/unit/test_configuration.rb

@@ -5,11 +5,27 @@ module SSHKit
   class TestConfiguration < UnitTest
 
     def setup
-      SSHKit.config = nil
+      super
       SSHKit.config.command_map.clear
       SSHKit.config.output = SSHKit::Formatter::Pretty.new($stdout)
     end
 
+    def test_deprecation_output
+      output = ''
+      SSHKit.config.deprecation_output = output
+      SSHKit.config.deprecation_logger.log('Test')
+      assert_equal "[Deprecated] Test\n", output.lines.first
+    end
+
+    def test_default_deprecation_output
+      SSHKit.config.deprecation_logger.log('Test')
+    end
+
+    def test_nil_deprecation_output
+      SSHKit.config.deprecation_output = nil
+      SSHKit.config.deprecation_logger.log('Test')
+    end
+
     def test_output
       assert SSHKit.config.output.is_a? SSHKit::Formatter::Pretty
       assert SSHKit.config.output = $stderr
@@ -51,14 +67,38 @@ module SSHKit
       assert_equal "/opt/sites/example/current/bin ruby", SSHKit.config.command_map[:ruby]
     end
 
-    def test_setting_formatter_to_dot
-      assert SSHKit.config.format = :dot
-      assert SSHKit.config.output.is_a? SSHKit::Formatter::Dot
+    def test_setting_formatter_types
+      {
+        dot:        SSHKit::Formatter::Dot,
+        blackhole:  SSHKit::Formatter::BlackHole,
+        simpletext: SSHKit::Formatter::SimpleText,
+      }.each do |format, expected_class|
+        SSHKit.config.format = format
+        assert SSHKit.config.output.is_a? expected_class
+      end
     end
 
-    def test_setting_formatter_to_blackhole
-      assert SSHKit.config.format = :BlackHole
-      assert SSHKit.config.output.is_a? SSHKit::Formatter::BlackHole
+    def test_prohibits_unknown_formatter_type_with_exception
+      assert_raises(NameError) do
+        SSHKit.config.format = :doesnotexist
+      end
+    end
+
+    def test_options_can_be_provided_to_formatter
+      SSHKit.config.use_format(TestFormatter, :color => false)
+      formatter = SSHKit.config.output
+      assert_instance_of(TestFormatter, formatter)
+      assert_equal($stdout, formatter.output)
+      assert_equal({ :color => false }, formatter.options)
+    end
+
+    class TestFormatter
+      attr_accessor :output, :options
+
+      def initialize(output, options={})
+        @output = output
+        @options = options
+      end
     end
   end
 

data/test/unit/test_coordinator.rb

@@ -5,20 +5,16 @@ module SSHKit
 
   class TestCoordinator < UnitTest
 
-    CloseEnough = 0.01; # 10 msec
-
     def setup
       super
-      @s = String.new
+      @output = String.new
+      SSHKit.config.output_verbosity = :debug
+      SSHKit.config.output = SSHKit::Formatter::SimpleText.new(@output)
       SSHKit.config.backend = SSHKit::Backend::Printer
     end
 
-    def tearddown
-      @s = nil
-    end
-
-    def block_to_run
-      lambda do |host|
+    def echo_time
+      lambda do |_host|
         execute "echo #{Time.now.to_f}"
       end
     end
@@ -42,69 +38,66 @@ module SSHKit
     end
 
     def test_the_connection_manager_yields_the_host_to_each_connection_instance
-      spy = lambda do |host|
+      Coordinator.new(%w{1.example.com}).each do |host|
         execute "echo #{host.hostname}"
       end
-      String.new.tap do |str|
-        SSHKit.capture_output str do
-          Coordinator.new(%w{1.example.com}).each &spy
-        end
-        assert_equal "/usr/bin/env echo 1.example.com", str.strip
-      end
+      assert_equal "Command: echo 1.example.com\n", actual_output_commands.last
     end
 
     def test_the_connection_manaager_runs_things_in_parallel_by_default
-      SSHKit.capture_output @s do
-        Coordinator.new(%w{1.example.com 2.example.com}).each &block_to_run
-      end
-      assert_equal 2, results.length
-      assert_in_delta *results, CloseEnough
+      Coordinator.new(%w{1.example.com 2.example.com}).each(&echo_time)
+      assert_equal 2, actual_execution_times.length
+      assert_within_10_ms(actual_execution_times)
     end
 
     def test_the_connection_manager_can_run_things_in_sequence
-      SSHKit.capture_output @s do
-        Coordinator.new(%w{1.example.com 2.example.com}).each in: :sequence, &block_to_run
-      end
-      assert_equal 2, results.length
-      assert_operator (results.last - results.first), :>, 1.0
+      Coordinator.new(%w{1.example.com 2.example.com}).each in: :sequence, &echo_time
+      assert_equal 2, actual_execution_times.length
+      assert_at_least_1_sec_apart(actual_execution_times.first, actual_execution_times.last)
     end
 
     def test_the_connection_manager_can_run_things_in_sequence_with_wait
       start = Time.now
-      SSHKit.capture_output @s do
-        Coordinator.new(%w{1.example.com 2.example.com}).each in: :sequence, wait: 10, &block_to_run
-      end
+      Coordinator.new(%w{1.example.com 2.example.com}).each in: :sequence, wait: 10, &echo_time
       stop = Time.now
-      assert_operator (stop - start), :>=, 10.0
+      assert_operator(stop - start, :>=, 10.0)
     end
 
     def test_the_connection_manager_can_run_things_in_groups
-      SSHKit.capture_output @s do
-        Coordinator.new(
-          %w{
-            1.example.com
-            2.example.com
-            3.example.com
-            4.example.com
-            5.example.com
-            6.example.com
-          }
-        ).each in: :groups, &block_to_run
-      end
-      assert_equal 6, results.length
-      assert_in_delta *results[0..1], CloseEnough
-      assert_in_delta *results[2..3], CloseEnough
-      assert_in_delta *results[4..5], CloseEnough
-      assert_operator (results[2] - results[1]), :>, 1.0
-      assert_operator (results[4] - results[3]), :>, 1.0
+      Coordinator.new(
+        %w{
+          1.example.com
+          2.example.com
+          3.example.com
+          4.example.com
+          5.example.com
+          6.example.com
+        }
+      ).each in: :groups, &echo_time
+      assert_equal 6, actual_execution_times.length
+      assert_within_10_ms(actual_execution_times[0..1])
+      assert_within_10_ms(actual_execution_times[2..3])
+      assert_within_10_ms(actual_execution_times[4..5])
+      assert_at_least_1_sec_apart(actual_execution_times[1], actual_execution_times[2])
+      assert_at_least_1_sec_apart(actual_execution_times[3], actual_execution_times[4])
     end
 
     private
 
-    def results
-      @s.lines.collect do |line|
-        line.split(' ').last.to_f
-      end
+    def assert_at_least_1_sec_apart(first_time, last_time)
+      assert_operator(last_time - first_time, :>, 1.0)
+    end
+
+    def assert_within_10_ms(array)
+      assert_in_delta(*array, 0.01) # 10 msec
+    end
+
+    def actual_execution_times
+      actual_output_commands.map { |line| line.split(' ').last.to_f }
+    end
+
+    def actual_output_commands
+      @output.lines.select { |line| line.start_with?('Command:') }
     end
 
   end