taf 0.3.7 → 0.3.8

data/lib/taf/my_log.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# Created on 04 Feb 2019
+# @author: Andy Perrett
+#
+# Versions:
+# 1.0 - Baseline
+module Taf
+  # logger.rb - logger file
+  # Logger function.
+  module MyLog
+    def self.log
+      if @logger.nil?
+        @logger = Logger.new STDOUT
+        @logger.level = Logger::DEBUG
+        @logger.datetime_format = '%Y-%m-%d %H:%M:%S '
+      end
+      @logger
+    end
+  end
+end

data/lib/taf/parser.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Created on 02 Aug 2018
+# @author: Andy Perrett
+#
+# Versions:
+# 1.0 - Baseline
+#
+module Taf
+  # parser.rb - basic parser functions
+  module Parser
+    def self.test_files
+      @test_files ||= Dir.glob("#{Taf::CMDLine.tests_folder}/*.json")
+                         .reject do |file|
+        File.basename(file).start_with?('~$')
+      end.sort
+    end
+
+    # readTestData
+    def self.read_test_data(test_file_name)
+      # get the file type
+      file_type = File.extname(test_file_name)
+      file_type.casecmp('.json').zero?
+      Taf::MyLog.log.info "Processing test file: #{test_file_name}"
+      json = File.read(test_file_name)
+      parse_json = JSON.parse(json)
+
+      Taf::JSONParser.parse_test_header_data(parse_json)
+      parse_json
+    end
+
+    # parseTestStepData
+    def self.parse_test_step_data(parse_json)
+      Taf::JSONParser.parse_test_step_data(parse_json)
+    end
+  end
+end

data/lib/taf/report.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+# Created on 20 Sept 2017
+# @author: Andy Perrett
+#
+# Versions:
+# 1.0 - Baseline
+#
+module Taf
+  # report.rb - methods for outputting console.
+  module Report
+    # get the current time in the format Day - Month - Date - Time (HH:MM:SS)
+    def self.current_time
+      Time.new.strftime('%a %b %d %H:%M:%S %Z')
+    end
+
+    # print the test Step info to the test results file
+    def self.print_test_step_header(test_file_name, test_step_idx, test_desc)
+      @test_start_time = current_time
+      Taf::MyLog.log.info "Test step: #{test_step_idx} : #{test_desc}"
+
+      step = { 'id' => test_step_idx,
+               'classname' => "SuiteID: #{Taf::JSONParser.test_id}" \
+               " Test Step: #{test_step_idx} #{test_desc}",
+               'name' => test_desc,
+               'file' => test_file_name }
+
+      # output to console to show test step
+      # puts step
+
+      return unless test_file_name
+
+      $testStep_xml ||= {}
+      $testStep_xml[test_file_name] ||= {}
+      $testStep_xml[test_file_name][test_step_idx] = step
+    end
+
+    # print the Pass / Fail status of a test to the test results file
+    def self.test_pass_fail(pass_fail, test_file_name, test_step_idx, metrics)
+      if pass_fail == true
+        @current_test_fail = false
+        metrics.stepPasses += 1
+        Taf::MyLog.log.info "Test #{test_step_idx} has Passed ".green
+      elsif pass_fail == false
+        @current_test_fail = true
+        metrics.stepFailures += 1
+        Taf::MyLog.log.warn "Test #{test_step_idx} has FAILED ".red
+        sc_file_name = Taf::Screenshot.save_screenshot(test_step_idx)
+        failstep = {
+          'message' => "SuiteID: #{Taf::JSONParser.test_id}" \
+          " Test Step: #{test_step_idx} Test has" \
+           " FAILED - Check logs, see Screenshot: #{sc_file_name}",
+          'type' => 'FAILURE',
+          'file' => test_file_name
+        }
+        # output to console to show test step failure
+        # puts failstep
+
+        return unless test_file_name
+
+        $failtestStep_xml ||= {}
+        $failtestStep_xml[test_file_name] ||= []
+        $failtestStep_xml[test_file_name][test_step_idx] = failstep
+      else
+        @current_test_fail = false
+        metrics.stepSkipped += 1
+        Taf::MyLog.log.info "Test #{test_step_idx} no checks performed ".blue
+        skipstep = {
+          'message' => "SuiteID: #{Taf::JSONParser.test_id}" \
+          " Test Step: #{test_step_idx} No" \
+            ' checks performed - Check logs',
+          'type' => 'SKIPPED',
+          'file' => test_file_name
+        }
+        # output to console to show test step failure
+        # puts skipstep
+
+        return unless test_file_name
+
+        $skiptestStep_xml ||= {}
+        $skiptestStep_xml[test_file_name] ||= []
+        $skiptestStep_xml[test_file_name][test_step_idx] = skipstep
+      end
+      test_end_time = current_time
+
+      test_duration = TimeDifference.between(
+        test_end_time, @test_start_time
+      ).humanize || 0
+      Taf::MyLog.log.info "Test step duration: #{test_duration} \n"
+    end
+
+    # check if the test failure threshold has been reached for total failures
+    # or consecutive failures.
+    # If a certain number of consecutive tests fail then throw an exception
+    def self.check_failure_threshold(test_file_name)
+      consecutive_fail_threshold = 3
+      if @current_test_fail
+        @consecutive_test_fail += 1
+      else
+        @consecutive_test_fail = 0
+      end
+
+      return if @consecutive_test_fail < consecutive_fail_threshold
+
+      raise Taf::FailureThresholdExceeded,
+            "Terminating the current test file: #{test_file_name} as the test" \
+            " failure threshold (#{@consecutive_test_fail}) has been reached."
+    end
+  end
+end

