bucky-core 0.9.0

data/lib/bucky/core/test_core/test_manager.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'parallel'
+require_relative '../test_core/test_case_loader'
+require_relative '../../utils/config'
+require_relative './test_class_generator'
+
+module Bucky
+  module Core
+    module TestCore
+      class TestManager
+        # Keep test conditions and round number
+        def initialize(test_cond)
+          @test_cond = test_cond
+          @re_test_count = @test_cond[:re_test_count]
+          @tdo = Bucky::Core::Database::TestDataOperator.new
+          @start_time = Time.now
+          $job_id = @tdo.save_job_record_and_get_job_id(@start_time, @test_cond[:command_and_option])
+        end
+
+        def run
+          execute_test
+        end
+
+        # Rerun by job id
+        def rerun
+          rerun_job_id = @test_cond[:job]
+          $round = @tdo.get_last_round_from_job_id(rerun_job_id)
+          @test_cond[:re_test_cond] = @tdo.get_ng_test_cases_at_last_execution(
+            is_error: 1, job_id: rerun_job_id, round: $round
+          )
+          execute_test
+        end
+
+        private
+
+        # Load test suite from test code.
+        def load_test_suites
+          test_suite_data = Bucky::Core::TestCore::TestCaseLoader.load_testcode(@test_cond)
+          raise StandardError, "\nThere is no test case!\nPlease check test condition." if test_suite_data.empty?
+
+          @tdo.update_test_suites_data(test_suite_data)
+          @tdo.add_suite_id_to_loaded_suite_data(test_suite_data)
+        end
+
+        # Generate and execute test
+        def do_test_suites(test_suite_data)
+          # For checking on linkstatus
+          link_status_url_log = {}
+          tcg = Bucky::Core::TestCore::TestClassGenerator.new(@test_cond)
+          Parallel.each(test_suite_data, in_processes: Bucky::Utils::Config.instance[:parallel_num]) do |data|
+            tcg.generate_test_class(data, link_status_url_log)
+          end
+        end
+
+        def execute_test
+          @re_test_count.times do |i|
+            $round = i + 1
+            test_suite_data = load_test_suites
+            do_test_suites(test_suite_data)
+            @test_cond[:re_test_cond] = @tdo.get_ng_test_cases_at_last_execution(
+              is_error: 1, job_id: $job_id, round: $round
+            )
+            break if @test_cond[:re_test_cond].empty?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bucky/core/test_core/test_result.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require 'json'
+require 'test/unit/testresult'
+
+require_relative '../database/test_data_operator'
+
+module Bucky
+  module Core
+    module TestCore
+      class TestResult
+        include Singleton
+
+        attr_accessor :result
+
+        def initialize
+          @result = Test::Unit::TestResult.new
+          @tdo = Bucky::Core::Database::TestDataOperator.new
+        end
+
+        # Save test result
+        # @param [Array] added_result_info
+        def save(added_result_info)
+          # Format data before saving to database.
+          test_suite_result = format_result_summary(added_result_info)
+          @tdo.save_test_result(test_suite_result)
+        end
+
+        private
+
+        # Return Bucky::Test::Unit::TestResult Object
+        # @param [Array] added_result_info
+        # @return [Array] Array data for Sequel
+        def format_result_summary(added_result_info)
+          # For sequel
+          data_set = {}
+          error_test_case_name = []
+
+          ##############################################
+          # Store failed cases in data set. #
+          ##############################################
+          @result.faults.each do |fault|
+            case_name = fault.method_name
+            case_id = @tdo.get_test_case_id(added_result_info[case_name.to_sym][:test_suite_id], added_result_info[case_name.to_sym][:case_name])
+            error_test_case_name.push(case_name.to_sym)
+            data_set[case_name] =
+              [
+                id = nil,
+                test_case_id = case_id,
+                error_title = fault.message,
+                error_message = fault.location.join("\n"),
+                elapsed_time = added_result_info[case_name.to_sym][:elapsed_time],
+                is_error = 1,
+                job_id = $job_id,
+                round = $round
+              ]
+          end
+
+          ############################################
+          # Store passed cases in data set. #
+          ############################################
+          added_result_info.delete_if { |k, _v| error_test_case_name.include?(k) }
+          added_result_info.each do |case_name, added_info|
+            case_id = @tdo.get_test_case_id(added_info[:test_suite_id], added_info[:case_name])
+            data_set[case_name] =
+              [
+                id = nil,
+                test_case_id = case_id,
+                error_title = '',
+                error_message = '',
+                elapsed_time = added_info[:elapsed_time],
+                is_error = 0,
+                job_id = $job_id,
+                round = $round
+              ]
+          end
+
+          # Data set for sequel
+          data_set_ary = data_set.map { |_, v| v }
+
+          # Table colomn
+          column_name_ary = %i[id test_case_id error_title error_message elapsed_time is_error job_id round]
+          {
+            column: column_name_ary,
+            data_set: data_set_ary
+          }
+        end
+      end
+    end
+  end
+end

