net-ssh 2.9.4 → 3.0.1

data/lib/net/ssh/known_hosts.rb

@@ -1,4 +1,6 @@
 require 'strscan'
+require 'openssl'
+require 'base64'
 require 'net/ssh/buffer'
 
 module Net; module SSH
@@ -111,7 +113,9 @@ module Net; module SSH
           next if scanner.match?(/$|#/)
 
           hostlist = scanner.scan(/\S+/).split(/,/)
-          next unless entries.all? { |entry| hostlist.include?(entry) }
+          found = entries.all? { |entry| hostlist.include?(entry) } ||
+            known_host_hash?(hostlist, entries, scanner)
+          next unless found
 
           scanner.skip(/\s*/)
           type = scanner.scan(/\S+/)
@@ -127,6 +131,21 @@ module Net; module SSH
       keys
     end
 
+    # Indicates whether one of the entries matches an hostname that has been
+    # stored as a HMAC-SHA1 hash in the known hosts.
+    def known_host_hash?(hostlist, entries, scanner)
+      if hostlist.size == 1 && hostlist.first =~ /\A\|1(\|.+){2}\z/
+        chunks = hostlist.first.split(/\|/)
+        salt = Base64.decode64(chunks[2])
+        digest = OpenSSL::Digest.new('sha1')
+        entries.each do |entry|
+          hmac = OpenSSL::HMAC.digest(digest, salt, entry)
+          return true if Base64.encode64(hmac).chomp == chunks[3]
+        end
+      end
+      false
+    end
+
     # Tries to append an entry to the current source file for the given host
     # and key. If it is unable to (because the file is not writable, for
     # instance), an exception will be raised.

data/lib/net/ssh/proxy/command.rb

@@ -1,4 +1,5 @@
 require 'socket'
+require 'rubygems'
 require 'net/ssh/proxy/errors'
 require 'net/ssh/ruby_compat'
 
@@ -66,12 +67,22 @@ module Net; module SSH; module Proxy
         raise ConnectError, "#{e}: #{command_line}"
       end
       @command_line = command_line
-      class << io
-        def send(data, flag)
+      if Gem.win_platform?
+        # read_nonblock and write_nonblock are not available on Windows
+        # pipe. Use sysread and syswrite as a replacement works.
+        def io.send(data, flag)
+          syswrite(data)
+        end
+
+        def io.recv(size)
+          sysread(size)
+        end
+      else
+        def io.send(data, flag)
           write_nonblock(data)
         end
 
-        def recv(size)
+        def io.recv(size)
           read_nonblock(size)
         end
       end

data/lib/net/ssh/proxy/http.rb

@@ -48,8 +48,9 @@ module Net; module SSH; module Proxy
 
     # Return a new socket connected to the given host and port via the
     # proxy that was requested when the socket factory was instantiated.
-    def open(host, port, connection_options = nil)
-      socket = TCPSocket.new(proxy_host, proxy_port)
+    def open(host, port, connection_options)
+      socket = Socket.tcp(proxy_host, proxy_port, nil, nil,
+                          connect_timeout: connection_options[:timeout])
       socket.write "CONNECT #{host}:#{port} HTTP/1.0\r\n"
 
       if options[:user]

data/lib/net/ssh/proxy/socks4.rb

@@ -48,7 +48,8 @@ module Net
         # Return a new socket connected to the given host and port via the
         # proxy that was requested when the socket factory was instantiated.
         def open(host, port, connection_options)
-          socket = TCPSocket.new(proxy_host, proxy_port)
+          socket = Socket.tcp(proxy_host, proxy_port, nil, nil,
+                              connect_timeout: connection_options[:timeout])
           ip_addr = IPAddr.new(Resolv.getaddress(host))
           
           packet = [VERSION, CONNECT, port.to_i, ip_addr.to_i, options[:user]].pack("CCnNZ*")

data/lib/net/ssh/proxy/socks5.rb

@@ -62,8 +62,9 @@ module Net
 
         # Return a new socket connected to the given host and port via the
         # proxy that was requested when the socket factory was instantiated.
-        def open(host, port, connection_options = nil)
-          socket = TCPSocket.new(proxy_host, proxy_port)
+        def open(host, port, connection_options)
+          socket = Socket.tcp(proxy_host, proxy_port, nil, nil,
+                              connect_timeout: connection_options[:timeout])
 
           methods = [METHOD_NO_AUTH]
           methods << METHOD_PASSWD if options[:user]

data/lib/net/ssh/ruby_compat.rb

@@ -9,11 +9,6 @@ class String
       self[index] = c
     end
   end
-  if RUBY_VERSION < "1.8.7"
-    def bytesize
-      self.size
-    end
-  end
 end
 
 module Net; module SSH

data/lib/net/ssh/transport/algorithms.rb

@@ -224,10 +224,9 @@ module Net; module SSH; module Transport
             end
             lwarn { "unsupported #{algorithm} algorithm: `#{unsupported}'" } unless unsupported.empty?
 
-            # make sure all of our supported algorithms are tacked onto the
-            # end, so that if the user tries to give a list of which none are
-            # supported, we can still proceed.
-            list.each { |name| algorithms[algorithm] << name unless algorithms[algorithm].include?(name) }
+            if options[:append_all_supported_algorithms]
+              list.each { |name| algorithms[algorithm] << name unless algorithms[algorithm].include?(name) }
+            end
           end
         end
 

data/lib/net/ssh/transport/cipher_factory.rb

@@ -76,7 +76,6 @@ module Net; module SSH; module Transport
       cipher.padding = 0
 
       cipher.extend(Net::SSH::Transport::CTR) if (name =~ /-ctr(@openssh.org)?$/)
-
       cipher.iv      = Net::SSH::Transport::KeyExpander.expand_key(cipher.iv_len, options[:iv], options) if ossl_name != "rc4"
 
       key_len = KEY_LEN_OVERRIDE[name] || cipher.key_len

data/lib/net/ssh/transport/server_version.rb

@@ -25,11 +25,11 @@ module Net; module SSH; module Transport
 
     # Instantiates a new ServerVersion and immediately (and synchronously)
     # negotiates the SSH protocol in effect, using the given socket.
-    def initialize(socket, logger)
+    def initialize(socket, logger, timeout = nil)
       @header = ""
       @version = nil
       @logger = logger
-      negotiate!(socket)
+      negotiate!(socket, timeout)
     end
 
     private
@@ -37,9 +37,12 @@ module Net; module SSH; module Transport
       # Negotiates the SSH protocol to use, via the given socket. If the server
       # reports an incompatible SSH version (e.g., SSH1), this will raise an
       # exception.
-      def negotiate!(socket)
+      def negotiate!(socket, timeout)
         info { "negotiating protocol version" }
 
+        if timeout && !IO.select([socket], nil, nil, timeout)
+          raise Net::SSH::ConnectionTimeout, "timeout during server version negotiating"
+        end
         loop do
           @version = ""
           loop do
@@ -63,6 +66,9 @@ module Net; module SSH; module Transport
           raise Net::SSH::Exception, "incompatible SSH version `#{@version}'"
         end
 
+        if timeout && !IO.select(nil, [socket], nil, timeout)
+          raise Net::SSH::ConnectionTimeout, "timeout during client version negotiating"
+        end
         debug { "local is `#{PROTO_VERSION}'" }
         socket.write "#{PROTO_VERSION}\r\n"
         socket.flush

data/lib/net/ssh/transport/session.rb

@@ -1,5 +1,4 @@
 require 'socket'
-require 'timeout'
 
 require 'net/ssh/errors'
 require 'net/ssh/loggable'
@@ -63,14 +62,15 @@ module Net; module SSH; module Transport
       @options = options
 
       debug { "establishing connection to #{@host}:#{@port}" }
-      factory = options[:proxy] || TCPSocket
-      @socket = timeout(options[:timeout] || 0) {
-        case
-        when options[:proxy] then factory.open(@host, @port, options)
-        when @bind_address.nil? then factory.open(@host, @port)
-        else factory.open(@host, @port, @bind_address)
+
+      @socket =
+        if (factory = options[:proxy])
+          factory.open(@host, @port, options)
+        else
+          Socket.tcp(@host, @port, @bind_address, nil,
+                     connect_timeout: options[:timeout])
         end
-      }
+
       @socket.extend(PacketStream)
       @socket.logger = @logger
 
@@ -81,10 +81,12 @@ module Net; module SSH; module Transport
       @host_key_verifier = select_host_key_verifier(options[:paranoid])
 
 
-      @server_version = timeout(options[:timeout] || 0) { ServerVersion.new(socket, logger) }
+      @server_version = ServerVersion.new(socket, logger, options[:timeout])
 
       @algorithms = Algorithms.new(self, options)
       wait { algorithms.initialized? }
+    rescue Errno::ETIMEDOUT
+      raise Net::SSH::ConnectionTimeout
     end
 
     # Returns the host (and possibly IP address) in a format compatible with

data/lib/net/ssh/version.rb

@@ -45,15 +45,15 @@ module Net; module SSH
     end
 
     # The major component of this version of the Net::SSH library
-    MAJOR = 2
+    MAJOR = 3
 
     # The minor component of this version of the Net::SSH library
-    MINOR = 9
+    MINOR = 0
 
     # The tiny component of this version of the Net::SSH library
-    TINY  = 4
+    TINY  = 1
 
-    # The prerelease component of this version of the Net::SSH library
+    # The prerelease component of this version of the Net::SSH library 
     # nil allowed
     PRE   = nil
 

data/lib/net/ssh.rb

@@ -62,13 +62,14 @@ module Net
     # Net::SSH.start for a description of each option.
     VALID_OPTIONS = [
       :auth_methods, :bind_address, :compression, :compression_level, :config,
-      :encryption, :forward_agent, :hmac, :host_key,
+      :encryption, :forward_agent, :hmac, :host_key, :remote_user,
       :keepalive, :keepalive_interval, :keepalive_maxcount, :kex, :keys, :key_data,
       :languages, :logger, :paranoid, :password, :port, :proxy,
       :rekey_blocks_limit,:rekey_limit, :rekey_packet_limit, :timeout, :verbose,
       :global_known_hosts_file, :user_known_hosts_file, :host_key_alias,
       :host_name, :user, :properties, :passphrase, :keys_only, :max_pkt_size,
-      :max_win_size, :send_env, :use_agent, :number_of_password_prompts
+      :max_win_size, :send_env, :use_agent, :number_of_password_prompts,
+      :append_supported_algorithms, :non_interactive
     ]
 
     # The standard means of starting a new SSH connection. When used with a
@@ -168,15 +169,25 @@ module Net
     # * :user => the user name to log in as; this overrides the +user+
     #   parameter, and is primarily only useful when provided via an SSH
     #   configuration file.
+    # * :remote_user => used for substitution into the '%r' part of a ProxyCommand
     # * :user_known_hosts_file => the location of the user known hosts file.
     #   Set to an array to specify multiple user known hosts files.
     #   Defaults to %w(~/.ssh/known_hosts ~/.ssh/known_hosts2).
     # * :use_agent => Set false to disable the use of ssh-agent. Defaults to 
     #   true
+    # * :non_interactive => set to true if your app is non interactive and prefers
+    #   authentication failure vs password prompt
     # * :verbose => how verbose to be (Logger verbosity constants, Logger::DEBUG
     #   is very verbose, Logger::FATAL is all but silent). Logger::FATAL is the
     #   default. The symbols :debug, :info, :warn, :error, and :fatal are also
     #   supported and are translated to the corresponding Logger constant.
+    # * :append_all_supported_algorithms => set to +true+ to append all supported
+    #   algorithms by net-ssh. Was the default behaviour until 2.10
+    # * :number_of_password_prompts => Number of prompts for the password
+    #   authentication method defaults to 3 set to 0 to disable prompt for
+    #   password auth method
+    # * :non_interactive => non interactive applications should set it to true
+    #   to prefer failing a password/etc auth methods vs asking for password
     def self.start(host, user, options={}, &block)
       invalid_options = options.keys - VALID_OPTIONS
       if invalid_options.any?
@@ -192,6 +203,10 @@ module Net
         options[:logger].level = Logger::FATAL
       end
 
+      if options[:non_interactive]
+        options[:number_of_password_prompts] = 0
+      end
+
       if options[:verbose]
         options[:logger].level = case options[:verbose]
           when Fixnum then options[:verbose]

data/net-ssh-public_cert.pem

@@ -1,20 +1,20 @@
 -----BEGIN CERTIFICATE-----
 MIIDODCCAiCgAwIBAgIBADANBgkqhkiG9w0BAQUFADBCMRAwDgYDVQQDDAduZXQt
 c3NoMRkwFwYKCZImiZPyLGQBGRYJc29sdXRpb3VzMRMwEQYKCZImiZPyLGQBGRYD
-Y29tMB4XDTE1MTIwNjIxMDYyNFoXDTE2MTIwNTIxMDYyNFowQjEQMA4GA1UEAwwH
+Y29tMB4XDTE0MTIwMjE3MzkyMFoXDTE1MTIwMjE3MzkyMFowQjEQMA4GA1UEAwwH
 bmV0LXNzaDEZMBcGCgmSJomT8ixkARkWCXNvbHV0aW91czETMBEGCgmSJomT8ixk
-ARkWA2NvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMYnhNtn0f6p
-nTylB8mE8lMdoMLJC8KwpMWsvk73Pe2WVDsH/OSwwwz6oUGk1i70cJyDjIEBNpwT
-88GpVXJSumvqVsf9fCg3mWNeb5t0J+aeNm9MIvYVMTqj5tydoXQiwnILRDYHV9tZ
-1c3o59/VlahSTpZ7YEgzVufpAkvEGkbJiG849exiipK7MN/ZIkMOxYVnyRXk43Xc
-6GYlsHOfSgPwcXwW5g57DCwLQLWrjDsTka28dxDmO7B5Lv5EqzINxVxWsu43OgZG
-21Io/jIyf5PNpeKPKNGDuAQJ8mvdMYBJoDhtCwgsUYbl0BZzA7g4ytl51HtIeP+j
-Qp/eAvs/RrECAwEAAaM5MDcwCQYDVR0TBAIwADAdBgNVHQ4EFgQUBfKiwO2eM4NE
-iRrVG793qEPLYyMwCwYDVR0PBAQDAgSwMA0GCSqGSIb3DQEBBQUAA4IBAQCfZFdb
-p4jzkfIzGDbiOxd0R8sdqJoC4nMLEgnQ7dLulawwA3IXe3sHAKgA5kmH3prsKc5H
-zVmM5NlH2P1nRbegIkQTYiIod1hZQCNxdmVG/fprMqPq0ybpUOjjrP5pj0OtszE1
-F2dQia1hOEstMR+n0nAtWII9HJAEyeZjVV0s2Cl7Pt85XJ3hxFcCKwzqsK5xRI7a
-B3vwh3/JJYrFonIohQ//Lg9qTZASEkoKLlq1/hFeICoCGGIGLq45ZB7CzXLooCKi
-s/ZUKye79ELwFYKJOhjW5g725OL3hy+llhEleytwKRwgXFQBPTC4f5UkdxZVVWGH
-e2C9M1m/2odPZo8h
+ARkWA2NvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJ0qnw4JV5JN
+MWelqu7pnW2z6GZJ7+zLFYJQNETJyF0U5zo7aCRK08OeUxnpu/TCCXK8iQVkNLfz
+9pVIhF+X8pMEIruAkYGwBt1aWfuSNeyodyMk0vpZdxBHbOTJ4qBRUc6qOtNOeOzv
+8ObYUX52P/EMMaeXTRU+e7MGkB9pb6FvPPNx5akxwIaoRvtcMsc/hJnQuP5r96w6
+t06MgKbXhWAX6gev0RVlrQqzxXst6iuvsrgZGjFqzob5wbTiX9M0+bFAB0EI7tJC
+sv5keEbtNRaU7p3ZbMm4wTHHJLOtD+BpUCSzwv4ToNj9mZtJBMYw2Eeo7z1DklEG
+mr95zbe+zNMCAwEAAaM5MDcwCQYDVR0TBAIwADAdBgNVHQ4EFgQU1bTfpzmitXwv
+LmTXi0IO5vd8NGYwCwYDVR0PBAQDAgSwMA0GCSqGSIb3DQEBBQUAA4IBAQA0Aps8
+UPINGa8XUUtrZtzrgX0/iyXNkKY1ld85g1N3WKEAVLfQI7TlGr0Qv2Ekx6RqlxbR
+Vyq08pytSnghW2otR3bIGMGQzqxAeRLb25cjEwH7YIJ32n7ZC1fpMnBZOBDmueWA
+B9EonmoO3ne7AJSgIvBbZzBPhzM4HrQGRW8LsPFsuj+dcJI43HOQwkmv2TRz0+t6
+mGZldmqLcK0abv4JepLfB9XTue3kuyA29NGBibqyvRwlKckLpvKfHZX6Jxad8xxm
+MbvRpzgROzyfw1qYi4dnIyMwTtXFFcZ0a2jpxHPkcTYFK6TzvFgDLAP0Y/u9jqUQ
+eZ7/3CdSi/isZHEw
 -----END CERTIFICATE-----

data/net-ssh.gemspec

@@ -2,17 +2,17 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: net-ssh 2.9.4 ruby lib
+# stub: net-ssh 3.0.1 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "net-ssh"
-  s.version = "2.9.4"
+  s.version = "3.0.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Jamis Buck", "Delano Mandelbaum", "Mikl\u{f3}s Fazekas"]
   s.cert_chain = ["net-ssh-public_cert.pem"]
