bucky-core 0.9.0

data/lib/bucky/core/database/test_data_operator.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require_relative './db_connector'
+require_relative '../../utils/config'
+
+module Bucky
+  module Core
+    module Database
+      class TestDataOperator
+        def initialize
+          @connector = DbConnector.new
+          @connector.connect
+          @config = Bucky::Utils::Config.instance
+        end
+
+        # Save job data and return job id
+        # @param  [Time] start_time
+        # @return [Fixnum] job_id
+        def save_job_record_and_get_job_id(start_time, command_and_option)
+          return 0 if $debug
+
+          job_id = @connector.con[:jobs].insert(start_time: start_time, command_and_option: command_and_option)
+          @connector.disconnect
+          job_id
+        end
+
+        # Save test result
+        # @param  [Hash] test_suite_result test data for Sequel
+        def save_test_result(test_suite_result)
+          @connector.con[:test_case_results].import(test_suite_result[:column], test_suite_result[:data_set])
+          @connector.disconnect
+        end
+
+        # Add test_suites.id to loaded suite data
+        # @return [Array] test_suite_data
+        def add_suite_id_to_loaded_suite_data(test_suite_data)
+          return test_suite_data if $debug
+
+          test_suite_data.each_with_index do |test_data, i|
+            suite = get_test_suite_from_test_data(test_data)
+            test_suite_data[i][:test_suite_id] = suite[:id]
+          end
+          @connector.disconnect
+          test_suite_data
+        end
+
+        # Save test suite data
+        def update_test_suites_data(test_suite_data)
+          return if $debug
+
+          test_suite_data.each do |test_data|
+            saved_test_suite = get_test_suite_from_test_data(test_data)
+            suite_id = get_suite_id_from_saved_test_suite(saved_test_suite, test_data)
+            test_data[:suite][:cases].each do |test_case|
+              labels = get_labels_from_suite_and_case(test_data[:suite][:labels], test_case[:labels])
+              label_ids = insert_and_return_label_ids(labels)
+              update_test_case_and_test_case_label(suite_id, test_case, label_ids)
+            end
+          end
+          @connector.disconnect
+        end
+
+        # Return file path and CaseName that failed at last time.
+        # @return [Hash] re_test_cond
+        def get_ng_test_cases_at_last_execution(cond)
+          re_test_cond = {}
+          return {} if $debug
+
+          cases = @connector.con[:test_case_results].filter(cond).select(:test_case_id).all.map { |row| row[:test_case_id] }
+          Sequel.split_symbols = true # To use test_cases__id
+          suites_and_cases = @connector.con[:test_cases]
+                                       .left_join(:test_suites, id: Sequel.qualify('test_cases', 'test_suite_id'))
+                                       .where(test_cases__id: cases).all
+          # Created data
+          # {
+          #   1 => {file_path: "/hoge/fuga.yml", cases_names: ["hogehoge_hoge_1", "hogehoge_hoge_2"]},
+          #   2 => {file_path: "/gefu/hugo.yml", cases_names: ["hogehoge_hoge_1", "hogehoge_hoge_2"]},
+          # }
+          suites_and_cases.each do |suite_case|
+            suite_id = suite_case[:test_suite_id]
+            if re_test_cond.key? suite_id
+              re_test_cond[suite_id][:case_names].push suite_case[:case_name]
+            else
+              re_test_cond[suite_id] = {
+                file_path: suite_case[:file_path],
+                case_names: [suite_case[:case_name]]
+              }
+            end
+          end
+          re_test_cond
+        end
+
+        def get_test_case_id(test_suite_id, case_name)
+          return nil if $debug
+
+          test_case = @connector.con[:test_cases].filter(test_suite_id: test_suite_id, case_name: case_name).first
+          @connector.disconnect
+          raise "Cannot get test_case id. test_suite_id: #{test_suite_id}, case_name: #{case_name}" if test_case.nil?
+
+          test_case[:id]
+        end
+
+        # Return last round
+        # @param  [Int] job_id
+        # @return [Int] round
+        def get_last_round_from_job_id(job_id)
+          round = @connector.con[:test_case_results].where(job_id: job_id).max(:round)
+          @connector.disconnect
+          round
+        end
+
+        private
+
+        # Common method for getting suite
+        def get_test_suite_from_test_data(test_data)
+          @connector.con[:test_suites].filter(
+            test_category: test_data[:test_category],
+            service: test_data[:suite][:service],
+            device: test_data[:suite][:device],
+            test_suite_name: test_data[:test_suite_name]
+          ).first
+        end
+
+        def get_suite_id_from_saved_test_suite(saved_test_suite, test_data)
+          file_path = "services/#{test_data[:suite][:service]}/#{test_data[:suite][:device]}/scenarios/#{test_data[:test_category]}/#{test_data[:test_suite_name]}.yml"
+          if saved_test_suite
+            @connector.con[:test_suites].where(id: saved_test_suite[:id]).update(
+              priority: test_data[:suite][:priority].to_s,
+              test_suite_name: test_data[:test_suite_name],
+              suite_description: test_data[:suite][:desc],
+              github_url: @config[:test_code_repo],
+              file_path: file_path
+            )
+            saved_test_suite[:id]
+          else # If there is no test_suite, save new record and return suite_id.
+            @connector.con[:test_suites].insert(
+              test_category: test_data[:test_category],
+              service: test_data[:suite][:service],
+              device: test_data[:suite][:device],
+              priority: test_data[:suite][:priority].to_s,
+              test_suite_name: test_data[:test_suite_name],
+              suite_description: test_data[:suite][:desc],
+              github_url: @config[:test_code_repo],
+              file_path: file_path
+            )
+          end
+        end
+
+        # Return array contains suite and case
+        def get_labels_from_suite_and_case(suite_labels, case_labels)
+          [suite_labels, case_labels].flatten.compact.uniq
+        end
+
+        # Return label ids if case has labels, else return nil
+        def insert_and_return_label_ids(labels)
+          label_ids = []
+          return nil if labels.empty?
+
+          labels.each do |label_name|
+            label = @connector.con[:labels].filter(label_name: label_name).first
+            label_ids << if label
+                           label[:id]
+                         else
+                           @connector.con[:labels].insert(label_name: label_name)
+                         end
+          end
+          label_ids
+        end
+
+        def update_test_case_and_test_case_label(suite_id, test_case, label_ids)
+          saved_test_case = @connector.con[:test_cases].filter(test_suite_id: suite_id, case_name: test_case[:case_name]).first
+          if saved_test_case
+            # Update case data
+            @connector.con[:test_cases].where(id: saved_test_case[:id]).update(case_name: test_case[:case_name], case_description: test_case[:desc])
+            # Update label of case
+            # At first, delete case connection
+            @connector.con[:test_case_labels].filter(test_case_id: saved_test_case[:id]).delete
+            # Create new connection
+            # If there is no labels, return nil
+            label_ids&.each do |label_id|
+              @connector.con[:test_case_labels].insert(test_case_id: saved_test_case[:id], label_id: label_id)
+            end
+          else
+            # Add case data
+            test_case_id = @connector.con[:test_cases].insert(test_suite_id: suite_id, case_name: test_case[:case_name], case_description: test_case[:desc])
+            # If there is no labels, return nil
+            label_ids&.each do |label_id|
+              @connector.con[:test_case_labels].insert(test_case_id: test_case_id, label_id: label_id)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bucky/core/exception/bucky_exception.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative '../../utils/bucky_logger'
+require_relative '../../utils/config'
+
+module Bucky
+  module Core
+    module Exception
+      class BuckyException
+        include Bucky::Utils::BuckyLogger
+        class << self
+          # Error handling on bucky framework
+          # @param [Object] err exception object
+          def handle(err)
+            Bucky::Utils::BuckyLogger.write(Bucky::Utils::Config.instance[:bucky_error], err)
+          end
+        end
+      end
+
+      class DbConnectorException < Bucky::Core::Exception::BuckyException
+        class << self
+          def handle(err)
+            super
+            raise err
+          end
+        end
+      end
+
+      class WebdriverException < Bucky::Core::Exception::BuckyException
+        class << self
+          def handle(err)
+            super
+            raise err
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bucky/core/report/screen_shot_generator.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative '../../utils/config'
+require_relative '../exception/bucky_exception'
+
+module Bucky
+  module Core
+    module Report
+      module ScreenShotGenerator
+        # Save screen shot
+        # @param [Webdriver] driver
+        # @param [String] test_case e.g.) test_sample_app_pc_e2e_1_1
+        def generate_screen_shot(driver, test_case)
+          timestamp = Time.now.strftime('%Y%m%d_%H%M%S')
+          driver.save_screenshot(
+            Bucky::Utils::Config.instance[:screen_shot_path] + test_case << "_#{timestamp}.png"
+          )
+        rescue StandardError => e
+          Bucky::Core::Exception::BuckyException.handle(e)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require_relative '../database/test_data_operator'
+require_relative '../../utils/yaml_load'
+
+class Hash
+  def deep_symbolize_keys!
+    deep_transform_keys! do |key|
+      key unless key.respond_to? :to_sym
+      key.to_sym
+    end
+  end
+
+  def deep_transform_keys!(&block)
+    keys.each do |key|
+      value = delete(key)
+      self[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys!(&block) : value
+    end
+    self
+  end
+end
+
+module Bucky
+  module Core
+    module TestCore
+      class TestCaseLoader
+        class << self
+          include Bucky::Utils::YamlLoad
+          # Load test code files and return test suite data.
+          # @return [Array] test suite
+          def load_testcode(test_cond)
+            return load_re_test_testcode(test_cond[:re_test_cond]) if test_cond.key? :re_test_cond
+
+            testcodes = []
+            service = (test_cond[:service] || ['*']).first
+            device = (test_cond[:device] || ['*']).first
+            category = (test_cond[:test_category] || ['*']).first
+
+            Dir.glob("#{$bucky_home_dir}/services/#{service}/#{device}/scenarios/#{category}/*.yml").each do |testcode_file|
+              testcodes << load_testcode_in_file(testcode_file, test_cond)
+            end
+            # Delete nil element
+            testcodes.compact
+          end
+
+          private
+
+          def load_testcode_in_file(testcode_file, test_cond)
+            testcode_info = testcode_file.split(%r{/|\.}).reverse
+            test_suite_name, test_category = testcode_info[1..3]
+            test_class_name = test_suite_name.split('_').map(&:capitalize).join
+            test_suite = load_suite_file(testcode_file)
+            return nil unless target_in_suite_options?(test_suite, test_cond, test_suite_name)
+
+            test_suite = set_suite_option_to_case(test_suite)
+            refined_suite = refine_case_with_option(test_cond, test_suite)
+            return nil if refined_suite[:cases].empty?
+
+            { test_class_name: test_class_name, test_suite_name: test_suite_name, test_category: test_category, suite: refined_suite }
+          end
+
+          def load_re_test_testcode(re_test_cond)
+            testcodes = []
+            re_test_cond.each_value do |cond|
+              testcode_info = cond[:file_path].split(%r{/|\.}).reverse
+              test_suite_name, test_category = testcode_info[1..3]
+              test_class_name = test_suite_name.split('_').map(&:capitalize).join
+              test_suite = load_suite_file(cond[:file_path])
+              test_suite[:cases].delete_if { |c| !cond[:case_names].include? c[:case_name] }
+              testcodes << { test_class_name: test_class_name, test_suite_name: test_suite_name, test_category: test_category, suite: test_suite }
+            end
+            testcodes
+          end
+
+          def load_suite_file(file)
+            test_suite = load_yaml(file)
+            test_suite.deep_symbolize_keys!
+            test_suite[:setup_each][:procs].each(&:deep_symbolize_keys!) if test_suite[:setup_each]
+            test_suite[:teardown_each][:procs].each(&:deep_symbolize_keys!) if test_suite[:teardown_each]
+            test_suite[:cases].each do |c|
+              c.deep_symbolize_keys!
+              next unless c.key? :procs
+
+              c[:procs].each do |p|
+                c[:procs].delete(p) unless when_match?(p)
+                p.deep_symbolize_keys!
+              end
+            end
+            test_suite
+          rescue StandardError => ex
+            raise ex, "loading #{file}, #{ex.message}"
+          end
+
+          def when_match?(proc)
+            return true unless proc.key?('when')
+            raise StandardError, 'Please input correct condition' unless [true, false].include?(proc['when'])
+
+            proc['when']
+          end
+
+          # Return true if match suite condition
+          # Only priority and suite name
+          def target_in_suite_options?(test_suite, test_cond, test_suite_name)
+            # priority
+            return false unless check_option_include_target?(test_cond[:priority], test_suite[:priority])
+            # suite_name
+            return false unless check_option_include_target?(test_cond[:suite_name], test_suite_name)
+
+            true
+          end
+
+          # Return true, if target includes specified option
+          def check_option_include_target?(option, target)
+            # If there is no option, return nil.
+            if option.nil?
+              nil
+            else
+              return false unless option.include?(target)
+            end
+            true
+          end
+
+          # set suite option to case e.g.) suite's labels are inherited by test cases
+          # only label
+          def set_suite_option_to_case(test_suite)
+            return test_suite unless test_suite.key?(:labels)
+
+            # Pattern of value is different depending on how to write (string/array)
+            # change to array on all pattern
+            test_suite[:labels] = [test_suite[:labels]].flatten
+            test_suite[:cases].each do |c|
+              c[:labels] = if c.key?(:labels)
+                             [c[:labels]].flatten | test_suite[:labels]
+                           else
+                             test_suite[:labels]
+                           end
+            end
+            test_suite
+          end
+
+          # Filter with option
+          def refine_case_with_option(test_cond, suite)
+            # Filtering by label
+            if test_cond.key? :label
+              # Delete test case that have no label
+              # Pattern of value is different depending on how to write (string/array)
+              # Change to array on all pattern
+              suite[:cases].delete_if { |c| c[:labels].nil? }
+              suite[:cases].delete_if { |c| !(test_cond[:label].sort - [c[:labels]].flatten.sort).empty? }
+            end
+            # If there is no option, do nothing.
+            return suite unless test_cond.key? :case
+
+            # Delete test case doesn't match
+            suite[:cases].delete_if { |c| !test_cond[:case].include? c[:case_name] }
+            suite
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative '../../test_equipment/test_case/e2e_test_case'
+require_relative '../../test_equipment/test_case/linkstatus_test_case'
+
+module Bucky
+  module Core
+    module TestCore
+      # For creating class dynamically.
+      class TestClasses
+      end
+
+      module TestClassGeneratorHelper
+        private
+
+        def add_test_procedure(procedures)
+          procedures.each.with_index(1) do |procedure, index|
+            puts "  #{index}:#{procedure[:proc]}" if procedure.key?(:proc)
+            method = procedure[:exec].key?(:operate) ? :operate : :verify
+            send(method, procedure[:exec])
+            check_js_error
+          end
+        end
+
+        def make_test_method_name(data, test_case, index)
+          if test_case[:case_name].nil?
+            return [
+              'test',
+              data[:suite][:service],
+              data[:suite][:device],
+              data[:test_category],
+              data[:test_suite_name],
+              index.to_s
+            ].join('_')
+          end
+          "test_#{test_case[:case_name]}"
+        end
+      end
+
+      class TestClassGenerator
+        attr_accessor :test_classes
+
+        def initialize(test_cond)
+          @test_classes = TestClasses
+          @test_cond = test_cond
+        end
+
+        # Genrate test class by test suite and test case data
+        def generate_test_class(data, link_status_url_log)
+          test_cond = @test_cond
+          # Common proccessing
+          # e.g.) TestSampleAppPcE2e1, TestSampleAppPcHttpstatus1
+          test_class_name = make_test_class_name(data)
+          # Select super class by test category
+          super_suite_class = eval format('Bucky::TestEquipment::TestCase::%<test_category>sTestCase', test_category: data[:test_category].capitalize)
+          # Define test suite class
+          test_classes.const_set(test_class_name.to_sym, Class.new(super_suite_class) do |_klass|
+            extend TestClassGeneratorHelper
+            include TestClassGeneratorHelper
+            define_method(:suite_data, proc { data[:suite] })
+            define_method(:suite_id, proc { data[:test_suite_id] })
+            define_method(:simple_test_class_name) do |original_name|
+              match_obj = /\Atest_(.+)\(.+::(Test.+)\)\z/.match(original_name)
+              "#{match_obj[1]}(#{match_obj[2]})"
+            end
+
+            # Class structure is different for each test category
+            case data[:test_category]
+            when 'linkstatus' then
+              data[:suite][:cases].each_with_index do |t_case, i|
+                method_name = make_test_method_name(data, t_case, i)
+                description(
+                  t_case[:case_name],
+                  define_method(method_name) do
+                    puts "\n#{simple_test_class_name(name)}"
+                    t_case[:urls].each do |url|
+                      link_status_check_args = { url: url, device: data[:suite][:device], exclude_urls: data[:suite][:exclude_urls], link_check_max_times: test_cond[:link_check_max_times], url_log: link_status_url_log }
+                      link_status_check(link_status_check_args)
+                    end
+                  end
+                )
+              end
+
+            when 'e2e' then
+              if data[:suite][:setup_each]
+                def setup
+                  super
+                  puts "[setup]#{simple_test_class_name(name)}"
+                  add_test_procedure(suite_data[:setup_each][:procs])
+                end
+              end
+
+              if data[:suite][:teardown_each]
+                def teardown
+                  puts "[teardown]#{simple_test_class_name(name)}"
+                  add_test_procedure(suite_data[:teardown_each][:procs])
+                  super
+                end
+              end
+
+              # Generate test case method
+              data[:suite][:cases].each_with_index do |t_case, i|
+                # e.g.) test_sample_app_pc_e2e_1_2
+                method_name = make_test_method_name(data, t_case, i)
+                method_obj = proc do
+                  puts "\n#{simple_test_class_name(name)}\n #{t_case[:desc]} ...."
+                  add_test_procedure(t_case[:procs])
+                end
+                description(t_case[:case_name], define_method(method_name, method_obj))
+              end
+            end
+          end)
+        end
+
+        private
+
+        def make_test_class_name(data)
+          [
+            'Test',
+            data[:suite][:service].split(/_|-/).map(&:capitalize).join.to_s,
+            data[:suite][:device].capitalize.to_s,
+            data[:test_category].to_s.capitalize.to_s,
+            (data[:test_class_name]).to_s
+          ].join
+        end
+      end
+    end
+  end
+end