sshkit 1.7.1 → 1.8.0

data/test/unit/backends/test_connection_pool.rb

@@ -6,6 +6,7 @@ module SSHKit
     class TestConnectionPool < UnitTest
 
       def setup
+        super
         pool.flush_connections
       end
 
@@ -14,11 +15,11 @@ module SSHKit
       end
 
       def connect
-        ->(*args) { Object.new }
+        ->(*_args) { Object.new }
       end
 
       def connect_and_close
-        ->(*args) { OpenStruct.new(:closed? => true) }
+        ->(*_args) { OpenStruct.new(:closed? => true) }
       end
 
       def echo_args
@@ -94,6 +95,18 @@ module SSHKit
         refute_equal conn1, conn2
       end
 
+      def test_expired_connection_is_closed
+        pool.idle_timeout = 0.1
+        conn1 = mock
+        conn1.expects(:closed?).returns(false)
+        conn1.expects(:close)
+
+        entry1 = pool.checkout("conn1"){|*args| conn1 }
+        pool.checkin entry1
+        sleep(pool.idle_timeout)
+        pool.checkout("conn2"){|*args| Object.new}
+      end
+
       def test_closed_connection_is_not_reused
         conn1 = pool.checkout("conn", &connect_and_close)
         pool.checkin conn1
@@ -110,6 +123,18 @@ module SSHKit
         refute_equal conn1, conn2
       end
 
+      def test_close_connections
+        conn1 = mock
+        conn1.expects(:closed?).returns(false)
+        conn1.expects(:close)
+        entry1 = pool.checkout("conn1"){|*args| conn1 }
+        pool.checkin entry1
+        entry2 = pool.checkout("conn2", &connect)
+        # entry2 isn't closed if close_connections is called
+
+        pool.close_connections
+      end
+
     end
   end
 end

data/test/unit/backends/test_printer.rb

@@ -1,73 +1,73 @@
 require 'helper'
 
 module SSHKit
-
   module Backend
-
     class TestPrinter < UnitTest
 
-      def block_to_run
-        lambda do |host|
-          execute :ls, '-l', '/some/directory'
-        end
-      end
-
-      def backend
-        @backend ||= Printer
+      def setup
+        super
+        SSHKit.config.output = SSHKit::Formatter::Pretty.new(output)
+        SSHKit.config.output_verbosity = Logger::DEBUG
+        Command.any_instance.stubs(:uuid).returns('aaaaaa')
       end
 
-      def teardown
-        @backend = nil
+      def output
+        @output ||= String.new
       end
 
       def printer
-        Printer.new(Host.new(:'example.com'), &block_to_run)
+        @printer ||= Printer.new(Host.new('example.com'))
       end
 
-      def setup
-        SSHKit.config.output_verbosity = :debug
+      def test_execute
+        printer.execute 'uname -a'
+        assert_output_lines(
+          '  INFO [aaaaaa] Running /usr/bin/env uname -a on example.com',
+          ' DEBUG [aaaaaa] Command: uname -a'
+        )
       end
 
-      def test_simple_printing
-        result = StringIO.new
-        SSHKit.capture_output(result) do
-          printer.run
-        end
-        result.rewind
-        assert_equal "/usr/bin/env ls -l /some/directory\n", result.read
-      end
+      def test_test_method
+        printer.test '[ -d /some/file ]'
 
-      def test_printer_respond_to_configure
-        assert backend.respond_to?(:configure)
+        assert_output_lines(
+          ' DEBUG [aaaaaa] Running /usr/bin/env [ -d /some/file ] on example.com',
+          ' DEBUG [aaaaaa] Command: [ -d /some/file ]'
+        )
       end
 
-      def test_printer_any_params_config
-        backend.configure do |ssh|
-          ssh.pty = true
-          ssh.connection_timeout = 30
-          ssh.ssh_options = {
-              keys: %w(/home/user/.ssh/id_rsa),
-              forward_agent: false,
-              auth_methods: %w(publickey password)
-          }
-        end
+      def test_capture
+        result = printer.capture 'ls -l'
 
-        assert_equal 30, backend.config.connection_timeout
-        assert_equal true, backend.config.pty
+        assert_equal '', result
 
