net-ssh 4.1.0 → 6.1.0

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

@@ -1,98 +1,101 @@
 require 'net/ssh/connection/constants'
 require 'net/ssh/transport/constants'
 
-module Net; module SSH; module Test
+module Net
+  module SSH
+    module Test
 
-  # This is an abstract class, not to be instantiated directly, subclassed by
-  # Net::SSH::Test::LocalPacket and Net::SSH::Test::RemotePacket. It implements
-  # functionality common to those subclasses.
-  #
-  # These packets are not true packets, in that they don't represent what was
-  # actually sent between the hosst; rather, they represent what was expected
-  # to be sent, as dictated by the script (Net::SSH::Test::Script). Thus,
-  # though they are defined with data elements, these data elements are used
-  # to either validate data that was sent by the local host (Net::SSH::Test::LocalPacket)
-  # or to mimic the sending of data by the remote host (Net::SSH::Test::RemotePacket).
-  class Packet
-    include Net::SSH::Transport::Constants
-    include Net::SSH::Connection::Constants
+      # This is an abstract class, not to be instantiated directly, subclassed by
+      # Net::SSH::Test::LocalPacket and Net::SSH::Test::RemotePacket. It implements
+      # functionality common to those subclasses.
+      #
+      # These packets are not true packets, in that they don't represent what was
+      # actually sent between the hosst; rather, they represent what was expected
+      # to be sent, as dictated by the script (Net::SSH::Test::Script). Thus,
+      # though they are defined with data elements, these data elements are used
+      # to either validate data that was sent by the local host (Net::SSH::Test::LocalPacket)
+      # or to mimic the sending of data by the remote host (Net::SSH::Test::RemotePacket).
+      class Packet
+        include Net::SSH::Transport::Constants
+        include Net::SSH::Connection::Constants
 
-    # Register a custom channel request. extra_parts is an array of types
-    # of extra parameters
-    def self.register_channel_request(request, extra_parts)
-      @registered_requests ||= {}
-      @registered_requests[request] = {extra_parts: extra_parts}
-    end
+        # Register a custom channel request. extra_parts is an array of types
+        # of extra parameters
+        def self.register_channel_request(request, extra_parts)
+          @registered_requests ||= {}
+          @registered_requests[request] = { extra_parts: extra_parts }
+        end
 
-    def self.registered_channel_requests(request)
-      @registered_requests && @registered_requests[request]
-    end
+        def self.registered_channel_requests(request)
+          @registered_requests && @registered_requests[request]
+        end
 
-    # Ceate a new packet of the given +type+, and with +args+ being a list of
-    # data elements in the order expected for packets of the given +type+
-    # (see #types).
-    def initialize(type, *args)
-      @type = self.class.const_get(type.to_s.upcase)
-      @data = args
-    end
+        # Ceate a new packet of the given +type+, and with +args+ being a list of
+        # data elements in the order expected for packets of the given +type+
+        # (see #types).
+        def initialize(type, *args)
+          @type = self.class.const_get(type.to_s.upcase)
+          @data = args
+        end
 
-    # The default for +remote?+ is false. Subclasses should override as necessary.
-    def remote?
-      false
-    end
+        # The default for +remote?+ is false. Subclasses should override as necessary.
+        def remote?
+          false
+        end
 
-    # The default for +local?+ is false. Subclasses should override as necessary.
-    def local?
-      false
-    end
+        # The default for +local?+ is false. Subclasses should override as necessary.
+        def local?
+          false
+        end
 
-    # Instantiates the packets data elements. When the packet was first defined,
-    # some elements may not have been fully realized, and were described as
-    # Proc objects rather than atomic types. This invokes those Proc objects
-    # and replaces them with their returned values. This allows for values 
-    # like Net::SSH::Test::Channel#remote_id to be used in scripts before
-    # the remote_id is known (since it is only known after a channel has been
-    # confirmed open).
-    def instantiate!
-      @data.map! { |i| i.respond_to?(:call) ? i.call : i }
-    end
+        # Instantiates the packets data elements. When the packet was first defined,
+        # some elements may not have been fully realized, and were described as
+        # Proc objects rather than atomic types. This invokes those Proc objects
+        # and replaces them with their returned values. This allows for values
+        # like Net::SSH::Test::Channel#remote_id to be used in scripts before
+        # the remote_id is known (since it is only known after a channel has been
+        # confirmed open).
+        def instantiate!
+          @data.map! { |i| i.respond_to?(:call) ? i.call : i }
+        end
 