-  s.date = "2016-01-30"
+  s.date = "2015-09-25"
   s.description = "Net::SSH: a pure-Ruby implementation of the SSH2 client protocol. It allows you to write programs that invoke and interact with processes on remote servers, via SSH2."
   s.email = "net-ssh@solutious.com"
   s.extra_rdoc_files = [
@@ -26,7 +26,6 @@ Gem::Specification.new do |s|
     "Manifest",
     "README.rdoc",
     "Rakefile",
-    "Rudyfile",
     "THANKS.txt",
     "lib/net/ssh.rb",
     "lib/net/ssh/authentication/agent.rb",
@@ -135,12 +134,19 @@ Gem::Specification.new do |s|
     "test/configs/negative_match",
     "test/configs/nohost",
     "test/configs/numeric_host",
+    "test/configs/proxy_remote_user",
     "test/configs/send_env",
     "test/configs/substitutes",
     "test/configs/wild_cards",
     "test/connection/test_channel.rb",
     "test/connection/test_session.rb",
+    "test/integration/README.txt",
+    "test/integration/Vagrantfile",
+    "test/integration/common.rb",
+    "test/integration/playbook.yml",
+    "test/integration/test_id_rsa_keys.rb",
     "test/known_hosts/github",
+    "test/known_hosts/github_hash",
     "test/manual/test_forward.rb",
     "test/manual/test_pageant.rb",
     "test/start/test_connection.rb",
@@ -180,6 +186,7 @@ Gem::Specification.new do |s|
   ]
   s.homepage = "https://github.com/net-ssh/net-ssh"
   s.licenses = ["MIT"]
