net-ssh 6.2.0.rc2 → 6.3.0.beta1

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

@@ -6,16 +6,14 @@ require 'net/ssh/connection/constants'
 require 'net/ssh/transport/constants'
 require 'net/ssh/transport/packet_stream'
 
-module Net 
-  module SSH 
+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
@@ -24,80 +22,82 @@ module Net
           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
@@ -107,16 +107,16 @@ module Net
             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
-    
+
           @extension_enabled = false
-    
+
           def self.with_test_extension(&block)
             orig_value = @extension_enabled
             @extension_enabled = true
@@ -126,11 +126,11 @@ module Net
               @extension_enabled = orig_value
             end
           end
-    
+
           def self.extension_enabled?
             @extension_enabled
           end
-    
+
           module ClassMethods
             def self.extended(obj) #:nodoc:
               class <<obj
@@ -138,23 +138,24 @@ module Net
                 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)
               return select_for_real(readers, writers, errors, wait) unless Net::SSH::Test::Extensions::IO.extension_enabled?
+
               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? }
-    
+
               return [ready_readers, ready_writers, ready_errors] if ready_readers.any? || ready_writers.any? || ready_errors.any?
-    
+
               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 && wait != 0
 
               [[], [], []]
@@ -162,7 +163,6 @@ module Net
           end
         end
       end
-
     end
   end
 end

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

@@ -5,10 +5,9 @@ require 'net/ssh/transport/algorithms'
 require 'net/ssh/transport/constants'
 require 'net/ssh/transport/kex'
 
-module Net 
-  module SSH 
+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.)
@@ -17,29 +16,28 @@ module Net
       # "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(512),
             shared_secret: OpenSSL::BN.new("1234567890", 10),
             hashing_algorithm: OpenSSL::Digest::SHA1 }
         end
       end
-
     end
   end
 end

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

@@ -4,7 +4,6 @@ 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
@@ -49,7 +48,6 @@ module Net
           end
         end
       end
-
     end
   end
 end

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

@@ -4,7 +4,6 @@ require 'net/ssh/transport/constants'
 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.
@@ -70,7 +69,7 @@ module Net
         # added. Unsupported packet types will otherwise raise an exception.
         def types
           @types ||= case @type
-                     when KEXINIT then
+                     when KEXINIT
                        %i[long long long long
                           string string string string string string string string string string
                           bool]
@@ -90,6 +89,7 @@ module Net
                        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}"

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

@@ -1,10 +1,9 @@
 require 'net/ssh/buffer'
 require 'net/ssh/test/packet'
 
-module Net 
-  module SSH 
+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
@@ -14,7 +13,7 @@ module Net
         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
@@ -23,8 +22,8 @@ module Net
         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 
+
+        # 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.
@@ -36,7 +35,6 @@ module Net
           end
         end
       end
-
     end
   end
 end

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

@@ -2,10 +2,9 @@ require 'net/ssh/test/channel'
 require 'net/ssh/test/local_packet'
 require 'net/ssh/test/remote_packet'
 
-module Net 
-  module SSH 
+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
@@ -22,12 +21,12 @@ module Net
         # 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.
@@ -37,26 +36,26 @@ module Net
         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
@@ -85,7 +84,7 @@ module Net
             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.
@@ -94,21 +93,21 @@ module Net
         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.
@@ -117,14 +116,14 @@ module Net
           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.
@@ -133,28 +132,28 @@ module Net
         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.
@@ -167,7 +166,7 @@ module Net
         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.
@@ -176,7 +175,6 @@ module Net
           event.process(packet)
         end
       end
-
     end
   end
 end