framework_gem 0.1.0

data/lib/lib/helpers/tmc_helpers/email_helper/email_helper.rb

@@ -0,0 +1,71 @@
+begin
+  require 'viewpoint'
+rescue LoadError
+end
+
+module EmailHelper
+  include Viewpoint::EWS rescue nil
+
+  # Public: Sends an email.
+  #
+  # subject  - String email subject.
+  # body     - String email message body.
+  # to       - String or Array of String recipient email addresses.
+  # endpoint - String EWS endpoint URL (default: nil).
+  # username - String EWS account username (default: nil).
+  # password - String EWS account password (default: nil).
+  #
+  # Returns nothing.
+  def send_email(subject, body, to, endpoint: nil, username: nil, password: nil)
+    logger.debug(%Q(Sending email to #{to} with subject "#{subject}" [#{body.length} chars]))
+    @spam_sleep = @last_email_time.nil? ? 0 : 60 - (Time.now - @last_email_time)
+    if @spam_sleep > 0
+      sleep(@spam_sleep.to_i.sec)
+    end
+    with_ews_client(endpoint, username, password) do |cli|
+      cli.send_message do |m|
+        m.subject = subject
+        m.body = body
+        if to.is_a?(Array)
+          to.each {|r| m.to_recipients << r}
+        else
+          m.to_recipients << to
+        end
+      end
+      @last_email_time = Time.now
+    end
+  end
+
+  # Public: Configures email.
+  #
+  # endpoint - String EWS endpoint URL.
+  # username - String EWS account username.
+  # password - String EWS account password.
+  #
+  # Returns nothing.
+  def send_email_setup(endpoint, username, password)
+    with_ews_client(endpoint, username, password) { }
+  end
+
+  private
+
+  # Internal: Opens an EWS client and passes it to the specified block.
+  def with_ews_client(endpoint, username, password, &block)
+    key = "#{username}::#{password}"
+    @ews_clients ||= {}
+    if @ews_clients[key].nil?
+      if endpoint.nil? || username.nil? || password.nil?
+        if @ews_clients.empty?
+          raise 'EWS endpoint, username, and password are required to configure email.'
+        end
+        cli = @ews_clients.values.last
+      else
+        cli = Viewpoint::EWSClient.new(endpoint, username, password)
+        @ews_clients[key] = cli
+      end
+    else
+      cli = @ews_clients[key]
+    end
+    block.call(cli)
+  end
+end

data/lib/lib/helpers/tmc_helpers/http_helper/http_helper.rb

@@ -0,0 +1,133 @@
+require 'net/http'
+require 'net/https'
+require 'json'
+
+# IMPORTANT: This helper is used by the test wrapper, so it doesn't always have TestCase context. See logger statements for example.
+
+module HttpHelper
+
+  # Public: Performs a web request for the given URI.
+  #
+  # http_method - Symbol HTTP method to use from :get, :post, :put, :delete.
+  # uri         - String full URI for the resource to request.
+  # body        - String data to populate the request body (default: nil).
+  # json        - Hash JSON object to send in the request body (default: nil). By default no JSON will be included.
+  # form_data   - Hash form data to send in the request (default: nil). By default no form data will be included.
+  # basic_auth  - Hash of basic authentication :username and :password to use (default: nil).
+  # headers     - Hash of headers to add to the request (default: {}).
+  # timeout     - Integer total milliseconds to wait for a response (default: 5.min).
+  # verify_mode - Integer desired HTTP verify mode (default: nil).
+  #
+  # Returns the Hash JSON response, or nil if there was an error.
+  def web_request(http_method, uri, body: nil, json: nil, form_data: nil, basic_auth: nil, headers: {}, timeout: nil,
+    verify_mode: nil, screen_image: nil, use_ssl: nil)
+    http_method = http_method.to_s.upcase
+    user_headers = headers
+    timeout ||= 5.min
+    logger.debug("Request: #{http_method} #{uri}#{body.nil? ? '': " #{body}"}", screen_image: screen_image, tag: 'REQUEST') if respond_to?(:logger)
+    logger.warn("`use_ssl' parameter is deprecated.") if !use_ssl.nil? && respond_to?(:logger)
+    uri = URI.parse(uri)
+    req = case http_method
+      when 'POST'
+        Net::HTTP::Post.new(uri.request_uri, user_headers)
+      when 'DELETE'
+        Net::HTTP::Delete.new(uri.request_uri, user_headers)
+      when 'PUT'
+        Net::HTTP::Put.new(uri.request_uri, user_headers)
+      when 'GET'
+        Net::HTTP::Get.new(uri.request_uri, user_headers)
+      else
+        raise "Unsupported HTTP method: #{http_method}"
+    end
+    if !body.nil?
+      req.body = body
+    elsif !json.nil?
+      req.body = json.to_json
+      req.add_field('Content-Type', 'application/json')
+    end
+    unless form_data.nil?
+      req.set_form_data(form_data)
+    end
+    unless basic_auth.nil?
+      req.basic_auth(basic_auth[:username], basic_auth[:password])
+    end
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.read_timeout = (timeout / 1000.0).round
+    http.ssl_version = 'SSLv23'
+    http.use_ssl = uri.scheme == 'https'
+    if !verify_mode.nil? && http.respond_to?(:verify_mode)
+      http.verify_mode = verify_mode
+    end
+    start_time = Time.now
+    response = http.request(req)
+    delta_sec = (Time.now - start_time)
+    logger.debug("Result: #{response.code} #{response.msg} [#{'%.3f' % delta_sec} s]", tag: 'REQUEST') if respond_to?(:logger)
+    if response.is_a?(Net::HTTPRedirection)
+      case response.code.to_i
+        when 304
+            # cached, do nothing
+        when 302, 307
+            # keep verb, data, and headers
+            response = web_request(http_method, response['location'], body: body, json: json, form_data: form_data, basic_auth: basic_auth,
+              headers: headers, timeout: timeout, verify_mode: verify_mode, screen_image: screen_image)
+        else
+            # drop verb, data, and headers
+            response = web_request('GET', response['location'], timeout: timeout, screen_image: screen_image)
+      end
+    end
+    WebHttpResponse.new(response)
+  end
+
+  private
+
+  # Adds json attribute to http response
+  class WebHttpResponse < SimpleDelegator
+  
+    def initialize(http_response)
+      super(http_response)
+      @code = self.code.to_i
+    end
+  
+    # Public: Gets response json, if any.
+    #
+    # Returns a Hash of response json, or nil.
+    def json
+      json_parse(self.body) rescue nil
+    end
+
+    private
+
+    # Public: Performs extended JSON parsing.
+    #
+    # obj - Object to parse.
+    #
+    # Returns a JSON object Hash.
+    def json_parse(obj)
+      json_parse_extended(JSON.parse(obj))
+    end
+
+    # Performs extended JSON parsing recursively on "obj"
+    def json_parse_extended(obj)
+      if obj.is_a?(Array)
+        obj.each_with_index { |v, i| obj[i] = json_parse_extended(v) }
+      elsif obj.is_a?(Hash)
+        obj.each { |k,v| obj[k] = json_parse_extended(v) }
+      elsif obj.is_a?(String)
+        if obj =~ /\/Date\((\d+)([+-]\d+)?\)\//  # parse Unix-style dates
+          time = Time.at($1.to_f / 1000)
+          unless $2.nil?
+            tz = $2.insert(-3, ':')
+            #TODO: in Ruby 1.8: time = time.getlocal(tz)
+          end
+          time
+        #elsif   # parse other dates here
+        else
+          obj
+        end
+      else
+        obj
+      end
+    end
+  end
+
+end

data/lib/lib/helpers/tmc_helpers/roi_helper/roi_helper.rb

@@ -0,0 +1,17 @@
+module RoiHelper
+  # Public: Change roi resolution. Should pass it an ROI that was made for 1080 resolution
+  #
+  # roi_obj    - roi object
+  # resolutionheight - set resolution height
+  # resolutionwidth  - set resolution width
+  #
+  # Returns roi, object roi object
+  def roi_resolution(roi_obj, resolutionheight, resolutionwidth)
+    roi_obj.rectangle=({:x => (roi_obj.rectangle[:x]*resolutionwidth/1920), 
+                        :y => (roi_obj.rectangle[:y]*resolutionheight/1080),
+                        :height => (roi_obj.rectangle[:height]*resolutionheight/1080), 
+                        :width => (roi_obj.rectangle[:width]*resolutionwidth/1920)})
+    # return roi
+    roi_obj
+  end
+end

data/lib/lib/helpers/tmc_helpers/snmp_helper/snmp_helper.rb

@@ -0,0 +1,71 @@
+begin
+  require 'snmp'
+rescue LoadError
+end
+
+module SnmpHelper
+  include SNMP rescue nil
+
+  # Public: Gets the specified SNMP object.
+  #
+  # host            - String hostname or IP.
+  # object          - String object OID to retrieve.
+  # port            - Integer SNMP port (default: 161).
+  # trap_port       - Integer SNMP trap port (default: 162).
+  # community       - String SNMP community string (default: 'public').
+  # write_community - String SNMP community string (default: 'public').
+  # version         - Symbol SNMP version (default: :SNMPv2c).
+  # timeout         - Integer timeout in seconds (default: 1).
+  # retries         - Integer retries (default: 5).
+  # transport       - Class SNMP transport (default: UDPTransport).
+  # max_recv_bytes  - Integer maximum receive bytes (default: 8000).
+  # use_IPv6        - Boolean indicating whether to use IPv6 (default: false).
+  #                   True if :host is formatted like an IPv6 address.
+  #
+  # Returns a String of value retrieved.
+  def snmp_get(host, object, args={})
+    logger.debug("SNMP get: #{host}#{args[:port].nil? ? '' : ":#{args[:port]}"} #{object.inspect}")
+    with_snmp_mgr(host, args) do |manager|
+      result = manager.get([object]).each_varbind.map {|vb| vb.value.to_s}.first
+      logger.debug("Result: #{result.inspect}")
+      result
+    end
+  end
+
+  # Public: Sets the specified SNMP object.
+  #
+  # host            - String hostname or IP.
+  # object          - String object OID to set.
+  # value           - String value to set.
+  # port            - Integer SNMP port (default: 161).
+  # trap_port       - Integer SNMP trap port (default: 162).
+  # community       - String SNMP community string (default: 'public').
+  # write_community - String SNMP community string (default: 'public').
+  # version         - Symbol SNMP version (default: :SNMPv2c).
+  # timeout         - Integer timeout in seconds (default: 1).
+  # retries         - Integer retries (default: 5).
+  # transport       - Class SNMP transport (default: UDPTransport).
+  # max_recv_bytes  - Integer maximum receive bytes (default: 8000).
+  # use_IPv6        - Boolean indicating whether to use IPv6 (default: false).
+  #                   True if :host is formatted like an IPv6 address.
+  #
+  # Returns the result.
+  def snmp_set(host, object, value, args={})
+    logger.debug("SNMP set: #{host}#{args[:port].nil? ? '' : ":#{args[:port]}"} #{object.inspect} => #{value.inspect}")
+    with_snmp_mgr(host, args) do |manager|
+      varbind = VarBind.new(object, OctetString.new(value))
+      ret = manager.set(varbind)
+      logger.debug("Result: #{ret.inspect}")
+      ret
+    end
+  end
+
+  private
+
+  # Internal: Opens an SNMP connection, passes the manager to the specified block, and closes it.
+  def with_snmp_mgr(host, args={}, &block)
+    SNMP::Manager.open(args.merge(:host => host)) do |manager|
+      block.call(manager)
+    end
+  end
+end

data/lib/lib/helpers/tmc_helpers/ssh_helper/ssh_helper.rb

@@ -0,0 +1,337 @@
+begin
+  require 'net/ssh'
+rescue LoadError
+end
+require 'thread'
+
+module SshHelper
+
+  # Public: Starts a new SSH session to the given host.
+  #
+  # host     - String host name or IP.
+  # username - String username to use.
+  # password - String password to use (default: nil).
+  #
+  # Returns nothing.
+  def ssh_to(host, username, password: nil)
+    ssh = TmcSsh.new(self)
+    ssh.start(host, username, password: password)
+    ssh
+  end
+
+  class TmcSsh
+
+    def initialize(test_case)
+      @debug = false
+      @test_case = test_case
+      @host = nil
+      @user = nil
+      @ssh = nil
+      @buffer = ''
+      @buffer_lock = Mutex.new
+      @last_sent_data = ''
+      reset_pty
+    end
+
+    # Public: Gets the underlying session, for advanced usage.
+    #
+    # Returns the Net::SSH session.
+    def session
+      @ssh
+    end
+
+    # Public: Starts a program in the session and waits for output. This should be used for running any interactive
+    #         programs like telnet, sudo, vim. Note that this will end any active program with possible loss of of data.
+    #
+    # program - String name of program to start.
+    # prompt  - String or Regexp prompt to use for the program.
+    # expect  - String or Regexp output to expect, if not the prompt (default: nil).
+    # timeout - Integer timeout in milliseconds (default: 10.sec).
+    #
+    # Returns a String data buffered before the prompt or expected output.
+    def start_program(program, prompt, expect: nil, timeout: 10.sec)
+      loginfo("Starting program: #{program}")
+      stop_pty unless @pty.nil?
+      start_pty(program, prompt)
+      expect(expect, timeout: timeout)
+    end
+
+    # Public: Starts a new SSH session in the current session.
+    #         Note that this will end any active program with possible loss of of data.
+    #
+    # host     - String host name or IP.
+    # username - String username to use.
+    # prompt   - String or Regexp prompt to use for the program.
+    # password - String password to use (default: nil).
+    # timeout  - Integer timeout in milliseconds (default: 30.sec).
+    #
+    # Returns a String data buffered before the prompt or expected output.
+    def start_ssh(host, username, prompt, password: nil, timeout: 30.sec)
+      loginfo("Starting SSH to #{username}@#{host}")
+      cmd = "ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no #{username}@#{host}"
+      start = Time.now
+      start_program(cmd, prompt, timeout: timeout, expect: password.nil? ? nil : /(?i)password:/)
+      unless password.nil?
+        time_left = timeout - ((Time.now - start) * 1000)
+        send_command(password, timeout: time_left)
+      end
+    end
+
+    # Public: Sends a command to the session and waits for output.
+    #
+    # cmd     - String command to send.
+    # prompt  - String or Regexp prompt to set for the current program (default: nil).
+    # expect  - String or Regexp output to expect, if not the prompt (default: nil).
+    # timeout - Integer timeout in milliseconds (default: 10.sec).
+    #
+    # Returns a String data buffered before the prompt or expected output.
+    def send_command(cmd, prompt: nil, expect: nil, timeout: 10.sec)
+      if @pty.nil?
+        # no active pty, just execute the command the normal way
+        loginfo("Sending command: #{cmd}")
+        output = @ssh.exec!(cmd)
+        logdebug("Output:\n#{output.rstrip}")
+        output
+      else
+        # send to active pty and wait
+        send_raw(cmd + "\n")
+        @pty_prompt = prompt unless prompt.nil?
+        expect(expect, timeout: timeout)
+      end
+    end
+
+    # Public: Sends some data to the active PTY.
+    #
+    # data    - String data to send.
+    # expect  - String or Regexp output to expect (default: nil).
+    # timeout - Integer timeout in milliseconds (default: 10.sec).
+    #
+    # Returns nothing, or a String data buffered before the expected output.
+    def send_raw(data, expect: nil, timeout: 10.sec)
+      raise 'No active pty.' if @pty.nil?
+      loginfo("Sending: #{data}".strip)
+      @last_sent_data = data
+      @pty.send_data(data)
+      if expect.nil?
+        nil
+      else
+        expect(expect, timeout: timeout)
+      end
+    end
+
+    # Public: Waits for some output in the active PTY.
+    #
+    # data    - String or Regexp output to expect.
+    # timeout - Integer timeout in milliseconds (default: 10.sec).
+    #
+    # Returns a String data buffered before the expected output.
+    def expect(data, timeout: 10.sec)
+      raise 'No active pty.' if @pty.nil? && !@pty_starting
+      data ||= @pty_prompt
+      logdebug("Expecting: #{data.inspect}")
+      reason = nil
+      begin
+        Timeout.timeout(timeout / 1000.0) do
+          @ssh.loop(0.1) do
+            ready = false
+            if @pty.nil?
+              unless @pty_starting
+                reason = 'no pty'
+                ready = true
+              end
+            elsif @pty.eof?
+              reason = 'pty is eof'
+              ready = true
+            elsif search_buffer(data)
+              reason = 'pty is ready'
+              ready = true
+            end
+            !ready
+          end
+        end
+      rescue TimeoutError
+        @buffer_lock.synchronize do
+          raise "#{session_info} Timed out waiting for expected output in buffer:\n#{@buffer}"
+        end
+      end
+      puts "*ready (#{reason})" if @debug
+      if @pty.nil?
+        @buffer_lock.synchronize do
+          puts "*buffer: #{@buffer.inspect}" if @debug
+          raw_output = @buffer
+        end
+      else
+        puts "*before: #{@before.inspect}" if @debug
+        puts "*match: #{@match.inspect}" if @debug
+        raw_output = @before
+      end
+      raw_output ||= ''
+      logdebug("Output:\n#{@last_match || ''}#{raw_output.rstrip}")
+      re = /^#{@last_sent_data.gsub(/\r?\n/, '\r?\n')}/
+      puts "*trimming start: #{re.inspect}" if @debug
+      raw_output.sub(re, '')
+    end
+
+    # Public: Starts a new SSH session.
+    #
+    # host     - String host name or IP.
+    # username - String username to use.
+    # password - String password to use (default: nil).
+    #
+    # Returns nothing.
+    def start(host, username, password: nil)
+      @test_case.logger.info("Starting new SSH session: #{username}@#{host}")
+      @ssh = Net::SSH.start(host, username, :password => password)
+      @host = host
+      @user = username
+      @test_case.add_teardown("#{session_info} Shutting down") { stop }
+      puts '*ssh connected' if @debug
+    end
+
+    # Public: Stops the SSH session.
+    #
+    # Returns nothing.
+    def stop
+      loginfo('Stopping')
+      stop_pty unless @pty.nil?
+      unless @ssh.nil?
+        @ssh.close
+        @ssh = nil
+        @ssh_channel = nil
+      end
+    end
+
+    private
+
+    # Internal: DEBUG logging helper that logs the session info first.
+    def logdebug(msg)
+      @test_case.logger.debug("#{session_info} #{msg}", tag: 'SSH')
+    end
+
+    # Internal: INFO logging helper that logs the session info first.
+    def loginfo(msg)
+      @test_case.logger.info("#{session_info} #{msg}", tag: 'SSH')
+    end
+
+    # Internal: Returns a string with session info.
+    def session_info
+      @ssh.nil? ? '[No session]' : "[#{@user}@#{@host}]"
+    end
+
+    # Internal: Stops the active pty.
+    def stop_pty
+      raise 'No active pty.' if @pty.nil?
+      @pty.close
+      reset_pty
+    end
+
+    # Internal: Resets pty attributes.
+    def reset_pty
+      @ssh_channel.close unless @ssh_channel.nil?
+      @ssh_channel = nil
+      @pty = nil
+      @pty_prompt = nil
+      @pty_starting = false
+      @before = nil
+      @match = nil
+      @buffer_lock.synchronize do
+        return @buffer
+      end
+    end
+
+    # Internal: Starts a new pty.
+    def start_pty(cmd, prompt)
+      raise 'No SSH session.' if @ssh.nil?
+      raise 'Cannot start another pty.' unless @pty.nil?
+      @pty_starting = true
+      @buffer_lock.synchronize do
+        @buffer = ''
+      end
+      @pty_prompt = prompt
+
+      @ssh.open_channel do |ch|
+        puts '*ssh channel opened' if @debug
+        @ssh_channel = ch
+
+        ch.on_data do |ch, data|
+          puts '*ssh channel on data' if @debug
+          loginfo("unexpected data: #{data}")
+        end
+
+        ch.on_extended_data do |ch, data|
+          puts '*ssh channel on extended data' if @debug
+          loginfo("unexpected extended data: #{data}")
+        end
+
+        ch.on_close do |ch|
+          puts '*ssh channel closing' if @debug
+        end
+
+        ch.on_process do |ch|
+          puts '*ssh channel on process' if @debug
+        end
+
+        ch.request_pty do |ch, success|
+          if success
+            puts '*pty successfully obtained' if @debug
+          else
+            puts '*could not obtain pty' if @debug
+          end
+
+          puts "*executing in pty: #{cmd}" if @debug
+          ch.exec(cmd) do |ch, success|
+            abort "could not execute '#{cmd}'" unless success
+            @pty = ch
+            @pty_starting = false
+
+            ch.on_process do |ch|
+              #return if ch.closing?
+              puts '*pty on process' if @debug
+            end
+
+            ch.on_close do |ch|
+              puts '*pty closing' if @debug
+              reset_pty
+            end
+
+            ch.on_data do |ch, data|
+              #return if ch.closing?
+              puts '*pty on data' if @debug
+              buffer_data(data)
+            end
+
+            ch.on_extended_data do |ch, data|
+              #return if ch.closing?
+              puts '*pty on extended data' if @debug
+              buffer_data(data)
+            end
+
+          end
+        end
+      end
+    end
+
+    # Internal: Searches the buffer for expected output.
+    def search_buffer(exp)
+      @buffer_lock.synchronize do
+        b, a = @buffer.split(exp, 2)
+        unless a.nil?
+          @before = b
+          @last_match = @match
+          @match = exp.is_a?(Regexp) ? @buffer.match(exp).to_s : exp
+          @buffer = a
+          return true
+        end
+      end
+      false
+    end
+
+    # Internal: Adds data to buffer.
+    def buffer_data(data)
+      @buffer_lock.synchronize do
+        @buffer += data
+      end
+    end
+  end
+
+end