Class: Net::SSH::Test::Script

Inherits:
Object
  • Object
show all
Defined in:
lib/net/ssh/test/script.rb

Overview

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

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Script

Create a new, empty script.



26
27
28
 
# File 'lib/net/ssh/test/script.rb', line 26

def initialize
  @events = []
end

Instance Attribute Details

#events ⇒ Object (readonly)

The list of scripted events. These will be Net::SSH::Test::LocalPacket and Net::SSH::Test::RemotePacket instances.



23
24
25
 
# File 'lib/net/ssh/test/script.rb', line 23

def events
  @events
end

Instance Method Details

#gets(type, *args) ⇒ Object

A convenience method for adding an arbitrary remote packet to the events list.



55
56
57
 
# File 'lib/net/ssh/test/script.rb', line 55

def gets(type, *args)
  events << RemotePacket.new(type, *args)
end

#gets_channel_close(channel) ⇒ Object

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.



153
154
155
 
# File 'lib/net/ssh/test/script.rb', line 153

def gets_channel_close(channel)
  events << RemotePacket.new(:channel_close, channel.local_id)
end

#gets_channel_data(channel, data) ⇒ Object

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.



123
124
125
 
# File 'lib/net/ssh/test/script.rb', line 123

def gets_channel_data(channel, data)
  events << RemotePacket.new(:channel_data, channel.local_id, data)
end

#gets_channel_eof(channel) ⇒ Object

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.



146
147
148
 
# File 'lib/net/ssh/test/script.rb', line 146

def gets_channel_eof(channel)
  events << RemotePacket.new(:channel_eof, channel.local_id)
end

#gets_channel_extended_data(channel, data) ⇒ Object

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.



132
133
134
 
# File 'lib/net/ssh/test/script.rb', line 132

def gets_channel_extended_data(channel, data)
  events << RemotePacket.new(:channel_extended_data, channel.local_id, 1, data)
end

#gets_channel_request(channel, request, reply, data) ⇒ Object

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.



139
140
141
 
# File 'lib/net/ssh/test/script.rb', line 139

def gets_channel_request(channel, request, reply, data)
  events << RemotePacket.new(:channel_request, channel.local_id, request, reply, data)
end

#next(mode = :shift) ⇒ Object

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)



166
167
168
 
# File 'lib/net/ssh/test/script.rb', line 166

def next(mode = :shift)
  events.send(mode)
end

#opens_channel(confirm = true) ⇒ Object

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.



36
37
38
39
40
41
42
43
44
45
 
# File 'lib/net/ssh/test/script.rb', line 36

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

#process(packet) ⇒ Object

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.



173
174
175
176
 
# File 'lib/net/ssh/test/script.rb', line 173

def process(packet)
  event = events.shift or raise "end of script reached, but got a packet type #{packet.read_byte}"
  event.process(packet)
end

#sends(type, *args, &block) ⇒ Object

A convenience method for adding an arbitrary local packet to the events list.



49
50
51
 
# File 'lib/net/ssh/test/script.rb', line 49

def sends(type, *args, &block)
  events << LocalPacket.new(type, *args, &block)
end

#sends_channel_close(channel) ⇒ Object

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.



107
108
109
 
# File 'lib/net/ssh/test/script.rb', line 107

def sends_channel_close(channel)
  events << LocalPacket.new(:channel_close, channel.remote_id)
end

#sends_channel_data(channel, data) ⇒ Object

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.



93
94
95
 
# File 'lib/net/ssh/test/script.rb', line 93

def sends_channel_data(channel, data)
  events << LocalPacket.new(:channel_data, channel.remote_id, data)
end

#sends_channel_eof(channel) ⇒ Object

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.



100
101
102
 
# File 'lib/net/ssh/test/script.rb', line 100

def sends_channel_eof(channel)
  events << LocalPacket.new(:channel_eof, channel.remote_id)
end

#sends_channel_request(channel, request, reply, data, success = true) ⇒ Object

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.



73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/net/ssh/test/script.rb', line 73

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

#sends_channel_request_pty(channel) ⇒ Object

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.



114
115
116
117
118
 
# File 'lib/net/ssh/test/script.rb', line 114

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