net-ssh 3.2.0 → 7.2.0.rc1

data/test/transport/test_server_version.rb

@@ -1,74 +0,0 @@
-require 'common'
-require 'net/ssh/transport/server_version'
-
-module Transport
-
-  class TestServerVersion < Test::Unit::TestCase
-
-    def test_1_99_server_version_should_be_acceptible
-      s = subject(socket(true, "SSH-1.99-Testing_1.0\r\n"))
-      assert s.header.empty?
-      assert_equal "SSH-1.99-Testing_1.0", s.version
-    end
-
-    def test_2_0_server_version_should_be_acceptible
-      s = subject(socket(true, "SSH-2.0-Testing_1.0\r\n"))
-      assert s.header.empty?
-      assert_equal "SSH-2.0-Testing_1.0", s.version
-    end
-
-    def test_trailing_whitespace_should_be_preserved
-      # some servers, like Mocana, send a version string with trailing
-      # spaces, which are significant when exchanging keys later.
-      s = subject(socket(true, "SSH-2.0-Testing_1.0    \r\n"))
-      assert_equal "SSH-2.0-Testing_1.0    ", s.version
-    end
-
-    def test_unacceptible_server_version_should_raise_exception
-      assert_raises(Net::SSH::Exception) { subject(socket(false, "SSH-1.4-Testing_1.0\r\n")) }
-    end
-
-    def test_unexpected_server_close_should_raise_exception
-      assert_raises(Net::SSH::Disconnect) { subject(socket(false, "\r\nDestination server does not have Ssh activated.\r\nContact Cisco Systems, Inc to purchase a\r\nlicense key to activate Ssh.\r\n", true)) }
-    end
-
-    def test_header_lines_should_be_accumulated
-      s = subject(socket(true, "Welcome\r\nAnother line\r\nSSH-2.0-Testing_1.0\r\n"))
-      assert_equal "Welcome\r\nAnother line\r\n", s.header
-      assert_equal "SSH-2.0-Testing_1.0", s.version
-    end
-
-    def test_server_disconnect_should_raise_exception
-      assert_raises(Net::SSH::Disconnect) { subject(socket(false, "SSH-2.0-Aborting")) }
-    end
-
-    private
-
-      def socket(good, version_header, raise_eot=false)
-        socket = mock("socket")
-
-        socket.expects(:write).with("#{Net::SSH::Transport::ServerVersion::PROTO_VERSION}\r\n")
-        socket.expects(:flush)
-
-        data = version_header.split('')
-        recv_times = data.length
-        recv_times += 1 if data[-1] != "\n"
-
-        unless raise_eot
-          
-#        socket.expects(:recv).with(1).times(recv_times).returns(*data).then.returns(nil)
-#        socket.expects(:readchar).times(recv_times).returns(*data).then.returns(nil)
-          socket.expects(:readpartial).with(1).times(recv_times).returns(*data).then.returns(nil)
-        else
-          socket.expects(:readpartial).with(1).times(recv_times+1).returns(*data).then.raises(EOFError, "end of file reached")
-        end
-
-        socket
-      end
-
-      def subject(socket)
-        Net::SSH::Transport::ServerVersion.new(socket, nil)
-      end
-  end
-
-end

data/test/transport/test_session.rb

