Ifd_Automation 1.9.2 → 2.0

data/lib/Ifd_Automation/javascript_steps.rb

@@ -1,33 +0,0 @@
-require_relative 'required_libs'
-
-Then(/^I accept pop-up alert$/) do
-  handle_alert('accept')
-end
-
-Then(/^I dismiss pop-up alert$/) do
-  handle_alert('dismiss')
-end
-
-And /^I focus in new open page$/ do
-  switch_to_windows(last)
-end
-
-And /^I focus in previous page$/ do
-  switch_to_windows(first)
-end
-
-And /^I close current windows$/ do
-  close_windows
-end
-
-Given /^I go back to the previous page$/ do
-  get_browser_back
-end
-
-When /^I refresh this page$/ do
-  refresh_page
-end
-
-And /^I open new browser windows$/ do
-  open_new_windows_browser
-end

data/lib/Ifd_Automation/required_libs.rb

@@ -1,7 +0,0 @@
-require_relative '../Ifd_Automation_support/assertion_helpers.rb'
-require_relative '../Ifd_Automation_support/connection_helpers.rb'
-require_relative '../Ifd_Automation_support/core.rb'
-require_relative '../Ifd_Automation_support/javascript_helpers.rb'
-require_relative '../Ifd_Automation_support/mail_helpers.rb'
-require_relative '../Ifd_Automation_support/selenium_sync_issues.rb'
-require_relative '../Ifd_Automation_support/web_steps_helpers.rb'

data/lib/Ifd_Automation/response.rb

@@ -1,105 +0,0 @@
-require 'json'
-require 'jsonpath'
-require 'rest-client'
-
-module CucumberApi
-
-  # Extension of {RestClient::Response} with support for JSON path traversal and validation
-  module Response
-
-    # include RestClient::Response
-
-    # Create a Response with JSON path support
-    # @param response [RestClient::Response] original response
-    # @return [Response] self
-    def self.create response
-      # include RestClient::Response
-      result = response
-      result.extend Response
-      result
-    end
-
-    # Check if given JSON path exists
-    # @param json_path [String] a valid JSON path expression
-    # @param json [String] optional JSON from which to check JSON path, default to response body
-    # @return [true, false] true if JSON path is valid and exists, false otherwise
-    def has json_path, json=nil
-      if json.nil?
-        json = JSON.parse body
-      end
-      not JsonPath.new(json_path).on(json).empty?
-    end
-
-    # Retrieve value of the first JSON element with given JSON path
-    # @param json_path [String] a valid JSON path expression
-    # @param json [String] optional JSON from which to apply JSON path, default to response body
-    # @return [Object] value of first retrieved JSON element in form of Ruby object
-    # @raise [Exception] if JSON path is invalid or no matching JSON element found
-    def get json_path, json=nil
-      if json.nil?
-        json = JSON.parse body
-      end
-      results = JsonPath.new(json_path).on(json)
-      if results.empty?
-        raise %/Expected json path '#{json_path}' not found\n#{to_json_s}/
-      end
-      results.first
-    end
-
-    # Retrieve value of the first JSON element with given JSON path as given type
-    # @param json_path [String] a valid JSON path expression
-    # @param type [String] required type, possible values are 'numeric', 'array', 'string', 'boolean', 'numeric_string'
-    # or 'object'
-    # @param json [String] optional JSON from which to apply JSON path, default to response body
-    # @return [Object] value of first retrieved JSON element in form of given type
-    # @raise [Exception] if JSON path is invalid or no matching JSON element found or matching element does not match
-    # required type
-    def get_as_type json_path, type, json=nil
-      value = get json_path, json
-      case type
-        when 'numeric'
-          valid = value.is_a? Numeric
-        when 'array'
-          valid = value.is_a? Array
-        when 'string'
-          valid = value.is_a? String
-        when 'boolean'
-          valid = !!value == value
-        when 'numeric_string'
-          valid = value.is_a?(Numeric) or value.is_a?(String)
-        when 'object'
-          valid = value.is_a? Hash
-        else
-          raise %/Invalid expected type '#{type}'/
-      end
-
-      unless valid
-        raise %/Expect '#{json_path}' as a '#{type}' but was '#{value.class}'\n#{to_json_s}/
-      end
-      value
-    end
-
-    # Retrieve value of the first JSON element with given JSON path as given type, with nil value allowed
-    # @param json_path [String] a valid JSON path expression
-    # @param type [String] required type, possible values are 'numeric', 'array', 'string', 'boolean', 'numeric_string'
-    # or 'object'
-    # @param json [String] optional JSON from which to apply JSON path, default to response body
-    # @return [Object] value of first retrieved JSON element in form of given type or nil
-    # @raise [Exception] if JSON path is invalid or no matching JSON element found or matching element does not match
-    # required type
-    def get_as_type_or_null json_path, type, json=nil
-      value = get json_path, json
-      value.nil? ? value : get_as_type(json_path, type, json)
-    end
-
-    # Retrieve pretty JSON response for logging
-    # @return [String] pretty JSON response if verbose setting is true, empty string otherwise
-    def to_json_s
-      if ENV['cucumber_api_verbose'] == 'true'
-        JSON.pretty_generate(JSON.parse to_s)
-      else
-        ''
-      end
-    end
-  end
-end