-    # Returns an array of symbols describing the data elements for packets of
-    # the same type as this packet. These types are used to either validate
-    # sent packets (Net::SSH::Test::LocalPacket) or build received packets
-    # (Net::SSH::Test::RemotePacket).
-    #
-    # Not all packet types are defined here. As new packet types are required
-    # (e.g., a unit test needs to test that the remote host sent a packet that
-    # is not implemented here), the description of that packet should be
-    # added. Unsupported packet types will otherwise raise an exception.
-    def types
-      @types ||= case @type
-        when KEXINIT then 
-          [:long, :long, :long, :long,
-           :string, :string, :string, :string, :string, :string, :string, :string, :string, :string,
-           :bool]
-        when NEWKEYS then []
-        when CHANNEL_OPEN then [:string, :long, :long, :long]
-        when CHANNEL_OPEN_CONFIRMATION then [:long, :long, :long, :long]
-        when CHANNEL_DATA then [:long, :string]
-        when CHANNEL_EXTENDED_DATA then [:long, :long, :string]
-        when CHANNEL_EOF, CHANNEL_CLOSE, CHANNEL_SUCCESS, CHANNEL_FAILURE then [:long]
-        when CHANNEL_REQUEST
-          parts = [:long, :string, :bool]
-          case @data[1]
-          when "exec", "subsystem","shell" then parts << :string
-          when "exit-status" then parts << :long
-          when "pty-req" then parts.concat([:string, :long, :long, :long, :long, :string])
-          when "env" then parts.contact([:string,:string])
-          else
-            request = Packet.registered_channel_requests(@data[1])
-            raise "don't know what to do about #{@data[1]} channel request" unless request
-            parts.concat(request[:extra_parts])
-          end
-        else raise "don't know how to parse packet type #{@type}"
+        # Returns an array of symbols describing the data elements for packets of
+        # the same type as this packet. These types are used to either validate
+        # sent packets (Net::SSH::Test::LocalPacket) or build received packets
+        # (Net::SSH::Test::RemotePacket).
+        #
+        # Not all packet types are defined here. As new packet types are required
+        # (e.g., a unit test needs to test that the remote host sent a packet that
+        # is not implemented here), the description of that packet should be
+        # added. Unsupported packet types will otherwise raise an exception.
+        def types
+          @types ||= case @type
+                     when KEXINIT then
+                       %i[long long long long
+                          string string string string string string string string string string
+                          bool]
+                     when NEWKEYS then []
+                     when CHANNEL_OPEN then %i[string long long long]
+                     when CHANNEL_OPEN_CONFIRMATION then %i[long long long long]
+                     when CHANNEL_DATA then %i[long string]
+                     when CHANNEL_EXTENDED_DATA then %i[long long string]
+                     when CHANNEL_EOF, CHANNEL_CLOSE, CHANNEL_SUCCESS, CHANNEL_FAILURE then [:long]
+                     when CHANNEL_REQUEST
+                       parts = %i[long string bool]
+                       case @data[1]
+                       when "exec", "subsystem","shell" then parts << :string
+                       when "exit-status" then parts << :long
+                       when "pty-req" then parts.concat(%i[string long long long long string])
+                       when "env" then parts.contact(%i[string string])
+                       else
+                         request = Packet.registered_channel_requests(@data[1])
+                         raise "don't know what to do about #{@data[1]} channel request" unless request
+                         parts.concat(request[:extra_parts])
+                       end
+                     else raise "don't know how to parse packet type #{@type}"
+                     end
         end
+      end
     end
   end
-
-end; end; end
+end

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

@@ -1,38 +1,42 @@
 require 'net/ssh/buffer'
 require 'net/ssh/test/packet'
 
-module Net; module SSH; module Test
+module Net 
+  module SSH 
+    module Test
 
