bucky-core 0.9.0

data/lib/bucky/test_equipment/test_case/linkstatus_test_case.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require_relative '../verifications/status_checker'
+require_relative './abst_test_case'
+
+module Bucky
+  module TestEquipment
+    module TestCase
+      class LinkstatusTestCase < Bucky::TestEquipment::TestCase::AbstTestCase
+        include Bucky::TestEquipment::Verifications::StatusChecker
+
+        class << self
+          def startup; end
+
+          def shutdown; end
+        end
+
+        def setup; end
+
+        def teardown
+          # Call abst_test_case.teardown to get elappsed time of every test case
+          super
+        end
+      end
+    end
+  end
+end

data/lib/bucky/test_equipment/user_operation/user_operation_helper.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Bucky
+  module TestEquipment
+    module UserOperation
+      class UserOperationHelper
+        def initialize(args)
+          @app = args[:app]
+          @device = args[:device]
+          @driver = args[:driver]
+          @pages  = args[:pages]
+        end
+
+        # Open url
+        # @param [Hash]
+        def go(args)
+          @driver.navigate.to args[:url]
+        end
+
+        def back(_)
+          @driver.navigate.back
+        end
+
+        def input(args)
+          @pages.get_part(args).send_keys args[:word]
+        end
+
+        # Clear textbox
+        def clear(args)
+          @pages.get_part(args).clear
+        end
+
+        def click(args)
+          elem = @pages.get_part(args)
+          elem.location_once_scrolled_into_view
+          sleep 1
+          elem.click
+        end
+
+        def refresh(_)
+          @driver.navigate.refresh
+        end
+
+        def switch_next_window(_)
+          @driver.switch_to.window(@driver.window_handles.last)
+        end
+
+        def back_to_window(_)
+          @driver.switch_to.window(@driver.window_handles.first)
+        end
+
+        # Close window
+        def close(_)
+          @driver.close
+        end
+
+        def stop(_)
+          puts 'stop. please enter to continue'
+          gets
+        end
+
+        def choose(args)
+          option = Selenium::WebDriver::Support::Select.new(@pages.get_part(args))
+          if args.key?(:text)
+            type = :text
+            selected = args[type].to_s
+          elsif args.key?(:value)
+            type = :value
+            selected = args[type].to_s
+          elsif args.key?(:index)
+            type = :index
+            selected = args[type].to_i
+          else
+            raise StandardError, "Included invalid key #{args.keys}"
+          end
+          option.select_by(type, selected)
+        end
+
+        # Alert accept
+        def accept_alert(_)
+          a = @driver.switch_to.alert
+          a.accept
+        end
+
+        def wait(args)
+          # Indent
+          print ' ' * 6
+          args[:sec].times do |count|
+            print "#{count + 1} "
+            sleep 1
+          end
+          puts ''
+        end
+      end
+    end
+  end
+end

