anhpham 0.1.1

data/lib/anhpham/lib_schema_data_steps.rb

@@ -0,0 +1,110 @@
+require_relative 'methods/required_files'
+#====================================
+# INTERACTION STEPS
+#====================================
+# Step used to execute a SQL script on a specific schema
+And /^I run sql script "([^\"]*)" on "([^\"]*)" schema$/ do |script, schema|
+  begin
+    sql = "#{script}"
+    DatabaseMethods.execute_select(schema, sql)
+    DatabaseMethods.close_connection(schema)
+  ensure
+  end
+end
+# Step used to execute SQL script from SQL file on specific schema
+Given /^I run sql script from file "([^\"]*)" on "([^\"]*)" schema$/ do |sql_script, schema|
+  if sql_script != nil and sql_script != ""
+    begin
+      File.readlines($sql_dir + sql_script).each do |line|
+        if line.nil? || line =~ /^\s*\n*--/
+          # puts "\nSQL: " + line;
+          next;
+        end
+        line = line.strip();
+        line = line[0..-2];
+        #puts "\nSQL: " + line;
+        DatabaseMethods.execute_select(schema, line)
+        sleep(1);
+      end
+      DatabaseMethods.close_connection(schema)
+    end
+  end
+end
+#====================================
+# VERIFICATION STEPS
+#====================================
+# Step used to check if data exists in database or not
+Then /^I should ( not)? see data in table "([^\"]*)" on "([^\"]*)" schema in database as following record:$/ do |negative, table, schema, table_data|
+  records = Util.read_table_data_from_steps_with_header(table_data.raw)
+  records = JSON.parse(JSON.generate(records))
+  puts records
+  records.each { |values|
+    table_type_obj = Util.generate_condition_statement(values)
+    # puts table_type_obj
+    begin
+      sql= "select count(*) from #{schema}.#{table} where #{table_type_obj}"
+      rs = DatabaseMethods.execute_select(schema, sql)
+      # puts sql
+      obj_array = Array.new
+      rs.each { |row|
+        row.each_pair { |col, value|
+          assert(false) if negative.nil? && value == 0 || !negative.nil? && value == 1
+        }
+      }
+    ensure
+      DatabaseMethods.close_connection(schema)
+    end
+  }
+end
+# Step used to check if data exists in database or not with condition in file
+Then /^I should ( not)? see data in schema "(.*)" database with SQL query in file "(.*)"$/ do |negative, schema, file|
+  sql = File.read($test_data_dir + file)
+  filepath = ($test_data_dir + file)
+  if File.exist?(filepath)
+    begin
+      rs = DatabaseMethods.execute_select(schema, sql)
+      obj_array = Array.new
+      rs.each { |row|
+        row.each_pair { |col, value|
+          assert(false) if negative.nil? && value == 0 || !negative.nil? && value == 1
+        }
+      }
+    ensure
+      DatabaseMethods.close_connection(schema)
+    end
+  else
+    raise "*** ERROR: Please check #{filepath} exists."
+  end
+end
+
+# Step used to get data from database
+Then /^I get "(.*)" data from table "([^\"]*)" on "([^\"]*)" schema in database as following record:$/ do |value, table, schema, table_data|
+  records = Util.read_table_data_from_steps_with_header(table_data.raw)
+  records = JSON.parse(JSON.generate(records))
+  records.each { |values|
+    table_type_obj = Util.generate_condition_statement(values)
+    begin
+      sql= "select #{value} from #{table} where #{table_type_obj}"
+      sql_count= "select count(*) from #{table} where #{table_type_obj}"
+      rs = DatabaseMethods.execute_select(schema, sql)
+      record_result= DatabaseMethods.execute_select(schema, sql_count)
+      record_result.each { |rows|
+        rows.each_pair { |cols, values|
+          @@value_count= values
+        }
+      }
+      if @@value_count == 0
+        puts ("***WARNING: NOT FOUND #{table_type_obj} in #{schema}")
+
+      else
+        rs.each { |row|
+          row.each_pair { |cols, values|
+            $result=values
+          }
+        }
+      end
+    ensure
+      DatabaseMethods.close_connection(schema)
+    end
+  }
+end

data/lib/anhpham/lib_web_steps.rb