-  # This is a specialization of Net::SSH::Test::Packet for representing mock
-  # packets that are received by the local (client) host. These are created
-  # automatically by Net::SSH::Test::Script and Net::SSH::Test::Channel by any
-  # of the gets_* methods.
-  class RemotePacket < Packet
-    # Returns +true+; this is a remote packet.
-    def remote?
-      true
-    end
-
-    # The #process method should only be called on Net::SSH::Test::LocalPacket
-    # packets; if it is attempted on a remote packet, then it is an expectation
-    # mismatch (a remote packet was received when a local packet was expected
-    # to be sent). This will happen when either your test script
-    # (Net::SSH::Test::Script) or your program are wrong.
-    def process(packet)
-      raise "received packet type #{packet.read_byte} and was not expecting any packet"
-    end
-
-    # Returns this remote packet as a string, suitable for parsing by 
-    # Net::SSH::Transport::PacketStream and friends. When a remote packet is
-    # received, this method is called and the result concatenated onto the
-    # input buffer for the packet stream.
-    def to_s
-      @to_s ||= begin
-        instantiate!
-        string = Net::SSH::Buffer.from(:byte, @type, *types.zip(@data).flatten).to_s
-        [string.length, string].pack("NA*")
+      # This is a specialization of Net::SSH::Test::Packet for representing mock
+      # packets that are received by the local (client) host. These are created
+      # automatically by Net::SSH::Test::Script and Net::SSH::Test::Channel by any
+      # of the gets_* methods.
+      class RemotePacket < Packet
+        # Returns +true+; this is a remote packet.
+        def remote?
+          true
+        end
+    
+        # The #process method should only be called on Net::SSH::Test::LocalPacket
+        # packets; if it is attempted on a remote packet, then it is an expectation
+        # mismatch (a remote packet was received when a local packet was expected
+        # to be sent). This will happen when either your test script
+        # (Net::SSH::Test::Script) or your program are wrong.
+        def process(packet)
+          raise "received packet type #{packet.read_byte} and was not expecting any packet"
+        end
+    
+        # Returns this remote packet as a string, suitable for parsing by 
+        # Net::SSH::Transport::PacketStream and friends. When a remote packet is
+        # received, this method is called and the result concatenated onto the
+        # input buffer for the packet stream.
+        def to_s
+          @to_s ||= begin
+            instantiate!
+            string = Net::SSH::Buffer.from(:byte, @type, *types.zip(@data).flatten).to_s
+            [string.length, string].pack("NA*")
+          end
+        end
       end
+
     end
   end
-
-end; end; end
+end

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

@@ -2,179 +2,181 @@ require 'net/ssh/test/channel'
 require 'net/ssh/test/local_packet'
 require 'net/ssh/test/remote_packet'
 