data/lib/taf/report_summary.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# Created on 20 Sept 2017
+# @author: Andy Perrett
+#
+# Versions:
+# 1.0 - Baseline
+#
+module Taf
+  # report_summary.rb - methods for writing to the test summary report file
+  module ReportSummary
+    # holds printable test report summary for all the executed tests
+    @test_step_report_summary = []
+    # output the test results summary for the current test case
+    def self.test_step_summary(test_file_name, test_file_name_index, metrics)
+      @test_step_report_summary[test_file_name_index] = <<~TEXT
+        Test file executed: #{test_file_name}
+        Browser Type: #{Taf::CMDLine.browser_type}
+        Browser Version: #{Taf::Browser.browser_version}
+        Browser Platform: #{Taf::Browser.browser_platform}
+        There are: #{metrics.stepPasses} Passes
+        There are: #{metrics.stepFailures} Failures
+        There are: #{metrics.stepSkipped} Skipped Tests \n
+      TEXT
+    end
+
+    # output the overall test results summary
+    def self.print_test_summary
+      # output to the console
+
+      Taf::MyLog.log.info 'Finished processing all test files ' \
+        "from the following test folder: #{Taf::CMDLine.tests_folder}"
+      Taf::MyLog.log.info "Overall Test Summary: \n"
+      @test_step_report_summary.each do |test_step_report_summary|
+        test_step_report_summary.each_line do |line|
+          Taf::MyLog.log.info(line.strip)
+        end
+      end
+    end
+
+    # output the overall test results summary
+    def self.overall_test_summary(ts_start_time, ts_end_time, total_metrics)
+      print_test_summary
+      t_time = TimeDifference.between(ts_end_time, ts_start_time).humanize || 0
+
+      Taf::MyLog.log.info "Total Tests started at: #{ts_start_time}"
+      Taf::MyLog.log.info "Total Tests finished at: #{ts_end_time}"
+      Taf::MyLog.log.info "Total Tests duration: #{t_time}"
+      Taf::MyLog.log.info "Total Tests Passed: #{total_metrics[0]}".green
+      Taf::MyLog.log.info "Total Tests Failed: #{total_metrics[1]}".red
+      Taf::MyLog.log.info "Total Tests Skipped: #{total_metrics[2]}".blue
+      total_tests = [total_metrics[0], total_metrics[1], total_metrics[2]].sum
+      Taf::MyLog.log.info "Total Tests: #{total_tests}\n"
+    end
+  end
+end