-        assert_equal %w(/home/user/.ssh/id_rsa),  backend.config.ssh_options[:keys]
-        assert_equal false,                       backend.config.ssh_options[:forward_agent]
-        assert_equal %w(publickey password),      backend.config.ssh_options[:auth_methods]
+        assert_output_lines(
+          ' DEBUG [aaaaaa] Running /usr/bin/env ls -l on example.com',
+          ' DEBUG [aaaaaa] Command: ls -l'
+        )
       end
 
-      def test_invoke_raises_no_method_error
-        assert_raises NoMethodError do
-          printer.invoke :echo
-        end
+      def test_upload
+        printer.upload! '/some/file', '/remote'
+        assert_output_lines(
+          '  INFO [aaaaaa] Running /usr/bin/env /some/file /remote on example.com',
+          ' DEBUG [aaaaaa] Command: /usr/bin/env /some/file /remote'
+        )
       end
 
-    end
+      def test_download
+        printer.download! 'remote/file', '/local/path'
+        assert_output_lines(
+          '  INFO [aaaaaa] Running /usr/bin/env remote/file /local/path on example.com',
+          ' DEBUG [aaaaaa] Command: /usr/bin/env remote/file /local/path'
+        )
+      end
 
-  end
+      private
 
-end
+      def assert_output_lines(*expected_lines)
+        assert_equal(expected_lines, output.split("\n"))
+      end
+    end
+  end
+end

data/test/unit/formatters/test_custom.rb

@@ -0,0 +1,65 @@
+require 'helper'
+
+module SSHKit
+  # Try to maintain backwards compatibility with Custom formatters defined by other people
+  class TestCustom < UnitTest
+
+    def setup
+      super
+      SSHKit.config.output_verbosity = Logger::DEBUG
+    end
+
+    def output
+      @output ||= String.new
+    end
+
+    def custom
+      @custom ||= CustomFormatter.new(output)
+    end
+
+    {
+        log:   'LM 1 Test',
+        fatal: 'LM 4 Test',
+        error: 'LM 3 Test',
+        warn:  'LM 2 Test',
+        info:  'LM 1 Test',
+        debug: 'LM 0 Test'
+    }.each do |level, expected_output|
+      define_method("test_#{level}_logging") do
+        custom.send(level, 'Test')
+        assert_log_output expected_output
+      end
+    end
+
+    def test_write_logs_commands
+      custom.write(Command.new(:ls))
+
+      assert_log_output 'C 1 /usr/bin/env ls'
+    end
+
+    def test_double_chevron_logs_commands
+      custom << Command.new(:ls)
+
+      assert_log_output 'C 1 /usr/bin/env ls'
+    end
+
+    private
+
+    def assert_log_output(expected_output)
+      assert_equal expected_output, output
+    end
+
+  end
+
+  class CustomFormatter < SSHKit::Formatter::Abstract
+    def write(obj)
+      original_output << case obj
+        when SSHKit::Command    then "C #{obj.verbosity} #{obj}"
+        when SSHKit::LogMessage then "LM #{obj.verbosity} #{obj}"
+      end
+    end
+    alias :<< :write
+
+  end
+
+end

data/test/unit/formatters/test_dot.rb

@@ -1,65 +1,58 @@
 require 'helper'
-require 'sshkit'
 
 module SSHKit
   class TestDot < UnitTest
 
     def setup
+      super
       SSHKit.config.output_verbosity = Logger::DEBUG
     end
 
     def output
-      @_output ||= String.new
+      @output ||= String.new
     end
 
     def dot
-      @_dot ||= SSHKit::Formatter::Dot.new(output)
+      @dot ||= SSHKit::Formatter::Dot.new(output)
     end
 
-    def teardown
-      remove_instance_variable :@_dot
-      remove_instance_variable :@_output
-      SSHKit.reset_configuration!
+    %w(fatal error warn info debug).each do |level|
+      define_method("test_#{level}_output") do
+        dot.send(level, 'Test')
+        assert_log_output('')
+      end
     end
 
-    def test_logging_fatal
-      dot << SSHKit::LogMessage.new(Logger::FATAL, "Test")
-      assert_equal "", output.strip
+    def test_log_command_start
+      dot.log_command_start(SSHKit::Command.new(:ls))
+      assert_log_output('')
     end
 