+  s.required_ruby_version = Gem::Requirement.new(">= 2.0")
   s.rubyforge_project = "net-ssh"
   s.rubygems_version = "2.4.6"
   s.signing_key = "/mnt/gem/net-ssh-private_key.pem"

data/setup.rb

@@ -1460,7 +1460,7 @@ class Installer
     begin
       require 'test/unit'
     rescue LoadError
-      setup_rb_error 'test/unit cannot loaded.  You need Ruby 1.8 or later to invoke this task.'
+      setup_rb_error 'test/unit cannot loaded.  You need Ruby 1.9 or later to invoke this task.'
     end
     runner = Test::Unit::AutoRunner.new(true)
     runner.to_run << TESTDIR

data/test/README.txt

@@ -1,28 +1,21 @@
-2011-01-19
-
 RUNNING TESTS
 
 Run the test suite from the net-ssh directory with the following command:
 
-     ruby -Ilib -Itest -rrubygems test/test_all.rb
+     ruby -Ilib -Itest test/test_all.rb
 
 Run a single test file like this:
 
-     ruby -Ilib -Itest -rrubygems test/transport/test_server_version.rb
-
+     ruby -Ilib -Itest test/transport/test_server_version.rb
 
 EXPECTED RESULTS
 
-* Ruby 1.9: all tests pass
-
-* Ruby 1.8: all tests pass (up until version 2.5)
-
-* JRuby 1.7: 98% test pass (510 tests, 1914 assertions, 2 failures, 9 errors)
-
-* JRuby 1.6: 98% test pass (510 tests, 1914 assertions, 4 failures, 5 errors)
+     https://travis-ci.org/net-ssh/net-ssh/
 