@@ -0,0 +1,184 @@
+require_relative 'methods/required_files'
+# Navigate to a particular page
+Given(/^I am on the "([^"]*)" page$/) do |page|
+  execute_openbrowser(page)
+end
+
+#Navigating to the login page
+Given /^I am on Login Page$/ do
+  execute_openbrowser($_CFWEB['Page Address'])
+end
+
+# Wait for the specific time
+When /^I wait for (\d+) seconds$/ do |second|
+  sleep(second.to_i)
+end
+
+# Finds a button or link by id, text or value and clicks it
+And /^I click on "([^\"]*)"$/ do |object|
+  execute_click(object)
+end
+
+# Finds and clicks it with JS
+And /^I move mouse to element "([^\"]*)" then click$/ do |object|
+  execute_mousehoverandclick(object)
+end
+
+# Fill in a text box or text area with a value
+And /^I set text on "(.*?)" with "(.*?)"$/ do |object, text|
+  text = var_collect(text)
+  text = replace_pipe(text)
+  execute_settext(object, text)
+end
+
+# set state for check box, combo box
+And /^I set state on "(.*?)" with "(.*?)"$/ do |object, state|
+  execute_setstate(object, state)
+end
+
+# Input data to text box, this function support in case user want to input data into many text boxes on the same time
+When /^I input data to web form with following values:$/ do |value|
+  records = Util.read_table_data_from_steps_with_header(value.raw)
+  records = JSON.parse(JSON.generate(records))
+  records.each { |rows|
+    rows.each { |col, val|
+      step %{I set text on "#{col}" with "#{val}"}
+    }
+  }
+end
+
+When /^I run the following steps?:$/ do |steps_table|
+  steps = steps_table.raw.flatten
+  steps.each do |step|
+    call_step step
+  end
+end
+
+When /^I click on following elements:$/ do |object|
+  object.raw.each do |lines|
+    lines.each do |line|
+      step %{I click on "#{line}"}
+    end
+  end
+end
+
+Then /^I run following steps in iframe (index|name) (.*):$/ do |frame_type, frame, step_table|
+  case frame_type.to_sym
+    when :index
+      steps = step_table.raw.flatten
+      browser = page.driver.browser
+      browser.switch_to.frame(frame.to_i)
+      steps.each do |step|
+        call_step step
+      end
+      browser.switch_to.default_content
+    when :name
+      browser = page.driver.browser
+      browser.switch_to.frame(frame.to_s)
+      steps.each do |step|
+        call_step step
+      end
+      browser.switch_to.default_content
+  end
+end
+
+# get text for object
+And /^I get text on "(.*?)" then store it into file "(.*)"$/ do |object, file_name|
+  $text = execute_gettext(object)
+  open($test_data_dir+file_name, 'a+') do |f|
+    f << $text + "\n"
+  end
+end
+
+# Fill in a text box or text area with a value from $test_data_dir file
+And /^I set text on "(.*?)" with value from file "(.*)"$/ do |object, file_name|
+  expected_file= ($test_data_dir + file_name)
+  if File.exist?(expected_file)
+    # data_file = File.read(expected_file)
+    data_file = read_file(expected_file)
+    execute_settext(object, data_file)
+    # data_file.each_line do |line|
+    #   execute_settext(object, line)
+    # end
+  else
+    raise "*** ERROR: File #{file_name} is not existed!"
+  end
+end
+
+# Upload new file windows
+When /^I click on "(.*?)" to upload file "(.*?)"$/ do |object, file_name|
+  execute_click_to_upload(object, file_name)
+end
+
+# Drag mouse hover on element
+When /^I move mouse to element "(.*?)"$/ do |element|
+  execute_hover_mouse_on(element)
+end
+
+And /^I click on "(.*?)" and wait (\d+) seconds$/ do |object, seconds|
+  execute_click(object)
+  sleep(seconds.to_i)
+end
+
+And /^I drag object "(.*?)" to "(.*?)"$/ do |from_object, object|
+  execute_drag_to_new_object(from_object, object)
+end
+
+# And /^I test$/ do
+#   es_data = File.read("C:/Users/Anh Pham/Desktop/testdata_ES_ruby.txt")
+#   data = JSON.parse(es_data)
+#   data['hits']['hits'].each do |child|
+#     replaced_value = child['_source']['timestamp'].gsub("Oct", "2015-10-").gsub!(/\s+/, "").insert(10, 'T')+ ".112Z"
+#     new_value = child.to_s.gsub(child['_source']['@timestamp'], "\""+replaced_value+"\"")
+#     open("D:/IFD Project Automation/Master Branch/features/MYM/Data/test.txt", 'a+') do |f|
+#       f << new_value + "\n"
+#     end
+#   end
+# end
+
+And /^I type to "(.*)" key is "(.*?)"$/ do |object, keys|
+  keys = var_collect(keys)
+  execute_sendkeys(object, keys)
+end
+
+# Click on ID of link or text of link
+When /^I click on "([^\"]*)" link$/ do |link|
+  click_link link
+end
+
+# Upload file
+When /^I attach the file "(.*)" to "(.*)"$/ do |filename, field|
+  filepath = File.join($base_dir, filename)
+  if filepath.match(/^C:\//)
+    filepath.gsub!(/\//, '\\')
+  end
+  attach_file(field, filepath)
+end
+
+# double click on web element
+Then(/^I double click on element "(.*?)"$/) do |element|
+  double_click(element)
+end
+
+# step to resize browser
+Then(/^I resize browser window size to width (\d+) and height (\d+)$/) do |width, heigth|
+  resize_browser(width, heigth)
+end
+
+# step to maximize browser
+Then(/^I maximize browser window$/) do
+  maximize_browser
+end
+
+Then(/^I switch to window having title "(.*?)"$/) do |window_title|
+  switch_to_window_by_title window_title
+end
+
+Then(/^I take screenshot$/) do
+  take_screenshot
+end
+
+# steps to scroll web page to top or end
+Then(/^I scroll to (top|end) of page$/) do |to|
+  scroll_page(to)
+end

data/lib/anhpham/lib_webservice_steps.rb

@@ -0,0 +1,44 @@
+require 'nokogiri'
+require_relative 'methods/required_files'
+# Send POST XML request with data in $test_data_dir
+When /^I send a POST XML request to "(.*?)" with the following file "(.*?)"$/ do |type, file|
+  file = Util.bind_with_dyn_vars(file)
+  url = Util.bind_with_dyn_vars($WS_URL)
+  # url=$WS_URL
+  data = File.read($test_data_dir + file)
+  $result=IFD_WS.send_XML_post_webservice(url,type,data)
+end
+# Verify XML response with data is table format
+Then /^The XML response of "(.*)" should be the following:$/ do |xpath,table|
+  data = table.raw
+  expected_result=data[0][0]
+  data = Nokogiri::XML.parse($result).remove_namespaces!
+  actual_result= data.xpath(xpath).to_s
+  # puts expected_result.to_s
+  puts actual_result.to_s
+  # Do assert with the different size of xml
+  IFD_Assertion.assert_string_equal(expected_result,actual_result)
+end
+# Send POST XML request with template in $test_data_dir and condition is table format
+When /^I send a POST XML request to "(.*?)" with file template "(.*?)" and following conditions:$/ do |type, file, data_table|
+  file = Util.bind_with_dyn_vars(file)
+  url = Util.bind_with_dyn_vars($WS_URL)
+  data = File.read($test_data_dir + file)
+  raw_data = JSON.parse(JSON.generate(data_table))
+  header = raw_data[0]
+  value = raw_data[1]
+  i = 0
+  header.zip(value).each do |headers, values|
+    value_condition = Nokogiri::XML.parse(data).xpath("//"+headers).to_s
+    tag_value= value_condition[/.*\>(.*?)</, 1]
+    $new_value = value_condition.gsub(tag_value, values)
+    if i>0 then
+      $data_new= $data_new.gsub(value_condition, $new_value)
+    else
+      $data_new=data.gsub(value_condition, $new_value)
+    end
+    i = i+1
+  end
+  $result=IFD_WS.send_XML_post_webservice(url, type, $data_new)
+end
+

data/lib/anhpham/methods/IFD_Assertion_methods.rb

@@ -0,0 +1,206 @@
+include Test::Unit::Assertions
+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

data/lib/anhpham/methods/IFD_Connection.rb

@@ -0,0 +1,28 @@
+require 'mysql2'
+require 'tiny_tds'
+
+class IFD_Connections
+  # Open the  MYSQL connection to specific schema
+  def self.get_mysql_db_connection(schema)
+    begin
+      # puts ("Connecting to database...");
+      data_source_schema = schema.downcase
+      return Mysql2::Client.new(host: $data_source_url, username: $data_source_username, password: $data_source_password,database:data_source_schema);
+    rescue Exception => e
+      raise "Cannot connect to database [username: %s; password: %s, dbUrl: %s, dbName: %s] with error %s" %
+                [$data_source_username, $data_source_password, $data_source_url,data_source_schema, e.message]
+    end
+  end
+
+  # Open the  SQL Server connection to specific schema
+  def self.get_sql_server_db_connection(schema)
+    begin
+      # puts ("Connecting to database...");
+      data_source_schema = schema.downcase
+      return TinyTds::Client.new(dataserver: $data_source_url, username: $data_source_username, password: $data_source_password, database:data_source_schema);
+    rescue Exception => e
+      raise "Cannot connect to database [username: %s; password: %s, dbUrl: %s, dbName: %s] with error %s" %
+                [$data_source_username, $data_source_password, $data_source_url,data_source_schema, e.message]
+    end
+  end
+end

data/lib/anhpham/methods/IFD_email_methods.rb

@@ -0,0 +1,16 @@
+require 'mail'
+require 'email_spec'
+# include EmailSpec::Helpers
+# include EmailSpec::Matcher
+class IFD_Email < ActionMailer::Base
+  def self.send_email(to_address, subject, body_email)
+    include Mail::Matchers
+    # Mail::TestMailer.deliveries.clear
+    Mail.deliver do
+      from $SEND_EMAIL_USERNAME
+      to to_address
+      subject subject
+      body body_email
+    end
+  end
+end

data/lib/anhpham/methods/IFD_webservice.rb

@@ -0,0 +1,17 @@
+class IFD_WS
+
+  def self.send_XML_post_webservice(host,type,data)
+    url = "#{host}/#{type}"
+    puts url
+    WebServiceMethods.send_XML_post_request(url,data)
+  end
+
+  def self.send_get_MYM_webservice(host,type,data)
+    url = "#{host}/#{type}?#{data}"
+    WebServiceMethods.send_get_request(url)
+  end
+
+end
+
+
+