Ifd_Automation 2.6 → 2.7

data/lib/helper/rest_helper.rb

@@ -0,0 +1,91 @@
+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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,39 @@
+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

data/lib/helper/web_steps_helper.rb

@@ -0,0 +1,447 @@
+require 'net/https'
+# Open Browser with config-able maximize browser option
+  def execute_openbrowser(url_site)
+    begin
+      if $_CFWEB['Maximize Browser'] == true
+        page.driver.browser.manage.window.maximize
+      end
+    rescue StandardError => myStandardError
+      raise "\n>>> Error: #{myStandardError}"
+    end
+
+    if url_site == ""
+      raise "\n>>> Error: Null web page URL."
+    else
+      visit(url_site)
+    end
+  end
+
+  def execute_click(element)
+    foundElement = find_object(element)
+    if foundElement != nil
+      page.driver.execute_script('window.focus();')
+      startTime = Time.new.to_i
+      begin
+        sleep(0.5)
+        currentTime = Time.new.to_i
+      end while (foundElement.native.enabled? == false and (currentTime - startTime) < $_CFWEB['Wait Time'])
+      page.driver.browser.execute_script("arguments[0].scrollIntoView(true);", foundElement.native)
+      page.driver.browser.action.move_to(foundElement.native, element).click.perform
+      # page.driver.browser.action.click(foundElement.native)
+      # foundElement.native.send_keys(:return)
+    else
+      raise "\nError >> Not found object: #{element}"
+    end
+  end
+
+  def double_click(element)
+    foundElement = find_object(element)
+    if foundElement != nil
+      begin
+        page.driver.browser.action.double_click(foundElement.native)
+      rescue StandardError => myStandardError
+        raise "\n>>> Error: #{myStandardError}"
+      end
+    else
+      raise "\nError >> Not found object: #{element}"
+      exit
+    end
+  end
+
+  def execute_settext(element, text)
+    foundElement = find_object(element)
+    if foundElement != nil
+      begin
+        foundElement.set(text)
+      rescue StandardError => myStandardError
+        raise "\n>>> Error: #{myStandardError}"
+      end
+    else
+      raise "\nError >> Not found object: #{element}"
+      exit
+    end
+  end
+
+  def maximize_browser
+    page.driver.browser.manage.window.maximize
+  end
+
+  def switch_to_window_by_title(window_title)
+    $previous_window = page.driver.browser.window_handle
+    window_found = false
+    page.driver.browser.window_handles.each { |handle|
+      page.driver.browser.switch_to.window handle
+      if page.title == window_title
+        window_found = true
+        break
+      end
+    }
+    raise "Window having title \"#{window_title}\" not found" if not window_found
+  end
+
+  def scroll_page(to)
+    if to == 'end'
+      page.driver.execute_script('window.scrollTo(0,Math.max(document.documentElement.scrollHeight,document.body.scrollHeight,document.documentElement.clientHeight));')
+    elsif to == 'top'
+      page.driver.execute_script('window.scrollTo(Math.max(document.documentElement.scrollHeight,document.body.scrollHeight,document.documentElement.clientHeight),0);')
+    else
+      raise "Exception : Invalid Direction (only scroll \"top\" or \"end\")"
+    end
+  end
+
+# Method to verify title
+# param 1 : String : expected title
+# param 2 : Boolean : test case [true or flase]
+  def check_title(title, test_case)
+    page_title = page.title
+    if test_case
+      if page_title != "#{title}"
+        raise "Page Title Not Matched, Actual Page Title : #{page_title}, Expected Page Title : #{title}"
+      end
+    else
+      if page_title == "#{title}"
+        raise "Page Title Matched, Actual Page Title: #{page_title}"
+      end
+    end
+  end
+
+  def check_alert_text(text)
+    alert = page.driver.browser.switch_to.alert.text
+    if alert != text
+      raise "Text on alert pop up not matched, Actual Text : #{alert}, Expected Text : #{text}"
+    end
+  end
+
+  def execute_select(element, text)
+    #select(text, :xpath => element)
+    foundElement = find_object(element)
+
+    if foundElement != nil
+      option_value = page.evaluate_script("$(\"##{foundElement[:id]} option:contains('#{text}')\").val()")
+      page.execute_script("$('##{foundElement[:id]}').val('#{option_value}')")
+      page.execute_script("$('##{foundElement[:id]}').trigger('liszt:updated').trigger('change')")
+    else
+      put_log "\nError >> Not found object: #{element}"
+      exit
+    end
+  end
+
+  def execute_mousehoverandclick(element)
+    foundElement = find_object(element)
+    if foundElement != nil
+      page.driver.browser.action.move_to(foundElement.native, element).click.perform
+      sleep(1)
+    else
+      put_log "\nError >> Not found object: #{element}"
+    end
+  end
+
+  def remove_element_attribute(element, attr)
+    foundElement = find_object(element)
+    if foundElement != nil
+      page.driver.browser.execute_script("arguments[0].removeAttribute('#{attr}');", foundElement.native)
+    else
+      put_log "\nError >> Not found object: #{element}"
+    end
+  end
+
+# Set state
+  def execute_setstate(element, state)
+    foundElement = find_object(element)
+    if foundElement != nil
+      if state.upcase == "TRUE"
+        foundElement.select_option
+      else
+        foundElement.unselect_option
+      end
+    else
+      put_log "\nError >> Not found object: #{element}"
+      exit
+    end
+  end
+
+  def resize_window_screen(x, y)
+    page.driver.browser.manage.window.resize_to(x, y)
+    puts page.driver.browser.manage.window.size
+  end
+
+  def get_computed_style(element, style)
+    foundElement = get_object_value(element)
+    computedStyle = ""
+    if foundElement != nil
+      computedStyle = page.evaluate_script(
+          "window.getComputedStyle(document.querySelector('#{foundElement}')).#{style}"
+      )
+    else
+      puts "\nError >> Not found object: #{element}"
+    end
+    puts "\nActual object style value is: #{computedStyle}"
+    computedStyle
+  end
+
+  require 'rspec'
+
+  def put_log str
+    p str if $_CFWEB['Print Log'] == true
+  end
+
+  def get_object_value(str_obj)
+    string_object = str_obj.gsub(/"/, "'")
+    hash_object = $OBJECT[string_object]
+    if hash_object == nil
+      raise ">>> OBJECT: #{str_obj} NAME MAYBE NOT FOUND!!!"
+    end
+    if hash_object.keys[0].to_s.upcase != "CSS_SELECTOR"
+      raise ">>> OBJECT: #{str_obj} should be formatted as Css Selector."
+    end
+    hash_object[hash_object.keys[0]]
+  end
+
+  def execute_checkproperty(element, property, negate, value, isSpecialChar=false)
+    Capybara.configure do |config|
+      config.ignore_hidden_elements = false
+    end
+    foundElement = find_object(element)
+
+    check = false
+    if foundElement == nil and value == ""
+      check = true
+      # check.should eq true
+      expect(check).to eq true
+    else
+      # put_log "\n\n\t>>> execute_checkproperty: finish to found element"
+      if foundElement != nil
+        if property.upcase == 'VALUE'
+          actual_value = foundElement.value()
+
+        elsif property.upcase == 'TEXT'
+          actual_value = foundElement.text()
+
+        elsif property.upcase == 'SPECIAL CHAR'
+          actual_value = foundElement.text()
+          isSpecialChar = true
+
+        elsif property.upcase == 'TAGNAME'
+          actual_value = foundElement.tag_name()
+
+        elsif property.upcase == 'STYLE'
+          actual_value = foundElement[:style]
+
+        elsif property.upcase == 'DISABLED'
+          actual_value = foundElement[:disabled]
+
+        elsif property.upcase == 'WIDTH'
+          actual_value = foundElement[:width]
+
+        elsif property.upcase == 'HEIGHT'
+          actual_value = foundElement[:height]
+
+        elsif property.upcase == 'ID'
+          actual_value = foundElement[:id]
+
+        elsif property.upcase == 'NAME'
+          actual_value = foundElement[:name]
+
+        elsif property.upcase == 'CLASS'
+          actual_value = foundElement[:class]
+
+        elsif property.upcase == 'HREF'
+          actual_value = foundElement[:href]
+
+        elsif property.upcase == 'TITLE'
+          actual_value = foundElement[:title]
+
+        elsif property.upcase == 'TYPE'
+          actual_value = foundElement[:type]
+
+        elsif property.upcase == 'CHECKED'
+          actual_value = "true" if foundElement.checked? == true
+          actual_value = "false" if foundElement.checked? == false
+        else
+          actual_value = foundElement["#{property}"]
+        end
+
+        if actual_value == nil
+          actual_value = ''
+        end
+      else
+        put_log "\nError >> Not found object: #{element}"
+      end
+
+      Capybara.configure do |config|
+        config.ignore_hidden_elements = true
+      end
+
+      # if IFD_Assertion.reg_compare(actual_value, value, isSpecialChar)
+      #   check = true
+      # end
+
+      put_log "\n#{property} :: Actual result is: '#{actual_value}' -- Expected result is: '#{value}'"
+
+      if negate == " not"
+        actual_value.should_not eq value
+        expect(actual_value).not_to eql value
+      elsif actual_value.should eq value
+        expect(actual_value).to eq value
+      end
+    end
+  end
+
+  def execute_gettext(element)
+    foundElement = find_object(element)
+    if foundElement != nil
+      tagname = foundElement.tag_name()
+
+      if tagname.upcase == 'SELECT'
+      else
+        actual_text = foundElement.text()
+        if (actual_text == nil or actual_text.length == 0) and (tagname.upcase == 'INPUT' or tagname.upcase == 'TEXTAREA')
+          actual_text = foundElement.value()
+        end
+      end
+
+      put_log "\nText is '" + actual_text + "' of object '" + element + "'"
+      $context_value = actual_text
+    else
+      put_log "\nError >> Not found object: #{element}"
+      exit
+    end
+  end
+
+  def find_object(string_object)
+    startTime = Time.new.to_i
+    string_object = string_object.gsub(/"/, "'")
+    locator_matching = /(.*?)(\{.*?\})/.match(string_object)
+    dyn_pros = {}
+    if locator_matching != nil
+      string_object = locator_matching[1]
+      eval(locator_matching[2].gsub(/['][\s,\t]*?:[\s,\t]*?[']?/, "'=>'")).each { |k, v|
+        dyn_pros[k.to_s.upcase] = v
+      }
+    end
+
+    hash_object = $OBJECT[string_object]
+    if hash_object == nil
+      raise "ERROR: >>> Object: #{string_object} is not found in Object Repository."
+    end
+    upcase_attrb = {}
+    if hash_object != nil
+      hash_object.each { |k, v|
+        k = k.to_s.upcase
+        if k =~ /ph_/i
+          if dyn_pros[k] != nil
+            if v =~ /<ph_value>/i
+              upcase_attrb[k[3..k.size-1]] = v.gsub(/<ph_value>/i, dyn_pros[k])
+            else
+              upcase_attrb[k[3..k.size-1]] = dyn_pros[k]
+            end
+
+            dyn_pros.delete(k)
+          end
+        else
+          upcase_attrb[k.to_s.upcase] = v
+        end
+
+      }
+    end
+    ph_attrs = {}
+    dyn_pros.each { |k, v|
+      if k =~ /ph_/i
+        ph_attrs[k] = v
+      else
+        upcase_attrb[k.to_s.upcase] = v
+      end
+    }
+
+    if upcase_attrb.size > 0
+      strCssSelector = ""
+      strXpathSelector = ""
+
+
+      upcase_attrb.each { |key, value|
+        upcase_key = key.to_s.upcase
+        case upcase_key
+          when "XPATH_SELECTOR"
+            strXpathSelector = value
+          when "CSS_SELECTOR"
+            strCssSelector = value
+          else
+            raise "ERROR: >>> Wrong format type: #{key.to_s} of object: #{string_object}. Available supported format are: XPATH_SELECTOR and CSS_SELECTOR"
+        end
+      }
+
+      begin
+        if strCssSelector != nil and strCssSelector.length > 0
+          foundElements = get_objects_by_css_selector(strCssSelector)
+        else
+          foundElements = get_objects_by_xpath_selector(strXpathSelector)
+        end
+        if foundElements == nil or foundElements.length == 0
+          currentTime = Time.new.to_i
+        else
+          put_log "\nBREAK!!!"
+          break
+        end
+        test = currentTime - startTime
+        put_log "\n#TIMEOUNT:#{test} < #{$_CFWEB['Wait Time']}"
+        sleep(0.5)
+      end while (currentTime - startTime) < $_CFWEB['Wait Time']
+
+      if foundElements != nil or foundElements.length != 0
+        return_element = nil
+        foundElements.each { |cur_element|
+          passCheck = find_object_check_object(cur_element)
+          if passCheck
+            return_element = cur_element
+            break
+          end
+        }
+        return return_element
+      end
+    end
+
+    nil
+  end
+
+  def get_objects_by_css_selector(strCssSelector)
+    foundElements = nil
+    begin
+      foundElements = page.all(:css, strCssSelector)
+    rescue StandardError => myStandardError
+      raise "\n>>> Error: #{myStandardError}"
+    end
+
+    foundElements
+  end
+
+  def get_objects_by_xpath_selector(strXpathSelector)
+    foundElements = nil
+    begin
+      foundElements = page.all(:xpath, strXpathSelector)
+    rescue StandardError => myStandardError
+      put_log "\n>>> Error: #{myStandardError}"
+    end
+    foundElements
+  end
+
+  def find_object_check_object(cur_element)
+    passCheck = true
+    if cur_element != nil
+      return passCheck
+    end
+    false
+  end
+
+def get_object_and_store_as_string(object,string)
+  text = execute_gettext(object)
+  txt = "'" + text + "'"
+  Utils.set_var(string, txt)
+end
+
+
+def get_object_and_store_to_file(object,file_name)
+  $text = execute_gettext(object)
+  open($test_data_dir+file_name, 'a+') do |f|
+    f << $text + "\n"
+  end
+end