@@ -1,331 +0,0 @@
-require 'common'
-require 'net/ssh/transport/session'
-
-# mocha adds #verify to Object, which throws off the host-key-verifier part of
-# these tests.
-
-# can't use .include? because ruby18 uses strings and ruby19 uses symbols :/
-if Object.instance_methods.any? { |v| v.to_sym == :verify }
-  Object.send(:undef_method, :verify)
-end
-
-module Transport
-
-  class TestSession < Test::Unit::TestCase
-    include Net::SSH::Transport::Constants
-
-    def test_constructor_defaults
-      assert_equal "net.ssh.test", session.host
-      assert_equal 22, session.port
-      assert_instance_of Net::SSH::Verifiers::Lenient, session.host_key_verifier
-    end
-
-    def test_paranoid_true_uses_lenient_verifier
-      assert_instance_of Net::SSH::Verifiers::Lenient, session(:paranoid => true).host_key_verifier
-    end
-
-    def test_paranoid_very_uses_strict_verifier
-      assert_instance_of Net::SSH::Verifiers::Strict, session(:paranoid => :very).host_key_verifier
-    end
-
-    def test_paranoid_secure_uses_secure_verifier
-      assert_instance_of Net::SSH::Verifiers::Secure, session(:paranoid => :secure).host_key_verifier
-    end
-
-    def test_paranoid_false_uses_null_verifier
-      assert_instance_of Net::SSH::Verifiers::Null, session(:paranoid => false).host_key_verifier
-    end
-
-    def test_unknown_paranoid_value_raises_exception_if_value_does_not_respond_to_verify
-      assert_raises(ArgumentError) { session(:paranoid => :bogus).host_key_verifier }
-    end
-
-    def test_paranoid_value_responding_to_verify_should_pass_muster
-      object = stub("thingy", :verify => true)
-      assert_equal object, session(:paranoid => object).host_key_verifier
-    end
-
-    def test_host_as_string_should_return_host_and_ip_when_port_is_default
-      session!
-      socket.stubs(:peer_ip).returns("1.2.3.4")
-      assert_equal "net.ssh.test,1.2.3.4", session.host_as_string
-    end
-
-    def test_host_as_string_should_return_host_and_ip_with_port_when_port_is_not_default
-      session(:port => 1234) # force session to be instantiated
-      socket.stubs(:peer_ip).returns("1.2.3.4")
-      assert_equal "[net.ssh.test]:1234,[1.2.3.4]:1234", session.host_as_string
-    end
-
-    def test_host_as_string_should_return_only_host_when_host_is_ip
-      session!(:host => "1.2.3.4")
-      socket.stubs(:peer_ip).returns("1.2.3.4")
-      assert_equal "1.2.3.4", session.host_as_string
-    end
-
-    def test_host_as_string_should_return_only_host_and_port_when_host_is_ip_and_port_is_not_default
-      session!(:host => "1.2.3.4", :port => 1234)
-      socket.stubs(:peer_ip).returns("1.2.3.4")
-      assert_equal "[1.2.3.4]:1234", session.host_as_string
-    end
-
-    def test_host_as_string_should_return_only_host_when_proxy_command_is_set
-      session!(:host => "1.2.3.4")
-      socket.stubs(:peer_ip).returns(Net::SSH::Transport::PacketStream::PROXY_COMMAND_HOST_IP)
-      assert_equal "1.2.3.4", session.host_as_string
-    end
-
-    def test_host_as_string_should_return_only_host_and_port_when_host_is_ip_and_port_is_not_default_and_proxy_command_is_set
-      session!(:host => "1.2.3.4", :port => 1234)
-      socket.stubs(:peer_ip).returns(Net::SSH::Transport::PacketStream::PROXY_COMMAND_HOST_IP)
-      assert_equal "[1.2.3.4]:1234", session.host_as_string
-    end
-
-    def test_close_should_cleanup_and_close_socket
-      session!
-      socket.expects(:cleanup)
-      socket.expects(:close)
-      session.close
-    end
-
-    def test_service_request_should_return_buffer
-      assert_equal "\005\000\000\000\004sftp", session.service_request('sftp').to_s
-    end
-
-    def test_rekey_when_kex_is_pending_should_do_nothing
-      algorithms.stubs(:pending? => true)
-      algorithms.expects(:rekey!).never
-      session.rekey!
-    end
-
-    def test_rekey_when_no_kex_is_pending_should_initiate_rekey_and_block_until_it_completes
-      algorithms.stubs(:pending? => false)
-      algorithms.expects(:rekey!)
-      session.expects(:wait).yields
-      algorithms.expects(:initialized?).returns(true)
-      session.rekey!
-    end
-
-    def test_rekey_as_needed_when_kex_is_pending_should_do_nothing
-      session!
-      algorithms.stubs(:pending? => true)
-      socket.expects(:if_needs_rekey?).never
-      session.rekey_as_needed
-    end
-
-    def test_rekey_as_needed_when_no_kex_is_pending_and_no_rekey_is_needed_should_do_nothing
-      session!
-      algorithms.stubs(:pending? => false)
-      socket.stubs(:if_needs_rekey? => false)
-      session.expects(:rekey!).never
-      session.rekey_as_needed
-    end
-
-    def test_rekey_as_needed_when_no_kex_is_pending_and_rekey_is_needed_should_initiate_rekey_and_block
-      session!
-      algorithms.stubs(:pending? => false)
-      socket.expects(:if_needs_rekey?).yields
-      session.expects(:rekey!)
-      session.rekey_as_needed
-    end
-
-    def test_peer_should_return_hash_of_info_about_peer
-      session!
-      socket.stubs(:peer_ip => "1.2.3.4")
-      assert_equal({:ip => "1.2.3.4", :port => 22, :host => "net.ssh.test", :canonized => "net.ssh.test,1.2.3.4"}, session.peer)
-    end
-
-    def test_next_message_should_block_until_next_message_is_available
-      session.expects(:poll_message).with(:block)
-      session.next_message
-    end
-
-    def test_poll_message_should_query_next_packet_using_the_given_blocking_parameter
-      session!
-      socket.expects(:next_packet).with(:blocking_parameter).returns(nil)
-      session.poll_message(:blocking_parameter)
-    end
-
-    def test_poll_message_should_default_to_non_blocking
-      session!
-      socket.expects(:next_packet).with(:nonblock).returns(nil)
-      session.poll_message
-    end
-
-    def test_poll_message_should_silently_handle_disconnect_packets
-      session!
-      socket.expects(:next_packet).returns(P(:byte, DISCONNECT, :long, 1, :string, "testing", :string, ""))
-      assert_raises(Net::SSH::Disconnect) { session.poll_message }
-    end
-
-    def test_poll_message_should_silently_handle_ignore_packets
-      session!
-      socket.expects(:next_packet).times(2).returns(P(:byte, IGNORE, :string, "test"), nil)
-      assert_nil session.poll_message
-    end
-
-    def test_poll_message_should_silently_handle_unimplemented_packets
-      session!
-      socket.expects(:next_packet).times(2).returns(P(:byte, UNIMPLEMENTED, :long, 15), nil)
-      assert_nil session.poll_message
-    end
-
-    def test_poll_message_should_silently_handle_debug_packets_with_always_display
-      session!
-      socket.expects(:next_packet).times(2).returns(P(:byte, DEBUG, :bool, true, :string, "testing", :string, ""), nil)
-      assert_nil session.poll_message
-    end
-
-    def test_poll_message_should_silently_handle_debug_packets_without_always_display
-      session!
-      socket.expects(:next_packet).times(2).returns(P(:byte, DEBUG, :bool, false, :string, "testing", :string, ""), nil)
-      assert_nil session.poll_message
-    end
-
-    def test_poll_message_should_silently_handle_kexinit_packets
-      session!
-      packet = P(:byte, KEXINIT, :raw, "lasdfalksdjfa;slkdfja;slkfjsdfaklsjdfa;df")
-      socket.expects(:next_packet).times(2).returns(packet, nil)
-      algorithms.expects(:accept_kexinit).with(packet)
-      assert_nil session.poll_message
-    end
-
-    def test_poll_message_should_return_other_packets
-      session!
-      packet = P(:byte, SERVICE_ACCEPT, :string, "test")
-      socket.expects(:next_packet).returns(packet)
-      assert_equal packet, session.poll_message
-    end
-
-    def test_poll_message_should_enqueue_packets_when_algorithm_disallows_packet
-      session!
-      packet = P(:byte, SERVICE_ACCEPT, :string, "test")
-      algorithms.stubs(:allow?).with(packet).returns(false)
-      socket.expects(:next_packet).times(2).returns(packet, nil)
-      assert_nil session.poll_message
-      assert_equal [packet], session.queue
-    end
-
-    def test_poll_message_should_read_from_queue_when_next_in_queue_is_allowed_and_consume_queue_is_true
-      session!
-      packet = P(:byte, SERVICE_ACCEPT, :string, "test")
-      session.push(packet)
-      socket.expects(:next_packet).never
-      assert_equal packet, session.poll_message
-      assert session.queue.empty?
-    end
-
-    def test_poll_message_should_not_read_from_queue_when_next_in_queue_is_not_allowed
-      session!
-      packet = P(:byte, SERVICE_ACCEPT, :string, "test")
-      algorithms.stubs(:allow?).with(packet).returns(false)
-      session.push(packet)
-      socket.expects(:next_packet).returns(nil)
-      assert_nil session.poll_message
-      assert_equal [packet], session.queue
-    end
-
-    def test_poll_message_should_not_read_from_queue_when_consume_queue_is_false
-      session!
-      packet = P(:byte, SERVICE_ACCEPT, :string, "test")
-      session.push(packet)
-      socket.expects(:next_packet).returns(nil)
-      assert_nil session.poll_message(:nonblock, false)
-      assert_equal [packet], session.queue
-    end
-
-    def test_wait_with_block_should_return_immediately_if_block_returns_truth
-      session.expects(:poll_message).never
-      session.wait { true }
-    end
-
-    def test_wait_should_not_consume_queue_on_reads
-      n = 0
-      session.expects(:poll_message).with(:nonblock, false).returns(nil)
-      session.wait { (n += 1) > 1 }
-    end
-
-    def test_wait_without_block_should_return_after_first_read
-      session.expects(:poll_message).returns(nil)
-      session.wait
-    end
-
-    def test_wait_should_enqueue_packets
-      session!
-
-      p1 = P(:byte, SERVICE_REQUEST, :string, "test")
-      p2 = P(:byte, SERVICE_ACCEPT, :string, "test")
-      socket.expects(:next_packet).times(2).returns(p1, p2)
-
-      n = 0
-      session.wait { (n += 1) > 2 }
-      assert_equal [p1, p2], session.queue
-    end
-
-    def test_push_should_enqueue_packet
-      packet = P(:byte, SERVICE_ACCEPT, :string, "test")
-      session.push(packet)
-      assert_equal [packet], session.queue
-    end
-
-    def test_send_message_should_delegate_to_socket
-      session!
-      packet = P(:byte, SERVICE_ACCEPT, :string, "test")
-      socket.expects(:send_packet).with(packet)
-      session.send_message(packet)
-    end
-
-    def test_enqueue_message_should_delegate_to_socket
-      session!
-      packet = P(:byte, SERVICE_ACCEPT, :string, "test")
-      socket.expects(:enqueue_packet).with(packet)
-      session.enqueue_message(packet)
-    end
-
-    def test_configure_client_should_pass_options_to_socket_client_state
-      session.configure_client :compression => :standard
-      assert_equal :standard, socket.client.compression
-    end
-
-    def test_configure_server_should_pass_options_to_socket_server_state
-      session.configure_server :compression => :standard
-      assert_equal :standard, socket.server.compression
-    end
-
-    def test_hint_should_set_hint_on_socket
-      assert !socket.hints[:authenticated]
-      session.hint :authenticated
-      assert socket.hints[:authenticated]
-    end
-
-    private
-
-      def socket
-        @socket ||= stub("socket", :hints => {})
-      end
-
-      def server_version
-        @server_version ||= stub("server_version")
-      end
-
-      def algorithms
-        @algorithms ||= stub("algorithms", :initialized? => true, :allow? => true, :start => true)
-      end
-
-      def session(options={})
-        @session ||= begin
-          host = options.delete(:host) || "net.ssh.test"
-          Socket.stubs(:tcp).with(host, options[:port] || 22, nil, nil, { connect_timeout: options[:timeout] }).returns(socket)
-          Net::SSH::Transport::ServerVersion.stubs(:new).returns(server_version)
-          Net::SSH::Transport::Algorithms.stubs(:new).returns(algorithms)
-
-          Net::SSH::Transport::Session.new(host, options)
-        end
-      end
-
-      # a simple alias to make the tests more self-documenting. the bang
-      # version makes it look more like the session is being instantiated
-      alias session! session
-  end
-
-end