-* JRuby 1.5: 98% tests pass (510 tests, 1914 assertions, 5 failures, 5 errors)
+INTEGRATION TESTS
 
+     brew install ansible ; ansible-galaxy install rvm_io.rvm1-ruby ; vagrant up ; vagrant ssh
+     cd /net-ssh ; rake integration-test
 
 PORT FORWARDING TESTS
 

data/test/authentication/methods/test_keyboard_interactive.rb

@@ -71,6 +71,27 @@ module Authentication; module Methods
       assert subject.authenticate("ssh-connection", "jamis", "the-password")
     end
 
+    def test_authenticate_should_not_prompt_for_input_when_in_non_interactive_mode
+
+      def transport.options
+        {non_interactive: true}
+      end
+      transport.expect do |t,packet|
+        assert_equal USERAUTH_REQUEST, packet.type
+        t.return(USERAUTH_INFO_REQUEST, :string, "", :string, "", :string, "", :long, 2, :string, "Name:", :bool, true, :string, "Password:", :bool, false)
+        t.expect do |t2,packet2|
+          assert_equal USERAUTH_INFO_RESPONSE, packet2.type
+          assert_equal 2, packet2.read_long
+          assert_equal "", packet2.read_string
+          assert_equal "", packet2.read_string
+          t2.return(USERAUTH_SUCCESS)
+        end
+      end
+
+      assert subject.authenticate("ssh-connection", "jamis", nil)
+    end
+
+
     def test_authenticate_should_prompt_for_input_when_password_is_not_given
       subject.expects(:prompt).with("Name:", true).returns("name")
       subject.expects(:prompt).with("Password:", false).returns("password")

