net-ssh 4.0.0.alpha1 → 4.0.0.alpha2

data/test/integration/README.md

@@ -1,18 +0,0 @@
-# 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
-    rvm all do bundle
-    rvm all do rake test
-
-# TODO
-
-* get it running on ci (probalby needs docker)
-* could not get gem install jeweler to work

data/test/integration/Vagrantfile

@@ -1,12 +0,0 @@
-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

data/test/integration/common.rb

@@ -1,65 +0,0 @@
-$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../../lib"
-gem "test-unit" # http://rubyforge.org/pipermail/test-unit-tracker/2009-July/000075.html
-gem 'mocha'
-require 'test/unit'
-require 'mocha/setup'
-require 'pty'
-require 'expect'
-
-module IntegrationTestHelpers
-  VERBOSE = false
-  def sh command
-    puts "$ #{command}" if VERBOSE
-    res = system(command)
-    status = $?
-    raise "Command: #{command} failed:#{status.exitstatus}" unless res
-  end
-
-  def tmpdir(&block)
-    Dir.mktmpdir do |dir|
-      yield(dir)
-    end
-  end
-
-  def set_authorized_key(user,pubkey)
-    authorized_key = "/home/#{user}/.ssh/authorized_keys"
-    sh "sudo cp #{pubkey} #{authorized_key}"
-    sh "sudo chown #{user} #{authorized_key}"
-    sh "sudo chmod 0744 #{authorized_key}"
-  end
-
-  def with_agent(&block)
-    puts "/usr/bin/ssh-agent -c" if VERBOSE
-    agent_out = `/usr/bin/ssh-agent -c`
-    agent_out.split("\n").each do |line|
-      if line =~ /setenv (\S+) (\S+);/
-        ENV[$1] = $2
-        puts "ENV[#{$1}]=#{$2}" if VERBOSE
-      end
-    end
-    begin
-      yield
-    ensure
-      sh "/usr/bin/ssh-agent -k > /dev/null"
-    end
-  end
-
-  def ssh_add(key,password)
-    command = "ssh-add #{key}"
-    status = nil
-    PTY.spawn(command) do |reader, writer, pid|
-      begin
-        reader.expect(/Enter passphrase for .*:/) { |data| puts data }
-        writer.puts(password)
-        until reader.eof? do
-          line = reader.readline
-          puts line if VERBOSE
-        end
-      rescue Errno::EIO => _e
-      end
-      pid, status = Process.wait2 pid
-    end
-    raise "Command: #{command} failed:#{status.exitstatus}" unless status
-    status.exitstatus
-  end
-end

data/test/integration/playbook.yml