data/test/transport/test_state.rb

@@ -1,181 +0,0 @@
-# encoding: ASCII-8BIT
-
-require 'common'
-require 'net/ssh/transport/state'
-
-module Transport
-
-  class TestState < Test::Unit::TestCase
-
-    def setup
-      @socket = @state = @deflater = @inflater = nil
-    end
-
-    def teardown
-      if @deflater
-        @deflater.finish if !@deflater.finished?
-        @deflater.close
-      end
-
-      if @inflater
-        @inflater.finish if !@inflater.finished?
-        @inflater.close
-      end
-
-      state.cleanup
-    end
-
-    def test_constructor_should_initialize_all_values
-      assert_equal 0, state.sequence_number
-      assert_equal 0, state.packets
-      assert_equal 0, state.blocks
-
-      assert_nil state.compression
-      assert_nil state.compression_level
-      assert_nil state.max_packets
-      assert_nil state.max_blocks
-      assert_nil state.rekey_limit
-
-      assert_equal "identity", state.cipher.name
-      assert_instance_of Net::SSH::Transport::HMAC::None, state.hmac
-    end
-
-    def test_increment_should_increment_counters
-      state.increment(24)
-      assert_equal 1, state.sequence_number
-      assert_equal 1, state.packets
-      assert_equal 3, state.blocks
-    end
-
-    def test_reset_should_reset_counters_and_fix_defaults_for_maximums
-      state.increment(24)
-      state.reset!
-      assert_equal 1, state.sequence_number
-      assert_equal 0, state.packets
-      assert_equal 0, state.blocks
-      assert_equal 2147483648, state.max_packets
-      assert_equal 134217728, state.max_blocks
-    end
-
-    def test_set_should_set_variables_and_reset_counters
-      state.expects(:reset!)
-      state.set :cipher => :a, :hmac => :b, :compression => :c,
-        :compression_level => :d, :max_packets => 500, :max_blocks => 1000,
-        :rekey_limit => 1500
-      assert_equal :a, state.cipher
-      assert_equal :b, state.hmac
-      assert_equal :c, state.compression
-      assert_equal :d, state.compression_level
-      assert_equal 500, state.max_packets
-      assert_equal 1000, state.max_blocks
-      assert_equal 1500, state.rekey_limit
-    end
-
-    def test_set_with_max_packets_should_respect_max_packets_setting
-      state.set :max_packets => 500
-      assert_equal 500, state.max_packets
-    end
-
-    def test_set_with_max_blocks_should_respect_max_blocks_setting
-      state.set :max_blocks => 1000
-      assert_equal 1000, state.max_blocks
-    end
-
-    def test_set_with_rekey_limit_should_include_rekey_limit_in_computation_of_max_blocks
-      state.set :rekey_limit => 4000
-      assert_equal 500, state.max_blocks
-    end
-
-    def test_compressor_defaults_to_default_zlib_compression
-      expect = deflater.deflate("hello world")
-      assert_equal expect, state.compressor.deflate("hello world")
-    end
-
-    def test_compressor_uses_compression_level_when_given
-      state.set :compression_level => 1
-      expect = deflater(1).deflate("hello world")
-      assert_equal expect, state.compressor.deflate("hello world")
-    end
-
-    def test_compress_when_no_compression_is_active_returns_text
-      assert_equal "hello everybody", state.compress("hello everybody")
-    end
-
-    def test_decompress_when_no_compression_is_active_returns_text
-      assert_equal "hello everybody", state.decompress("hello everybody")
-    end
-
-    def test_compress_when_compression_is_delayed_and_no_auth_hint_is_set_should_return_text
-      state.set :compression => :delayed
-      assert_equal "hello everybody", state.compress("hello everybody")
-    end
-
-    def test_decompress_when_compression_is_delayed_and_no_auth_hint_is_set_should_return_text
-      state.set :compression => :delayed
-      assert_equal "hello everybody", state.decompress("hello everybody")
-    end
-
-    def test_compress_when_compression_is_enabled_should_return_compressed_text
-      state.set :compression => :standard     
-      # JRuby Zlib implementation (1.4 & 1.5) does not have byte-to-byte compatibility with MRI's.
-      # skip this test under JRuby.
-      return if defined?(JRUBY_VERSION)
-      assert_equal "x\234\312H\315\311\311WH-K-\252L\312O\251\004\000\000\000\377\377", state.compress("hello everybody")
-    end
-
-    def test_decompress_when_compression_is_enabled_should_return_decompressed_text
-      state.set :compression => :standard     
-      # JRuby Zlib implementation (1.4 & 1.5) does not have byte-to-byte compatibility with MRI's.
-      # skip this test under JRuby.
-      return if defined?(JRUBY_VERSION)
-      assert_equal "hello everybody", state.decompress("x\234\312H\315\311\311WH-K-\252L\312O\251\004\000\000\000\377\377")
-    end
-
-    def test_compress_when_compression_is_delayed_and_auth_hint_is_set_should_return_compressed_text
-      socket.hints[:authenticated] = true
-      state.set :compression => :delayed
-      assert_equal "x\234\312H\315\311\311WH-K-\252L\312O\251\004\000\000\000\377\377", state.compress("hello everybody")
-    end
-
-    def test_decompress_when_compression_is_delayed_and_auth_hint_is_set_should_return_decompressed_text
-      socket.hints[:authenticated] = true
-      state.set :compression => :delayed
-      assert_equal "hello everybody", state.decompress("x\234\312H\315\311\311WH-K-\252L\312O\251\004\000\000\000\377\377")
-    end
-
-    def test_needs_rekey_should_be_true_if_packets_exceeds_max_packets
-      state.set :max_packets => 2
-      state.increment(8)
-      state.increment(8)
-      assert !state.needs_rekey?
-      state.increment(8)
-      assert state.needs_rekey?
-    end
-
-    def test_needs_rekey_should_be_true_if_blocks_exceeds_max_blocks
-      state.set :max_blocks => 10
-      assert !state.needs_rekey?
-      state.increment(88)
-      assert state.needs_rekey?
-    end
-
-    private
-
-      def deflater(level=Zlib::DEFAULT_COMPRESSION)
-        @deflater ||= Zlib::Deflate.new(level)
-      end
-
-      def inflater
-        @inflater ||= Zlib::Inflate.new(nil)
-      end
-
-      def socket
-        @socket ||= stub("socket", :hints => {})
-      end
-
-      def state
-        @state ||= Net::SSH::Transport::State.new(socket, :test)
-      end
-  end
-
-end

