depengine 0.0.1

data/etc/isolate/jruby-1.8/gems/net-ssh-2.0.23/lib/net/ssh/test/packet.rb

@@ -0,0 +1,81 @@
+require 'net/ssh/connection/constants'
+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.
+  #
+  # 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
+
+    # 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 +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
+
+    # 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_EOF, CHANNEL_CLOSE, CHANNEL_SUCCESS, CHANNEL_FAILURE then [:long]
+        when CHANNEL_REQUEST
+          parts = [:long, :string, :bool]
+          case @data[1]
+          when "exec", "subsystem" then parts << :string
+          when "exit-status" then parts << :long
+          else raise "don't know what to do about #{@data[1]} channel request"
+          end
+        else raise "don't know how to parse packet type #{@type}"
+        end
+    end
+  end
+
+end; end; end

data/etc/isolate/jruby-1.8/gems/net-ssh-2.0.23/lib/net/ssh/test/remote_packet.rb

@@ -0,0 +1,38 @@
+require 'net/ssh/buffer'
+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 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

data/etc/isolate/jruby-1.8/gems/net-ssh-2.0.23/lib/net/ssh/test/script.rb

@@ -0,0 +1,157 @@
+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 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)
+      events << LocalPacket.new(:channel_request, channel.remote_id, request, reply, data)
+      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 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 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

data/etc/isolate/jruby-1.8/gems/net-ssh-2.0.23/lib/net/ssh/test/socket.rb

@@ -0,0 +1,64 @@
+require 'socket'
+require 'stringio'
+require 'net/ssh/test/extensions'
+require 'net/ssh/test/script'
+
+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.gets(:kexinit, 1, 2, 3, 4, "test", "ssh-rsa", "none", "none", "none", "none", "none", "none", "", "", false)
+      script.sends(:kexinit)
+      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)
+      @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/etc/isolate/jruby-1.8/gems/net-ssh-2.0.23/lib/net/ssh/test.rb

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