net-ssh-net-ssh 2.0.12

data/test/transport/test_server_version.rb

@@ -0,0 +1,68 @@
+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_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)
+        socket = mock("socket")
+
+        data = version_header.split('')
+        recv_times = data.length
+        if data[-1] != "\n"
+            recv_times += 1
+        end
+        socket.expects(:recv).with(1).times(recv_times).returns(*data).then.returns(nil)
+
+        if good
+          socket.expects(:write).with("#{Net::SSH::Transport::ServerVersion::PROTO_VERSION}\r\n")
+          socket.expects(:flush)
+        else
+          socket.expects(:write).never
+        end
+
+        socket
+      end
+
+      def subject(socket)
+        Net::SSH::Transport::ServerVersion.new(socket, nil)
+      end
+  end
+
+end

data/test/transport/test_session.rb

@@ -0,0 +1,315 @@
+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_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_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)
+      end
+
+      def session(options={})
+        @session ||= begin
+          host = options.delete(:host) || "net.ssh.test"
+          TCPSocket.stubs(:open).with(host, options[:port] || 22).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

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