shift sequence, move code into own files (#477)

* shift sequence, move code into own files

* pass along RunnerProperties so we can properly name the video file

* beautify name

* specify video including path in docker contanier

* add up selenoid options

Author: dothebart

jenkins/common/gather_coredumps.sh

@@ -1,6 +1,9 @@
 if [ `ls -1 "$(pwd)/test_dir/core"* 2>/dev/null | wc -l ` -gt 0 ]; then
     7z a coredumps "$(pwd)/test_dir/core"*
-    printf "\nCoredumps found after testrun:\n $(ls -l "$(pwd)/test_dir/core"*)\n" >> "$(pwd)/test_dir/testfailures.txt"
+    (
+        cat "$(pwd)/test_dir/testfailures.txt";
+        printf "\nCoredumps found after testrun:\n $(ls -l "$(pwd)/test_dir/core"*)\n"
+    ) > "$(pwd)/test_dir/testfailures.txt"
     rm -f "$(pwd)/test_dir/core"*
     mv coredumps.7z "$(pwd)/test_dir/"
     echo "FAILED BY COREDUMP FOUND!"

release_tester/arangodb/starter/deployments/runner.py

@@ -159,6 +159,7 @@ def __init__(
         selenium_include_suites: list,
         testrun_name: str,
     ):
+        self.properties = properties
         load_scenarios()
         assert runner_type, "no runner no cry? no!"
         mem = psutil.virtual_memory()
@@ -261,6 +262,7 @@ def __init__(
 
             self.selenium = init_selenium(
                 runner_type,
+                self.properties,
                 selenium_worker,
                 selenium_driver_args,
                 selenium_include_suites,

release_tester/arangodb/starter/deployments/selenium_deployments/__init__.py

@@ -1,139 +1,69 @@
 #!/usr/bin/env python3
 """ baseclass to manage selenium UI tests """
 
-import time
-
-from selenium import webdriver
-from selenium.common.exceptions import SessionNotCreatedException
-
 from arangodb.starter.deployments import RunnerType
+from arangodb.starter.deployments.runner import RunnerProperties
+
 from arangodb.starter.deployments.selenium_deployments.sbase import SeleniumRunner, cleanup_temp_files
 
-# pylint: disable=import-outside-toplevel disable=too-many-locals disable=too-many-branches disable=too-many-statements
+# pylint: disable=import-outside-toplevel disable=too-many-locals
+# pylint: disable=too-many-branches disable=too-many-statements
+# pylint: disable=too-many-return-statements disable=too-many-arguments
 def init(
     runner_type: RunnerType,
+    properties: RunnerProperties,
     selenium_worker: str,
     selenium_driver_args: list,
     selenium_include_suites: list,
     testrun_name: str,
     ssl: bool,
 ) -> SeleniumRunner:
     """build selenium testcase for runner_type"""
-    if "_" in selenium_worker:
-        sw_split = selenium_worker.split("_")
-        driver_func = getattr(webdriver, sw_split[0])
-        selenium_worker = sw_split[1].lower()
-        worker_options = ""
-    else:
-        driver_func = getattr(webdriver, selenium_worker)
-        worker_options = selenium_worker = selenium_worker.lower() + "_"
-    if driver_func is None:
-        raise Exception("webdriver " + selenium_worker + "unknown")
-
-    kwargs = {}
-    is_headless = False
-    if len(selenium_driver_args) > 0:
-        opts_func = getattr(webdriver, selenium_worker)
-        opts_func = getattr(opts_func, "options")
-        opts_func = getattr(opts_func, "Options")
-        options = opts_func()
-        kwargs[worker_options + "options"] = options
-        for opt in selenium_driver_args:
-            split_opts = opt.split("=")
-            if opt == "headless":
-                is_headless = True
-            elif len(split_opts) == 2:
-                if split_opts[0] == "command_executor":
-                    is_headless = True
-                    kwargs["command_executor"] = split_opts[1]
-                    continue
-            elif len(split_opts) >= 3:
-                key = split_opts.pop(0)
-                where_to_put = {}
-                while len(split_opts) > 2:
-                    if split_opts[0] not in where_to_put:
-                        where_to_put[split_opts[0]] = {}
-                    where_to_put = where_to_put[split_opts[0]]
-                if len(split_opts) == 2:
-                    val = split_opts[1]
-                    if val == "True":
-                        val = True
-                    elif val == "False":
-                        val = False
-                    where_to_put[split_opts[0]] = val
-                    options.set_capability(key, where_to_put)
-                    split_opts = []
-                continue
-            options.add_argument("--" + opt)
-
-    cleanup_temp_files(is_headless)
-    driver = None
-    count = 0
-    while driver is None and count < 10:
-        count += 1
-        try:
-            driver = driver_func(**kwargs)
-        except TypeError:
-            try:
-                driver = driver_func.webdriver.WebDriver(**kwargs)
-            except SessionNotCreatedException as ex:
-                if count == 10:
-                    raise ex
-                print("S: retrying to launch browser")
-                cleanup_temp_files(is_headless)
-                time.sleep(2)
-        except SessionNotCreatedException as ex:
-            if count == 10:
-                raise ex
-            print("S: retrying to launch browser")
-            cleanup_temp_files(is_headless)
-            time.sleep(2)
-    if selenium_worker.lower() == "chrome":
-        required_width = driver.execute_script("return document.body.parentNode.scrollWidth")
-        required_height = driver.execute_script("return document.body.parentNode.scrollHeight")
-        driver.set_window_size(required_width, required_height)
-
+    selenium_args = {
+        "selenium_worker": selenium_worker,
+        "selenium_driver_args": selenium_driver_args,
+    }
     if runner_type == RunnerType.SINGLE:
         from arangodb.starter.deployments.selenium_deployments.single import (
             Single,
         )
 
-        return Single(driver, is_headless, testrun_name, ssl, selenium_include_suites)
+        return Single(selenium_args, properties, testrun_name, ssl, selenium_include_suites)
 
     if runner_type == RunnerType.LEADER_FOLLOWER:
         from arangodb.starter.deployments.selenium_deployments.leaderfollower import (
             LeaderFollower,
         )
 
-        return LeaderFollower(driver, is_headless, testrun_name, ssl, selenium_include_suites)
+        return LeaderFollower(selenium_args, properties, testrun_name, ssl, selenium_include_suites)
 
     if runner_type == RunnerType.ACTIVE_FAILOVER:
         from arangodb.starter.deployments.selenium_deployments.activefailover import (
             ActiveFailover,
         )
 
-        return ActiveFailover(driver, is_headless, testrun_name, ssl, selenium_include_suites)
+        return ActiveFailover(selenium_args, properties, testrun_name, ssl, selenium_include_suites)
 
     if runner_type == RunnerType.CLUSTER:
         from arangodb.starter.deployments.selenium_deployments.cluster import Cluster
 
-        return Cluster(driver, is_headless, testrun_name, ssl, selenium_include_suites)
+        return Cluster(selenium_args, properties, testrun_name, ssl, selenium_include_suites)
 
     if runner_type == RunnerType.DC2DC:
         from arangodb.starter.deployments.selenium_deployments.dc2dc import Dc2Dc
 
-        return Dc2Dc(driver, is_headless, testrun_name, ssl, selenium_include_suites)
+        return Dc2Dc(selenium_args, properties, testrun_name, ssl, selenium_include_suites)
 
     if runner_type == RunnerType.DC2DCENDURANCE:
         from arangodb.starter.deployments.selenium_deployments.dc2dc_endurance import (
             Dc2DcEndurance,
         )
 
-        return Dc2DcEndurance(driver, is_headless, testrun_name, ssl, selenium_include_suites)
+        return Dc2DcEndurance(selenium_args, properties, testrun_name, ssl, selenium_include_suites)
 
     if runner_type == RunnerType.NONE:
         from arangodb.starter.deployments.selenium_deployments.none import NoStarter
 
-        return NoStarter(driver, is_headless, testrun_name, ssl, selenium_include_suites)
+        return NoStarter(selenium_args, properties, testrun_name, ssl, selenium_include_suites)
 
     raise Exception("unknown starter type")

release_tester/arangodb/starter/deployments/selenium_deployments/activefailover.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 """ test the UI of a active failover setup """
+from arangodb.starter.deployments.runner import RunnerProperties
 from arangodb.starter.deployments.selenium_deployments.sbase import SeleniumRunner
 from selenium_ui_test.test_suites.activefailover.after_install_test_suite import ActiveFailoverAfterInstallTestSuite
 from selenium_ui_test.test_suites.activefailover.jam_1_test_suite import ActiveFailoverJamStepOneSuite
@@ -13,9 +14,9 @@
 class ActiveFailover(SeleniumRunner):
     """check the active failover setup and its properties"""
 
-    def __init__(self, webdriver, is_headless: bool, testrun_name: str, ssl: bool, selenium_include_suites: list[str]):
+    def __init__(self, selenium_args, properties: RunnerProperties, testrun_name: str, ssl: bool, selenium_include_suites: list[str]):
         # pylint: disable=useless-super-delegation
-        super().__init__(webdriver, is_headless, testrun_name, ssl, selenium_include_suites)
+        super().__init__(selenium_args, properties, testrun_name, ssl, selenium_include_suites)
         self.main_test_suite_list = [BasicTestSuite]
         self.after_install_test_suite_list = [ActiveFailoverAfterInstallTestSuite]
         self.wait_for_upgrade_test_suite_list = [ActiveFailoverWaitForUpgradeTestSuite]

release_tester/arangodb/starter/deployments/selenium_deployments/cluster.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 """ test the UI of a cluster setup """
+from arangodb.starter.deployments.runner import RunnerProperties
 from arangodb.starter.deployments.selenium_deployments.sbase import SeleniumRunner
 from selenium_ui_test.test_suites.basic_test_suite import BasicTestSuite
 from selenium_ui_test.test_suites.cluster.wait_for_upgrade_test_suite import ClusterWaitForUpgradeTestSuite
@@ -10,9 +11,9 @@
 class Cluster(SeleniumRunner):
     """check the leader follower setup and its properties"""
 
-    def __init__(self, webdriver, is_headless: bool, testrun_name: str, ssl: bool, selenium_include_suites: list[str]):
+    def __init__(self, selenium_args, properties: RunnerProperties, testrun_name: str, ssl: bool, selenium_include_suites: list[str]):
         # pylint: disable=useless-super-delegation
-        super().__init__(webdriver, is_headless, testrun_name, ssl, selenium_include_suites)
+        super().__init__(selenium_args, properties, testrun_name, ssl, selenium_include_suites)
         self.is_cluster = True
         self.main_test_suite_list = [BasicTestSuite]
         self.wait_for_upgrade_test_suite_list = [ClusterWaitForUpgradeTestSuite]

release_tester/arangodb/starter/deployments/selenium_deployments/leaderfollower.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 """ test the UI of a leader follower setup """
+from arangodb.starter.deployments.runner import RunnerProperties
 from arangodb.starter.deployments.selenium_deployments.sbase import SeleniumRunner
 
 from selenium_ui_test.test_suites.basic_test_suite import BasicTestSuite
@@ -10,9 +11,9 @@
 class LeaderFollower(SeleniumRunner):
     """check the leader follower setup and its properties"""
 
-    def __init__(self, webdriver, is_headless: bool, testrun_name: str, ssl: bool, selenium_include_suites: list[str]):
+    def __init__(self, selenium_args, properties: RunnerProperties, testrun_name: str, ssl: bool, selenium_include_suites: list[str]):
         # pylint: disable=useless-super-delegation
-        super().__init__(webdriver, is_headless, testrun_name, ssl, selenium_include_suites)
+        super().__init__(selenium_args, properties, testrun_name, ssl, selenium_include_suites)
         self.main_test_suite_list = [BasicTestSuite]
         self.after_install_test_suite_list = [LeaderFollowerAfterInstallTestSuite]
         self.jam_test_suite_list = [LeaderFollowerJamStepOneSuite]

release_tester/arangodb/starter/deployments/selenium_deployments/none.py

@@ -1,14 +1,15 @@
 #!/usr/bin/env python3
 """ test the UI of a leader follower setup """
+from arangodb.starter.deployments.runner import RunnerProperties
 from arangodb.starter.deployments.selenium_deployments.sbase import SeleniumRunner
 
 
 class NoStarter(SeleniumRunner):
     """check the leader follower setup and its properties"""
 
-    def __init__(self, webdriver, is_headless: bool, testrun_name: str, ssl: bool, selenium_include_suites: list[str]):
+    def __init__(self, selenium_args, properties: RunnerProperties, testrun_name: str, ssl: bool, selenium_include_suites: list[str]):
         # pylint: disable=useless-super-delegation
-        super().__init__(webdriver, is_headless, testrun_name, ssl, selenium_include_suites)
+        super().__init__(selenium_args, properties, testrun_name, ssl, selenium_include_suites)
 
     def check_old(self, cfg, leader_follower=False, expect_follower_count=2, retry_count=10):
         """check the integrity of the old system before the upgrade

release_tester/arangodb/starter/deployments/selenium_deployments/sbase.py

@@ -2,12 +2,12 @@
 """ base class for arangodb starter deployment selenium frontend tests """
 from abc import ABC
 import logging
-import os
-from pathlib import Path
 import re
-import shutil
 import time
 
+from arangodb.starter.deployments.runner import RunnerProperties
+from arangodb.starter.deployments.selenium_deployments.selenoid_swiper import cleanup_temp_files
+from arangodb.starter.deployments.selenium_deployments.selenium_session_spawner import spawn_selenium_session
 from allure_commons._allure import attach
 from allure_commons.types import AttachmentType
 from reporting.reporting_utils import step
@@ -17,50 +17,21 @@
 FNRX = re.compile("[\n@]*")
 
 
-def cleanup_temp_files(is_headless):
-    """attempt to cleanup the selenoid docker contaires leftovers"""
-    if is_headless and os.getuid() == 0:
-        tmpdir = "/tmp"  # tempfile.gettempdir()
-        trashme_rx = "(?:% s)" % f"|{tmpdir}/".join(
-            [
-                "pulse-*",
-                "xvfb-run.*",
-                ".X99-lock",
-                ".X11-unix",
-                ".org.chromium.Chromium.*",
-                ".com.google.Chrome.*",
-                ".org.chromium.Chromium.*",
-            ]
-        )
-        print(f"cleanup headless files: {str(trashme_rx)}")
-        for one_tmp_file in Path(tmpdir).iterdir():
-            print(f"checking {str(one_tmp_file)}")
-            try:
-                if re.match(trashme_rx, str(one_tmp_file)) and one_tmp_file.group() == "root":
-                    print(f"Purging: {str(one_tmp_file)}")
-                    if one_tmp_file.is_dir():
-                        shutil.rmtree(one_tmp_file)
-                    else:
-                        one_tmp_file.unlink()
-            except FileNotFoundError:
-                pass
 
 
 class SeleniumRunner(ABC):
     "abstract base class for selenium UI testing"
     # pylint: disable=line-too-long disable=too-many-public-methods disable=too-many-instance-attributes disable=too-many-arguments
-    def __init__(self, webdriver, is_headless: bool, testrun_name: str, ssl: bool, selenium_include_suites: list[str]):
+    def __init__(self,
+                 selenium_args,
+                 properties: RunnerProperties,
+                 testrun_name: str,
+                 ssl: bool,
+                 selenium_include_suites: list[str]):
         """hi"""
         self.ssl = ssl
-        self.is_headless = is_headless
         self.testrun_name = testrun_name
-        self.webdriver = webdriver
-        self.supports_console_flush = self.webdriver.capabilities["browserName"] == "chrome"
-        self.original_window_handle = None
         self.state = ""
-        time.sleep(3)
-        self.webdriver.set_window_size(1600, 900)
-        time.sleep(3)
         self.importer = None
         self.restorer = None
         self.ui_entrypoint_instance = None
@@ -73,6 +44,19 @@ def __init__(self, webdriver, is_headless: bool, testrun_name: str, ssl: bool, s
         self.jam_step_2_test_suite_list = []
         self.wait_for_upgrade_test_suite_list = []
         self.selenium_include_suites = selenium_include_suites
+        mylist = list(
+            selenium_args['selenium_driver_args'])
+        mylist.append(
+            f"selenoid:options=videoName={properties.short_name}_{testrun_name}.mp4".replace(
+                '\n', '_').replace('@', '_')
+        )
+        selenium_args['selenium_driver_args'] = mylist
+        (self.is_headless, self.webdriver) = spawn_selenium_session(**selenium_args)
+        self.supports_console_flush = self.webdriver.capabilities["browserName"] == "chrome"
+        self.original_window_handle = None
+        time.sleep(3)
+        self.webdriver.set_window_size(1600, 900)
+        time.sleep(3)
 
     def _cleanup_temp_files(self):
         cleanup_temp_files(self.is_headless)