data/test/verifiers/test_secure.rb

@@ -1,40 +0,0 @@
-require 'common'
-require 'net/ssh/verifiers/secure'
-require 'ostruct'
-
-class TestSecure < Test::Unit::TestCase
-  def test_raises_unknown_key_error_if_empty
-    secure_verifier = Net::SSH::Verifiers::Secure.new
-    host_keys = []
-    def host_keys.host
-      'foo'
-    end
-    assert_raises(Net::SSH::HostKeyUnknown) {
-      secure_verifier.verify(session:OpenStruct.new(host_keys:host_keys))
-    }
-  end
-
-  def test_passess_if_sam
-    secure_verifier = Net::SSH::Verifiers::Secure.new
-    key = OpenStruct.new(ssh_type:'key_type',to_blob:'keyblob')
-    host_keys = [key]
-    def host_keys.host
-      'foo'
-    end
-    secure_verifier.verify(session:OpenStruct.new(host_keys:host_keys), key:key)
-  end
-
-  def test_raises_mismatch_error_if_not_the_same
-    secure_verifier = Net::SSH::Verifiers::Secure.new
-    key_in_known_hosts = OpenStruct.new(ssh_type:'key_type',to_blob:'keyblob')
-    key_actual = OpenStruct.new(ssh_type:'key_type',to_blob:'not keyblob')
-
-    host_keys = [key_in_known_hosts]
-    def host_keys.host
-      'foo'
-    end
-    assert_raises(Net::SSH::HostKeyMismatch) {
-      secure_verifier.verify(session:OpenStruct.new(host_keys:host_keys), key:key_actual)
-    }
-  end
-end