net-ssh 4.2.0 → 7.0.1

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

@@ -2,179 +2,179 @@ 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
+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
+        # 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 << 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
+          events << RemotePacket.new(:channel_open_confirmation, channel.local_id, channel.remote_id, 0x20000, 0x10000) if confirm
 
-      channel
-    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 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
+        # 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)
+        # 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
-      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 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 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 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 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 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 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 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 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
+        # 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
+        # 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)
+        # 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; end
+end

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

@@ -3,62 +3,63 @@ require 'stringio'
 require 'net/ssh/test/extensions'
 require 'net/ssh/test/script'
 
-module Net; module SSH; module Test
+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
 
-  # 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
 
-    # 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"
 
-    # 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 = 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
 
-      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
 
-    # 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 = {})
+          @host, @port = host, port
+          self
+        end
 
-    # Allows the socket to also mimic a socket factory, simply returning
-    # +self+.
-    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
 
-    # 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
 
-    # Alias to #read, but never returns nil (returns an empty string instead).
-    def recv(n)
-      read(n) || ""
+        def readpartial(n)
+          recv(n)
+        end
+      end
     end
-
-    def readpartial(n)
-      recv(n)
-    end
-    
   end
-
-end; end; end
+end

data/lib/net/ssh/test.rb

@@ -3,90 +3,92 @@ require 'net/ssh/connection/session'
 require 'net/ssh/test/kex'
 require 'net/ssh/test/socket'
 
-module Net; module SSH
+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 'minitest/autorun'
+    #   require 'net/ssh/test'
+    #
+    #   class MyTest < Minitest::Test
+    #     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
+        Net::SSH::Test::Extensions::IO.with_test_extension { yield socket.script if block_given? }
+        return socket.script
+      end
 
-  # 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 'minitest/autorun'
-  #   require 'net/ssh/test'
-  #
-  #   class MyTest < Minitest::Test
-  #     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
-      Net::SSH::Test::Extensions::IO.with_test_extension { 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 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 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", append_all_supported_algorithms: true, verify_host_key: :never, proxy: socket(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", verify_host_key: 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?
 
-    # 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?
-      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"
+        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; end
+end