expect-behaviors 0.1.1

data/test/acceptance/test_expect_ssh.rb

@@ -0,0 +1,97 @@
+require 'helper'
+require 'sshd'
+
+require 'expect/ssh'
+
+class TestExpectSSH < Test::Unit::TestCase
+
+  def self.startup
+    @@hostname = '127.0.0.1'
+    @@username = ENV['USER']
+    @@sshd = SSHD.new
+    @@sshd.start
+    @@port = @@sshd.port
+  end
+
+
+  def self.shutdown
+    @@sshd.teardown
+  end
+
+  context :init_and_start do
+
+    setup do
+      @ssh = Expect::SSH.new(@@hostname, @@username, port: @@port, key_file: @@sshd.client_key_path, ignore_known_hosts: true)
+    end
+
+    should "return an options hash when calling #options" do
+      expected = {
+          :auth_methods => ["none", "publickey", "password"],
+          :keys => [@@sshd.client_key_path],
+          :logger => nil,
+          :port => @@port,
+          :user_known_hosts_file => "/dev/null"
+      }
+      result = @ssh.send(:options)
+      result[:logger] = nil
+      assert_equal(expected, result)
+    end
+  end
+
+  context :startup do
+
+    setup do
+      @ssh = Expect::SSH.new(@@hostname, @@username, port: @@port, key_file: @@sshd.client_key_path, ignore_known_hosts: true)
+    end
+
+    should "be able to authenticate" do
+      @ssh.start
+      @ssh.stop
+    end
+
+  end
+
+  context :expect do
+
+    setup do
+      @ssh = Expect::SSH.new(@@hostname, @@username, port: @@port, key_file: @@sshd.client_key_path, ignore_known_hosts: true)
+      @ssh.start
+    end
+
+    teardown do
+      @ssh.stop
+    end
+
+    should "be able to send a few commands" do
+      result = @ssh.expect do
+        when_matching(/.*\$.*/) { @exp_match }
+      end
+      assert_match(/Last login:/, result.to_s)
+      @ssh.send_data("cat /etc/resolv.conf")
+      result = @ssh.expect do
+        when_matching(/.*nameserver.*/) { @exp_match }
+      end
+      assert_match(/nameserver [\d\.]+.*/, result.exact_match_string)
+      @ssh.send_data("date")
+      result = @ssh.expect do
+        when_matching(/.*20.*/) { @exp_match }
+      end
+      assert_match(/20/, result.exact_match_string)
+    end
+
+    should "timeout as expected" do
+      result = @ssh.expect do
+        when_matching(/.*\$.*/) { @exp_match }
+      end
+      assert_match(/Last login:/, result.to_s)
+      @ssh.send_data("sleep 2")
+      result = @ssh.expect do
+        when_matching(/.*\$.*/) { @exp_match }
+        when_timeout(1) { "timeout" }
+      end
+      assert_match(/timeout/, result)
+    end
+
+  end
+
+end

data/test/class_including_expect_behavior.rb

@@ -0,0 +1,33 @@
+require 'expect/behavior'
+
+class ClassIncludingExpectBehavior
+  include Expect::Behavior
+  # :Required methods to be created by the class mixing Expect::Behaviors :
+  #   #exp_process - should do one iteration of handle input and append buffer
+  #   #exp_buffer - provide the current buffer contents and empty it
+
+  attr_accessor :exp_buffer_values, :wait_sec
+
+  def initialize(wait: nil, values: [])
+    @exp_buffer = ''
+    @exp_buffer_values = values
+    @wait_sec = wait
+  end
+
+  ##
+  # exp_buffer - provide the current buffer contents and empty it
+  def exp_buffer
+    result = @exp_buffer
+    @exp_buffer = ''
+    result
+  end
+
+  ##
+  # exp_process - should do one iteration of handle input and append buffer
+  def exp_process
+    sleep(@wait_sec.to_f)
+    # handle input
+    @exp_buffer << @exp_buffer_values.shift.to_s
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,22 @@
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+require 'rubygems'
+require 'bundler'
+gem 'mocha'
+require 'mocha/test_unit'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+# add lib folder from parent
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+# ...and the test folder
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'expect/behavior'

