Ifd_Automation 2.9 → 2.9.1

data/lib/helper/assertion_helper.rb

@@ -1,100 +0,0 @@
-class IFD_Assertion
-  #Assert two files, rows not in order and REMOVE 1 COLUMN OF ID
-  def self.do_assertion_csv_tab_non_order(expected_obj, actual_obj)
-    for i in (1..expected_obj.length - 1)
-      expected_row = expected_obj[i].drop(1).to_s.split("\t")
-      found = false
-      for j in (1..actual_obj.length - 1)
-        actual_row = actual_obj[j].drop(1).to_s.split("\t")
-        if (expected_row == actual_row)
-          found = true
-          break
-        end
-      end
-      assert(found, "Expected Record: [#{expected_obj[i].to_s}] is not included in reporting file")
-    end
-  end
-
-  # Assert 2 values
-  def self.reg_compare sActual, regValue, isSpecialChar=false
-    begin
-      if !isSpecialChar
-        sActual = sActual.strip
-        regValue = regValue.strip.gsub("[", "\\[").gsub("]", "\\]").gsub("(", "\\(").gsub(")", "\\)").gsub(">", "\\>")
-      end
-    rescue StandardError => myStandardError
-      put_log "\n>>> Error: #{myStandardError}"
-    end
-
-    # put_log "\nsActual:#{sActual}, regValue:#{regValue}"
-    if ((sActual.nil? and regValue.nil?) or (!sActual.nil? and sActual.empty? and !regValue.nil? and regValue.empty?))
-      return true
-    end
-
-    if ((sActual.nil? and !regValue.nil?) or (!sActual.nil? and regValue.nil?))
-      return false
-    end
-
-    if (!sActual.nil? and !sActual.empty?)
-      sCookActual = sActual.gsub(/\n|\r/, " ")
-      if (sCookActual == regValue or (isSpecialChar and sCookActual.include? regValue) or (!isSpecialChar and sCookActual =~ /^.*#{regValue}.*$/))
-        return true
-      end
-    end
-
-    return false
-  end
-
-  def self.do_assertion_json(expected_obj, actual_obj, options = {})
-    # puts "\n\n actual_obj.class: #{actual_obj.class}"
-    # puts "\n\n expected_obj.class: #{expected_obj.class}"
-
-    if expected_obj.kind_of? Hash
-      # if options['isIncludedAssertion'].nil? or options['isIncludedAssertion'] == false
-      #   do_assertion(expected_obj.keys.size, actual_obj.keys.size)
-      # end
-      expected_obj.keys.each do |key|
-        # puts "\n\n key: #{key}"
-        # puts "\n\n value: #{expected_obj[key]}"
-        # puts "\n\n value: #{actual_obj[key]}"
-        if actual_obj[key].nil?
-          raise "[%s] expected [%s] but actual value was nil." % [key, expected_obj[key].to_s]
-        else
-          IFD_Assertion.do_assertion_json(expected_obj[key], actual_obj[key], options)
-        end
-      end
-    elsif expected_obj.kind_of? Array
-      if options['isIncludedAssertion'].nil? or options['isIncludedAssertion'] == false
-        IFD_Assertion.do_assertion_json(expected_obj.size, actual_obj.size)
-      end
-      for i in (0..expected_obj.length-1)
-        IFD_Assertion.do_assertion_json(expected_obj[i], actual_obj[i], options)
-      end
-    else
-      begin
-        IFD_Assertion.assert_string_equal(expected_obj.to_s, actual_obj.to_s)
-      rescue => e
-        raise("Assert fail. \n\n Expected: '#{expected_obj}' \n\n Got: '#{actual_obj}'. Detail info: #{e.message}")
-      end
-    end
-  end
-
-  def self.assert_string_contain(expected, actual)
-    unless (actual.to_s).include? (expected.to_s)
-      raise ("*** ASSERTION ERROR: \nExpected: #{expected}. \nGot: #{actual}.")
-    end
-  end
-
-  def self.assert_string_equal(expected, actual)
-    if expected.to_s != actual.to_s
-      raise ("*** ASSERTION ERROR: \nExpected: #{expected}. \nGot: #{actual}.")
-    end
-  end
-
-  def self.assert_string_not_equal(expected, actual)
-    if expected.to_s == actual.to_s
-      raise ("*** ASSERTION ERROR: \nExpected: #{expected}. \nGot: #{actual}.")
-    end
-  end
-
-end

data/lib/helper/auto_util.rb

@@ -1,164 +0,0 @@
-class Utils
-#-----------------------------------------------------
-# support define and bind variable dynamically
-#-----------------------------------------------------
-  $dyn_vars = nil
-
-# set value to a variable
-  def self.set_var(var_name, var_value)
-    if $dyn_vars == nil
-      $dyn_vars = binding
-    end
-
-    strEval = var_name + "=" + var_value
-    eval strEval, $dyn_vars
-  end
-
-  def self.check_dynamic_value value
-    if !value.is_a? Fixnum
-      if value.include? "params="
-        resolve_params value
-      else
-        bind_with_dyn_vars value
-      end
-    else
-      value
-    end
-  end
-
-
-  def self.resolve_params url
-    condition = url.match(/params='([^']*)'/)[0]
-    if condition
-      params_name = url.match(/params='([^']*)'/)[1]
-      params_value = $PARAMS["#{params_name.downcase}"].to_s.strip
-      if params_value.present?
-        url = url.gsub(condition, params_value)
-      else
-        raise "ERROR: no data found with given params #{params_name}"
-      end
-    end
-    url
-  end
-
-# bind string with $dyn_vars context
-  def self.bind_with_dyn_vars(str)
-    if $dyn_vars == nil
-      $dyn_vars = binding
-    end
-
-    strEval = '"' + str + '"'
-    return eval strEval, $dyn_vars
-  end
-
-# evaluate operation/statement with $dyn_vars context
-  def self.eval_with_dyn_vars(operation)
-    if $dyn_vars == nil
-      $dyn_vars = binding
-    end
-
-    eval operation, $dyn_vars
-  end
-
-  def self.bind_with_dyn_json_vars(json, bind_json)
-    if json.kind_of? Hash
-      json.each_pair do |k, v|
-        if v.kind_of? String
-          bind_json[bind_with_dyn_vars(k)] = bind_with_dyn_json_vars(v, bind_json)
-        elsif v.kind_of? Hash
-          temp = Hash.new
-          v.each_pair do |k1, v1|
-            temp[bind_with_dyn_vars(k1)] = bind_with_dyn_json_vars(v1, temp)
-          end
-          bind_json[bind_with_dyn_vars(k)] = temp
-        elsif v.kind_of? Array
-          temp1 = Array.new
-          v.each { |item|
-            temp2 = Hash.new
-            bind_with_dyn_json_vars(item, temp2)
-            temp1 << temp2
-          }
-          bind_json[bind_with_dyn_vars(k)] = temp1
-        end
-      end
-    elsif json.kind_of? Array
-      temp1 = Array.new
-      json.each { |item|
-        temp2 = Hash.new
-        bind_with_dyn_json_vars(item, temp2)
-        temp1 << temp2
-      }
-      return temp1
-    else
-      return bind_with_dyn_vars(json)
-    end
-  end
-
-
-  def self.var_collect string_var
-    if string_var =~ /^.*{year}.*$/
-      string_var = replace_year(string_var)
-    end
-
-    if string_var =~ /^.*{month}.*$/
-      string_var = replace_month(string_var)
-    end
-
-    if string_var =~ /^.*{day}.*$/
-      string_var = replace_day(string_var)
-    end
-
-    if string_var =~ /^.*{store_value}.*$/
-      string_var = $context_value
-    end
-
-    return string_var
-  end
-
-  def self.replace_year str
-    t = Time.now()
-    return str.gsub("{year}", t.year.to_s)
-  end
-
-  def replace_month str
-    t = Time.now()
-    _month = t.month
-    if _month < 10
-      return str.gsub("{month}", "0#{_month.to_s}")
-    else
-      return str.gsub("{month}", "#{_month.to_s}")
-    end
-    return str
-  end
-
-  def self.replace_day str
-    t = Time.now()
-    _day = t.day
-    if _day < 10
-      return str.gsub("{day}", "0#{_day.to_s}")
-    else
-      return str.gsub("{day}", "#{_day.to_s}")
-    end
-    return str
-  end
-
-  def self.replace_pipe str_pipe
-    put_log ">>>> #{str_pipe}"
-    if str_pipe =~ /^.*{pipe}.*$/
-      return str_pipe.gsub("{pipe}", "|")
-    end
-    return str_pipe
-  end
-
-  def self.store_string_as_variable(string,variable)
-    # $context_value = Utils.bind_with_dyn_vars(string)
-    # Utils.set_var(variable, '$context_value')
-    require 'erb'
-    ERB.new(string, 0, "", "#{variable}").result(binding)
-  end
-
-  def self.print_variable(variable)
-    puts "VALUE OF #{variable}: #{Utils.eval_with_dyn_vars(variable)}"
-  end
-
-end