@@ -1,57 +0,0 @@
----
-- hosts: all
-  sudo: yes
-  vars:
-    ruby_version: '2.0.0-p598'
-    ruby_versions:
-      - '2.0.0-p598'
-      - '2.3.0'
-    rvm_install_path: '/usr/local/rvm'
-    foopwd: "$6$mhOzf/yapZwS$3RwDl4GfWZ5VcfcsHrK9xNNTxyzLOJBsmMttDNaegIbXxMahV86.v/5HsNtit16MEl0EFf5CSW8Dz2yXV.8GB0"
-    foo2pwd: "$6$JiB7y7.M0yI$Abt.ZGIc4DwkRWeI6nKxzzPUZcux7hLRXSdpoKoZvswJz1SZyg5GRQWn9pGID0dgC6e4wFglfW6ev/qZoTqGk/"
-  pre_tasks:
-    - name: get currently installed ruby version
-      command: "{{rvm_install_path}}/rubies/ruby-{{ruby_version}}/bin/ruby -e 'puts \"#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}\"'"
-      register: current_ruby_version
-      ignore_errors: True
-  roles:
-    - { role: rvm_io.rvm1-ruby,
-        tags: ruby, sudo: True,
-        rvm1_rubies: ["ruby-{{ruby_version}}","ruby-2.3.0"],
-        rvm1_install_path: "{{rvm_install_path}}",
-        rvm1_gpg_key_server: pool.sks-keyservers.net,
-        when: "'{{current_ruby_version.stdout|default()}}' != '{{ruby_version}}'" }
-  tasks:
-    - user: name=net_ssh_1 password="{{foopwd}}" group=vagrant state=present
-    - user: name=net_ssh_2 password="{{foo2pwd}}" group=vagrant state=present
-    - file: dest=/home/net_ssh_1/.ssh/ state=directory mode=0740 owner=net_ssh_1
-    - file: dest=/home/net_ssh_2/.ssh/ state=directory mode=0740 owner=net_ssh_2
-    - lineinfile: dest=/etc/sudoers.d/net_ssh_1 mode=0440 state=present create=yes
-        line='net_ssh_1 ALL=(ALL) NOPASSWD:ALL' regexp=net_ssh_1
-    - lineinfile: dest=/etc/sudoers.d/net_ssh_1 mode=0440 state=present create=yes
-        line='net_ssh_2 ALL=(ALL) NOPASSWD:ALL' regexp=net_ssh_2
-    - command: ssh-keygen -A
-      args:
-        creates: /etc/ssh/ssh_host_ed25519_key
-      notify: restart sshd
-    - name: sshd debug
-      lineinfile: dest='/etc/ssh/sshd_config' line='LogLevel DEBUG' regexp=LogLevel
-      notify: restart sshd
-    - name: put NET_SSH_RUN_INTEGRATION_TESTS=YES environment
-      lineinfile: dest='/etc/environment' line='NET_SSH_RUN_INTEGRATION_TESTS=YES'
-    - name: change dir in bashrc
-      lineinfile: dest=/home/vagrant/.bashrc owner=vagrant mode=0644
-        regexp='^cd ' line='cd /net-ssh'
-    - apt: name="{{item}}" state=present
-      with_items:
-        - pv
-        - libgmp3-dev
-    - gem: name="{{ item[1] }}" state=present user_install=no executable=/usr/local/rvm/wrappers/ruby-{{ item[0] }}/gem
-      with_nested:
-        - "{{ruby_versions}}"
-        - [ 'byebug', 'jeweler', 'mocha', 'rbnacl', 'rbnacl-libsodium' ]
-    - copy: content='echo "cd /net-ssh ; rake integration-test"' dest=/etc/update-motd.d/99-net-ssh-tests mode=0755
-  handlers:
-    - name: restart sshd
-      service: name=ssh state=restarted
-

data/test/integration/test_ed25519_pkeys.rb

@@ -1,70 +0,0 @@
-require_relative 'common'
-require 'fileutils'
-require 'tmpdir'
-
-require 'net/ssh'
-
-# see Vagrantfile,playbook for env.
-# we're running as net_ssh_1 user password foo
-# and usually connecting to net_ssh_2 user password foo2pwd
-class TestED25519PKeys < Test::Unit::TestCase
-  include IntegrationTestHelpers
-
-  def test_in_file_no_password
-    Dir.mktmpdir do |dir|
-      sh "rm -rf #{dir}/id_rsa_ed25519 #{dir}/id_rsa_ed25519.pub"
-      sh "ssh-keygen -q -f #{dir}/id_rsa_ed25519 -t ed25519 -N ''"
-      set_authorized_key('net_ssh_1',"#{dir}/id_rsa_ed25519.pub")
-
-      # TODO: fix bug in net ssh which reads public key even if private key is there
-      sh "mv #{dir}/id_rsa_ed25519.pub #{dir}/id_rsa_ed25519.pub.hidden"
-      
-      #sshopts = '-vvvv -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no'
-      #sh "ssh -i #{dir}/id_rsa_ed25519 #{sshopts} net_ssh_1@localhost echo 'hello'"
-
-      ret = Net::SSH.start("localhost", "net_ssh_1", {keys: "#{dir}/id_rsa_ed25519"}) do |ssh|
-        ssh.exec! 'echo "hello from:$USER"'
-      end
-      assert_equal "hello from:net_ssh_1\n", ret
-    end
-  end
-
-
-  def test_ssh_agent
-    Dir.mktmpdir do |dir|
-      with_agent do
-        sh "rm -rf #{dir}/id_rsa_ed25519 #{dir}/id_rsa_ed25519.pub"
-        sh "ssh-keygen -q -f #{dir}/id_rsa_ed25519 -t ed25519 -N 'pwd'"
-        set_authorized_key('net_ssh_1',"#{dir}/id_rsa_ed25519.pub")
-        ssh_add("#{dir}/id_rsa_ed25519","pwd")
-
-        # TODO: fix bug in net ssh which reads public key even if private key is there
-        sh "mv #{dir}/id_rsa_ed25519.pub #{dir}/id_rsa_ed25519.pub.hidden"
-
-        ret = Net::SSH.start("localhost", "net_ssh_1") do |ssh|
-          ssh.exec! 'echo "hello from:$USER"'
-        end
-        assert_equal "hello from:net_ssh_1\n", ret
-      end
-    end
-  end
-
-  def test_in_file_with_password
-    Dir.mktmpdir do |dir|
-      sh "rm -rf #{dir}/id_rsa_ed25519 #{dir}/id_rsa_ed25519.pub"
-      sh "ssh-keygen -q -f #{dir}/id_rsa_ed25519 -t ed25519 -N 'pwd'"
-      set_authorized_key('net_ssh_1',"#{dir}/id_rsa_ed25519.pub")
-
-      # TODO: fix bug in net ssh which reads public key even if private key is there
-      sh "mv #{dir}/id_rsa_ed25519.pub #{dir}/id_rsa_ed25519.pub.hidden"
-
-      #sshopts = '-vvvv -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no'
-      #sh "ssh -i #{dir}/id_rsa_ed25519 #{sshopts} net_ssh_1@localhost echo 'hello'"
-
-      ret = Net::SSH.start("localhost", "net_ssh_1", {keys: "#{dir}/id_rsa_ed25519", passphrase:'pwd'}) do |ssh|
-        ssh.exec! 'echo "hello from:$USER"'
-      end
-      assert_equal "hello from:net_ssh_1\n", ret
-    end
-  end
-end