data/test/sshd.rb

@@ -0,0 +1,139 @@
+require 'erb'
+require 'fileutils'
+require 'socket'
+
+
+##
+# A Helper to start a second instance of SSHD on an unprivilege port which allows for a custom client key
+#  All keys for this server are created just in time.
+class SSHD
+
+  TEST_ROOT = File.dirname(__FILE__)
+  SSHD_CFG_ROOT = File.join(TEST_ROOT, 'acceptance', 'sshd')
+  SSHD_TMP_ROOT = File.join(TEST_ROOT, 'tmp', 'sshd')
+  PIDFILE_PATH = File.join(SSHD_TMP_ROOT, 'sshd.pid')
+  ERB_ROOT = File.join(SSHD_CFG_ROOT, 'erb')
+  SSHD_CONFIG_ERB_PATH = File.join(ERB_ROOT, 'sshd_config.erb')
+  SSH_CONFIG_ERB_PATH = File.join(ERB_ROOT, 'ssh_config.erb')
+  SSHD_CONFIG_PATH = File.join(SSHD_TMP_ROOT, 'sshd_config')
+  SSH_CONFIG_PATH = File.join(SSHD_TMP_ROOT, 'ssh_config')
+  SSHD_LOG_PATH = File.join(SSHD_TMP_ROOT, 'sshd.log')
+
+  KEY_ROOT = SSHD_TMP_ROOT
+  SSHD_CLIENT_KEY_PATH = File.join(KEY_ROOT, 'id_rsa')
+  SSHD_CLIENT_PUBKEY_PATH = File.join(KEY_ROOT, 'id_rsa.pub')
+  SSHD_RSA_HOST_KEY_PATH = File.join(KEY_ROOT, 'ssh_host_key_rsa')
+  SSHD_DSA_HOST_KEY_PATH = File.join(KEY_ROOT, 'ssh_host_key_dsa')
+  SSHD_AUTHORIZED_KEYS_PATH = SSHD_CLIENT_PUBKEY_PATH
+
+  attr_reader :port
+
+  def initialize(address = '127.0.0.1')
+    @tcpserver = nil
+    @address = address
+    @port = reserve_unprivileged_tcp_port
+    @sshd_filepath = %x(which sshd).chomp
+    @ssh_keygen_filepath = %x(which ssh-keygen).chomp
+    teardown
+  end
+
+  def client_key_path
+    SSHD_CLIENT_KEY_PATH
+  end
+
+  def start
+    unless openssh_files_found?
+      raise(RuntimeError, "[SSHD] Error: Unable to locate sshd or ssh-keygen.")
+    end
+    create_sshd_config
+    create_ssh_config
+    generate_keys
+    release_port
+    start_ssh_server
+  end
+
+  def stop
+    this_pid = pid
+    unless this_pid.nil?
+      $stdout.puts("[SSHD] [#{__method__}]: Killing SSHD, [pid=#{this_pid}]")
+      begin
+        Process.kill(0, this_pid)
+      rescue Errno::ESRCH
+        $stderr.puts("[SSHD] [#{__method__}]: No Action: Process not found, [pid=#{this_pid}]")
+      ensure
+        File.delete(PIDFILE_PATH) if File.exists?(PIDFILE_PATH)
+      end
+    else
+      $stderr.puts("[SSHD] [#{__method__}]: No Action: PIDFILE Doesnt exist: #{PIDFILE_PATH}")
+    end
+  end
+
+  def teardown
+    stop
+    clean_tmp_root
+  end
+
+
+  #####################
+  private
+  #####################
+
+  def clean_tmp_root
+    FileUtils.rmtree(SSHD_TMP_ROOT)
+    FileUtils.mkpath(SSHD_TMP_ROOT)
+    nil
+  end
+
+  def create_ssh_config
+    erb = ERB.new(IO.read(SSH_CONFIG_ERB_PATH))
+    result = erb.result(binding)
+    File.open(SSH_CONFIG_PATH, 'w') {|f| f.write(result)}
+    result
+  end
+
+  def create_sshd_config
+    erb = ERB.new(IO.read(SSHD_CONFIG_ERB_PATH))
+    result = erb.result(binding)
+    File.open(SSHD_CONFIG_PATH, 'w') {|f| f.write(result)}
+    result
+  end
+
+  def generate_keys
+    [SSHD_CLIENT_KEY_PATH, SSHD_RSA_HOST_KEY_PATH, SSHD_DSA_HOST_KEY_PATH].each do |key_path|
+      %x(#{@ssh_keygen_filepath} -t rsa -b 4096 -C user@localhost -f #{key_path} -N '')
+    end
+  end
+
+  def openssh_files_found?
+    not @ssh_keygen_filepath.empty? and not @sshd_filepath.empty?
+  end
+
+  def pid
+    pid = nil
+    if File.exists?(PIDFILE_PATH)
+      pid = IO.read(PIDFILE_PATH).chomp.to_i
+    end
+    pid
+  end
+
+  def reserve_unprivileged_tcp_port
+    @tcpserver ||= TCPServer.new(@host, 0)
+    @port = @tcpserver.addr[1]
+  end
+
+  def release_port
+    @tcpserver.close
+    @tcpserver = nil
+    @port
+  end
+
+  def start_ssh_server
+    %x(#{@sshd_filepath} -4 -f #{SSHD_CONFIG_PATH})
+    #  -E #{SSHD_LOG_PATH}
+    $stdout.puts("[SSHD] [#{__method__}]: Starting on [port=#{@port}]")
+    sleep(0.5)
+    $stdout.puts("[SSHD] [#{__method__}]: Started on [port=#{@port}] [pid=#{pid}]")
+    pid
+  end
+end
+

data/test/unit/expect/test_expect_behaviors.rb

@@ -0,0 +1,178 @@
+require 'helper'
+require 'expect/behavior'
+require 'class_including_expect_behavior'
+gem 'mocha'
+require 'mocha/test_unit'
+
+class TestExpectBehaviors < Test::Unit::TestCase
+
+  ####################################
+  context "expect" do
+    setup do
+      @values = []
+      @values << "the sun is a mass"
+      @values << "\nof incandescent gas"
+      @values << "\nswitch-prompt#"
+      @values << "\nblip blip"
+      @values << "\nblah blah"
+      @values << "\nswitch-prompt2#"
+      @includer = ClassIncludingExpectBehavior.new(values: @values)
+      @wait_sec = 0.1
+    end
+
+    should "match up to first switch-prompt" do
+      result = @includer.expect do
+        when_matching(/switch-prompt#/) do
+          @exp_match
+        end
+      end
+      expected = "the sun is a mass\nof incandescent gas\nswitch-prompt#"
+      assert_equal(expected, result.to_s)
+    end
+
+    should "timeout for switch-prompt2#" do
+      @includer.wait_sec = @wait_sec
+      @includer.exp_timeout_sec = @wait_sec * 4
+      result = @includer.expect do
+        when_matching(/switch-prompt2#/) do
+          @exp_match
+        end
+        when_timeout(@wait_sec * 3) do
+          "timed out"
+        end
+      end
+      assert_equal('timed out', result.to_s)
+    end
+
+    should "not timeout for switch-prompt2# if expect_continue for blip" do
+      omit("See acceptance version of this test... doesn't work for such a short interval: (#{@wait_sec}")
+    end
+
+    should "timeout for switch-prompt2# if expect_continue for incandescent" do
+      omit("See acceptance version of this test... doesn't work for such a short interval: (#{@wait_sec}")
+    end
+
+
+    should "handle subsequent expect statements" do
+      @includer.wait_sec = @wait_sec
+      @includer.expect do
+        when_matching(/incandescent/) do
+          @exp_match
+        end
+        when_timeout(@wait_sec * 3) do
+          "timed out"
+        end
+      end
+      result = @includer.expect do
+        when_matching(/switch-prompt#/) do
+          @exp_match
+        end
+        when_timeout(@wait_sec * 3) do
+          "timed out"
+        end
+      end
+      expected = "\nswitch-prompt#"
+      assert_equal(expected, result.to_s)
+    end
+
+  end
+
+
+  ####################################
+  context "initialize_expect" do
+    setup do
+      @includer = ClassIncludingExpectBehavior.new(values: ["bobert"])
+    end
+
+    should "be run when calling expect" do
+      @includer.expects(:initialize_expect)
+      @includer.expects(:execute_expect_loop)
+      @includer.expect do
+        when_matching(/bob/) do
+          return_value
+        end
+      end
+    end
+
+    should "key instance variables undefined before first expect" do
+      # undefined/nil before first expect
+      assert_equal(nil, @includer.instance_variable_get(:@exp_match_registry))
+      assert_equal(nil, @includer.instance_variable_get(:@exp_timeout_sec))
+      assert_equal(nil, @includer.instance_variable_get(:@exp_match))
+      assert_equal(nil, @includer.instance_variable_get(:@exp_timeout_block))
+      assert_equal(nil, @includer.instance_variable_get(:@__exp_buffer))
+    end
+
+    should "setup instance variables prior to expect" do
+      @includer.expects(:execute_expect_loop) #stub out expect loop
+      @includer.expect do
+        "bob"
+      end
+      assert_equal({}, @includer.instance_variable_get(:@exp_match_registry))
+      assert_equal(10, @includer.instance_variable_get(:@exp_timeout_sec))
+      assert_equal(nil, @includer.instance_variable_get(:@exp_match))
+      assert_equal(nil, @includer.instance_variable_get(:@exp_timeout_block))
+      assert_equal('', @includer.instance_variable_get(:@__exp_buffer))
+    end
+  end
+
+
+  ####################################
+  context "match registry" do
+    setup do
+      @includer = ClassIncludingExpectBehavior.new
+    end
+
+    should "be populated by when_matching statements" do
+      @includer.stubs(:execute_expect_loop)
+      return_value = "Matched BOB"
+      @includer.expect do
+        when_matching(/bob/) do
+          return_value
+        end
+        when_matching(/joe/) do
+          "Matched JOE"
+        end
+        when_timeout do
+          "TIMEOUT"
+        end
+      end
+      assert_equal(/bob/, @includer.instance_variable_get(:@exp_match_registry).keys.first)
+      assert_equal(2, @includer.instance_variable_get(:@exp_match_registry).length)
+      assert_equal(return_value, @includer.instance_variable_get(:@exp_match_registry).values.first.call)
+      assert_equal("TIMEOUT", @includer.instance_variable_get(:@exp_timeout_block).call)
+    end
+  end
+
+
+  ####################################
+  context "timeout" do
+    setup do
+      @includer = ClassIncludingExpectBehavior.new(wait: 0.2)
+    end
+
+    should "raise TimeoutError when timeout is reached before match is found" do
+      @includer.exp_timeout_sec = 0.1
+      assert_raises(Expect::TimeoutError) do
+        @includer.expect do
+          when_matching(/bob/) do
+            return_value
+          end
+        end
+      end
+    end
+
+    should "execute arbitrary block on timeout with override" do
+      result = @includer.expect do
+        when_matching(/bob/) do
+          return_value
+        end
+        when_timeout(0.1) do
+          "timeout"
+        end
+      end
+      assert_equal('timeout', result)
+    end
+  end
+
+end