net-ssh 4.0.0.alpha1 → 4.0.0.alpha2

data/test/integration/test_id_rsa_keys.rb

@@ -1,96 +0,0 @@
-require '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 TestIDRSAPKeys < Test::Unit::TestCase
-  include IntegrationTestHelpers
-
-  def test_in_file_no_password
-    tmpdir do |dir|
-      sh "rm -rf #{dir}/id_rsa #{dir}/id_rsa.pub"
-      sh "ssh-keygen -q -f #{dir}/id_rsa -t rsa -N ''"
-      set_authorized_key('net_ssh_1',"#{dir}/id_rsa.pub")
-
-      #sshopts = '-vvvv -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no'
-      #sh "ssh -i #{dir}/id_rsa #{sshopts} net_ssh_1@localhost echo 'hello'"
-
-      ret = Net::SSH.start("localhost", "net_ssh_1", {keys: "#{dir}/id_rsa"}) do |ssh|
-        ssh.exec! 'echo "hello from:$USER"'
-      end
-      assert_equal "hello from:net_ssh_1\n", ret
-    end
-  end
-
-
-  def test_ssh_agent
-    tmpdir do |dir|
-      with_agent do
-        sh "rm -rf #{dir}/id_rsa #{dir}/id_rsa.pub"
-        sh "ssh-keygen -q -f #{dir}/id_rsa -t rsa -N 'pwd123'"
-        set_authorized_key('net_ssh_1',"#{dir}/id_rsa.pub")
-        ssh_add("#{dir}/id_rsa","pwd123")
-
-        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_ssh_agent_ignores_if_already_in_agent
-    tmpdir do |dir|
-      with_agent do
-        sh "rm -rf #{dir}/id_rsa #{dir}/id_rsa.pub"
-        sh "ssh-keygen -q -f #{dir}/id_rsa -t rsa -N 'pwd123'"
-        set_authorized_key('net_ssh_1',"#{dir}/id_rsa.pub")
-        ssh_add("#{dir}/id_rsa","pwd123")
-
-        ret = Net::SSH.start("localhost", "net_ssh_1", keys: ["#{dir}/id_rsa"]) 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
-    tmpdir do |dir|
-      sh "rm -rf #{dir}/id_rsa #{dir}/id_rsa.pub"
-      sh "ssh-keygen -q -f #{dir}/id_rsa -t rsa -N 'pwd12'"
-      set_authorized_key('net_ssh_1',"#{dir}/id_rsa.pub")
-
-      #sshopts = '-vvvv -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no'
-      #sh "ssh -i #{dir}/id_rsa #{sshopts} net_ssh_1@localhost echo 'hello'"
-
-      ret = Net::SSH.start("localhost", "net_ssh_1", {keys: "#{dir}/id_rsa",
-        passphrase: 'pwd12'}) do |ssh|
-        ssh.exec! 'echo "hello from:$USER"'
-      end
-      assert_equal "hello from:net_ssh_1\n", ret
-    end
-  end
-
-  def test_asks_for_passwords_when_read_from_memory
-    tmpdir do |dir|
-      sh "rm -rf #{dir}/id_rsa #{dir}/id_rsa.pub"
-      sh "ssh-keygen -q -f #{dir}/id_rsa -t rsa -N 'pwd12'"
-      set_authorized_key('net_ssh_1',"#{dir}/id_rsa.pub")
-      private_key = File.read("#{dir}/id_rsa")
-
-      options = {keys: [], key_data: [private_key]}
-
-      #key_manager = Net::SSH::Authentication::KeyManager.new(nil, options)
-
-      Net::SSH::KeyFactory.expects(:prompt).with('Enter passphrase for :', false).returns('pwd12')
-      Net::SSH.start("localhost", "net_ssh_1", options) do |ssh|
-        ssh.exec! 'whoami'
-      end
-    end
-  end
-end

data/test/integration/test_proxy.rb