-module Net; module SSH; module Test
-
-  # Represents a sequence of scripted events that identify the behavior that
-  # a test expects. Methods named "sends_*" create events for packets being
-  # sent from the local to the remote host, and methods named "gets_*" create
-  # events for packets being received by the local from the remote host.
-  #
-  # A reference to a script. is generally obtained in a unit test via the
-  # Net::SSH::Test#story helper method:
-  #
-  #   story do |script|
-  #     channel = script.opens_channel
-  #     ...
-  #   end
-  class Script
-    # The list of scripted events. These will be Net::SSH::Test::LocalPacket
-    # and Net::SSH::Test::RemotePacket instances.
-    attr_reader :events
-
-    # Create a new, empty script.
-    def initialize
-      @events = []
-    end
-
-    # Scripts the opening of a channel by adding a local packet sending the
-    # channel open request, and if +confirm+ is true (the default), also
-    # adding a remote packet confirming the new channel.
-    #
-    # A new Net::SSH::Test::Channel instance is returned, which can be used
-    # to script additional channel operations.
-    def opens_channel(confirm=true)
-      channel = Channel.new(self)
-      channel.remote_id = 5555
-
-      events << LocalPacket.new(:channel_open) { |p| channel.local_id = p[:remote_id] }
-
-      if confirm
-        events << RemotePacket.new(:channel_open_confirmation, channel.local_id, channel.remote_id, 0x20000, 0x10000)
-      end
-
-      channel
-    end
-
-    # A convenience method for adding an arbitrary local packet to the events
-    # list.
-    def sends(type, *args, &block)
-      events << LocalPacket.new(type, *args, &block)
-    end
-
-    # A convenience method for adding an arbitrary remote packet to the events
-    # list.
-    def gets(type, *args)
-      events << RemotePacket.new(type, *args)
-    end
-
-    # Scripts the sending of a new channel request packet to the remote host.
-    # +channel+ should be an instance of Net::SSH::Test::Channel. +request+
-    # is a string naming the request type to send, +reply+ is a boolean
-    # indicating whether a response to this packet is required , and +data+
-    # is any additional request-specific data that this packet should send.
-    # +success+ indicates whether the response (if one is required) should be
-    # success or failure. If +data+ is an array it will be treated as multiple
-    # data.
-    #
-    # If a reply is desired, a remote packet will also be queued, :channel_success
-    # if +success+ is true, or :channel_failure if +success+ is false.
-    #
-    # This will typically be called via Net::SSH::Test::Channel#sends_exec or
-    # Net::SSH::Test::Channel#sends_subsystem.
-    def sends_channel_request(channel, request, reply, data, success=true)
-      if data.is_a? Array
-        events << LocalPacket.new(:channel_request, channel.remote_id, request, reply, *data)
-      else
-        events << LocalPacket.new(:channel_request, channel.remote_id, request, reply, data)
-      end
-      if reply
-        if success
-          events << RemotePacket.new(:channel_success, channel.local_id)
-        else
-          events << RemotePacket.new(:channel_failure, channel.local_id)
+module Net 
+  module SSH 
+    module Test
+
+      # Represents a sequence of scripted events that identify the behavior that
+      # a test expects. Methods named "sends_*" create events for packets being
+      # sent from the local to the remote host, and methods named "gets_*" create
+      # events for packets being received by the local from the remote host.
+      #
+      # A reference to a script. is generally obtained in a unit test via the
+      # Net::SSH::Test#story helper method:
+      #
+      #   story do |script|
+      #     channel = script.opens_channel
+      #     ...
+      #   end
+      class Script
+        # The list of scripted events. These will be Net::SSH::Test::LocalPacket
+        # and Net::SSH::Test::RemotePacket instances.
+        attr_reader :events
+    
+        # Create a new, empty script.
+        def initialize
+          @events = []
+        end
+    
+        # Scripts the opening of a channel by adding a local packet sending the
+        # channel open request, and if +confirm+ is true (the default), also
+        # adding a remote packet confirming the new channel.
+        #
+        # A new Net::SSH::Test::Channel instance is returned, which can be used
+        # to script additional channel operations.
+        def opens_channel(confirm=true)
+          channel = Channel.new(self)
+          channel.remote_id = 5555
+    
+          events << LocalPacket.new(:channel_open) { |p| channel.local_id = p[:remote_id] }
+    
+          events << RemotePacket.new(:channel_open_confirmation, channel.local_id, channel.remote_id, 0x20000, 0x10000) if confirm
+    
+          channel
+        end
+    
+        # A convenience method for adding an arbitrary local packet to the events
+        # list.
+        def sends(type, *args, &block)
+          events << LocalPacket.new(type, *args, &block)
+        end
+    
+        # A convenience method for adding an arbitrary remote packet to the events
+        # list.
+        def gets(type, *args)
+          events << RemotePacket.new(type, *args)
+        end
+    
+        # Scripts the sending of a new channel request packet to the remote host.
+        # +channel+ should be an instance of Net::SSH::Test::Channel. +request+
+        # is a string naming the request type to send, +reply+ is a boolean
+        # indicating whether a response to this packet is required , and +data+
+        # is any additional request-specific data that this packet should send.
+        # +success+ indicates whether the response (if one is required) should be
+        # success or failure. If +data+ is an array it will be treated as multiple
+        # data.
+        #
+        # If a reply is desired, a remote packet will also be queued, :channel_success
+        # if +success+ is true, or :channel_failure if +success+ is false.
+        #
+        # This will typically be called via Net::SSH::Test::Channel#sends_exec or
+        # Net::SSH::Test::Channel#sends_subsystem.
+        def sends_channel_request(channel, request, reply, data, success=true)
+          if data.is_a? Array
+            events << LocalPacket.new(:channel_request, channel.remote_id, request, reply, *data)
+          else
+            events << LocalPacket.new(:channel_request, channel.remote_id, request, reply, data)
+          end
+          if reply
+            if success
+              events << RemotePacket.new(:channel_success, channel.local_id)
+            else
+              events << RemotePacket.new(:channel_failure, channel.local_id)
+            end
+          end
+        end
+    
+        # Scripts the sending of a channel data packet. +channel+ must be a
+        # Net::SSH::Test::Channel object, and +data+ is the (string) data to
+        # expect will be sent.
+        #
+        # This will typically be called via Net::SSH::Test::Channel#sends_data.
+        def sends_channel_data(channel, data)
+          events << LocalPacket.new(:channel_data, channel.remote_id, data)
+        end
+    
+        # Scripts the sending of a channel EOF packet from the given
+        # Net::SSH::Test::Channel +channel+. This will typically be called via
+        # Net::SSH::Test::Channel#sends_eof.
+        def sends_channel_eof(channel)
+          events << LocalPacket.new(:channel_eof, channel.remote_id)
+        end
+    
+        # Scripts the sending of a channel close packet from the given
+        # Net::SSH::Test::Channel +channel+. This will typically be called via
+        # Net::SSH::Test::Channel#sends_close.
+        def sends_channel_close(channel)
+          events << LocalPacket.new(:channel_close, channel.remote_id)
+        end
+    
+        # Scripts the sending of a channel request pty packets from the given
+        # Net::SSH::Test::Channel +channel+. This will typically be called via
+        # Net::SSH::Test::Channel#sends_request_pty.
+        def sends_channel_request_pty(channel)
+          data = ['pty-req', false]
+          data += Net::SSH::Connection::Channel::VALID_PTY_OPTIONS.merge(modes: "\0").values
+          events << LocalPacket.new(:channel_request, channel.remote_id, *data)
+        end
+    
+        # Scripts the reception of a channel data packet from the remote host by
+        # the given Net::SSH::Test::Channel +channel+. This will typically be
+        # called via Net::SSH::Test::Channel#gets_data.
+        def gets_channel_data(channel, data)
+          events << RemotePacket.new(:channel_data, channel.local_id, data)
+        end
+    
+        # Scripts the reception of a channel extended data packet from the remote
+        # host by the given Net::SSH::Test::Channel +channel+. This will typically
+        # be called via Net::SSH::Test::Channel#gets_extended_data.
+        #
+        # Currently the only extended data type is stderr == 1.
+        def gets_channel_extended_data(channel, data)
+          events << RemotePacket.new(:channel_extended_data, channel.local_id, 1, data)
+        end
+    
+        # Scripts the reception of a channel request packet from the remote host by
+        # the given Net::SSH::Test::Channel +channel+. This will typically be
+        # called via Net::SSH::Test::Channel#gets_exit_status.
+        def gets_channel_request(channel, request, reply, data)
+          events << RemotePacket.new(:channel_request, channel.local_id, request, reply, data)
+        end
+    
+        # Scripts the reception of a channel EOF packet from the remote host by
+        # the given Net::SSH::Test::Channel +channel+. This will typically be
+        # called via Net::SSH::Test::Channel#gets_eof.
+        def gets_channel_eof(channel)
+          events << RemotePacket.new(:channel_eof, channel.local_id)
+        end
+    
+        # Scripts the reception of a channel close packet from the remote host by
+        # the given Net::SSH::Test::Channel +channel+. This will typically be
+        # called via Net::SSH::Test::Channel#gets_close.
+        def gets_channel_close(channel)
+          events << RemotePacket.new(:channel_close, channel.local_id)
+        end
+    
+        # By default, removes the next event in the list and returns it. However,
+        # this can also be used to non-destructively peek at the next event in the
+        # list, by passing :first as the argument.
+        #
+        #   # remove the next event and return it
+        #   event = script.next
+        #
+        #   # peek at the next event
+        #   event = script.next(:first)
+        def next(mode=:shift)
+          events.send(mode)
+        end
+    
+        # Compare the given packet against the next event in the list. If there is
+        # no next event, an exception will be raised. This is called by
+        # Net::SSH::Test::Extensions::PacketStream#test_enqueue_packet.
+        def process(packet)
+          event = events.shift or raise "end of script reached, but got a packet type #{packet.read_byte}"
+          event.process(packet)
         end
       end
