k-yamada-net-ssh 2.3.0

data/lib/net/ssh/test.rb

@@ -0,0 +1,89 @@
+require 'net/ssh/transport/session'
+require 'net/ssh/connection/session'
+require 'net/ssh/test/kex'
+require 'net/ssh/test/socket'
+
+module Net; module SSH
+
+  # This module may be used in unit tests, for when you want to test that your
+  # SSH state machines are really doing what you expect they are doing. You will
+  # typically include this module in your unit test class, and then build a
+  # "story" of expected sends and receives:
+  #
+  #   require 'test/unit'
+  #   require 'net/ssh/test'
+  #
+  #   class MyTest < Test::Unit::TestCase
+  #     include Net::SSH::Test
+  #
+  #     def test_exec_via_channel_works
+  #       story do |session|
+  #         channel = session.opens_channel
+  #         channel.sends_exec "ls"
+  #         channel.gets_data "result of ls"
+  #         channel.gets_close
+  #         channel.sends_close
+  #       end
+  #
+  #       assert_scripted do
+  #         result = nil
+  #
+  #         connection.open_channel do |ch|
+  #           ch.exec("ls") do |success|
+  #             ch.on_data { |c, data| result = data }
+  #             ch.on_close { |c| c.close }
+  #           end
+  #         end
+  #
+  #         connection.loop
+  #         assert_equal "result of ls", result
+  #       end
+  #     end
+  #   end
+  #
+  # See Net::SSH::Test::Channel and Net::SSH::Test::Script for more options.
+  #
+  # Note that the Net::SSH::Test system is rather finicky yet, and can be kind
+  # of frustrating to get working. Any suggestions for improvement will be
+  # welcome!
+  module Test
+    # If a block is given, yields the script for the test socket (#socket).
+    # Otherwise, simply returns the socket's script. See Net::SSH::Test::Script.
+    def story
+      yield socket.script if block_given?
+      return socket.script
+    end
+
+    # Returns the test socket instance to use for these tests (see
+    # Net::SSH::Test::Socket).
+    def socket(options={})
+      @socket ||= Net::SSH::Test::Socket.new
+    end
+
+    # Returns the connection session (Net::SSH::Connection::Session) for use
+    # in these tests. It is a fully functional SSH session, operating over
+    # a mock socket (#socket).
+    def connection(options={})
+      @connection ||= Net::SSH::Connection::Session.new(transport(options), options)
+    end
+
+    # Returns the transport session (Net::SSH::Transport::Session) for use
+    # in these tests. It is a fully functional SSH transport session, operating
+    # over a mock socket (#socket).
+    def transport(options={})
+      @transport ||= Net::SSH::Transport::Session.new(options[:host] || "localhost", options.merge(:kex => "test", :host_key => "ssh-rsa", :paranoid => false, :proxy => socket(options)))
+    end
+
+    # First asserts that a story has been described (see #story). Then yields,
+    # and then asserts that all items described in the script have been
+    # processed. Typically, this is called immediately after a story has
+    # been built, and the SSH commands being tested are then executed within
+    # the block passed to this assertion.
+    def assert_scripted
+      raise "there is no script to be processed" if socket.script.events.empty?
+      yield
+      assert socket.script.events.empty?, "there should not be any remaining scripted events, but there are still #{socket.script.events.length} pending"
+    end
+  end
+
+end; end

data/lib/net/ssh/test/channel.rb