@@ -1,93 +0,0 @@
-require_relative './common'
-require 'net/ssh/buffer'
-require 'net/ssh'
-require 'timeout'
-require 'tempfile'
-require 'net/ssh/proxy/command'
-
-class TestProxy < Test::Unit::TestCase
-  include IntegrationTestHelpers
-
-  def localhost
-    'localhost'
-  end
-
-  def user
-    'net_ssh_1'
-  end
-
-  def ssh_start_params(options)
-    [localhost ,user , {:keys => @key_id_rsa}.merge(options)]
-  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 test_smoke
-    setup_ssh_env do
-      proxy = Net::SSH::Proxy::Command.new("/bin/nc localhost 22")
-      msg = 'echo123'
-      ret = Net::SSH.start(*ssh_start_params(:proxy => proxy)) do |ssh|
-        ssh.exec! "echo \"$USER:#{msg}\""
-      end
-      assert_equal "net_ssh_1:#{msg}\n", ret
-    end
-  end
-
-  def with_spurious_write_wakeup_emulate(rate=99,&block)
-    orig_io_select = Net::SSH::Compat.method(:io_select)
-    count = 0
-    Net::SSH::Compat.singleton_class.send(:define_method,:io_select) do |*params|
-      count += 1
-      if (count % rate != 0)
-        if params && params[1] && !params[1].empty?
-          return [[],params[1],[]]
-        end
-        #if params && params[0] && !params[0].empty?
-        #return [params[0],[],[]]
-        #end
-      end
-      IO.select(*params)
-    end
-    begin
-      yield
-    ensure
-      Net::SSH::Compat.singleton_class.send(:define_method,:io_select,&orig_io_select)
-    end
-  end
-
-  def test_with_rate_limit_and_spurious_wakeup
-    system("sudo sh -c 'echo 4096 > /proc/sys/fs/pipe-max-size'")
-    begin
-      setup_ssh_env do
-        proxy = Net::SSH::Proxy::Command.new("/usr/bin/pv --rate-limit 100k | /bin/nc localhost 22")
-        #proxy = Net::SSH::Proxy::Command.new("/bin/nc localhost 22")
-        begin
-          large_msg = 'echo123'*30000
-          ok = Net::SSH.start(*ssh_start_params(:proxy => proxy)) do |ssh|
-              with_spurious_write_wakeup_emulate do
-                ret = ssh.exec! "echo \"$USER:#{large_msg}\""
-                #assert_equal "net_ssh_1:#{large_msg}\n", ret
-                assert_equal "/bin/sh: Argument list too long\n", ret
-                hello_count = 1000
-                ret = ssh.exec! "ruby -e 'puts \"Hello\"*#{hello_count}'"
-                assert_equal "Hello"*hello_count+"\n", ret
-              end
-              :ok
-            end
-        end
-        assert_equal :ok, ok
-      end
-    ensure
-      system("sudo sh -c 'echo 1048576 > /proc/sys/fs/pipe-max-size'")
-    end
-  end
-
-end

data/test/known_hosts/github

@@ -1 +0,0 @@
-github.com ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAq2A7hRGmdnm9tUDbO9IDSwBK6TbQa+PXYPCPy6rbTrTtw7PHkccKrpp0yVhp5HdEIcKr6pLlVDBfOLX9QUsyCOV0wzfjIJNlGEYsdlLJizHhbn2mUjvSAHQqZETYP81eFzLQNnPHt4EVVUh7VfDESU84KezmD5QlWpXLmvU31/yMf+Se8xhHTvKSCZIFImWwoG6mbUoWf9nzpIoaSjB+weqqUUmpaaasXVal72J+UX2B+2RPW3RcT0eOzQgqlJL3RKrTJvdsjE3JEAvGq3lGHSZXy28G3skua2SmVi/w4yCE6gbODqnTWlg7+wC604ydGXA8VJiS5ap43JXiUFFAaQ==

data/test/known_hosts/github_hash

@@ -1 +0,0 @@
-|1|eKp+6E0rZ3lONgsIziurXEnaIik=|rcQB/rlJMUquUyFta64KugPjX4o= ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAq2A7hRGmdnm9tUDbO9IDSwBK6TbQa+PXYPCPy6rbTrTtw7PHkccKrpp0yVhp5HdEIcKr6pLlVDBfOLX9QUsyCOV0wzfjIJNlGEYsdlLJizHhbn2mUjvSAHQqZETYP81eFzLQNnPHt4EVVUh7VfDESU84KezmD5QlWpXLmvU31/yMf+Se8xhHTvKSCZIFImWwoG6mbUoWf9nzpIoaSjB+weqqUUmpaaasXVal72J+UX2B+2RPW3RcT0eOzQgqlJL3RKrTJvdsjE3JEAvGq3lGHSZXy28G3skua2SmVi/w4yCE6gbODqnTWlg7+wC604ydGXA8VJiS5ap43JXiUFFAaQ==

data/test/manual/test_pageant.rb

@@ -1,37 +0,0 @@
-#
-# Tests for communication capability with Pageant (or KeeAgent)
-# process, to include the case where it is running in different UAC
-# context.
-#
-# To run:
-# - Ensure that Pageant is running (not as administrator).
-# - Open two command prompts, one as an administrator and one limited
-#     (normal).
-# - Within each, from the root net/ssh project directory, execute:
-#       ruby -Ilib -Itest -rrubygems test/manual/test_pageant.rb
-#
-
-require 'common'
-require 'net/ssh/authentication/agent'
-
-module Authentication
-
-  class TestPageant < Test::Unit::TestCase
-
-    def test_agent_should_be_able_to_negotiate
-      assert_nothing_raised(Net::SSH::Authentication::AgentNotAvailable) { agent.negotiate! }
-    end
-
-    private
-
-      def agent(auto=:connect)
-        @agent ||= begin
-          agent = Net::SSH::Authentication::Agent.new
-          agent.connect! if auto == :connect
-          agent
-        end
-      end
-
-  end
-
-end