-    end
-
-    # Scripts the sending of a channel data packet. +channel+ must be a
-    # Net::SSH::Test::Channel object, and +data+ is the (string) data to
-    # expect will be sent.
-    #
-    # This will typically be called via Net::SSH::Test::Channel#sends_data.
-    def sends_channel_data(channel, data)
-      events << LocalPacket.new(:channel_data, channel.remote_id, data)
-    end
-
-    # Scripts the sending of a channel EOF packet from the given
-    # Net::SSH::Test::Channel +channel+. This will typically be called via
-    # Net::SSH::Test::Channel#sends_eof.
-    def sends_channel_eof(channel)
-      events << LocalPacket.new(:channel_eof, channel.remote_id)
-    end
-
-    # Scripts the sending of a channel close packet from the given
-    # Net::SSH::Test::Channel +channel+. This will typically be called via
-    # Net::SSH::Test::Channel#sends_close.
-    def sends_channel_close(channel)
-      events << LocalPacket.new(:channel_close, channel.remote_id)
-    end
-
-    # Scripts the sending of a channel request pty packets from the given
-    # Net::SSH::Test::Channel +channel+. This will typically be called via
-    # Net::SSH::Test::Channel#sends_request_pty.
-    def sends_channel_request_pty(channel)
-      data = ['pty-req', false]
-      data += Net::SSH::Connection::Channel::VALID_PTY_OPTIONS.merge(modes: "\0").values
-      events << LocalPacket.new(:channel_request, channel.remote_id, *data)
-    end
 