data/test/authentication/test_key_manager.rb

@@ -56,6 +56,15 @@ module Authentication
       assert_equal({:from => :file, :file => second, :key => dsa}, manager.known_identities[dsa])
     end
 
+    def test_each_identity_should_not_prompt_for_passphrase_in_non_interactive_mode
+      manager(:non_interactive => true).stubs(:agent).returns(nil)
+      first = File.expand_path("/first")
+      stub_file_private_key first, rsa, :passphrase => :should_not_be_asked
+      identities = []
+      manager.each_identity { |identity| identities << identity }
+      assert_equal(identities, [])
+    end
+
     def test_identities_should_load_from_agent
       manager.stubs(:agent).returns(agent)
 
@@ -156,7 +165,9 @@ module Authentication
 
       def stub_file_private_key(name, key, options = {})
         manager.add(name)
+        File.stubs(:file?).with(name).returns(true)
         File.stubs(:readable?).with(name).returns(true)
+        File.stubs(:file?).with(name + ".pub").returns(true)
         File.stubs(:readable?).with(name + ".pub").returns(false)
 
         case options.fetch(:passphrase, :indifferently)
@@ -179,7 +190,9 @@ module Authentication
 
       def stub_file_public_key(name, key)
         manager.add(name)
-        File.stubs(:readable?).with(name).returns(false)
+        File.stubs(:file?).with(name).returns(true)
+        File.stubs(:readable?).with(name).returns(true)
+        File.stubs(:file?).with(name + ".pub").returns(true)
         File.stubs(:readable?).with(name + ".pub").returns(true)
 
         Net::SSH::KeyFactory.expects(:load_public_key).with(name + ".pub").returns(key).at_least_once