data/test/start/test_connection.rb

@@ -1,53 +0,0 @@
-require 'common'
-require 'net/ssh'
-
-module NetSSH
-  class TestConnection < Test::Unit::TestCase
-    attr_reader :connection_session
-    
-    def setup
-      authentication_session = mock('authentication_session')
-      authentication_session.stubs(:authenticate).returns(true)
-      Net::SSH::Authentication::Session.stubs(:new).returns(authentication_session)
-      Net::SSH::Transport::Session.stubs(:new).returns(mock('transport_session'))
-      @connection_session = mock('connection_session')
-      Net::SSH::Connection::Session.expects(:new => connection_session)
-    end
-    
-    def test_close_connection_on_exception
-      @connection_session.expects(:closed?).returns(false)
-      @connection_session.expects(:close).once
-      
-      begin
-        Net::SSH.start('localhost', 'testuser') { raise "error" }
-      rescue RuntimeError
-        # We aren't interested in the exception
-      end
-    end
-
-    def test_close_connection_on_exception_only_if_still_open
-      conn_open = states('conn').starts_as(true)
-      @connection_session.expects(:close).then(conn_open.is(false)).once
-      @connection_session.expects(:closed?).when(conn_open.is(false)).returns(true)
-      
-      begin
-        Net::SSH.start('localhost', 'testuser') do |ssh|
-          ssh.close
-          raise "error"
-        end
-      rescue RuntimeError
-        # We aren't interested in the exception
-      end
-    end
-    
-    def test_return_value_is_returned
-      @connection_session.expects(:closed?).returns(false)
-      @connection_session.expects(:close).once
-      
-      val = 1
-      retval = Net::SSH.start('localhost', 'testuser') { val }
-      assert_equal(val, retval)
-    end
-  end
-end
-

data/test/start/test_options.rb

@@ -1,57 +0,0 @@
-require 'common'
-require 'net/ssh'
-
-module NetSSH
-  class TestStartOptions < Test::Unit::TestCase
-    def setup
-      authentication_session = mock('authentication_session')
-      authentication_session.stubs(:authenticate).returns(true)
-      Net::SSH::Authentication::Session.stubs(:new).returns(authentication_session)
-      Net::SSH::Transport::Session.stubs(:new).returns(mock('transport_session'))
-      Net::SSH::Connection::Session.stubs(:new).returns(mock('connection_session'))
-    end
-
-    def test_start_should_accept_keepalive_option
-      assert_nothing_raised do
-        options = { :keepalive => true }
-        Net::SSH.start('localhost', 'testuser', options)
-      end
-    end
-
-    def test_start_should_accept_keepalive_interval_option
-      assert_nothing_raised do
-        options = { :keepalive_interval => 10 }
-        Net::SSH.start('localhost', 'testuser', options)
-      end
-    end
-
-    def test_start_should_accept_send_env_option
-      assert_nothing_raised do
-        options = { :send_env => [ /^LC_.*$/, "LANG" ] }
-        Net::SSH.start('localhost', 'testuser', options)
-      end
-    end
-
-    def test_start_should_accept_number_of_password_prompts_option
-      assert_nothing_raised do
-        options = { :number_of_password_prompts => 2 }
-        Net::SSH.start('localhost', 'testuser', options)
-      end
-    end
-
-    def test_start_should_accept_non_interactive_option
-      assert_nothing_raised do
-        options = { :non_interactive => true }
-        Net::SSH.start('localhost', 'testuser', options)
-      end
-    end
-
-    def test_start_should_accept_remote_user_option
-      assert_nothing_raised do
-        options = { :remote_user => 'foo' }
-        Net::SSH.start('localhost', 'testuser', options)
-      end
-    end
-  end
-end
-

data/test/start/test_transport.rb

@@ -1,28 +0,0 @@
-require 'common'
-require 'net/ssh'
-
-module NetSSH
-  class TestStart < Test::Unit::TestCase
-    attr_reader :transport_session
-    attr_reader :authentication_session
-    
-    def setup
-      @transport_session = mock('transport_session')
-      @authentication_session = mock('authentication_session')
-      Net::SSH::Transport::Session.expects(:new => transport_session)
-      Net::SSH::Authentication::Session.expects(:new => authentication_session)
-    end
-    
-    def test_close_transport_when_authentication_fails
-      authentication_session.expects(:authenticate => false)
-      
-      transport_session.expects(:close).at_least_once
-      
-      begin
-        Net::SSH.start('localhost', 'testuser') {}
-      rescue Net::SSH::AuthenticationFailed
-        # Authentication should fail, as it is part of the context
-      end
-    end
-  end
-end