data/test/integration/test_forward.rb

@@ -1,532 +0,0 @@
-#     $ ruby -Ilib -Itest -rrubygems test/manual/test_forward.rb
-
-# Tests for the following patch:
-#
-#   http://github.com/net-ssh/net-ssh/tree/portfwfix
-#
-# It fixes 3 issues, regarding closing forwarded ports:
-#
-# 1.) if client closes a forwarded connection, but the server is reading, net-ssh terminates with IOError socket closed.
-# 2.) if client force closes (RST) a forwarded connection, but server is reading, net-ssh terminates with
-# 3.) if server closes the sending side, the on_eof is not handled.
-#
-# More info:
-#
-# http://net-ssh.lighthouseapp.com/projects/36253/tickets/7
-
-require_relative './common'
-require 'net/ssh/buffer'
-require 'net/ssh'
-require 'timeout'
-require 'tempfile'
-
-class TestForward < Test::Unit::TestCase
-  include IntegrationTestHelpers
-
-  def localhost
-    'localhost'
-  end
-
-  def user
-    'net_ssh_1'
-  end
-
-  def ssh_start_params
-    [localhost ,user , {:keys => @key_id_rsa}]
-  end
-
-  def setup_ssh_env(&block)
-    tmpdir do |dir|
-      @key_id_rsa = "#{dir}/id_rsa"
-      sh "rm -rf #{@key_id_rsa} #{@key_id_rsa}.pub"
-      sh "ssh-keygen -q -f #{@key_id_rsa} -t rsa -N ''"
-      set_authorized_key(user,"#{@key_id_rsa}.pub")
-      yield
-    end
-  end
-
-  def start_server_sending_lot_of_data(exceptions)
-    server = TCPServer.open(0)
-    Thread.start do
-      loop do
-        Thread.start(server.accept) do |client|
-          begin
-            10000.times do |i|
-              client.puts "item#{i}"
-            end
-            client.close
-          rescue
-            exceptions << $!
-            raise
-          end
-        end
-      end
-    end
-    return server
-  end
-
-  def start_server_closing_soon(exceptions=nil)
-    server = TCPServer.open(0)
-    Thread.start do
-      loop do
-        Thread.start(server.accept) do |client|
-          begin
-            client.recv(1024)
-            client.setsockopt(Socket::SOL_SOCKET, Socket::SO_LINGER, [1, 0].pack("ii"))
-            client.close
-          rescue
-            exceptions <<  $!
-            raise
-          end
-        end
-      end
-    end
-    return server
-  end
-
-  def test_in_file_no_password
-    setup_ssh_env do
-      ret = Net::SSH.start(*ssh_start_params) do |ssh|
-      #ret = Net::SSH.start("localhost", "net_ssh_1", {keys: @key_id_rsa}) do |ssh|
-        ssh.exec! 'echo "hello from:$USER"'
-      end
-      assert_equal "hello from:net_ssh_1\n", ret
-    end
-  end
-
-  def test_local_ephemeral_port_should_work_correctly
-    setup_ssh_env do
-      session = Net::SSH.start(*ssh_start_params)
-
-      assert_nothing_raised do
-        assigned_port = session.forward.local(0, localhost, 22)
-        assert_not_nil assigned_port
-        assert_operator assigned_port, :>, 0
-      end
-    end
-  end
-
-  def test_remote_ephemeral_port_should_work_correctly
-    setup_ssh_env do
-      session = Net::SSH.start(*ssh_start_params)
-
-      assert_nothing_raised do
-        session.forward.remote(22, localhost, 0, localhost)
-        session.loop { !(session.forward.active_remotes.length > 0) }
-        assigned_port = session.forward.active_remotes.first[0]
-        assert_not_nil assigned_port
-        assert_operator assigned_port, :>, 0
-      end
-    end
-  end
-
-  def test_remote_callback_should_fire
-    setup_ssh_env do
-      session = Net::SSH.start(*ssh_start_params)
-
-      assert_nothing_raised do
-        got_port = nil
-        session.forward.remote(22, localhost, 0, localhost) do |port|
-          got_port = port
-        end
-        session.loop { !(session.forward.active_remotes.length > 0) }
-        assert_operator session.forward.active_remote_destinations.length, :==, 1
-        assert_operator session.forward.active_remote_destinations.keys.first, :==, [ 22, localhost ]
-        assert_operator session.forward.active_remote_destinations.values.first, :==, [ got_port, localhost ]
-        assert_operator session.forward.active_remotes.first, :==, [ got_port, localhost ]
-        assigned_port = session.forward.active_remotes.first[0]
-        assert_operator got_port, :==, assigned_port
-        assert_not_nil assigned_port
-        assert_operator assigned_port, :>, 0
-      end
-    end
-  end
-
-  def test_remote_callback_should_fire_on_error_and_still_throw_exception
-    setup_ssh_env do
-      session = Net::SSH.start(*ssh_start_params)
-
-      assert_nothing_raised do
-        session.forward.remote(22, localhost, 22, localhost) do |port|
-          assert_operator port, :==, :error
-        end
-      end
-      assert_raises(Net::SSH::Exception) do
-        session.loop { true }
-      end
-    end
-  end
-
-  def test_remote_callback_should_fire_on_error_but_not_throw_exception_if_asked_not_to
-    setup_ssh_env do
-      session = Net::SSH.start(*ssh_start_params)
-
-      assert_nothing_raised do
-        got_port = nil
-        session.forward.remote(22, localhost, 22, localhost) do |port|
-          assert_operator port, :==, :error
-          got_port = port
-          :no_exception
-        end
-        session.loop { !got_port }
-        assert_operator got_port, :==, :error
-        assert_operator session.forward.active_remotes.length, :==, 0
-      end
-    end
-  end
-
-  def test_loop_should_not_abort_when_local_side_of_forward_is_closed
-    setup_ssh_env do
-      session = Net::SSH.start(*ssh_start_params)
-      server_exc = Queue.new
-      server = start_server_sending_lot_of_data(server_exc)
-      remote_port = server.addr[1]
-      local_port = 0 # request ephemeral port
-      session.forward.local(local_port, localhost, remote_port)
-      client_done = Queue.new
-      Thread.start do
-        begin
-          client = TCPSocket.new(localhost, local_port)
-          client.recv(1024)
-          client.close
-          sleep(0.2)
-        ensure
-          client_done << true
-        end
-      end
-      session.loop(0.1) { client_done.empty? }
-      assert_equal "Broken pipe", "#{server_exc.pop}" unless server_exc.empty?
-    end
-  end
-
-  def test_loop_should_not_abort_when_local_side_of_forward_is_reset
-    setup_ssh_env do
-      session = Net::SSH.start(*ssh_start_params)
-      server_exc = Queue.new
-      server = start_server_sending_lot_of_data(server_exc)
-      remote_port = server.addr[1]
-      local_port = 0 # request ephemeral port
-      session.forward.local(local_port, localhost, remote_port)
-      client_done = Queue.new
-      Thread.start do
-        begin
-          client = TCPSocket.new(localhost, local_port)
-          client.recv(1024)
-          client.setsockopt(Socket::SOL_SOCKET, Socket::SO_LINGER, [1, 0].pack("ii"))
-          client.close
-          sleep(0.1)
-        ensure
-          client_done << true
-        end
-      end
-      session.loop(0.1) { client_done.empty? }
-      assert_equal "Broken pipe", "#{server_exc.pop}" unless server_exc.empty?
-    end
-  end
-
-  def create_local_socket(&blk)
-    tempfile = Tempfile.new("net_ssh_forward_test")
-    path = tempfile.path
-    tempfile.delete
-    yield UNIXServer.open(path)
-    File.delete(path)
-  end if defined?(UNIXServer)
-
-  def test_forward_local_unix_socket_to_remote_port
-    setup_ssh_env do
-      session = Net::SSH.start(*ssh_start_params)
-      server_exc = Queue.new
-      server = start_server_sending_lot_of_data(server_exc)
-      remote_port = server.addr[1]
-      client_data = nil
-
-      create_local_socket do |local_socket|
-        session.forward.local(local_socket, localhost, remote_port)
-        client_done = Queue.new
-
-        Thread.start do
-          begin
-            client = UNIXSocket.new(local_socket.path)
-            client_data = client.recv(1024)
-            client.close
-            sleep(0.2)
-          ensure
-            client_done << true
-          end
-        end
-
-        session.loop(0.1) { client_done.empty? }
-      end
-
-      assert_not_nil(client_data, "client should have received data")
-      assert(client_data.match(/item\d/), 'client should have received the string item')
-    end
-  end if defined?(UNIXSocket)
-
-  def test_loop_should_not_abort_when_server_side_of_forward_is_closed
-    setup_ssh_env do
-      session = Net::SSH.start(*ssh_start_params)
-      server = start_server_closing_soon
-      remote_port = server.addr[1]
-      local_port = 0 # request ephemeral port
-      session.forward.local(local_port, localhost, remote_port)
-      client_done = Queue.new
-      Thread.start do
-        begin
-          client = TCPSocket.new(localhost, local_port)
-          1.times do |i|
-            client.puts "item#{i}"
-          end
-          client.close
-          sleep(0.1)
-        ensure
-          client_done << true
-        end
-      end
-      session.loop(0.1) { client_done.empty? }
-    end
-  end
-
-  def start_server(server = nil, &block)
-    server ||= TCPServer.open(0)
-    Thread.start do
-      loop do
-        Thread.start(server.accept) do |client|
-          yield(client)
-        end
-      end
-    end
-    return server
-  end
-
-  def test_client_close_should_be_handled_remote
-    setup_ssh_env do
-      message = "This is a small message!"*1000
-      session = Net::SSH.start(*ssh_start_params)
-      server_done = Queue.new
-      server = start_server do |client|
-        begin
-          data = client.read message.size
-          server_done << data
-          client.close
-        rescue
-          server_done << $!
-        end
-      end
-      client_done = Queue.new
-      got_remote_port = Queue.new
-      local_port = server.addr[1]
-      session.forward.remote(0, localhost, local_port) do |actual_remote_port|
-        got_remote_port << actual_remote_port
-      end
-      session.loop(0.1) { got_remote_port.empty? }
-      remote_port = got_remote_port.pop
-      Thread.start do
-        begin
-          client = TCPSocket.new(localhost, remote_port)
-          client.write(message)
-          client.close
-          client_done << true
-        rescue
-          client_done << $!
-        end
-      end
-      Timeout.timeout(5) do
-        session.loop(0.1) { server_done.empty? }
-        assert_equal message, server_done.pop
-      end
-    end
-  end
-
-  def test_client_close_should_be_handled
-    setup_ssh_env do
-      message = "This is a small message!"*1000
-      session = Net::SSH.start(*ssh_start_params)
-      server_done = Queue.new
-      server = start_server do |client|
-        begin
-          data = client.read message.size
-          server_done << data
-          client.close
-        rescue
-          server_done << $!
-        end
-      end
-      client_done = Queue.new
-      remote_port = server.addr[1]
-      local_port = session.forward.local(0, localhost, remote_port)
-      Thread.start do
-        begin
-          client = TCPSocket.new(localhost, local_port)
-          client.write(message)
-          client.close
-          client_done << true
-        rescue
-          client_done << $!
-        end
-      end
-      Timeout.timeout(5) do
-        session.loop(0.1) { server_done.empty? }
-        assert_equal message, server_done.pop
-      end
-    end
-  end
-
-  def test_server_eof_should_be_handled_remote
-    setup_ssh_env do
-      message = "This is a small message!"
-      session = Net::SSH.start(*ssh_start_params)
-      server = start_server do |client|
-        client.write message
-        client.close
-      end
-      client_done = Queue.new
-      got_remote_port = Queue.new
-      local_port = server.addr[1]
-      session.forward.remote(0, localhost, local_port) do |actual_remote_port|
-        got_remote_port << actual_remote_port
-      end
-      session.loop(0.1) { got_remote_port.empty? }
-      remote_port = got_remote_port.pop
-      Thread.start do
-        begin
-          client = TCPSocket.new(localhost, remote_port)
-          data = client.read(4096)
-          client.close
-          client_done << data
-        rescue
-          client_done << $!
-        end
-      end
-      Timeout.timeout(5) do
-        session.loop(0.1) { client_done.empty? }
-        assert_equal message, client_done.pop
-      end
-    end
-  end
-
-  def test_server_eof_should_be_handled
-    setup_ssh_env do
-      message = "This is a small message!"
-      session = Net::SSH.start(*ssh_start_params)
-      server = start_server do |client|
-        client.write message
-        client.close
-      end
-      client_done = Queue.new
-      remote_port = server.addr[1]
-      local_port = session.forward.local(0, localhost, remote_port)
-      Thread.start do
-        begin
-          client = TCPSocket.new(localhost, local_port)
-          data = client.read(4096)
-          client.close
-          client_done << data
-        rescue
-          client_done << $!
-        end
-      end
-      Timeout.timeout(5) do
-        session.loop(0.1) { client_done.empty? }
-        assert_equal message, client_done.pop
-      end
-    end
-  end
-
-  def _run_reading_client(client_done, local_port)
-    Thread.start do
-      begin
-        client = TCPSocket.new(localhost, local_port)
-        data = client.read(4096)
-        client.close
-        client_done << data
-      rescue
-        client_done << $!
-      end
-    end
-  end
-
-  def test_cannot_open_connection_should_allow_further_connections_on_different_forward
-    setup_ssh_env do
-      session = Net::SSH.start(*ssh_start_params)
-      server = start_server do |client|
-        _data = client.write "hello"
-        client.close
-      end
-      # Forward to a non existing port
-      non_existing_port = 1234
-      local_port = session.forward.local(0, localhost, non_existing_port)
-      # should return connection refused
-      client_done = Queue.new
-      _run_reading_client(client_done, local_port)
-      Timeout.timeout(5) do
-        session.loop(0.1) { client_done.empty? }
-      end
-      assert_equal nil, client_done.pop
-      assert client_done.empty?
-      # Forward to existing port
-      remote_port = server.addr[1]
-      local_port = session.forward.local(0, localhost, remote_port)
-      _run_reading_client(client_done, local_port)
-      Timeout.timeout(5) do
-        session.loop(0.1) { client_done.empty? }
-      end
-      assert_equal "hello", client_done.pop
-      assert client_done.empty?
-    end
-  end
-
-  def test_cannot_open_connection_should_allow_further_connections_on_same
-    setup_ssh_env do
-      session = Net::SSH.start(*ssh_start_params)
-      server = TCPServer.open(0)
-      # Forward to a non existing port
-      remote_port = server.addr[1]
-      server.close
-      local_port = session.forward.local(0, localhost, remote_port)
-      # should return connection refused
-      client_done = Queue.new
-      _run_reading_client(client_done, local_port)
-      Timeout.timeout(5) do
-        session.loop(0.1) { client_done.empty? }
-      end
-      assert_equal nil, client_done.pop
-      assert client_done.empty?
-      # start server
-      server = TCPServer.open(remote_port)
-      server = start_server(server) do |client|
-        _data = client.write "hello"
-        client.close
-      end
-      _run_reading_client(client_done, local_port)
-      Timeout.timeout(5) do
-        session.loop(0.1) { client_done.empty? }
-      end
-      assert_equal "hello", client_done.pop
-      assert client_done.empty?
-    end
-  end
-
-  def test_cancel_local
-    setup_ssh_env do
-      session = Net::SSH.start(*ssh_start_params)
-      server = start_server(server) do |client|
-        _data = client.write "hello"
-        client.close
-      end
-      remote_port = server.addr[1]
-      local_port = session.forward.local(0, localhost, remote_port)
-      # run client
-      client_done = Queue.new
-      _run_reading_client(client_done, local_port)
-      Timeout.timeout(5) do
-        session.loop(0.1) { client_done.empty? }
-      end
-      assert_equal "hello", client_done.pop
-      # cancel
-      session.forward.cancel_local(local_port)
-      session.loop(0.1)
-      assert_equal({}, session.channels)
-    end
-  end
-end