-    # Scripts the reception of a channel data packet from the remote host by
-    # the given Net::SSH::Test::Channel +channel+. This will typically be
-    # called via Net::SSH::Test::Channel#gets_data.
-    def gets_channel_data(channel, data)
-      events << RemotePacket.new(:channel_data, channel.local_id, data)
-    end
-
-    # Scripts the reception of a channel extended data packet from the remote
-    # host by the given Net::SSH::Test::Channel +channel+. This will typically
-    # be called via Net::SSH::Test::Channel#gets_extended_data.
-    #
-    # Currently the only extended data type is stderr == 1.
-    def gets_channel_extended_data(channel, data)
-      events << RemotePacket.new(:channel_extended_data, channel.local_id, 1, data)
-    end
-
-    # Scripts the reception of a channel request packet from the remote host by
-    # the given Net::SSH::Test::Channel +channel+. This will typically be
-    # called via Net::SSH::Test::Channel#gets_exit_status.
-    def gets_channel_request(channel, request, reply, data)
-      events << RemotePacket.new(:channel_request, channel.local_id, request, reply, data)
-    end
-
-    # Scripts the reception of a channel EOF packet from the remote host by
-    # the given Net::SSH::Test::Channel +channel+. This will typically be
-    # called via Net::SSH::Test::Channel#gets_eof.
-    def gets_channel_eof(channel)
-      events << RemotePacket.new(:channel_eof, channel.local_id)
-    end
-
-    # Scripts the reception of a channel close packet from the remote host by
-    # the given Net::SSH::Test::Channel +channel+. This will typically be
-    # called via Net::SSH::Test::Channel#gets_close.
-    def gets_channel_close(channel)
-      events << RemotePacket.new(:channel_close, channel.local_id)
-    end
-
-    # By default, removes the next event in the list and returns it. However,
-    # this can also be used to non-destructively peek at the next event in the
-    # list, by passing :first as the argument.
-    #
-    #   # remove the next event and return it
-    #   event = script.next
-    #
-    #   # peek at the next event
-    #   event = script.next(:first)
-    def next(mode=:shift)
-      events.send(mode)
-    end
-
-    # Compare the given packet against the next event in the list. If there is
-    # no next event, an exception will be raised. This is called by
-    # Net::SSH::Test::Extensions::PacketStream#test_enqueue_packet.
-    def process(packet)
-      event = events.shift or raise "end of script reached, but got a packet type #{packet.read_byte}"
-      event.process(packet)
     end
   end
-
-end; end; end
+end