@@ -0,0 +1,129 @@
+module Net; module SSH; module Test
+
+  # A mock channel, used for scripting actions in tests. It wraps a
+  # Net::SSH::Test::Script instance, and delegates to it for the most part.
+  # This class has little real functionality on its own, but rather acts as
+  # a convenience for scripting channel-related activity for later comparison
+  # in a unit test.
+  #
+  #   story do |session|
+  #     channel = session.opens_channel
+  #     channel.sends_exec "ls"
+  #     channel.gets_data "result of ls"
+  #     channel.gets_close
+  #     channel.sends_close
+  #   end
+  class Channel
+    # The Net::SSH::Test::Script instance employed by this mock channel.
+    attr_reader :script
+
+    # Sets the local-id of this channel object (the id assigned by the client).
+    attr_writer :local_id
+
+    # Sets the remote-id of this channel object (the id assigned by the mock-server).
+    attr_writer :remote_id
+
+    # Creates a new Test::Channel instance on top of the given +script+ (which
+    # must be a Net::SSH::Test::Script instance).
+    def initialize(script)
+      @script = script
+      @local_id = @remote_id = nil
+    end
+
+    # Returns the local (client-assigned) id for this channel, or a Proc object
+    # that will return the local-id later if the local id has not yet been set.
+    # (See Net::SSH::Test::Packet#instantiate!.)
+    def local_id
+      @local_id || Proc.new { @local_id or raise "local-id has not been set yet!" }
+    end
+
+    # Returns the remote (server-assigned) id for this channel, or a Proc object
+    # that will return the remote-id later if the remote id has not yet been set.
+    # (See Net::SSH::Test::Packet#instantiate!.)
+    def remote_id
+      @remote_id || Proc.new { @remote_id or raise "remote-id has not been set yet!" }
+    end
+
+    # Because adjacent calls to #gets_data will sometimes cause the data packets
+    # to be concatenated (causing expectations in tests to fail), you may
+    # need to separate those calls with calls to #inject_remote_delay! (which
+    # essentially just mimics receiving an empty data packet):
+    #
+    #   channel.gets_data "abcdefg"
+    #   channel.inject_remote_delay!
+    #   channel.gets_data "hijklmn"
+    def inject_remote_delay!
+      gets_data("")
+    end
+
+    # Scripts the sending of an "exec" channel request packet to the mock 
+    # server. If +reply+ is true, then the server is expected to reply to the
+    # request, otherwise no response to this request will be sent. If +success+
+    # is +true+, then the request will be successful, otherwise a failure will
+    # be scripted.
+    #
+    #   channel.sends_exec "ls -l"
+    def sends_exec(command, reply=true, success=true)
+      script.sends_channel_request(self, "exec", reply, command, success)
+    end
+
+    # Scripts the sending of a "subsystem" channel request packet to the mock
+    # server. See #sends_exec for a discussion of the meaning of the +reply+
+    # and +success+ arguments.
+    #
+    #   channel.sends_subsystem "sftp"
+    def sends_subsystem(subsystem, reply=true, success=true)
+      script.sends_channel_request(self, "subsystem", reply, subsystem, success)
+    end
+
+    # Scripts the sending of a data packet across the channel.
+    #
+    #   channel.sends_data "foo"
+    def sends_data(data)
+      script.sends_channel_data(self, data)
+    end
+
+    # Scripts the sending of an EOF packet across the channel.
+    #
+    #   channel.sends_eof
+    def sends_eof
+      script.sends_channel_eof(self)
+    end
+
+    # Scripts the sending of a "channel close" packet across the channel.
+    #
+    #   channel.sends_close
+    def sends_close
+      script.sends_channel_close(self)
+    end
+
+    # Scripts the reception of a channel data packet from the remote end.
+    #
+    #   channel.gets_data "bar"
+    def gets_data(data)
+      script.gets_channel_data(self, data)
+    end
+
+    # Scripts the reception of an "exit-status" channel request packet.
+    #
+    #   channel.gets_exit_status(127)
+    def gets_exit_status(status=0)
+      script.gets_channel_request(self, "exit-status", false, status)
+    end
+
+    # Scripts the reception of an EOF packet from the remote end.
+    #
+    #   channel.gets_eof
+    def gets_eof
+      script.gets_channel_eof(self)
+    end
+
+    # Scripts the reception of a "channel close" packet from the remote end.
+    #
+    #   channel.gets_close
+    def gets_close
+      script.gets_channel_close(self)
+    end
+  end
+
+end; end; end

data/lib/net/ssh/test/extensions.rb