data/test/start/test_user_nil.rb

@@ -1,27 +0,0 @@
-require 'common'
-require 'net/ssh'
-
-module NetSSH
-  class TestStartUserNil < Test::Unit::TestCase
-    def setup
-      @authentication_session = mock('authentication_session')
-      Net::SSH::Authentication::Session.stubs(:new).returns(@authentication_session)
-      Net::SSH::Transport::Session.stubs(:new).returns(mock('transport_session'))
-      Net::SSH::Connection::Session.stubs(:new).returns(mock('connection_session'))
-    end
-
-    def test_start_should_accept_nil_user
-      @authentication_session.stubs(:authenticate).returns(true)
-      assert_nothing_raised do
-        Net::SSH.start('localhost')
-      end
-    end
-
-    def test_start_should_use_default_user_when_nil
-      @authentication_session.stubs(:authenticate).with() {|_next_service, user, _password| user == Etc.getlogin }.returns(true)
-      assert_nothing_raised do
-        Net::SSH.start('localhost')
-      end
-    end
-  end
-end

data/test/test_all.rb

@@ -1,12 +0,0 @@
-$: << '.'
-
-#     $ ruby -Ilib -Itest -rrubygems test/test_all.rb
-#     $ ruby -Ilib -Itest -rrubygems test/transport/test_server_version.rb
-Dir.chdir(File.dirname(__FILE__)) do
-  test_files = Dir['**/test_*.rb']-['test_all.rb'] # prevent circular require
-  test_files -= Dir['integration/test_*.rb'] unless ENV['NET_SSH_RUN_INTEGRATION_TESTS']
-  test_files = test_files.reject { |f| f =~ /^manual/ }
-  test_files = test_files.select { |f| f =~ Regexp.new(ENV['ONLY']) } if ENV['ONLY']
-  test_files = test_files.reject { |f| f =~ Regexp.new(ENV['EXCEPT']) } if ENV['EXCEPT']
-  test_files.each { |file| require(file) }
-end

data/test/test_buffer.rb