-    def test_logging_error
-      dot << SSHKit::LogMessage.new(Logger::ERROR, "Test")
-      assert_equal "", output.strip
-    end
-
-    def test_logging_warn
-      dot << SSHKit::LogMessage.new(Logger::WARN, "Test")
-      assert_equal "", output.strip
-    end
-
-    def test_logging_info
-      dot << SSHKit::LogMessage.new(Logger::INFO, "Test")
-      assert_equal "", output.strip
-    end
-
-    def test_logging_debug
-      dot << SSHKit::LogMessage.new(Logger::DEBUG, "Test")
-      assert_equal "", output.strip
+    def test_log_command_data
+      dot.log_command_data(SSHKit::Command.new(:ls), :stdout, 'Some output')
+      assert_log_output('')
     end
 
     def test_command_success
+      output.stubs(:tty?).returns(true)
       command = SSHKit::Command.new(:ls)
       command.exit_status = 0
-      dot << command
-      assert_equal "\e[0;32;49m.\e[0m", output.strip
+      dot.log_command_exit(command)
+      assert_log_output("\e[0;32;49m.\e[0m")
     end
 
     def test_command_failure
+      output.stubs(:tty?).returns(true)
       command = SSHKit::Command.new(:ls, {raise_on_non_zero_exit: false})
       command.exit_status = 1
-      dot << command
-      assert_equal "\e[0;31;49m.\e[0m", output.strip
+      dot.log_command_exit(command)
+      assert_log_output("\e[0;31;49m.\e[0m")
     end
 
+    private
+
+    def assert_log_output(expected_output)
+      assert_equal expected_output, output
+    end
   end
 end

data/test/unit/formatters/test_pretty.rb

@@ -1,50 +1,142 @@
 require 'helper'
-require 'sshkit'
 
 module SSHKit
   class TestPretty < UnitTest
 
     def setup
+      super
       SSHKit.config.output_verbosity = Logger::DEBUG
+      Command.any_instance.stubs(:uuid).returns('aaaaaa')
     end
 
     def output
-      @_output ||= String.new
+      @output ||= String.new
     end
 
     def pretty
-      @_pretty ||= SSHKit::Formatter::Pretty.new(output)
+      @pretty ||= SSHKit::Formatter::Pretty.new(output)
     end
 
-    def teardown
-      remove_instance_variable :@_pretty
-      remove_instance_variable :@_output
-      SSHKit.reset_configuration!
+    {
+      log:   "\e[0;34;49mINFO\e[0m Test\n",
+      fatal: "\e[0;31;49mFATAL\e[0m Test\n",
+      error: "\e[0;31;49mERROR\e[0m Test\n",
+      warn:  "\e[0;33;49mWARN\e[0m Test\n",
+      info:  "\e[0;34;49mINFO\e[0m Test\n",
+      debug: "\e[0;30;49mDEBUG\e[0m Test\n"
+    }.each do |level, expected_output|
+      define_method("test_#{level}_output_with_color") do
+        output.stubs(:tty?).returns(true)
+        pretty.send(level, 'Test')
+        assert_log_output(expected_output)
+      end
     end
 
-    def test_logging_fatal
-      pretty << SSHKit::LogMessage.new(Logger::FATAL, "Test")
-      assert_equal output.strip, "\e[0;31;49mFATAL\e[0m Test"
+    def test_command_lifecycle_logging_with_color
+      output.stubs(:tty?).returns(true)
+      simulate_command_lifecycle(pretty)
+
+      expected_log_lines = [
+        "\e[0;34;49mINFO\e[0m [\e[0;32;49maaaaaa\e[0m] Running \e[1;33;49m/usr/bin/env a_cmd some args\e[0m as \e[0;34;49muser\e[0m@\e[0;34;49mlocalhost\e[0m",
+        "\e[0;30;49mDEBUG\e[0m [\e[0;32;49maaaaaa\e[0m] Command: \e[0;34;49m/usr/bin/env a_cmd some args\e[0m",
+        "\e[0;30;49mDEBUG\e[0m [\e[0;32;49maaaaaa\e[0m] \e[0;32;49m\tstdout message\e[0m",
+        "\e[0;30;49mDEBUG\e[0m [\e[0;32;49maaaaaa\e[0m] \e[0;31;49m\tstderr message\e[0m",
+        "\e[0;34;49mINFO\e[0m [\e[0;32;49maaaaaa\e[0m] Finished in 1.000 seconds with exit status 0 (\e[1;32;49msuccessful\e[0m)."
+      ]
+      assert_equal expected_log_lines, output.split("\n")
+    end
+
+    {
+        log:   "  INFO Test\n",
+        fatal: " FATAL Test\n",
+        error: " ERROR Test\n",
+        warn:  "  WARN Test\n",
+        info:  "  INFO Test\n",
+        debug: " DEBUG Test\n"
+    }.each do |level, expected_output|
+      define_method("test_#{level}_output_without_color") do
+        pretty.send(level, "Test")
+        assert_log_output expected_output
+      end
+    end
+
+    def test_logging_message_with_leading_and_trailing_space
+      pretty.log("       some spaces\n\n  \t")
+      assert_log_output "  INFO some spaces\n"
     end
 