data/lib/helper/database_helper.rb

@@ -1,81 +0,0 @@
-require 'tiny_tds'
-require 'activerecord-sqlserver-adapter'
-require 'active_record'
-
-module IFD_DBConnection
-  def self.new(connection_params)
-    begin
-      put_log ("Connecting to database...")
-      return ActiveRecord::Base.establish_connection(connection_params)
-    rescue Exception => e
-      raise e.message
-    end
-  end
-
-  def self.create_database_connection(data)
-    unless data.hashes.empty?
-      data = data.hashes[0]
-      data = JSON.parse(data) unless data.is_a? Hash
-
-      data.each_pair do |k, v|
-        data[k] = Utils.check_dynamic_value(v)
-      end
-      @connection = IFD_DBConnection.new(data)
-      put_log "Connect to database successfully!" if @connection
-    end
-  end
-
-  def self.close_database_connection
-    @connection.disconnect!
-    if !@connection.connected?
-      put_log "Disconnected to Database!"
-    end
-  end
-
-  def self.execute_select(script)
-    script = Utils.check_dynamic_value(script)
-    if @connection
-      @result = @connection.connection.exec_query(script)
-    else
-      raise "ERROR: Create connection to database first!"
-    end
-  end
-
-  def self.execute_script(script)
-    script = Utils.check_dynamic_value(script)
-    if @connection
-      @result = @connection.connection.execute(script)
-    else
-      raise "ERROR: Create connection to database first!"
-    end
-  end
-
-  def self.print_sql_result
-    if @result.present?
-      @result.each do |row|
-        p row
-      end
-    else
-      p "WARNING: No result from SQL statement"
-    end
-  end
-
-  def self.verify_sql_result_with_json(json)
-    expected = JSON.parse(json)
-    @result.each do |row|
-      IFD_Assertion.assert_string_equal(expected,row)
-    end
-  end
-
-  def self.verify_sql_result_with_json_node(json_node, value)
-    @result.each do|row|
-      results = JsonPath.new(json_node).on(row).to_a.map(&:to_s)
-      IFD_Assertion.assert_string_equal(results[0], value)
-    end
-  end
-
-  def self.store_sql_result_into_string(string)
-    Utils.set_var(string, @result)
-  end
-
-end