data/lib/bucky/test_equipment/evidence/evidence_generator.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative '../../core/report/screen_shot_generator'
+require_relative '../../utils/bucky_logger'
+
+module Bucky
+  module TestEquipment
+    module Evidence
+      class EvidenceGenerator
+        include Bucky::Utils::BuckyLogger
+
+        # Save log
+        # @param [String] file
+        # @param [Exception Object] err
+        def report(file, err)
+          Bucky::Utils::BuckyLogger.write(file, err)
+        end
+      end
+
+      # Create evidence for each test category
+      class E2eEvidence < EvidenceGenerator
+        include Bucky::Core::Report::ScreenShotGenerator
+
+        def initialize(**evid_args)
+          @driver = evid_args[:driver]
+          @tc = evid_args[:test_case]
+        end
+
+        def save_evidence(err)
+          generate_screen_shot(@driver, @tc)
+          report("#{@tc}_error", err)
+        end
+      end
+    end
+  end
+end

data/lib/bucky/test_equipment/pageobject/base_pageobject.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative '../../utils/yaml_load'
+require_relative '../../core/exception/bucky_exception'
+
+module Bucky
+  module TestEquipment
+    module PageObject
+      class BasePageObject
+        include Bucky::Utils::YamlLoad
+        def initialize(service, device, page_name, driver)
+          @driver = driver
+          generate_parts(service, device, page_name)
+        end
+
+        private
+
+        # Load parts file and define parts method
+        # @param [String] service
+        # @param [String] device (pc, sp)
+        # @param [String] paga_name
+        def generate_parts(service, device, page_name)
+          Dir.glob("./services/#{service}/#{device}/parts/#{page_name}.yml").each do |file|
+            parts_data = load_yaml(file)
+
+            # Define part method e.g.) page.parts
+            parts_data.each do |part_name, value|
+              self.class.class_eval { define_method(part_name) { find_elem(value[0], value[1]) } }
+            end
+          end
+        end
+
+        # @param [String] method Method name for searching WebElement
+        #   http://www.rubydoc.info/gems/selenium-webdriver/0.0.28/Selenium/WebDriver/Find
+        # @param [String] Condition of search (xpath/id)
+        # @return [Selenium::WebDriver::Element]
+        def find_elem(method, value)
+          if method.end_with?('s')
+            elem = @driver.find_elements(method.sub(/s$/, '').to_sym, value)
+            raise_if_element_empty(elem, method, value)
+            return elem
+          end
+
+          @driver.find_element(method.to_sym, value)
+        rescue StandardError => e
+          Bucky::Core::Exception::WebdriverException.handle(e)
+        end
+
+        def raise_if_element_empty(elem, method, value)
+          raise Selenium::WebDriver::Error::NoSuchElementError, "#{method} #{value}" if elem.empty?
+        end
+      end
+    end
+  end
+end