data/lib/taf/screenshot.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Created on 07 May 2019
+# @author: Andy Perrett
+#
+# Versions:
+# 1.0 - Baseline
+#
+module Taf
+  # screenshot.rb - a screenshot save function
+  module Screenshot
+    # create screenshot filename and save the screenshot if the test has failed.
+    def self.save_screenshot(test_step_idx)
+      time = Time.now.strftime('%H%M')
+      sc_dir = Taf::CreateDirectories.construct_testspecdirs
+
+      sc_file_name = "#{sc_dir}/Test_ID-#{Taf::JSONParser.test_id.delete(' ')}"\
+                        "_Test_step-#{test_step_idx}_Failed_#{time}.png"
+
+      # Screenshot capture for websites
+      Taf::Browser.b.screenshot.save sc_file_name
+      Taf::MyLog.log.info("Screenshot saved to: #{sc_file_name} \n")
+      sc_file_name
+    rescue StandardError => e
+      # construct the error message from custom text and the actual system
+      # error message (converted to a string).
+      Taf::MyLog.log.warn("Error saving the screenshot: #{sc_file_name}   #{e}")
+    end
+  end
+end

data/lib/taf/test_engine.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# Created on 20 Sept 2017
+# @author: Andy Perrett
+#
+# Versions:
+# 1.0 - Baseline
+#
+module Taf
+  # test_engine.rb - controls the iteration through the test suite and specs
+  module TestEngine
+    # process the test files to execute the tests
+    def self.process_testfiles
+      total_passes = 0
+      total_failures = 0
+      total_skipped = 0
+
+      # loop through all the available test files to execute the tests
+      Taf::Parser.test_files.each_with_index do |test_file_name, test_file_idx|
+        metrics = Struct.new(:stepPasses, :stepFailures, :stepSkipped)
+                        .new(0, 0, 0)
+
+        begin
+          # read in the test data
+          tests = Taf::Parser.read_test_data(test_file_name)
+          # if unable to read the test data, show the error and move onto the
+          # next file (if there is one)
+        rescue StandardError => e
+          Taf::MyLog.log.warn 'Terminating the current test spec: ' \
+                       "#{test_file_name} #{e}"
+          Taf::MyLog.log.info
+          '...continuing with the next test file (if there is one)'
+        end
+
+        # create project folders - these only need creating once per test suite
+        Taf::CreateDirectories.construct_projectdirs
+
+        # get the test case start time
+        tc_start = Taf::Report.current_time
+
+        Taf::Browser.open_browser
+
+        begin
+          tests['steps'].each_with_index do |test_step, test_step_idx|
+            test_step_idx += 1
+
+            parsed_steps = Taf::Parser.parse_test_step_data(test_step)
+
+            # process the test step data
+            Taf::TestSteps.process_test_steps(test_file_name, test_step_idx,
+                                              parsed_steps, metrics)
+          end
+        rescue Taf::TafError => e
+          warn e
+          Taf::MyLog.log.warn e
+        end
+
+        # get the test case end time
+        tc_end = Taf::Report.current_time
+
+        # output the test results summary for the current test case,
+        # pass in the test file number to save the summary against it's
+        # testfile
+        Taf::ReportSummary.test_step_summary(test_file_name, test_file_idx,
+                                             metrics)
+        Taf::JUnitReport.test_step_summary_xml(test_file_name, test_file_idx,
+                                               tc_start, tc_end, metrics)
+
+        # close the browser if created
+        Taf::Browser.b.quit
+
+        # record total passes and failures and reset the failure counters for
+        # the test steps
+        total_passes   += metrics.stepPasses
+        total_failures += metrics.stepFailures
+        total_skipped  += metrics.stepSkipped
+      end
+
+      [total_passes, total_failures, total_skipped]
+    end
+  end
+end