data/lib/helper/file_helper.rb

@@ -1,36 +0,0 @@
-class IFD_File
-
-  def self.delete_file(file_name)
-    file_path = ($test_data_dir + file_name.gsub(" ", "_"))
-    if File.exists?(file_path)
-      File.delete(file_path)
-      puts "#{file_name} is deleted successfully"
-    else
-      puts "File #{file_name} does not exists"
-    end
-  end
-
-  def self.read_file(file_name)
-    @file_data = ""
-    file_path = $test_data_dir + file_name.downcase
-    if File.exist?(file_path)
-      file = File.open(file_path)
-      @file_data += file.read
-      file.close
-    else
-      raise "*** WARNING: File #{file_name} does not exist."
-    end
-    p @file_data
-  end
-
-  def self.execute_windows_file(filename, file_location)
-    file = file_location + filename
-    p file
-    if File.exist? file
-      system("'"+file+"'")
-    else
-      raise "*** ERROR: File #{file} is not existed."
-    end
-  end
-
-end

data/lib/helper/mail_helper.rb

@@ -1,58 +0,0 @@
-require 'mail'
-# require 'email_spec'
-# include EmailSpec::Helpers
-# include EmailSpec::Matcher
-class IFD_Email
-
-  def self.send_email(raw_data)
-    include Mail::Matchers
-    raw_data.strip!
-    header, body = raw_data.split(/\n\n/, 2) # 2: maximum number of fields
-    conditions = {}
-    header.split("\n").each do |row|
-      if row.lstrip.chop.match(/^[a-z\-]+:/i)
-        key, value = row.split(":", 2)
-        conditions[key.gsub(' ','').underscore.to_sym] = value.gsub(' ','')
-
-      end
-    end
-    conditions[:body] = body if body
-    filepath = ($test_data_dir + conditions[:attachments] if conditions[:attachments])
-    # Mail::TestMailer.deliveries.clear
-    Mail.deliver do
-      from "abc@gmail.com"
-      to to_address if conditions[:to]
-      subject subject if conditions[:subject]
-      body body_email if conditions[:body]
-      add_file attachments if filepath
-    end
-  end
-
-  def self.verify_receive_email(raw_data)
-    raw_data.strip!
-    header, body = raw_data.split(/\n\n/, 2) # 2: maximum number of fields
-    conditions = {}
-    header.split("\n").each do |row|
-      if row.lstrip.chop.match(/^[a-z\-]+:/i)
-        key, value = row.split(":", 2)
-        conditions[key.gsub(' ','').underscore.to_sym] = value.gsub(' ','')
-
-      end
-    end
-    conditions[:body] = body.squeeze(' ').strip if body
-    sleep 5
-    emails = Mail.find(:what => :last, :count => 1)
-
-    if emails.instance_of? Mail::Message
-      IFD_Assertion.assert_string_equal(conditions[:from], emails.from[0].to_s)
-      IFD_Assertion.assert_string_equal(conditions[:subject], emails.subject)
-      IFD_Assertion.assert_string_contain(conditions[:body], emails.body)
-      emails.attachments.each do |attachment|
-        IFD_Assertion.assert_string_equal(conditions[:attachments], attachment.filename)
-      end if conditions[:attachments]
-    else
-      raise "WARNING: *** No new Email is found"
-    end
-  end
-
-end