data/lib/bucky/test_equipment/pageobject/pages.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Bucky
+  module TestEquipment
+    module PageObject
+      class Pages
+        def initialize(service, device, driver)
+          collect_pageobjects(service, device, driver)
+        end
+
+        # Load page class and define page method
+        # @param [String] service
+        # @param [String] device (pc, sp)
+        # @param [Object] driver Webdriver object
+        def collect_pageobjects(service, device, driver)
+          # Create module name
+          module_service_name = service.split('_').map(&:capitalize).join
+          Dir.glob("#{$bucky_home_dir}/services/#{service}/#{device}/pageobject/*.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 class
+            page_class = eval(format('Services::%<module_service_name>s::%<device>s::PageObject::%<page_class_name>s', module_service_name: module_service_name, device: device.capitalize, page_class_name: page_class_name))
+            page_instance = page_class.new(service, device, page_name, driver)
+
+            # Define method by page name
+            self.class.class_eval do
+              define_method(page_name) { page_instance }
+            end
+          end
+        end
+
+        # Get Web element by page, part, num
+        # @param [Hash] args
+        def get_part(args)
+          return send(args[:page]).send(args[:part][:locate])[args[:part][:num]] if part_plural?(args)
+
+          send(args[:page]).send(args[:part])
+        end
+
+        # @param [Hash] args
+        # @return [Boolean]
+        def part_plural?(args)
+          # If the part is hash and has 'num' key, it has plural elements.
+          args[:part].class == Hash && args[:part].key?(:num)
+        end
+
+        # @param [Hash] args
+        # @return [Bool]
+        def part_exist?(args)
+          get_part(args)
+          true
+        rescue Selenium::WebDriver::Error::NoSuchElementError
+          false
+        end
+      end
+    end
+  end
+end

data/lib/bucky/test_equipment/selenium_handler/webdriver_handler.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'selenium-webdriver'
+require_relative '../../core/exception/bucky_exception'
+require_relative '../../utils/config'
+
+module Bucky
+  module TestEquipment
+    module SeleniumHandler
+      module WebdriverHandler
+        # Create and return webdriver object
+        # @param  [String] device_type e.g.) sp, pc, tablet
+        # @return [Selenium::WebDriver]
+        def create_webdriver(device_type)
+          @@config = Bucky::Utils::Config.instance
+          driver_args = create_driver_args(device_type)
+          driver = Selenium::WebDriver.for(:remote, **driver_args)
+          driver.manage.window.resize_to(1280, 1000)
+          driver.manage.timeouts.implicit_wait = @@config[:find_element_timeout]
+          driver
+        rescue StandardError => e
+          Bucky::Core::Exception::BuckyException.handle(e)
+        end
+        module_function :create_webdriver
+
+        private
+
+        # @param  [String] device_type e.g.) sp, pc, tablet
+        # @return [Hash] driver_args
+        def create_driver_args(device_type)
+          driver_args = { url: format('http://%<ip>s:%<port>s/wd/hub', ip: @@config[:selenium_ip], port: @@config[:selenium_port]) }
+          driver_args[:desired_capabilities] = generate_desire_caps(device_type)
+          client = Selenium::WebDriver::Remote::Http::Default.new
+          client.open_timeout = @@config[:driver_open_timeout]
+          client.read_timeout = @@config[:driver_read_timeout]
+          driver_args[:http_client] = client
+          driver_args
+        end
+
+        # @param  [String] device_type e.g.) sp, pc, tablet
+        # @return [Hash]   desire_capabilities
+        def generate_desire_caps(device_type)
+          case @@config[:browser]
+          when :chrome then
+            set_chrome_option(device_type)
+          else
+            raise 'Currently only supports chrome. Sorry.'
+          end
+        end
+
+        def set_chrome_option(device_type)
+          chrome_options = { 'goog:chromeOptions' => {} }
+          unless device_type == 'pc'
+            device_type = "#{device_type}_device_name".to_sym
+            mobile_emulation = { 'deviceName' => @@config[:device_name_on_chrome][@@config[device_type]] }
+            chrome_options['goog:chromeOptions']['mobileEmulation'] = mobile_emulation
+          end
+          chrome_options['goog:chromeOptions'][:args] = ["--load-extension=#{@@config[:js_error_collector_path]}"] if @@config[:js_error_check]
+          chrome_options['goog:chromeOptions'][:args] = ["--user-agent=#{@@config[:user_agent]}"] if @@config[:user_agent]
+
+          Selenium::WebDriver::Remote::Capabilities.chrome(chrome_options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'test/unit'
+require_relative '../../core/test_core/test_result'
+
+module Bucky
+  module TestEquipment
+    module TestCase
+      class AbstTestCase < Test::Unit::TestCase
+        class << self
+          def startup
+            return if $debug
+
+            @@this_result = Bucky::Core::TestCore::TestResult.instance
+            @@added_result_info = {}
+          end
+
+          def shutdown
+            @@this_result.save(@@added_result_info) unless $debug
+          end
+        end
+
+        # Override Test::Unit::TestCase#run
+        # Save test result to own test result object.
+        def run(result)
+          super
+          @@this_result.result = result unless $debug
+        end
+
+        def setup
+          # To make it easy to read
+          puts "\n"
+        end
+
+        def teardown
+          return if $debug
+
+          @@added_result_info[method_name.to_sym] = {
+            test_suite_id: suite_id,
+            elapsed_time: Time.now - start_time,
+            case_name: description
+          }
+        end
+
+        def cleanup; end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'selenium-webdriver'
+require_relative './abst_test_case'
+require_relative '../user_operation/user_operator'
+require_relative '../pageobject/pages'
+require_relative '../selenium_handler/webdriver_handler'
+require_relative '../verifications/js_error_checker'
+require_relative '../verifications/service_verifications'
+
+module Bucky
+  module TestEquipment
+    module TestCase
+      class E2eTestCase < Bucky::TestEquipment::TestCase::AbstTestCase
+        include Bucky::TestEquipment::SeleniumHandler::WebdriverHandler
+        include Bucky::TestEquipment::Verifications::JsErrorChecker
+
+        TEST_CATEGORY = 'e2e'
+
+        class << self
+          def startup; end
+
+          def shutdown; end
+        end
+
+        # Initialize the following class
+        #   - webdriver
+        #   - page object
+        #   - user oparation
+        #   - verification
+        # @param [Hash] suite
+        def t_equip_setup
+          @driver = create_webdriver(suite_data[:device])
+          @pages = Bucky::TestEquipment::PageObject::Pages.new(suite_data[:service], suite_data[:device], @driver)
+          service_verifications_args = { service: suite_data[:service], device: suite_data[:device], driver: @driver, pages: @pages, method_name: method_name }
+          @service_verifications = Bucky::TestEquipment::Verifications::ServiceVerifications.new(service_verifications_args)
+          user_operator_args = { app: suite_data[:service], device: suite_data[:device], driver: @driver, pages: @pages }
+          @user_operator = Bucky::TestEquipment::UserOperation::UserOperator.new(user_operator_args)
+        end
+
+        # Call mothod of verification
+        # @param [Hash] verify_args e.g.) {verify: "assert_title", expect: "page title"}
+        def verify(**verify_args)
+          @service_verifications.send(verify_args[:verify], verify_args)
+        end
+
+        # Call method of user operation
+        # @param [Hash] op_args e.g.){page: 'top', part: 'rosen_tokyo', operation: 'click'}
+        def operate(**op_args)
+          @user_operator.send(op_args[:operate], method_name, op_args)
+        end
+
+        # Check javascript error
+        def check_js_error
+          assert_no_js_error(@driver) if @@config[:js_error_check]
+        end
+
+        def setup
+          super
+          t_equip_setup
+        end
+
+        def teardown
+          @driver.quit
+          super
+        end
+      end
+    end
+  end
+end