net-ssh 6.1.0 → 7.1.0

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:
+
+          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:
+          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:
+          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,35 +126,36 @@ module Net
               @extension_enabled = orig_value
             end
           end
-    
+
           def self.extension_enabled?
             @extension_enabled
           end
-    
+
           module ClassMethods
-            def self.extended(obj) #:nodoc:
-              class <<obj
+            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)
+            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]
@@ -83,13 +82,14 @@ module Net
                      when CHANNEL_REQUEST
                        parts = %i[long string bool]
                        case @data[1]
-                       when "exec", "subsystem","shell" then parts << :string
+                       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}"

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
+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,41 +21,41 @@ 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.
         #
         # A new Net::SSH::Test::Channel instance is returned, which can be used
         # to script additional channel operations.
-        def opens_channel(confirm=true)
+        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
@@ -71,7 +70,7 @@ module Net
         #
         # 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)
+        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
@@ -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.
@@ -164,10 +163,10 @@ module Net
         #
         #   # peek at the next event
         #   event = script.next(:first)
-        def next(mode=:shift)
+        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
+end

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

@@ -3,66 +3,63 @@ require 'stringio'
 require 'net/ssh/test/extensions'
 require 'net/ssh/test/script'
 
-module Net 
-  module SSH 
+module Net
+  module SSH
     module Test
-
       # A mock socket implementation for use in testing. It implements the minimum
       # necessary interface for interacting with the rest of the Net::SSH::Test
       # system.
       class Socket < StringIO
         attr_reader :host, :port
-    
+
         # The Net::SSH::Test::Script object in use by this socket. This is the
         # canonical script instance that should be used for any test depending on
         # this socket instance.
         attr_reader :script
-    
+
         # Create a new test socket. This will also instantiate a new Net::SSH::Test::Script
         # and seed it with the necessary events to power the initialization of the
         # connection.
         def initialize
           extend(Net::SSH::Transport::PacketStream)
           super "SSH-2.0-Test\r\n"
-    
+
           @script = Script.new
-    
+
           script.sends(:kexinit)
           script.gets(:kexinit, 1, 2, 3, 4, "test", "ssh-rsa", "none", "none", "none", "none", "none", "none", "", "", false)
           script.sends(:newkeys)
           script.gets(:newkeys)
         end
-    
+
         # This doesn't actually do anything, since we don't really care what gets
         # written.
         def write(data)
           # black hole, because we don't actually care about what gets written
         end
-    
+
         # Allows the socket to also mimic a socket factory, simply returning
         # +self+.
-        def open(host, port, options={})
+        def open(host, port, options = {})
           @host, @port = host, port
           self
         end
-    
+
         # Returns a sockaddr struct for the port and host that were used when the
         # socket was instantiated.
         def getpeername
           ::Socket.sockaddr_in(port, host)
         end
-    
+
         # Alias to #read, but never returns nil (returns an empty string instead).
         def recv(n)
           read(n) || ""
         end
-    
+
         def readpartial(n)
           recv(n)
         end
-        
       end
-
     end
   end
 end

data/lib/net/ssh/test.rb

@@ -5,7 +5,6 @@ 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
@@ -57,21 +56,21 @@ module Net
 
       # Returns the test socket instance to use for these tests (see
       # Net::SSH::Test::Socket).
-      def socket(options={})
+      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={})
+      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={})
+      def transport(options = {})
         @transport ||= Net::SSH::Transport::Session.new(
           options[:host] || "localhost",
           options.merge(kex: "test", host_key: "ssh-rsa", append_all_supported_algorithms: true, verify_host_key: :never, proxy: socket(options))
@@ -85,11 +84,11 @@ module Net
       # the block passed to this assertion.
       def assert_scripted
         raise "there is no script to be processed" if socket.script.events.empty?
+
         Net::SSH::Test::Extensions::IO.with_test_extension { 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