-    def test_logging_error
-      pretty << SSHKit::LogMessage.new(Logger::ERROR, "Test")
-      assert_equal output.strip, "\e[0;31;49mERROR\e[0m Test"
+    def test_can_log_non_strings
+      pretty.log(Pathname.new('/var/log/my.log'))
+      assert_log_output "  INFO /var/log/my.log\n"
     end
 
-    def test_logging_warn
-      pretty << SSHKit::LogMessage.new(Logger::WARN, "Test")
-      assert_equal output.strip, "\e[0;33;49mWARN\e[0m Test".strip
+    def test_command_lifecycle_logging_without_color
+      simulate_command_lifecycle(pretty)
+
+      expected_log_lines = [
+          '  INFO [aaaaaa] Running /usr/bin/env a_cmd some args as user@localhost',
+          ' DEBUG [aaaaaa] Command: /usr/bin/env a_cmd some args',
+          " DEBUG [aaaaaa] \tstdout message",
+          " DEBUG [aaaaaa] \tstderr message",
+          '  INFO [aaaaaa] Finished in 1.000 seconds with exit status 0 (successful).'
+      ]
+
+      assert_equal expected_log_lines, output.split("\n")
     end
 
-    def test_logging_info
-      pretty << SSHKit::LogMessage.new(Logger::INFO, "Test")
-      assert_equal output.strip, "\e[0;34;49mINFO\e[0m Test".strip
+    def test_unsupported_class
+      raised_error = assert_raises RuntimeError do
+        pretty << 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_message_when_verbosity_is_too_low
+      SSHKit.config.output_verbosity = Logger::WARN
+      pretty.info('Some info')
+      assert_log_output('')
+
+      SSHKit.config.output_verbosity = Logger::INFO
+      pretty.info('Some other info')
+      assert_log_output("  INFO Some other info\n")
+    end
+
+    def test_does_not_log_command_when_verbosity_is_too_low
+      SSHKit.config.output_verbosity = Logger::WARN
+      command = Command.new(:ls, host: Host.new('user@localhost'), verbosity: Logger::INFO)
+      pretty.log_command_start(command)
+      assert_log_output('')
+
+      SSHKit.config.output_verbosity = Logger::INFO
+      pretty.log_command_start(command)
+      assert_log_output("  INFO [aaaaaa] Running /usr/bin/env ls as user@localhost\n")
+    end
+
+
+    def test_can_write_to_output_which_just_supports_append
+      # Note output doesn't have to be an IO, it only needs to support <<
+      output = stub(:<<)
+      pretty = SSHKit::Formatter::Pretty.new(output)
+      simulate_command_lifecycle(pretty)
+    end
+
+    private
+
+    def simulate_command_lifecycle(pretty)
+      command = SSHKit::Command.new(:a_cmd, 'some args', host: Host.new('user@localhost'))
+      command.stubs(:runtime).returns(1)
+      pretty.log_command_start(command)
+      command.started = true
+      command.on_stdout(nil, 'stdout message')
+      pretty.log_command_data(command, :stdout, 'stdout message')
+      command.on_stderr(nil, 'stderr message')
+      pretty.log_command_data(command, :stderr, 'stderr message')
+      command.exit_status = 0
+      pretty.log_command_exit(command)
     end
 
-    def test_logging_debug
-      pretty << SSHKit::LogMessage.new(Logger::DEBUG, "Test")
-      assert_equal output.strip, "\e[0;30;49mDEBUG\e[0m Test".strip
+    def assert_log_output(expected_output)
+      assert_equal expected_output, output
     end
 
   end