data/lib/Ifd_Automation/webservice_steps.rb

@@ -1,281 +0,0 @@
-require 'rest-client'
-require 'json-schema'
-require 'savon'
-require_relative 'required_libs'
-require_relative 'response'
-
-if ENV['webservice_verbose'] == 'true'
-  RestClient.log = 'stdout'
-end
-
-$cache = {}
-
-Given /^I set headers:$/ do |headers|
-  @headers = headers.hashes[0]
-  p @headers
-end
-
-Given /^I send and accept (XML|JSON)$/ do |type|
-  @headers = {
-      :'Accept' => "application/#{type.downcase}",
-      :'Content-Type' => "application/#{type.downcase}"
-  }
-  p @headers
-end
-
-# Example
-# When I get SOAP operations list from 'http://ws.cdyne.com/emailverify/Emailvernotestemail.asmx?wsdl'
-When /^I get SOAP operations list from '(.*?)'$/ do |url|
-  request_url = URI.encode check_match_url url
-  @client = Savon.client(ssl_verify_mode: :none, wsdl: "#{request_url}")
-  p @client.operations
-end
-
-When /^I get SOAP operations list$/ do
-  p @client.operations
-end
-
-When /^I create new SOAP request with:$/ do |params|
-  soap_params = {}
-  soap_params[:ssl_verify_mode] = :none
-  params.hashes[0].each { |k, v| soap_params[k.to_sym] = v }
-  @client = Savon.client(soap_params)
-end
-
-When /^I send "(.*?)" SOAP request with namespace "(.*)" and the following:$/ do |operation, namespace, json|
-  params = JSON.parse(json)
-  @response = @client.call(operation.downcase.to_sym, :message => params, soap_action: namespace)
-end
-
-
-# Example
-# When I send "verify_email" SOAP request with the following:
-# """
-#     { "email": "soap@example.com",
-#       "LicenseKey": "?" }
-#     """
-When /^I send "(.*?)" SOAP request with the following:$/ do |operation, json|
-  params = JSON.parse(json)
-  @response = @client.call(operation.downcase.to_sym, :message => params)
-  # p JSON.parse(@response.body)
-  # p response_text = response.body[:verify_email_response][:verify_email_result][:response_text]
-end
-
-# Example
-# Then the SOAP response node should have "$..response_text" with text "Email Domain Not Found"
-Then /^the SOAP response node should have "(.*?)" with text "(.*?)"$/ do |json_path, text|
-  json = JSON.parse(@response.body.to_json)
-  results = JsonPath.new(json_path).on(json).to_a.map(&:to_s)
-  IFD_Assertion.assert_string_equal(text, results)
-end
-
-When(/^I set JSON request body to '(.*?)'$/) do |body|
-  @body = JSON.parse body
-end
-
-When(/^I set form request body from:$/) do |json|
-  params = check_match_url json
-  @body = JSON.parse(params)
-  p @body
-end
-
-When(/^I set request body from file "(.*?).(yml|json)"$/) do |filename, extension|
-  path = $test_data_dir+filename+".#{extension}"
-  if File.file? path
-    case extension
-      when 'yml'
-        @body = YAML.load File.open(path)
-      when 'json'
-        @body = JSON.parse File.read(path)
-      else
-        raise %/Unsupported file type: '#{path}'/
-    end
-  else
-    raise %/File not found: '#{path}'/
-  end
-end
-
-# Example
-# When I grab "$[0]" as "id"
-When(/^I grab "(.*?)" (REST|SOAP) as "(.*?)"$/) do |json_path, method, place_holder|
-  if @response.nil?
-    raise 'No response found, a request need to be made first before you can grab response'
-  end
-  @grabbed = {} if @grabbed.nil?
-  case method
-    when /REST/
-      @grabbed[%/#{place_holder}/] = @response.get json_path
-      p @grabbed
-    else
-      json = JSON.parse(@response.body.to_json)
-      results = JsonPath.new(json_path).on(json).to_a.map(&:to_s)
-      @grabbed[%/#{place_holder}/] = results[0]
-      p @grabbed
-  end
-
-
-end
-# Example
-# And I send a GET request to "https://hacker-news.firebaseio.com/v0/item/8863.json" with:
-#       | print  |
-#       | pretty |
-When(/^I send a (GET|POST|PATCH|PUT|DELETE) request to "(.*?)" with:$/) do |method, url, params|
-  unless params.hashes.empty?
-    query = params.hashes.first.map { |key, value| %/#{key}=#{value}/ }.join("&")
-    url = url.include?('?') ? %/#{url}&#{query}/ : %/#{url}?#{query}/
-  end
-  steps %Q{
-      When I send a #{method} request to "#{url}"
-    }
-end
-
-# Example
-# And I send a POST request to "https://hacker-news.firebaseio.com/v0/item/8863.json?print=pretty"
-When(/^I send a (GET|POST|PATCH|PUT|DELETE) request to "(.*?)"$/) do |method, url|
-  request_url = URI.encode check_match_url url
-  if 'GET' == %/#{method}/ and $cache.has_key? %/#{request_url}/
-    @response = $cache[%/#{request_url}/]
-    @headers = nil
-    @body = nil
-    @grabbed = nil
-    next
-  end
-
-  @headers = {} if @headers.nil?
-  begin
-    case method
-      when 'GET'
-        response = RestClient.get request_url, @headers
-      when 'POST'
-        response = RestClient.post request_url, @body, @headers
-      when 'PATCH'
-        response = RestClient.patch request_url, @body, @headers
-      when 'PUT'
-        response = RestClient.put request_url, @body, @headers
-      else
-        response = RestClient.delete request_url, @headers
-    end
-  rescue RestClient::Exception => e
-    response = e.response
-  end
-  @response = CucumberApi::Response.create response
-  @headers = nil
-  @body = nil
-  @grabbed = nil
-  $cache[%/#{request_url}/] = @response if 'GET' == %/#{method}/
-end
-
-# Example
-# Then the response status should be "200"  
-Then(/^the response status should be "(\d+)"$/) do |status_code|
-  raise %/Expect #{status_code} but was #{@response.code}/ if @response.code != status_code.to_i
-end
-
-# Example
-# Then the JSON response should be:
-#      """
-#      {
-#        "test" : "anh pham"
-#      }
-#      """
-Then /^the JSON response should be:$/ do |json|
-  expected = JSON.parse(json)
-  actual = JSON.parse(@response.body)
-
-  if self.respond_to?(:expect)
-    # expect(actual).to eq(expected)
-    IFD_Assertion.assert_string_equal(actual, expected)
-  else
-    IFD_Assertion.assert_string_equal(actual, @response)
-    # assert_equal actual, response
-  end
-end
-
-# Example
-# Then the JSON response should have "$..id"
-Then /^the JSON response should have "(.*)"$/ do |json_path|
-  json = JSON.parse(@response.body)
-  results = JsonPath.new(json_path).on(json).to_a.map(&:to_s)
-  if self.respond_to?(:expect)
-    expect(results).not_to be_empty
-  end
-end
-
-Then(/^the JSON response root should be (object|array)$/) do |type|
-  steps %Q{
-    Then the JSON response should have required key "$" of type #{type}
-        }
-end
-
-Then(/^the JSON response should have key "([^\"]*)"$/) do |json_path|
-  steps %Q{
-    Then the JSON response should have required key "#{json_path}" of type any
-  }
-end
-
-
-Then(/^the JSON response should have (required|optional) key "(.*?)" of type \
-(numeric|string|array|boolean|numeric_string|object|array|any)( or null)?$/) do |optionality, json_path, type, null_allowed|
-  next if optionality == 'optional' and not @response.has(json_path) # if optional and no such key then skip
-  if 'any' == type
-    @response.get json_path
-  elsif null_allowed.nil?
-    @response.get_as_type json_path, type
-  else
-    @response.get_as_type_or_null json_path, type
-  end
-end
-
-# Example
-# Then the JSON response should have "$..kids" with a length of 2
-Then /^the JSON response should have "(.*)" with a length of (\d+)$/ do |json_path, length|
-  json = JSON.parse(@response.body)
-  results = JsonPath.new(json_path).on(json)
-  if self.respond_to?(:expect)
-    expect(results.length).to eq(length.to_i)
-  else
-    assert_equal length.to_i, results.length
-  end
-end
-
-# Example
-# Then the JSON response node should have "$..by" with the text "dhouston"
-Then /^the JSON response node should have "(.*)" with the text "(.*)"$/ do |json_path, text|
-  json = JSON.parse(@response.body)
-  results = JsonPath.new(json_path).on(json).to_a.map(&:to_s)
-  if self.respond_to?(:expect)
-    expect(results).to include(text)
-  else
-    assert results.include?(text)
-  end
-end
-
-# Bind grabbed values into placeholders in given URL
-# Ex: http://example.com?id={id} with {id => 1} becomes http://example.com?id=1
-# @param url [String] parameterized URL with placeholders
-# @return [String] binded URL or original URL if no placeholders
-# def resolve url
-#   unless @grabbed.nil?
-#     @grabbed.each { |key, value| url = url.gsub /\{#{key}\}/, %/#{value}/ }
-#   end
-#   url
-# end
-
-Then /^show me SOAP response$/ do
-  puts @response.body
-end
-
-Then /^show me REST (unparsed)?\s?response$/ do |unparsed|
-  last_response = @response
-  if unparsed == 'unparsed'
-    puts last_response.body
-  elsif last_response.headers['Content-Type'] =~ /json/
-    json_response = JSON.parse(last_response.body)
-    puts JSON.pretty_generate(json_response)
-  elsif last_response.headers['Content-Type'] =~ /xml/
-    puts Nokogiri::XML(last_response.body)
-  else
-    puts last_response.headers
-    puts last_response.body
-  end
-end

data/lib/Ifd_Automation_support/assertion_helpers.rb

@@ -1,205 +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
-
-
-  # Method to find difference between images
-  def self.does_images_similar?(actual_img_access_type, actual_img_access_name, excp_img_access_type, excp_img_access_name)
-    if !compare_image(actual_img_access_type, actual_img_access_name, excp_img_access_type, excp_img_access_name)
-      raise TestCaseFailed, 'Actual image is different from expected image'
-    end
-  end
-
-  # Method to compare two images
-  # param 1 : String : Locator type (id, name, class, xpath, css, url)
-  # param 2 : String : Locator value
-  # param 3 : String : Locator type (id, name, class, xpath, css, url, image_name)
-  # param 4 : String : Locator value
-  def self.compare_image(actual_img_access_type, actual_img_access_name, excp_img_access_type, excp_img_access_name)
-    if actual_img_access_type == 'url'
-      actual_img_url = actual_img_access_name
-    elsif actual_img_access_type == 'image_name'
-      actual_img_url = $test_data_dir + '/actual_images/' + actual_img_access_name
-    else
-      actual_img_url = get_element_attribute(actual_img_access_type, actual_img_access_name, 'src')
-    end
-
-    if excp_img_access_type == 'url'
-      expected_img_url = excp_img_access_name
-    elsif excp_img_access_type == 'image_name'
-      expected_img_url = $test_data_dir + '/expected_images/' + excp_img_access_name
-    else
-      expected_img_url = get_element_attribute(excp_img_access_type, excp_img_access_name, 'src')
-    end
-
-    # replace 'https' with 'http' from actual image url
-    if actual_img_url.include? 'https'
-      actual_img_url['https'] = 'http'
-    end
-
-    # replace 'https' with 'http' from expected image url
-    if expected_img_url.include? 'https'
-      expected_img_url['https'] = 'http'
-    end
-
-    if expected_img_url.include? '.png'
-      image_type = 'png'
-    else
-      image_type = 'jpg'
-    end
-
-    # Storing actual image locally
-    open($test_data_dir + '/actual_images/actual_image.' + image_type, 'wb') do |file|
-      file << open(actual_img_url).read
-    end
-
-    if actual_img_access_type == 'url'
-      actual_img_url = $test_data_dir + '/actual_images/actual_image.' + image_type
-    end
-
-    # Storing Expected image locally
-    if excp_img_access_type != 'image_name'
-      open($test_data_dir + '/expected_images/expected_image.' + image_type, 'wb') do |file|
-        file << open(expected_img_url).read
-      end
-      expected_img_url = $test_data_dir + '/expected_images/expected_image.' + image_type
-    end
-
-    # Verify image extension and call respective compare function
-    if image_type == 'png'
-      return compare_png_images(expected_img_url, actual_img_url)
-    end
-
-    compare_jpeg_images(expected_img_url, actual_img_url)
-  end
-
-  # Comparing jpg images
-  def self.compare_jpeg_images(expected_img_url, actual_img_url)
-    if open(expected_img_url).read == open(actual_img_url).read
-      return true
-    else
-      puts 'Difference in images'
-      return false
-    end
-  end
-
-  # Comparing png images
-  def self.compare_png_images(expected_img_url, actual_img_url)
-    images = [
-        ChunkyPNG::Image.from_file(expected_img_url),
-        ChunkyPNG::Image.from_file(actual_img_url)
-    ]
-
-    diff = []
-
-    images.first.height.times do |y|
-      images.first.row(y).each_with_index do |pixel, x|
-        diff << [x, y] unless pixel == images.last[x, y]
-      end
-    end
-
-    if diff.length != 0
-      puts "\npixels (total):     #{images.first.pixels.length}"
-      puts "pixels changed:     #{diff.length}"
-      puts "pixels changed (%): #{(diff.length.to_f / images.first.pixels.length) * 100}%"
-
-      x, y = diff.map { |xy| xy[0] }, diff.map { |xy| xy[1] }
-      images.last.rect(x.min, y.min, x.max, y.max, ChunkyPNG::Color.rgb(0, 255, 0))
-      cur_time = Time.now.strftime('%Y%m%d%H%M%S%L')
-      images.last.save($test_data_dir + "/image_difference/difference_#{cur_time}.png")
-
-      puts "\nDifference between images saved as : difference_#{cur_time}.png\n"
-      return false
-    end
-    true
-  end
-end