data/lib/bucky/test_equipment/user_operation/user_operation_logger.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Bucky
+  module TestEquipment
+    module UserOperation
+      class UserOperationLogger
+        class << self
+          def get_user_opr_log(op_args)
+            op_args.to_s << "\n"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bucky/test_equipment/user_operation/user_operator.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative '../../core/exception/bucky_exception'
+require_relative './user_operation_helper'
+require_relative '../../utils/bucky_logger'
+
+module Bucky
+  module TestEquipment
+    module UserOperation
+      class UserOperator
+        include Bucky::Utils::BuckyLogger
+
+        def initialize(args)
+          @operation_helper = Bucky::TestEquipment::UserOperation::UserOperationHelper.new(args)
+          @pages = args[:pages]
+        end
+
+        # Call user operation by argument
+        # @param [String] operation
+        # @param [String] test_case_name
+        # @param [Hash] args
+        def method_missing(operation, test_case_name, **args)
+          @operation = operation
+          @test_case_name = test_case_name
+          Bucky::Utils::BuckyLogger.write(test_case_name, args)
+
+          # Call method of UserOperationHelper
+          return @operation_helper.send(@operation, args) if @operation_helper.methods.include?(@operation)
+
+          # Call method of page object
+          # e.g) {page: 'top', operation: 'input_freeword', word: 'testing word'}
+          return page_method(args) if args.key?(:page) && !args.key?(:part)
+
+          # Call method of part
+          part_mothod(args) if args.key?(:part)
+        rescue StandardError => e
+          Bucky::Core::Exception::WebdriverException.handle(e)
+        end
+
+        private
+
+        def page_method(args)
+          @pages.send(args[:page]).send(@operation, args)
+        end
+
+        def part_mothod(args)
+          # Multiple parts is saved as hash
+          # e.g){page: 'top', part: {locate: 'rosen_tokyo', num: 1}, operate: 'click'}
+          if args[:part].class == Hash
+            part_name = args[:part][:locate]
+            num = args[:part][:num]
+            @pages.send(args[:page]).send(part_name)[num].send(@operation)
+          # e.g.){page: 'top', part: 'rosen_tokyo', operate: 'click'}
+          else
+            @pages.send(args[:page]).send(args[:part]).send(@operation)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bucky/test_equipment/verifications/abst_verification.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'test/unit'
+
+module Bucky
+  module TestEquipment
+    module Verifications
+      class AbstVerification
+        include Test::Unit::Assertions
+      end
+    end
+  end
+end

data/lib/bucky/test_equipment/verifications/e2e_verification.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative '../../utils/bucky_logger'
+require_relative '../../utils/bucky_output'
+require_relative './abst_verification'
+require_relative '../evidence/evidence_generator'
+
+module Bucky
+  module TestEquipment
+    module Verifications
+      class E2eVerification < Bucky::TestEquipment::Verifications::AbstVerification
+        include Bucky::Utils::BuckyLogger
+        include Bucky::Utils::BuckyOutput
+        using StringColorize
+
+        def initialize(driver, pages, test_case_name)
+          @driver = driver
+          @pages = pages
+          @evidence = Bucky::TestEquipment::Evidence::E2eEvidence.new(driver: driver, test_case: test_case_name)
+        end
+
+        def pages_getter
+          @pages
+        end
+
+        # Check whether title of web page matches expected value
+        # @param [Hash]
+        def assert_title(**args)
+          Bucky::Utils::BuckyLogger.write('assert_title', args)
+          verify_rescue { assert_equal(args[:expect]&.to_s, @driver.title, 'Not Expected Title.') }
+        end
+
+        # Check whether text of web element matches expected value
+        # @param [Hash]
+        def assert_text(**args)
+          Bucky::Utils::BuckyLogger.write('assert_text', args)
+          part = @pages.get_part(args)
+          verify_rescue { assert_equal(args[:expect]&.to_s, part.text, 'Not Expected Text.') }
+        end
+
+        # Check whether text of web element contains expected value
+        # @param [Hash]
+        def assert_contained_text(**args)
+          Bucky::Utils::BuckyLogger.write('assert_contained_text', args)
+          part = @pages.get_part(args)
+          verify_rescue { assert(part.text.include?(args[:expect]&.to_s), "Not Contain Expected Text.\nexpect: #{args[:expect].to_s.bg_green.black}\nactual: #{part.text.to_s.bg_red.black}") }
+        end
+
+        # Check whether url contains excepted value
+        # @param [Hash]
+        def assert_contained_url(**args)
+          Bucky::Utils::BuckyLogger.write('assert_contained_url', args)
+          verify_rescue { assert(@driver.current_url.include?(args[:expect]&.to_s), "Not Contain Expected URL.\nexpect:  #{args[:expect].to_s.bg_green.black}\nactual: #{@driver.current_url.to_s.bg_red.black}") }
+        end
+
+        # Check whether attribute of web element contains excepted value.
+        # @param [Hash]
+        def assert_contained_attribute(**args)
+          Bucky::Utils::BuckyLogger.write('assert_contained_attribute', args)
+          part = @pages.get_part(args)
+          verify_rescue { assert(part[args[:attribute]].include?(args[:expect]&.to_s), "Not Contain Expected Attribute.\nexpect: #{args[:expect].to_s.bg_green.black}\nactual: #{part[args[:attribute]].to_s.bg_red.black}") }
+        end
+
+        # Check whether text of part is number
+        # @param [Hash]
+        def assert_is_number(**args)
+          Bucky::Utils::BuckyLogger.write('assert is number', args)
+          text = @pages.get_part(args).text.sub(',', '')
+          verify_rescue { assert(text.to_i.to_s == text.to_s, "Not number.\nactual: #{text.bg_red.black}") }
+        end
+
+        # Check whether style property includes display:block
+        # @param [Hash]
+        def assert_display(**args)
+          Bucky::Utils::BuckyLogger.write('assert display', args)
+          verify_rescue { assert_true(@pages.get_part(args).displayed?, "No display this parts.\nURL: #{@driver.current_url}\npage: #{args[:page]}\npart: #{args[:part]}") }
+        end
+
+        # Check whether web element exists
+        # @param [Hash]
+        def assert_exist_part(**args)
+          Bucky::Utils::BuckyLogger.write('assert_exist_part', args)
+          verify_rescue { assert_true(@pages.part_exist?(args), "This part is not exist.\nURL: #{@driver.current_url}\npage: #{args[:page]}\npart: #{args[:part]}") }
+        end
+
+        # Check whether web element don't exist
+        # @param [Hash]
+        def assert_not_exist_part(**args)
+          Bucky::Utils::BuckyLogger.write('assert_not_exist_part', args)
+          verify_rescue { assert_false(@pages.part_exist?(args), "This part is exist.\nURL: #{@driver.current_url}\npage: #{args[:page]}\npart: #{args[:part]}") }
+        end
+
+        private
+
+        # Common exception method
+        # @param [Method] &assert
+        def verify_rescue
+          yield
+        rescue StandardError => e
+          @evidence.save_evidence(e)
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/bucky/test_equipment/verifications/js_error_checker.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'test/unit'
+
+module Bucky
+  module TestEquipment
+    module Verifications
+      module JsErrorChecker
+        include Test::Unit::Assertions
+
+        # Check Javascript Error in page
+        # @param [Webdriver] driver
+        def assert_no_js_error(driver)
+          js_errors = driver.execute_script(
+            'return window.JSErrorCollector_errors ? window.JSErrorCollector_errors.pump() : []'
+          )
+          # Empty is ok
+          assert_empty(js_errors, '[JS Error]')
+        end
+      end
+    end
+  end
+end