@@ -1,433 +0,0 @@
-# encoding: ASCII-8BIT
-
-require 'common'
-require 'net/ssh/buffer'
-
-class TestBuffer < Test::Unit::TestCase
-  def test_constructor_should_initialize_buffer_to_empty_by_default
-    buffer = new
-    assert buffer.empty?
-    assert_equal 0, buffer.position
-  end
-
-  def test_constructor_with_string_should_initialize_buffer_to_the_string
-    buffer = new("hello")
-    assert !buffer.empty?
-    assert_equal "hello", buffer.to_s
-    assert_equal 0, buffer.position
-  end
-
-  def test_from_should_require_an_even_number_of_arguments
-    assert_raises(ArgumentError) { Net::SSH::Buffer.from("this") }
-  end
-
-  def test_from_should_build_new_buffer_from_definition
-    buffer = Net::SSH::Buffer.from(:byte, 1, :long, 2, :int64, 3, :string, "4", :bool, true, :bool, false, :bignum, OpenSSL::BN.new("1234567890", 10), :raw, "something")
-    assert_equal "\1\0\0\0\2\0\0\0\0\0\0\0\3\0\0\0\0014\1\0\000\000\000\004I\226\002\322something", buffer.to_s
-  end
-
-  def test_from_with_array_argument_should_write_multiple_of_the_given_type
-    buffer = Net::SSH::Buffer.from(:byte, [1,2,3,4,5])
-    assert_equal "\1\2\3\4\5", buffer.to_s
-  end
-
-  def test_from_should_measure_bytesize_of_utf_8_string_correctly
-    buffer = Net::SSH::Buffer.from(:string, "\u2603") # Snowman is 3 bytes
-    assert_equal "\0\0\0\3\u2603", buffer.to_s
-  end
-
-  def test_read_without_argument_should_read_to_end
-    buffer = new("hello world")
-    assert_equal "hello world", buffer.read
-    assert buffer.eof?
-    assert_equal 11, buffer.position
-  end
-
-  def test_read_with_argument_that_is_less_than_length_should_read_that_many_bytes
-    buffer = new "hello world"
-    assert_equal "hello", buffer.read(5)
-    assert_equal 5, buffer.position
-  end
-
-  def test_read_with_argument_that_is_more_than_length_should_read_no_more_than_length
-    buffer = new "hello world"
-    assert_equal "hello world", buffer.read(500)
-    assert_equal 11, buffer.position
-  end
-
-  def test_read_at_eof_should_return_empty_string
-    buffer = new "hello"
-    buffer.position = 5
-    assert_equal "", buffer.read
-  end
-
-  def test_consume_without_argument_should_resize_buffer_to_start_at_position
-    buffer = new "hello world"
-    buffer.read(5)
-    assert_equal 5, buffer.position
-    assert_equal 11, buffer.length
-    buffer.consume!
-    assert_equal 0, buffer.position
-    assert_equal 6, buffer.length
-    assert_equal " world", buffer.to_s
-  end
-
-  def test_consume_with_argument_should_resize_buffer_starting_at_n
-    buffer = new "hello world"
-    assert_equal 0, buffer.position
-    buffer.consume!(5)
-    assert_equal 0, buffer.position
-    assert_equal 6, buffer.length
-    assert_equal " world", buffer.to_s
-  end
-
-  def test_read_bang_should_read_and_consume_and_return_read_portion
-    buffer = new "hello world"
-    assert_equal "hello", buffer.read!(5)
-    assert_equal 0, buffer.position
-    assert_equal 6, buffer.length
-    assert_equal " world", buffer.to_s
-  end
-
-  def test_available_should_return_length_after_position_to_end_of_string
-    buffer = new "hello world"
-    buffer.read(5)
-    assert_equal 6, buffer.available
-  end
-
-  def test_clear_bang_should_reset_buffer_contents_and_counters
-    buffer = new "hello world"
-    buffer.read(5)
-    buffer.clear!
-    assert_equal 0, buffer.length
-    assert_equal 0, buffer.position
-    assert_equal "", buffer.to_s
-  end
-
-  def test_append_should_append_argument_without_changing_position_and_should_return_self
-    buffer = new "hello world"
-    buffer.read(5)
-    buffer.append(" again")
-    assert_equal 5, buffer.position
-    assert_equal 12, buffer.available
-    assert_equal 17, buffer.length
-    assert_equal "hello world again", buffer.to_s
-  end
-
-  def test_remainder_as_buffer_should_return_a_new_buffer_filled_with_the_text_after_the_current_position
-    buffer = new "hello world"
-    buffer.read(6)
-    b2 = buffer.remainder_as_buffer
-    assert_equal 6, buffer.position
-    assert_equal 0, b2.position
-    assert_equal "world", b2.to_s
-  end
-
-  def test_read_int64_should_return_8_byte_integer
-    buffer = new "\xff\xee\xdd\xcc\xbb\xaa\x99\x88"
-    assert_equal 0xffeeddccbbaa9988, buffer.read_int64
-    assert_equal 8, buffer.position
-  end
-
-  def test_read_int64_should_return_nil_on_partial_read
-    buffer = new "\0\0\0\0\0\0\0"
-    assert_nil buffer.read_int64
-    assert buffer.eof?
-  end
-
-  def test_read_long_should_return_4_byte_integer
-    buffer = new "\xff\xee\xdd\xcc\xbb\xaa\x99\x88"
-    assert_equal 0xffeeddcc, buffer.read_long
-    assert_equal 4, buffer.position
-  end
-
-  def test_read_long_should_return_nil_on_partial_read
-    buffer = new "\0\0\0"
-    assert_nil buffer.read_long
-    assert buffer.eof?
-  end
-
-  def test_read_byte_should_return_single_byte_integer
-    buffer = new "\xfe\xdc"
-    assert_equal 0xfe, buffer.read_byte
-    assert_equal 1, buffer.position
-  end
-
-  def test_read_byte_should_return_nil_at_eof
-    assert_nil new.read_byte
-  end
-
-  def test_read_string_should_read_length_and_data_from_buffer
-    buffer = new "\0\0\0\x0bhello world"
-    assert_equal "hello world", buffer.read_string
-  end
-
-  def test_read_string_should_return_nil_if_4_byte_length_cannot_be_read
-    assert_nil new("\0\1").read_string
-  end
-
-  def test_read_bool_should_return_true_if_non_zero_byte_is_read
-    buffer = new "\1\2\3\4\5\6"
-    6.times { assert_equal true, buffer.read_bool }
-  end
-
-  def test_read_bool_should_return_false_if_zero_byte_is_read
-    buffer = new "\0"
-    assert_equal false, buffer.read_bool
-  end
-
-  def test_read_bool_should_return_nil_at_eof
-    assert_nil new.read_bool
-  end
-
-  def test_read_bignum_should_read_openssl_formatted_bignum
-    buffer = new("\000\000\000\004I\226\002\322")
-    assert_equal OpenSSL::BN.new("1234567890", 10), buffer.read_bignum
-  end
-
-  def test_read_bignum_should_return_nil_if_length_cannot_be_read
-    assert_nil new("\0\1\2").read_bignum
-  end
-
-  def test_read_key_blob_should_read_dsa_keys
-    random_dss { |buffer| buffer.read_keyblob("ssh-dss") }
-  end
-
-  def test_read_key_blob_should_read_rsa_keys
-    random_rsa { |buffer| buffer.read_keyblob("ssh-rsa") }
-  end
-
-  def test_read_key_should_read_dsa_key_type_and_keyblob
-    random_dss do |buffer|
-      b2 = Net::SSH::Buffer.from(:string, "ssh-dss", :raw, buffer)
-      b2.read_key
-    end
-  end
-
-  def test_read_key_should_read_rsa_key_type_and_keyblob
-    random_rsa do |buffer|
-      b2 = Net::SSH::Buffer.from(:string, "ssh-rsa", :raw, buffer)
-      b2.read_key
-    end
-  end
-
-  def test_read_buffer_should_read_a_string_and_return_it_wrapped_in_a_buffer
-    buffer = new("\0\0\0\x0bhello world")
-    b2 = buffer.read_buffer
-    assert_equal 0, b2.position
-    assert_equal 11, b2.length
-    assert_equal "hello world", b2.read
-  end
-
-  def test_read_to_should_return_nil_if_pattern_does_not_exist_in_buffer
-    buffer = new("one two three")
-    assert_nil buffer.read_to("\n")
-  end
-
-  def test_read_to_should_grok_string_patterns
-    buffer = new("one two three")
-    assert_equal "one tw", buffer.read_to("tw")
-    assert_equal 6, buffer.position
-  end
-
-  def test_read_to_should_grok_regex_patterns
-    buffer = new("one two three")
-    assert_equal "one tw", buffer.read_to(/tw/)
-    assert_equal 6, buffer.position
-  end
-
-  def test_read_to_should_grok_fixnum_patterns
-    buffer = new("one two three")
-    assert_equal "one tw", buffer.read_to(?w)
-    assert_equal 6, buffer.position
-  end
-
-  def test_reset_bang_should_reset_position_to_0
-    buffer = new("hello world")
-    buffer.read(5)
-    assert_equal 5, buffer.position
-    buffer.reset!
-    assert_equal 0, buffer.position
-  end
-
-  def test_write_should_write_arguments_directly_to_end_buffer
-    buffer = new("start")
-    buffer.write "hello", " ", "world"
-    assert_equal "starthello world", buffer.to_s
-    assert_equal 0, buffer.position
-  end
-
-  def test_write_int64_should_write_arguments_as_8_byte_integers_to_end_of_buffer
-    buffer = new("start")
-    buffer.write_int64 0xffeeddccbbaa9988, 0x7766554433221100
-    assert_equal "start\xff\xee\xdd\xcc\xbb\xaa\x99\x88\x77\x66\x55\x44\x33\x22\x11\x00", buffer.to_s
-  end
-
-  def test_write_long_should_write_arguments_as_4_byte_integers_to_end_of_buffer
-    buffer = new("start")
-    buffer.write_long 0xffeeddcc, 0xbbaa9988
-    assert_equal "start\xff\xee\xdd\xcc\xbb\xaa\x99\x88", buffer.to_s
-  end
-
-  def test_write_byte_should_write_arguments_as_1_byte_integers_to_end_of_buffer
-    buffer = new("start")
-    buffer.write_byte 1, 2, 3, 4, 5
-    assert_equal "start\1\2\3\4\5", buffer.to_s
-  end
-
-  def test_write_bool_should_write_arguments_as_1_byte_boolean_values_to_end_of_buffer
-    buffer = new("start")
-    buffer.write_bool nil, false, true, 1, Object.new
-    assert_equal "start\0\0\1\1\1", buffer.to_s
-  end
-
-  def test_write_bignum_should_write_arguments_as_ssh_formatted_bignum_values_to_end_of_buffer
-    buffer = new("start")
-    buffer.write_bignum OpenSSL::BN.new('1234567890', 10)
-    assert_equal "start\000\000\000\004I\226\002\322", buffer.to_s
-  end
-
-  def test_write_dss_key_should_write_argument_to_end_of_buffer
-    buffer = new("start")
-
-    key = OpenSSL::PKey::DSA.new
-    key.p = 0xffeeddccbbaa9988
-    key.q = 0x7766554433221100
-    key.g = 0xffddbb9977553311
-    key.pub_key = 0xeeccaa8866442200
-
-    buffer.write_key(key)
-assert_equal "start\0\0\0\7ssh-dss\0\0\0\011\0\xff\xee\xdd\xcc\xbb\xaa\x99\x88\0\0\0\010\x77\x66\x55\x44\x33\x22\x11\x00\0\0\0\011\0\xff\xdd\xbb\x99\x77\x55\x33\x11\0\0\0\011\0\xee\xcc\xaa\x88\x66\x44\x22\x00", buffer.to_s
-  end
-
-  def test_write_rsa_key_should_write_argument_to_end_of_buffer
-    buffer = new("start")
-
-    key = OpenSSL::PKey::RSA.new
-    key.e = 0xffeeddccbbaa9988
-    key.n = 0x7766554433221100
-
-    buffer.write_key(key)
-    assert_equal "start\0\0\0\7ssh-rsa\0\0\0\011\0\xff\xee\xdd\xcc\xbb\xaa\x99\x88\0\0\0\010\x77\x66\x55\x44\x33\x22\x11\x00", buffer.to_s
-  end
-
-  if defined?(OpenSSL::PKey::EC)
-    def test_read_key_blob_should_read_ecdsa_sha2_nistp256_keys
-      random_ecdsa_sha2_nistp256 { |buffer|
-        buffer.read_keyblob("ecdsa-sha2-nistp256")
-      }
-    end
-    def test_read_key_blob_should_read_ecdsa_sha2_nistp384_keys
-      random_ecdsa_sha2_nistp384 { |buffer|
-        buffer.read_keyblob("ecdsa-sha2-nistp384")
-      }
-    end
-    def test_read_key_blob_should_read_ecdsa_sha2_nistp521_keys
-      random_ecdsa_sha2_nistp521 { |buffer|
-        buffer.read_keyblob("ecdsa-sha2-nistp521")
-      }
-    end
-
-    def test_read_key_should_read_ecdsa_sha2_nistp256_key_type_and_keyblob
-      random_ecdsa_sha2_nistp256 do |buffer|
-        b2 = Net::SSH::Buffer.from(:string, "ecdsa-sha2-nistp256", :raw, buffer)
-        b2.read_key
-      end
-    end
-    def test_read_key_should_read_ecdsa_sha2_nistp384_key_type_and_keyblob
-      random_ecdsa_sha2_nistp384 do |buffer|
-        b2 = Net::SSH::Buffer.from(:string, "ecdsa-sha2-nistp384", :raw, buffer)
-        b2.read_key
-      end
-    end
-    def test_read_key_should_read_ecdsa_sha2_nistp521_key_type_and_keyblob
-      random_ecdsa_sha2_nistp521 do |buffer|
-        b2 = Net::SSH::Buffer.from(:string, "ecdsa-sha2-nistp521", :raw, buffer)
-        b2.read_key
-      end
-    end
-
-    def test_write_ecdsa_sha2_nistp256_key_should_write_argument_to_end_of_buffer
-      buffer = new("start")
-      key = OpenSSL::PKey::EC.new("-----BEGIN EC PRIVATE KEY-----\nMHcCAQEEIISGj5vAJCWt2KPI8NwaWVDSNLl2vbRxDIOkY+n6O0VVoAoGCCqGSM49\nAwEHoUQDQgAEnKbs0yEogTKT4QRu8T9nb2svl2mEWXb6g224oCpD2o6TYNXNw54H\nmWkdCv+kFCqSlfSi5fqFhrXdfEY6zSzQYQ==\n-----END EC PRIVATE KEY-----\n")
-
-      buffer.write_key(key)
-      assert_equal "start\000\000\000\023ecdsa-sha2-nistp256\000\000\000\bnistp256\000\000\000A\004\234\246\354\323!(\2012\223\341\004n\361?gok/\227i\204Yv\372\203m\270\240*C\332\216\223`\325\315\303\236\a\231i\035\n\377\244\024*\222\225\364\242\345\372\205\206\265\335|F:\315,\320a", buffer.to_s
-    end
-
-    def test_write_ecdsa_sha2_nistp384_key_should_write_argument_to_end_of_buffer
-      buffer = new("start")
-      key = OpenSSL::PKey::EC.new("-----BEGIN EC PRIVATE KEY-----\nMIGkAgEBBDBAfxJpzhsR7O+wMol6BcDgualR8rJBvYegUDYbBUrDnPzDx2/gD1lZ\nnwG1FuD2s9igBwYFK4EEACKhZANiAATsfiU4Kxyvvj1DdvFYsdDnZIT7loRlan9I\n8geCWPPl6x7NFRP+awrnTaarMgieGqxG8IQaIA0SsDOICfbDBkuatRi0S1Et/in4\nZwVEZvO81Ro5YSrjuUDAsytnI6OXS28=\n-----END EC PRIVATE KEY-----\n")
-
-      buffer.write_key(key)
-      assert_equal "start\000\000\000\023ecdsa-sha2-nistp384\000\000\000\bnistp384\000\000\000a\004\354~%8+\034\257\276=Cv\361X\261\320\347d\204\373\226\204ej\177H\362\a\202X\363\345\353\036\315\025\023\376k\n\347M\246\2532\b\236\032\254F\360\204\032 \r\022\2603\210\t\366\303\006K\232\265\030\264KQ-\376)\370g\005Df\363\274\325\0329a*\343\271@\300\263+g#\243\227Ko", buffer.to_s
-    end
-
-    def test_write_ecdsa_sha2_nistp521_key_should_write_argument_to_end_of_buffer
-      buffer = new("start")
-      key = OpenSSL::PKey::EC.new("-----BEGIN EC PRIVATE KEY-----\nMIHbAgEBBEGhnQF/SFo4Vym88HnCfc6BR8WwYqDh9wNTPeqzR8auxIpp0GKQlCG2\nuHzyteJX5/YalV8empYhEzNmNLNn8x7j0aAHBgUrgQQAI6GBiQOBhgAEAYygOgV9\nVI8UyLQ3BDlv+rb3es+ufrIcj++cqcc9QcmRn237NiWRr/1NKy2AKijsEdACtZXo\nxPC0x9Vs9ieC2oR+ANOBubcxPl2giDnBYm8ywAmmlXsP5ByAM17k97CzW5O+Z/uO\nbxGUzzhoXTNcjqpAckhRVKdnh6FL/rKelT0tBYi+\n-----END EC PRIVATE KEY-----\n")
-
-      buffer.write_key(key)
-      assert_equal "start\000\000\000\023ecdsa-sha2-nistp521\000\000\000\bnistp521\000\000\000\205\004\001\214\240:\005}T\217\024\310\2647\0049o\372\266\367z\317\256~\262\034\217\357\234\251\307=A\311\221\237m\3736%\221\257\375M+-\200*(\354\021\320\002\265\225\350\304\360\264\307\325l\366'\202\332\204~\000\323\201\271\2671>]\240\2109\301bo2\300\t\246\225{\017\344\034\2003^\344\367\260\263[\223\276g\373\216o\021\224\3178h]3\\\216\252@rHQT\247g\207\241K\376\262\236\225=-\005\210\276", buffer.to_s
-    end
-  end
-
-  private
-
-    def random_rsa
-      n1 = OpenSSL::BN.new(rand(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF).to_s, 10)
-      n2 = OpenSSL::BN.new(rand(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF).to_s, 10)
-      buffer = Net::SSH::Buffer.from(:bignum, [n1, n2])
-      key = yield(buffer)
-      assert_equal "ssh-rsa", key.ssh_type
-      assert_equal n1, key.e
-      assert_equal n2, key.n
-    end
-
-    def random_dss
-      n1 = OpenSSL::BN.new(rand(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF).to_s, 10)
-      n2 = OpenSSL::BN.new(rand(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF).to_s, 10)
-      n3 = OpenSSL::BN.new(rand(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF).to_s, 10)
-      n4 = OpenSSL::BN.new(rand(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF).to_s, 10)
-      buffer = Net::SSH::Buffer.from(:bignum, [n1, n2, n3, n4])
-      key = yield(buffer)
-      assert_equal "ssh-dss", key.ssh_type
-      assert_equal n1, key.p
-      assert_equal n2, key.q
-      assert_equal n3, key.g
-      assert_equal n4, key.pub_key
-    end
-
-    if defined?(OpenSSL::PKey::EC)
-      def random_ecdsa_sha2_nistp256
-        k = OpenSSL::PKey::EC.new("prime256v1").generate_key
-        buffer = Net::SSH::Buffer.from(:string, "nistp256",
-                                       :string, k.public_key.to_bn.to_s(2))
-        key = yield(buffer)
-        assert_equal "ecdsa-sha2-nistp256", key.ssh_type
-        assert_equal k.public_key, key.public_key
-      end
-
-      def random_ecdsa_sha2_nistp384
-        k = OpenSSL::PKey::EC.new("secp384r1").generate_key
-        buffer = Net::SSH::Buffer.from(:string, "nistp384",
-                                       :string, k.public_key.to_bn.to_s(2))
-        key = yield(buffer)
-        assert_equal "ecdsa-sha2-nistp384", key.ssh_type
-        assert_equal k.public_key, key.public_key
-      end
-
-      def random_ecdsa_sha2_nistp521
-        k = OpenSSL::PKey::EC.new("secp521r1").generate_key
-        buffer = Net::SSH::Buffer.from(:string, "nistp521",
-                                       :string, k.public_key.to_bn.to_s(2))
-        key = yield(buffer)
-        assert_equal "ecdsa-sha2-nistp521", key.ssh_type
-        assert_equal k.public_key, key.public_key
-      end
-    end
-
-    def new(*args)
-      Net::SSH::Buffer.new(*args)
-    end
-end