data/lib/helper/rest_helper.rb

@@ -1,91 +0,0 @@
-require 'httparty'
-class IFD_Rest
-  def self.set_headers(data)
-    unless data.hashes.empty?
-      data = data.hashes[0]
-      data = JSON.parse(data) unless data.is_a? Hash
-
-      data.each_pair do |k, v|
-        data[k] = Utils.check_dynamic_value(v)
-      end
-      @header = data
-    end
-    p "HEADER: #{@header}"
-  end
-
-  def self.get_rest_result
-    if @response.nil?
-      p "WARNING***: MISSING STEPS: Please send a REST request to get response first."
-    end
-    @response
-  end
-
-  def self.store_json_node_result(json_node,string)
-    $context_value = JsonPath.new(json_node).on(IFD_Rest.get_rest_result.body).to_a.map(&:to_s)[0]
-    Utils.set_var(string, '$context_value')
-  end
-
-  def self.print_rest_code
-    puts "REST RESULT code: #{IFD_Rest.get_rest_result.code}"
-  end
-
-  def self.get_rest_body
-    puts "REST RESULT body: #{IFD_Rest.get_rest_result.body}"
-  end
-
-  def self.verify_rest_response_code(code)
-    IFD_Assertion.assert_string_equal(code, IFD_Rest.get_rest_result.code.to_s)
-  end
-
-  def self.verify_response_body_with_json(json)
-    IFD_Assertion.assert_string_equal(json, IFD_Rest.get_rest_result.body.to_s)
-  end
-
-  def self.verify_response_at_json_node(json_node,string)
-    result = JsonPath.new(json_node).on(IFD_Rest.get_rest_result.body).to_a.map(&:to_s)
-    IFD_Assertion.assert_string_equal(string, result[0])
-  end
-
-  def self.send_request(*args)
-    request_type = args.shift.downcase
-    url = Utils.check_dynamic_value(args.shift)
-    put_log "Request URL: #{url}"
-    json_payload = args.shift
-    if json_payload
-      payload = Hash.new
-      JSON.parse(json_payload).each do |k1, v1|
-        payload[Utils.check_dynamic_value(k1)] = Utils.check_dynamic_value(v1)
-      end
-      payload = payload.to_json
-    end
-    put_log "Data Body from #{request_type} method: #{payload}"
-
-    if (payload.nil? && request_type == 'get' && @header.nil?)
-      @response = Request.get(url)
-    elsif (payload.nil? && request_type == 'get')
-      @response = Request.get(url, {headers: @header})
-    elsif (payload.nil? && request_type == 'delete' && @header.nil?)
-      @response = Request.delete(url)
-    elsif (payload.nil? && request_type == 'delete')
-      @response = Request.delete(url, {headers: @header})
-    elsif (payload && request_type == 'get' && @header.nil?)
-      @response = Request.get(url, {body: payload})
-    elsif (payload && request_type == 'get')
-      @response = Request.get(url, {body: payload, headers: @header})
-    elsif (payload && request_type == 'post' && @header.nil?)
-      @response = Request.post(url, {body: payload})
-    elsif (payload && request_type == 'post')
-      @response = Request.post(url, {body: payload, headers: @header})
-    elsif (payload && request_type == 'put' && @header.nil?)
-      @response = Request.put(url, {body: payload})
-    elsif (payload && request_type == 'put')
-      @response = Request.put(url, {body: payload, headers: @header})
-    end
-  end
-
-end
-
-class Request
-  include HTTParty
-  default_options.update(verify: false)
-end