data/lib/taf/test_steps.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Created on 20 Sept 2017
+# @author: Andy Perrett
+#
+# Versions:
+# 1.0 - Baseline
+#
+module Taf
+  # test_steps.rb - process the required test step functions
+  module TestSteps
+    def self.handlers
+      @handlers ||= {}
+    end
+
+    # process the test step data by matching the test step functions and
+    # processing the associated data accordingly
+    def self.process_test_steps(test_file_name, test_step_idx, step_attributes,
+                                metrics)
+      # print the test step information
+      Taf::Report.print_test_step_header(test_file_name, test_step_idx,
+                                         step_attributes[:testdesc])
+      runtest = step_attributes[:skipTestCase]
+      step_function = step_attributes[:testFunction]
+      handler = handlers[step_function.to_s]
+
+      if handler.respond_to?(:perform)
+        func = handler.perform(step_attributes) if runtest == false
+        Taf::Report.test_pass_fail(func, test_file_name, test_step_idx, metrics)
+        Taf::Report.check_failure_threshold(test_file_name)
+        return true
+      else
+        Taf::MyLog.log.warn "\nUnable to match function: #{step_function}"
+        raise Taf::UnknownTestStep, "Unknown test step: #{step_function}"
+      end
+    end
+  end
+end

data/lib/taf/test_steps/handlers/base.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Taf
+  # Base Hanfer file to contain all shared login functions
+  module TestSteps
+    module Handlers
+      # All Login functions function.
+      class Base
+        def initialize(step_attributes)
+          @value =  step_attributes[:testvalue]
+          @value2 = step_attributes[:testvalue2]
+          @locate = step_attributes[:locate]
+          @locate2 = step_attributes[:locate2]
+        end
+
+        def self.register(name)
+          TestSteps.handlers[name.to_s] = self
+        end
+
+        def self.perform(*args)
+          new(*args).perform
+        end
+
+        def login_process(b_title, user_elm, pass_elm, user, pass)
+          if Taf::Browser.b.title.eql?(b_title)
+            Taf::Browser.b.text_field(id: user_elm).wait_until(&:exists?)
+                        .set user
+            Taf::Browser.b.text_field(id: pass_elm).wait_until(&:exists?)
+                        .set pass
+            button = 'Sign in' || 'Log in'
+            Taf::Browser.b.button(value: button).wait_until(&:exists?).click
+            sleep 1
+          else
+            Taf::MyLog.log.warn("User: #{user} has failed to log in.")
+          end
+        end
+
+        def login_check(b_title_sucess, user)
+          if Taf::Browser.b.title.eql?(b_title_sucess)
+            Taf::MyLog.log.info("User: #{user} has logged in successful.")
+            true
+          else
+            Taf::MyLog.log.warn("User: #{user} has failed to log in.")
+            false
+          end
+        end
+
+        def mem_word_check(user, b_title_sucess)
+          if Taf::Browser.b.title.eql?('Memorable word')
+            portal_mem_word(user, b_title_sucess)
+          elsif Taf::Browser.b.title.eql?(b_title_sucess)
+            Taf::MyLog.log.info("User: #{user} has logged in successful.")
+            true
+          else
+            Taf::MyLog.log.warn("User: #{user} has failed to log in.")
+            false
+          end
+        end
+
+        def portal_mem_word(user, b_title_sucess)
+          password = ENV['PORTAL_MEM']
+          nums = (1..256).to_a
+          found_mem_nums = nums.each_with_object([]) do |num_val, mem_word|
+            elm_id = "user_memorable_parts_#{num_val}"
+            mem_word.push(num_val) if Taf::Browser.b.select(id: elm_id).exist?
+          end.compact
+
+          array_password = password.split('')
+          array_password.map!(&:upcase)
+
+          found_mem_nums.each do |mem_num|
+            char = array_password[(mem_num - 1)]
+            elm_id = "user_memorable_parts_#{mem_num}"
+            Taf::Browser.b.select_list(id: elm_id).option(value: char.to_s)
+                        .select
+          end
+
+          Taf::Browser.b.button(value: 'Sign in').wait_until(&:exists?).click
+          if Taf::Browser.b.title.eql?(b_title_sucess)
+            Taf::MyLog.log.info("User: #{user} has logged in successful.")
+            return true
+          else
+            Taf::MyLog.log.warn("User: #{user} has failed to log in.")
+            return false
+          end
+        end
+      end
+    end
+  end
+end