data/test/configs/proxy_remote_user

@@ -0,0 +1,2 @@
+Host behind-proxy
+  ProxyCommand ssh %r@proxy -W %h:%p

data/test/connection/test_channel.rb

@@ -74,11 +74,8 @@ module Connection
       assert !channel.closing?
 
       connection.expect { |t,packet| assert_equal CHANNEL_CLOSE, packet.type }
-      connection.expects(:cleanup_channel).with(channel)
       channel.close
 
-      channel.process
-
       assert channel.closing?
     end
 

data/test/connection/test_session.rb

@@ -117,14 +117,14 @@ module Connection
     end
 
     def test_process_should_exit_after_processing_if_block_is_true_then_false
-      session.channels[0] = stub("channel", :local_closed? => false)
+      session.channels[0] = stub("channel", :closing? => false)
       session.channels[0].expects(:process)
       IO.expects(:select).never
       process_times(2)
     end
 
     def test_process_should_not_process_channels_that_are_closing
-      session.channels[0] = stub("channel", :local_closed? => true)
+      session.channels[0] = stub("channel", :closing? => true)
       session.channels[0].expects(:process).never
       IO.expects(:select).never
       process_times(2)
@@ -299,17 +299,8 @@ module Connection
     end
 
     def test_channel_close_packet_should_be_routed_to_corresponding_channel_and_channel_should_be_closed_and_removed