data/lib/helper/soap_helper.rb

@@ -1,59 +0,0 @@
-require 'savon'
-require 'jsonpath'
-
-class IFD_Soap
-  def self.get_soap_operation_list(url)
-    request_url = URI.encode Utils.check_dynamic_value url
-    @SOAPclient = Savon.client(ssl_verify_mode: :none,
-                               wsdl: "#{request_url}",
-                               :open_timeout => 10,
-                               :read_timeout => 10,
-                               :log => false)
-    p "Operations List: #{@SOAPclient.operations}"
-  end
-
-  def self.call_and_fail_gracefully(client, *args, &block)
-    if client.nil?
-      raise "ERROR***: MISSING STEPS: Please run step to get operation list from WSDL first."
-    else
-      client.call(*args, &block)
-    end
-  rescue Savon::SOAPFault => e
-    raise e.message
-  end
-
-  def self.get_soap_response
-    soap_response = @response
-    if soap_response.nil?
-      raise "ERROR***: MISSING STEPS: Please send SOAP request to get the response first."
-    else
-      soap_response
-    end
-    soap_response
-  end
-
-  def self.send_soap_with_operation_and_xml(operation,file_name)
-    xml = File.read($test_data_dir + file_name)
-    @response = IFD_Soap.call_and_fail_gracefully(@SOAPclient, operation.downcase.to_sym, xml: xml )
-  end
-
-  def self.send_soap_with_operation_and_data(operation,data)
-    xml = Utils.bind_with_dyn_vars(data)
-    @response = IFD_Soap.call_and_fail_gracefully(@SOAPclient, operation.downcase.to_sym, xml: xml )
-  end
-
-  def self.verify_response_with_json_node(json_node,string)
-    json = IFD_Soap.get_soap_response.body.to_json
-    results = JsonPath.new(json_node).on(json).to_a.map(&:to_s)
-    IFD_Assertion.assert_string_equal(string, results[0])
-  end
-
-  def self.verify_response_code(status_code)
-    IFD_Assertion.assert_string_equal(IFD_Soap.get_soap_response.http.code, status_code.to_i)
-  end
-
-  def self.print_response
-    p "SOAP RESPONSE: #{IFD_Soap.get_soap_response}"
-  end
-
-end

data/lib/helper/ssh_helper.rb

@@ -1,39 +0,0 @@
-require 'net/ssh'
-
-class IFD_Ssh
-  def self.connect_to_server_with_credential(host_name,table)
-    hostname = Utils.check_dynamic_value host_name
-    @keys = []
-    @auth_methods ||= %w(password)
-    session = table.hashes.first
-    session_keys = Array.new(@keys)
-    session_auth_methods = Array.new(@auth_methods)
-    if session["keyfile"]
-      session_keys << session["keyfile"]
-      session_auth_methods << "publickey"
-    end
-
-    @SSHconnection = Net::SSH.start(hostname, session["username"], :password => session["password"],
-                                    :auth_methods => session_auth_methods,
-                                    :keys => session_keys)
-  end
-
-  def self.exec_command(command)
-    command = Utils.check_dynamic_value command
-    @output = @SSHconnection.exec!(command)
-  end
-
-  def self.print_output
-    p @output
-  end
-
-  def self.verify_output(string)
-    string = Utils.check_dynamic_value(string)
-    IFD_Assertion.assert_string_equal(string, @output.strip)
-  end
-
-  def self.store_result_string(name)
-    $context_value = Utils.bind_with_dyn_vars(@output)
-    Utils.set_var(name, '$context_value')
-  end
-end