@@ -0,0 +1,152 @@
+require 'net/ssh/buffer'
+require 'net/ssh/packet'
+require 'net/ssh/buffered_io'
+require 'net/ssh/connection/channel'
+require 'net/ssh/connection/constants'
+require 'net/ssh/transport/constants'
+require 'net/ssh/transport/packet_stream'
+
+module Net; module SSH; module Test
+
+  # A collection of modules used to extend/override the default behavior of
+  # Net::SSH internals for ease of testing. As a consumer of Net::SSH, you'll
+  # never need to use this directly--they're all used under the covers by
+  # the Net::SSH::Test system.
+  module Extensions
+
+    # An extension to Net::SSH::BufferedIo (assumes that the underlying IO
+    # is actually a StringIO). Facilitates unit testing.
+    module BufferedIo
+      # Returns +true+ if the position in the stream is less than the total
+      # length of the stream.
+      def select_for_read?
+        pos < size
+      end
+
+      # Set this to +true+ if you want the IO to pretend to be available for writing
+      attr_accessor :select_for_write
+
+      # Set this to +true+ if you want the IO to pretend to be in an error state
+      attr_accessor :select_for_error
+
+      alias select_for_write? select_for_write
+      alias select_for_error? select_for_error
+    end
+
+    # An extension to Net::SSH::Transport::PacketStream (assumes that the
+    # underlying IO is actually a StringIO). Facilitates unit testing.
+    module PacketStream
+      include BufferedIo # make sure we get the extensions here, too
+
+      def self.included(base) #:nodoc:
+        base.send :alias_method, :real_available_for_read?, :available_for_read?
+        base.send :alias_method, :available_for_read?, :test_available_for_read?
+
+        base.send :alias_method, :real_enqueue_packet, :enqueue_packet
+        base.send :alias_method, :enqueue_packet, :test_enqueue_packet
+
+        base.send :alias_method, :real_poll_next_packet, :poll_next_packet
+        base.send :alias_method, :poll_next_packet, :test_poll_next_packet
+      end
+
+      # Called when another packet should be inspected from the current
+      # script. If the next packet is a remote packet, it pops it off the
+      # script and shoves it onto this IO object, making it available to
+      # be read.
+      def idle!
+        return false unless script.next(:first)
+
+        if script.next(:first).remote?
+          self.string << script.next.to_s
+          self.pos = pos
+        end
+
+        return true
+      end
+
+      # The testing version of Net::SSH::Transport::PacketStream#available_for_read?.
+      # Returns true if there is data pending to be read. Otherwise calls #idle!.
+      def test_available_for_read?
+        return true if select_for_read?
+        idle!
+        false
+      end
+
+      # The testing version of Net::SSH::Transport::PacketStream#enqueued_packet.
+      # Simply calls Net::SSH::Test::Script#process on the packet.
+      def test_enqueue_packet(payload)
+        packet = Net::SSH::Buffer.new(payload.to_s)
+        script.process(packet)
+      end
+
+      # The testing version of Net::SSH::Transport::PacketStream#poll_next_packet.
+      # Reads the next available packet from the IO object and returns it.
+      def test_poll_next_packet
+        return nil if available <= 0
+        packet = Net::SSH::Buffer.new(read_available(4))
+        length = packet.read_long
+        Net::SSH::Packet.new(read_available(length))
+      end
+    end
+
+    # An extension to Net::SSH::Connection::Channel. Facilitates unit testing.
+    module Channel
+      def self.included(base) #:nodoc:
+        base.send :alias_method, :send_data_for_real, :send_data
+        base.send :alias_method, :send_data, :send_data_for_test
+      end
+
+      # The testing version of Net::SSH::Connection::Channel#send_data. Calls
+      # the original implementation, and then immediately enqueues the data for
+      # output so that scripted sends are properly interpreted as discrete
+      # (rather than concatenated) data packets.
+      def send_data_for_test(data)
+        send_data_for_real(data)
+        enqueue_pending_output
+      end
+    end
+
+    # An extension to the built-in ::IO class. Simply redefines IO.select
+    # so that it can be scripted in Net::SSH unit tests.
+    module IO
+      def self.included(base) #:nodoc:
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def self.extended(obj) #:nodoc:
+          class <<obj
+            alias_method :select_for_real, :select
+            alias_method :select, :select_for_test
+          end
+        end
+
+        # The testing version of ::IO.select. Assumes that all readers,
+        # writers, and errors arrays are either nil, or contain only objects
+        # that mix in Net::SSH::Test::Extensions::BufferedIo.
+        def select_for_test(readers=nil, writers=nil, errors=nil, wait=nil)
+          ready_readers = Array(readers).select { |r| r.select_for_read? }
+          ready_writers = Array(writers).select { |r| r.select_for_write? }
+          ready_errors  = Array(errors).select  { |r| r.select_for_error? }
+
+          if ready_readers.any? || ready_writers.any? || ready_errors.any?
+            return [ready_readers, ready_writers, ready_errors]
+          end
+
+          processed = 0
+          Array(readers).each do |reader|
+            processed += 1 if reader.idle!
+          end
+
+          raise "no readers were ready for reading, and none had any incoming packets" if processed == 0
+        end
+      end
+    end
+  end
+
+end; end; end
+
+Net::SSH::BufferedIo.__send__(:include, Net::SSH::Test::Extensions::BufferedIo)
+Net::SSH::Transport::PacketStream.__send__(:include, Net::SSH::Test::Extensions::PacketStream)
+Net::SSH::Connection::Channel.__send__(:include, Net::SSH::Test::Extensions::Channel)
+IO.__send__(:include, Net::SSH::Test::Extensions::IO)