-      session.channels[14] = stub("channel") do
-          # this simulates the case where we closed the channel first, sent
-          # CHANNEL_CLOSE to server and are waiting for server's response.
-          expects(:local_closed?).returns(true)
-          expects(:do_close)
-          expects(:close).with()
-          expects(:remote_closed!).with()
-          expects(:remote_closed?).with().returns(true)
-          expects(:local_id).returns(14)
-      end
-
+      channel_at(14).expects(:do_close).with()
+      session.channels[14].expects(:close).with()
       transport.return(CHANNEL_CLOSE, :long, 14)
       process_times(2)
       assert session.channels.empty?
@@ -386,13 +377,13 @@ module Connection
       options = { :keepalive => true, :keepalive_interval => 300, :keepalive_maxcount => 3 }
       expected_packet = P(:byte, Net::SSH::Packet::GLOBAL_REQUEST, :string, "keepalive@openssh.com", :bool, true)
       [1,2,3].each do |i|
-        Time.stubs(:now).returns(i*300)
+        Time.stubs(:now).returns(Time.at(i*300))
         IO.stubs(:select).with([socket],[],nil,timeout).returns(nil)
-        transport.expects(:enqueue_message).with{ |msg| msg.content == expected_packet.content  }
+        transport.expects(:enqueue_message).with{ |msg| msg.content == expected_packet.content }
         session(options).process
       end
 
-      Time.stubs(:now).returns(4*300)
+      Time.stubs(:now).returns(Time.at(4*300))
       IO.stubs(:select).with([socket],[],nil,timeout).returns(nil)
       transport.expects(:enqueue_message).with{ |msg| msg.content == expected_packet.content }
       assert_raises(Net::SSH::Timeout) { session(options).process }
@@ -482,6 +473,11 @@ module Connection
       assert_equal "some data", session.exec!("ls")
     end
 
+    def test_exec_bang_without_block_should_return_empty_string_for_empty_command_output
+      prep_exec('ls', :stdout, '')
+      assert_equal "", session.exec!('ls')
+    end
+
     private
 
       def prep_exec(command, *data)
@@ -497,10 +493,8 @@ module Connection
 
             t2.return(CHANNEL_SUCCESS, :long, p[:remote_id])
 
-            0.step(data.length-1, 2) do |index|
-              type = data[index]
-              datum = data[index+1]
-
+            data.each_slice(2) do |type, datum|
+              next if datum.empty?
               if type == :stdout
                 t2.return(CHANNEL_DATA, :long, p[:remote_id], :string, datum)
               else
@@ -532,7 +526,7 @@ module Connection
       end
 
       def channel_at(local_id)
-        session.channels[local_id] = stub("channel", :process => true, :local_closed? => false)
+        session.channels[local_id] = stub("channel", :process => true, :closing? => false)
       end
 
       def transport(options={})

data/test/integration/README.txt

@@ -0,0 +1,19 @@
+# Integration tests with vagrant
+
+Requirements:
+
+* Vagrant (https://www.vagrantup.com/)
+* Ansible (http://docs.ansible.com/intro_installation.html)
+
+Setup:
+
+    ansible-galaxy install rvm_io.rvm1-ruby
+    vagrant up
+    vagrant ssh
+    cd /net-ssh
+    rake integration-test
+
+# TODO
+
+* get it running on ci (probalby needs docker)
+* could not get gem install jeweler to work

data/test/integration/Vagrantfile

@@ -0,0 +1,12 @@
+VAGRANTFILE_API_VERSION = "2"
+
+Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
+  config.vm.box = "ubuntu/trusty64"
+  config.vm.provision "ansible" do |ansible|
+    ansible.playbook = "./playbook.yml"
+    ansible.sudo = true
+    ansible.verbose ='vvvv'
+  end
+
+  config.vm.synced_folder "../..", "/net-ssh"
+end