data/lib/bucky/test_equipment/verifications/service_verifications.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative '../verifications/e2e_verification'
+
+module Bucky
+  module TestEquipment
+    module Verifications
+      class ServiceVerifications
+        attr_reader :e2e_verification
+
+        # @param [String] @service
+        # @param [String] @device (pc, sp)
+        # @param [Selenium::WebDriver::Remote::Driver] @driver
+        # @param [Bucky::TestEquipment::PageObject::Pages] @pages
+        # @param [String] @test_case_name
+        def initialize(args)
+          @service = args[:service]
+          @device = args[:device]
+          @driver = args[:driver]
+          @pages = args[:pages]
+          @test_case_name = args[:method_name]
+          collect_verifications
+          @e2e_verification = Bucky::TestEquipment::Verifications::E2eVerification.new(@driver, @pages, @test_case_name)
+        end
+
+        def method_missing(verification, **args)
+          if e2e_verification.respond_to? verification
+            puts "    #{verification} is defined in E2eVerificationClass."
+            e2e_verification.send(verification, args)
+          elsif args.key?(:page)
+            send(args[:page]).send(verification, args)
+          else
+            raise StandardError, "Undefined verification method or invalid arguments. #{verification},#{args}"
+          end
+        rescue StandardError => e
+          raise e
+        end
+
+        private
+
+        # Load page and define page verification method
+        def collect_verifications
+          module_service_name = @service.split('_').map(&:capitalize).join
+          Dir.glob("#{$bucky_home_dir}/services/#{@service}/#{@device}/verifications/*.rb").each do |file|
+            require file
+
+            page_name = file.split('/')[-1].sub('.rb', '')
+            page_class_name = page_name.split('_').map(&:capitalize).join
+
+            # Get instance of page object
+            page_class = eval(format('Services::%<module_service_name>s::%<device>s::Verifications::%<page_class_name>s', module_service_name: module_service_name, device: @device.capitalize, page_class_name: page_class_name))
+            page_instance = page_class.new(@driver, @pages, @test_case_name)
+
+            self.class.class_eval do
+              define_method(page_name) { page_instance }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bucky/test_equipment/verifications/status_checker.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require 'test/unit'
+require 'nokogiri'
+require 'parallel'
+require_relative '../../utils/requests'
+require_relative '../../utils/config'
+
+REDIRECT_LIMIT = 5
+
+# Check http status code from response
+#   2xx -> OK
+#   3xx -> request again
+#   4xx~5xx -> NG
+
+module Bucky
+  module TestEquipment
+    module Verifications
+      module StatusChecker
+        include Test::Unit::Assertions
+        include Bucky::Utils::Requests
+
+        # Check http status code
+        # @param [String] url
+        # @return [String] message
+        def http_status_check(args)
+          url = args[:url]
+          device = args[:device]
+          link_check_max_times = args[:link_check_max_times]
+          url_log = args[:url_log]
+          redirect_count = args[:redirect_count]
+          redirect_url_list = args[:redirect_url_list]
+
+          # If number of requests is over redirect limit
+          return { error_message: "\n[Redirect Error] #{url} is redirected more than #{REDIRECT_LIMIT}" } if redirect_count > REDIRECT_LIMIT
+
+          check_result = check_log_and_get_response(url, device, link_check_max_times, url_log)
+          # If result include response continue to check, else return result
+          !check_result.key?(:response) ? (return check_result) : response = check_result[:response]
+
+          # Store original url
+          redirect_url_list << url
+          case response.code
+          when /2[0-9]{2}/
+            url_log[url][:entity] = response.entity
+            puts "  #{url} ...  [#{response.code}:OK]"
+            { entity: response.entity }
+          when /3[0-9]{2}/
+            fqdn = url[%r{^(https?:\/\/([a-zA-Z0-9\-_.]+))}]
+            redirect_url = response['location']
+            # Add fqdn if location doesn't include fqdn
+            redirect_url = fqdn << redirect_url unless redirect_url.include?('http')
+            puts "  #{url} ... redirect to #{redirect_url} [#{response.code}:RD]"
+            http_status_check_args = { url: redirect_url, device: device, link_check_max_times: link_check_max_times, url_log: url_log, redirect_count: redirect_count + 1, redirect_url_list: redirect_url_list }
+            http_status_check(http_status_check_args)
+          when /(4|5)[0-9]{2}/
+            url_log[url][:error_message] = "[Status Error] http status returned #{response.code}.\ncheck this url: #{redirect_url_list.join(' -> ')}"
+            puts "  #{url} ...  [#{response.code}:NG]"
+            { error_message: url_log[url][:error_message] }
+          else
+            url_log[url][:error_message] = "[Status Code Invalid Error] Status Code is Invalid. \n Status:#{response.code}"
+            { error_message: url_log[url][:error_message] }
+          end
+        end
+
+        def link_status_check(args)
+          url = args[:url]
+          device = args[:device]
+          exclude_urls = args[:exclude_urls]
+          link_check_max_times = args[:link_check_max_times]
+          url_log = args[:url_log]
+          only_same_fqdn = args[:only_same_fqdn] ||= true
+
+          # Extract base url and check if it is valid
+          url_reg = %r{^(https?://([a-zA-Z0-9\-_.]+))}
+          url_obj = url.match(url_reg)
+          raise "Invalid URL #{url}" unless url_obj
+
+          base_url  = url_obj[1]
+          base_fqdn = url_obj[2]
+
+          # Check base url
+          http_status_check_args = { url: url, device: device, link_check_max_times: link_check_max_times, url_log: url_log, redirect_count: 0, redirect_url_list: [] }
+          base_response = http_status_check(http_status_check_args)
+          assert_nil(base_response[:error_message], "Response of base URL is incorrect.\n#{base_response[:error_message]}")
+
+          # Collect links
+          links_args = { base_url: base_url, base_fqdn: base_fqdn, url_reg: url_reg, only_same_fqdn: only_same_fqdn, entity: base_response[:entity] }
+          links = make_target_links(links_args)
+          links = exclude(links, exclude_urls) unless exclude_urls.nil?
+
+          errors = []
+          Parallel.each(links.uniq, in_threads: Bucky::Utils::Config.instance[:linkstatus_parallel_num]) do |link|
+            http_status_check_args[:url] = link
+            http_status_check_args[:redirect_url_list] = []
+            link_response = http_status_check(http_status_check_args)
+            errors << link_response[:error_message] if link_response[:error_message]
+          end
+          assert_empty(errors, errors.join("\n"))
+        end
+
+        def make_target_links(args)
+          base_url = args[:base_url]
+          base_fqdn = args[:base_fqdn]
+          url_reg = args[:url_reg]
+          only_same_fqdn = args[:only_same_fqdn]
+          entity = args[:entity]
+          doc = Nokogiri::HTML.parse(entity)
+          links = []
+          doc.xpath('//a').each do |node|
+            href = node.attr('href')
+            next if exclude_href?(href)
+
+            # Add fqdn if href doesn't include fqdn
+            unless url_reg.match?(href)
+              links << base_url + href
+              next
+            end
+
+            href_fqdn = href.match(url_reg)[2]
+            if only_same_fqdn == false
+              links << href
+            elsif base_fqdn == href_fqdn
+              links << href
+            end
+          end
+          links
+        end
+
+        # Exclude non test target url
+        def exclude(links, exclude_urls)
+          excluded_links = links - exclude_urls
+
+          # Exclude url if it has "*" in the last of it
+          exclude_urls.each do |ex_url|
+            next unless ex_url.end_with?('*')
+
+            excluded_links.delete_if { |l| l.start_with?(ex_url.delete('*')) }
+          end
+
+          excluded_links
+        end
+
+        private
+
+        def exclude_href?(href)
+          return true if href.nil?
+
+          exclude_regexps = [/^javascript.+/, /^tel:\d.+/, /^mailto:.+/]
+          exclude_regexps.keep_if { |reg| reg.match?(href) }
+          return true unless exclude_regexps.empty?
+
+          false
+        end
+
+        # Check result hash and submit request or return result.
+        # Return: 1.(if request submitted) respons 2. (code 2xx)entity 3. (reach max check times)error message
+        def check_log_and_get_response(url, device, link_check_max_times, url_log)
+          unless url_log.key?(url)
+            response = get_response(url, device, Bucky::Utils::Config.instance[:linkstatus_open_timeout], Bucky::Utils::Config.instance[:linkstatus_read_timeout])
+            url_log[url] = { code: response.code, entity: nil, error_message: nil, count: 1 }
+            return { response: response }
+          end
+
+          if url_log[url][:code].match?(/2[0-9]{2}/)
+            puts "  #{url} is already [#{url_log[url][:code]}:OK]"
+            return { entity: url_log[url][:entity] }
+          elsif url_log[url][:count] >= link_check_max_times
+            puts "  #{url} reach maximum check times [#{url_log[url][:code]}:NG]"
+            return { error_message: url_log[url][:error_message] }
+          else
+            response = get_response(url, device, Bucky::Utils::Config.instance[:linkstatus_open_timeout], Bucky::Utils::Config.instance[:linkstatus_read_timeout])
+            url_log[url][:count] += 1
+            return { response: response }
+          end
+        end
+      end
+    end
+  end
+end