data/lib/net/ssh/test/kex.rb

@@ -0,0 +1,44 @@
+require 'openssl'
+
+require 'net/ssh/errors'
+require 'net/ssh/transport/algorithms'
+require 'net/ssh/transport/constants'
+require 'net/ssh/transport/kex'
+
+module Net; module SSH; module Test
+
+  # An implementation of a key-exchange strategy specifically for unit tests.
+  # (This strategy would never really work against a real SSH server--it makes
+  # too many assumptions about the server's response.)
+  #
+  # This registers itself with the transport key-exchange system as the
+  # "test" algorithm.
+  class Kex
+    include Net::SSH::Transport::Constants
+
+    # Creates a new instance of the testing key-exchange algorithm with the
+    # given arguments.
+    def initialize(algorithms, connection, data)
+      @connection = connection
+    end
+
+    # Exchange keys with the server. This returns a hash of constant values,
+    # and does not actually exchange keys.
+    def exchange_keys
+      result = Net::SSH::Buffer.from(:byte, NEWKEYS)
+      @connection.send_message(result)
+
+      buffer = @connection.next_message
+      raise Net::SSH::Exception, "expected NEWKEYS" unless buffer.type == NEWKEYS
+
+      { :session_id        => "abc-xyz",
+        :server_key        => OpenSSL::PKey::RSA.new(32),
+        :shared_secret     => OpenSSL::BN.new("1234567890", 10),
+        :hashing_algorithm => OpenSSL::Digest::SHA1 }
+    end
+  end
+
+end; end; end
+
+Net::SSH::Transport::Algorithms::ALGORITHMS[:kex] << "test"
+Net::SSH::Transport::Kex::MAP["test"] = Net::SSH::Test::Kex

data/lib/net/ssh/test/local_packet.rb

@@ -0,0 +1,51 @@
+require 'net/ssh/packet'
+require 'net/ssh/test/packet'
+
+module Net; module SSH; module Test
+
+  # This is a specialization of Net::SSH::Test::Packet for representing mock
+  # packets that are sent from the local (client) host. These are created
+  # automatically by Net::SSH::Test::Script and Net::SSH::Test::Channel by any
+  # of the sends_* methods.
+  class LocalPacket < Packet
+    attr_reader :init
+
+    # Extend the default Net::SSH::Test::Packet constructor to also accept an
+    # optional block, which is used to finalize the initialization of the
+    # packet when #process is first called.
+    def initialize(type, *args, &block)
+      super(type, *args)
+      @init = block
+    end
+
+    # Returns +true+; this is a local packet.
+    def local?
+      true
+    end
+
+    # Called by Net::SSH::Test::Extensions::PacketStream#test_enqueue_packet
+    # to mimic remote processing of a locally-sent packet. It compares the
+    # packet it was given with the contents of this LocalPacket's data, to see
+    # if what was sent matches what was scripted. If it differs in any way,
+    # an exception is raised.
+    def process(packet)
+      @init.call(Net::SSH::Packet.new(packet.to_s)) if @init
+      type = packet.read_byte
+      raise "expected #{@type}, but got #{type}" if @type != type
+
+      @data.zip(types).each do |expected, type|
+        type ||= case expected
+          when nil then break
+          when Numeric then :long
+          when String then :string
+          when TrueClass, FalseClass then :bool
+          end
+
+        actual = packet.__send__("read_#{type}")
+        next if expected.nil?
+        raise "expected #{type} #{expected.inspect} but got #{actual.inspect}" unless expected == actual
+      end
+    end
+  end
+
+end; end; end