hardpy 0.1.0__py3-none-any.whl

hardpy/pytest_hardpy/plugin.py

@@ -0,0 +1,244 @@
+# Copyright (c) 2024 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+import signal
+from typing import Any, Callable
+from logging import getLogger
+from pathlib import Path, PurePath
+from platform import system
+
+from natsort import natsorted
+from pytest import (
+    exit,
+    TestReport,
+    Item,
+    Session,
+    Config,
+    Parser,
+    fixture,
+    ExitCode,
+)
+
+from hardpy.pytest_hardpy.reporter import HookReporter
+from hardpy.pytest_hardpy.utils import (
+    TestStatus,
+    RunStatus,
+    NodeInfo,
+    ProgressCalculator,
+    ConfigData,
+)
+
+
+def pytest_addoption(parser: Parser):
+    """Register argparse-style options."""
+    config_data = ConfigData()
+    # fmt: off
+    parser.addoption("--hardpy-dbu", action="store", default=config_data.db_user, help="database user")  # noqa: E501
+    parser.addoption("--hardpy-dbpw", action="store", default=config_data.db_pswd, help="database user password")  # noqa: E501
+    parser.addoption("--hardpy-dbp", action="store", default=config_data.db_port, help="database port number")  # noqa: E501
+    parser.addoption("--hardpy-dbh", action="store", default=config_data.db_host, help="database hostname")  # noqa: E501
+    # fmt: on
+
+
+class HardpyPlugin(object):
+    """HardPy integration plugin for pytest.
+
+    Extends hook functions from pytest API.
+    """
+
+    def __init__(self):
+        self._progress = ProgressCalculator()
+        self._results = {}
+        self._post_run_functions: list[Callable] = []
+
+        if system() == "Linux":
+            signal.signal(signal.SIGTERM, self._stop_handler)
+        elif system() == "Windows":
+            signal.signal(signal.SIGBREAK, self._stop_handler)
+        self._log = getLogger(__name__)
+
+    # Initialization hooks
+
+    def pytest_configure(self, config: Config):
+        """Configure pytest."""
+        config_data = ConfigData()
+        config_data.db_user = config.getoption("--hardpy-dbu")
+        config_data.db_host = config.getoption("--hardpy-dbh")
+        config_data.db_pswd = config.getoption("--hardpy-dbpw")
+        config_data.db_port = config.getoption("--hardpy-dbp")
+
+        config.addinivalue_line("markers", "case_name")
+        config.addinivalue_line("markers", "module_name")
+
+        # must be init after config data is set
+        self._reporter = HookReporter()
+
+    def pytest_sessionfinish(self, session: Session, exitstatus: int):
+        """Call at the end of test session.
+
+        Args:
+            session (Session): session description
+            exitstatus (int): exit test status
+        """
+        if "--collect-only" in session.config.invocation_params.args:
+            return
+        status = self._get_run_status(exitstatus)
+        self._reporter.finish(status)
+
+        # call post run methods
+        if self._post_run_functions:
+            for action in self._post_run_functions:
+                action()
+
+    # Collection hooks
+
+    def pytest_collection_modifyitems(
+        self, session: Session, config: Config, items: list[Item]
+    ):
+        """Call after collection phase."""
+        self._reporter.init_doc(str(PurePath(config.rootpath).name))
+
+        nodes = {}
+
+        session.items = natsorted(
+            session.items,
+            key=lambda x: x.parent.name if x.parent is not None else x.name,
+        )
+        for item in session.items:
+            if item.parent is None:
+                continue
+            node_info = NodeInfo(item)
+
+            self._init_case_result(node_info.module_id, node_info.case_id)
+
+            if node_info.module_id not in nodes:
+                nodes[node_info.module_id] = [node_info.case_id]
+            else:
+                nodes[node_info.module_id].append(node_info.case_id)
+
+            self._reporter.add_case(node_info)
+            self._reporter.set_module_status(node_info.module_id, TestStatus.READY)
+        self._reporter.update_node_order(nodes)
+
+    # Test running (runtest) hooks
+
+    def pytest_runtestloop(self, session: Session):
+        """Call at the start of test run."""
+        self._progress.set_test_amount(session.testscollected)
+        if session.config.option.collectonly:
+            # ignore collect only mode
+            return True
+
+        # testrun entrypoint
+        self._reporter.start()
+
+    def pytest_runtest_setup(self, item: Item):
+        """Call before each test setup phase."""
+        if item.parent is None:
+            self._log.error(f"Test module name for test {item.name} not found.")
+            return
+
+        node_info = NodeInfo(item)
+
+        self._reporter.set_module_status(node_info.module_id, TestStatus.RUN)
+        self._reporter.set_module_start_time(node_info.module_id)
+        self._reporter.set_case_status(
+            node_info.module_id,
+            node_info.case_id,
+            TestStatus.RUN,
+        )
+        self._reporter.set_case_start_time(
+            node_info.module_id,
+            node_info.case_id,
+        )
+
+    # Reporting hooks
+
+    def pytest_runtest_logreport(self, report: TestReport):
+        """Call after call of each test item."""
+        if report.when != "call":
+            # ignore setup and teardown phase
+            return True
+
+        module_id = Path(report.fspath).stem
+        case_id = report.nodeid.rpartition("::")[2]
+
+        self._reporter.set_case_status(
+            module_id,
+            case_id,
+            TestStatus(report.outcome),
+        )
+        self._reporter.set_case_stop_time(
+            module_id,
+            case_id,
+        )
+
+        assertion_msg = self._decode_assertion_msg(report.longreprtext)
+        self._reporter.set_assertion_msg(module_id, case_id, assertion_msg)
+        self._reporter.set_progress(self._progress.calculate(report.nodeid))
+        self._results[module_id][case_id] = report.outcome  # noqa: WPS204
+
+        if None not in self._results[module_id].values():
+            self._collect_module_result(module_id)
+
+    # Fixture
+
+    @fixture(scope="session")
+    def post_run_functions(self) -> list[Callable]:
+        """Get post run methods list.
+
+        Fill this list in conftest.py and functions from this
+        list will be called after tests running (in the end of pytest_sessionfinish).
+
+        Returns:
+            list[Callable]: list of post run methods
+        """
+        return self._post_run_functions
+
+    # Not hooks
+
+    def _stop_handler(self, signum: int, frame: Any):
+        exit("Tests stopped by user")
+
+    def _init_case_result(self, module_id: str, case_id: str):
+        if self._results.get(module_id) is None:
+            self._results[module_id] = {
+                "module_status": TestStatus.READY,
+                case_id: None,
+            }
+        else:
+            self._results[module_id][case_id] = None
+
+    def _collect_module_result(self, module_id: str):
+        if TestStatus.ERROR in self._results[module_id].values():
+            status = TestStatus.ERROR
+        elif TestStatus.FAILED in self._results[module_id].values():
+            status = TestStatus.FAILED
+        elif TestStatus.SKIPPED in self._results[module_id].values():
+            status = TestStatus.SKIPPED
+        else:
+            status = TestStatus.PASSED
+        self._results[module_id]["module_status"] = status
+        self._reporter.set_module_status(module_id, status)
+        self._reporter.set_module_stop_time(module_id)
+
+    def _get_run_status(self, exitstatus: int) -> RunStatus:
+        match exitstatus:
+            case ExitCode.OK:
+                return RunStatus.PASSED
+            case ExitCode.TESTS_FAILED:
+                return RunStatus.FAILED
+            case ExitCode.INTERRUPTED:
+                return RunStatus.STOPPED
+            case _:
+                return RunStatus.ERROR
+
+    def _decode_assertion_msg(self, msg: str) -> str | None:
+        assertion_str = "AssertionError: "
+
+        if assertion_str in msg:
+            index = msg.find(assertion_str)
+            report = msg[index + len(assertion_str) :]
+            index = report.find("\nE")
+            return report[:index]
+        return None

hardpy/pytest_hardpy/pytest_call.py

@@ -0,0 +1,218 @@
+# Copyright (c) 2024 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from os import environ
+from dataclasses import dataclass
+from typing import Optional
+from uuid import uuid4
+
+from pycouchdb.exceptions import NotFound
+from pydantic import ValidationError
+
+from hardpy.pytest_hardpy.db import (
+    DatabaseField as DF,
+    ResultRunStore,
+    RunStore,
+)
+from hardpy.pytest_hardpy.utils import DuplicateSerialNumberError
+from hardpy.pytest_hardpy.reporter import RunnerReporter
+
+
+@dataclass
+class CurrentTestInfo(object):
+    """Current test info."""
+
+    module_id: str
+    case_id: str
+
+
+def get_current_report() -> ResultRunStore | None:
+    """Get current report from runstore database.
+
+    Returns:
+        ResultRunStore | None: report, or None if not found or invalid
+    """
+    runstore = RunStore()
+    try:
+        return runstore.get_document()
+    except NotFound:
+        return None
+    except ValidationError:
+        return None
+    except TypeError:
+        return None
+
+
+def set_dut_info(info: dict):
+    """Add DUT info to document.
+
+    Args:
+        info (dict): DUT info
+    """
+    reporter = RunnerReporter()
+    for dut_key, dut_value in info.items():
+        key = reporter.generate_key(DF.DUT, DF.INFO, dut_key)
+        reporter.set_db_value(key, dut_value)
+
+
+def set_dut_serial_number(serial_number: str):
+    """Add DUT serial number to document.
+
+    Args:
+        serial_number (str): DUT serial number
+
+    Raises:
+        DuplicateSerialNumberError: if serial number is already set
+    """
+    reporter = RunnerReporter()
+    key = reporter.generate_key(DF.DUT, DF.SERIAL_NUMBER)
+    if reporter.get_field(key):
+        raise DuplicateSerialNumberError
+    reporter.set_db_value(key, serial_number)
+
+
+def set_stand_info(info: dict):
+    """Add test stand info to document.
+
+    Args:
+        info (dict): test stand info
+    """
+    reporter = RunnerReporter()
+    for stand_key, stand_value in info.items():
+        key = reporter.generate_key(DF.TEST_STAND, stand_key)
+        reporter.set_db_value(key, stand_value)
+
+
+def set_message(msg: str, msg_key: Optional[str] = None) -> None:
+    """Add or update message in current test.
+
+    Args:
+        msg (str): Message content.
+        msg_key (Optional[str]): Message ID.
+                                     If not specified, a random ID will be generated.
+    """
+    current_test = _get_current_test()
+    reporter = RunnerReporter()
+
+    if msg_key is None:
+        msg_key = str(uuid4())
+
+    key = reporter.generate_key(
+        DF.MODULES,
+        current_test.module_id,
+        DF.CASES,
+        current_test.case_id,
+        DF.MSG,
+    )
+
+    msgs = reporter.get_field(key)
+    if msgs is None:
+        msgs = {}
+
+    msgs[msg_key] = msg
+
+    reporter.set_db_value(key, msgs)
+
+
+def set_case_artifact(data: dict):
+    """Add data to current test case.
+
+    Artifact saves only in RunStore database
+    because state in StateStore and case artifact must be separated.
+
+    Args:
+        data (dict): data
+    """
+    current_test = _get_current_test()
+    reporter = RunnerReporter()
+    for stand_key, stand_value in data.items():
+        key = reporter.generate_key(
+            DF.MODULES,
+            current_test.module_id,
+            DF.CASES,
+            current_test.case_id,
+            DF.ARTIFACT,
+            stand_key,
+        )
+        reporter.set_db_value(key, stand_value, is_statestore=False)
+
+
+def set_module_artifact(data: dict):
+    """Add data to current test module.
+
+    Artifact saves only in RunStore database
+    because state in StateStore and module artifact must be separated.
+
+    Args:
+        data (dict): data
+    """
+    current_test = _get_current_test()
+    reporter = RunnerReporter()
+    for artifact_key, artifact_value in data.items():
+        key = reporter.generate_key(
+            DF.MODULES,
+            current_test.module_id,
+            DF.ARTIFACT,
+            artifact_key,
+        )
+        reporter.set_db_value(key, artifact_value, is_statestore=False)
+
+
+def set_run_artifact(data: dict):
+    """Add data to current test run.
+
+    Artifact saves only in RunStore database
+    because state in StateStore and run artifact must be separated.
+
+    Args:
+        data (dict): data
+    """
+    reporter = RunnerReporter()
+    for artifact_key, artifact_value in data.items():
+        key = reporter.generate_key(
+            DF.ARTIFACT,
+            artifact_key,
+        )
+        reporter.set_db_value(key, artifact_value, is_statestore=False)
+
+
+def set_driver_info(drivers: dict) -> None:
+    """Adds or updates drivers data.
+
+    Driver data is stored in both StateStore and RunStore databases.
+
+    Args:
+        drivers (dict): A dictionary of drivers, where keys are driver names
+                        and values are driver-specific data.
+    """
+    reporter = RunnerReporter()
+
+    for driver_name, driver_data in drivers.items():
+        key = reporter.generate_key(
+            DF.DRIVERS,
+            driver_name,
+        )
+        reporter.set_db_value(key, driver_data)
+
+
+def _get_current_test() -> CurrentTestInfo:
+    current_node = environ.get("PYTEST_CURRENT_TEST")
+
+    if current_node is None:
+        raise RuntimeError("PYTEST_CURRENT_TEST variable is not set")
+
+    module_delimiter = ".py::"
+    module_id_end_index = current_node.find(module_delimiter)
+    module_id = current_node[:module_id_end_index]
+
+    folder_delimeter = "/"
+    folder_delimeter_index = current_node.rfind(folder_delimeter)
+    if folder_delimeter_index != -1:
+        module_id = module_id[folder_delimeter_index + 1 :]
+
+    case_with_stage = current_node[module_id_end_index + len(module_delimiter) :]
+    case_delimiter = " "
+    case_id_end_index = case_with_stage.find(case_delimiter)
+    case_id = case_with_stage[:case_id_end_index]
+
+    return CurrentTestInfo(module_id=module_id, case_id=case_id)

hardpy/pytest_hardpy/pytest_wrapper.py

@@ -0,0 +1,117 @@
+# Copyright (c) 2024 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+import sys
+import signal
+import subprocess
+from platform import system
+
+from hardpy.pytest_hardpy.utils.config_data import ConfigData
+
+
+class PyTestWrapper(object):
+    """Wrapper for pytest subprocess."""
+
+    def __init__(self):
+        self._proc = None
+        self.python_executable = sys.executable
+
+        # Make sure test structure is stored in DB
+        # before clients come in
+        self.config = ConfigData()
+        self.collect()
+
+    def start(self):
+        """Start pytest subprocess.
+
+        Returns True if pytest was started.
+        """
+        if self.python_executable is None:
+            return False
+
+        if self.is_running():
+            return False
+
+        if system() == "Linux":
+            self._proc = subprocess.Popen(  # noqa: S603
+                [
+                    self.python_executable,
+                    "-m",
+                    "pytest",
+                    "--hardpy-dbp",
+                    str(self.config.db_port),
+                    "--hardpy-dbh",
+                    self.config.db_host,
+                    "--hardpy-dbu",
+                    self.config.db_user,
+                    "--hardpy-dbpw",
+                    self.config.db_pswd,
+                ],
+                cwd=self.config.tests_dir.absolute(),
+            )
+        elif system() == "Windows":
+            self._proc = subprocess.Popen(  # noqa: S603
+                [
+                    self.python_executable,
+                    "-m",
+                    "pytest",
+                    "--hardpy-dbp",
+                    str(self.config.db_port),
+                    "--hardpy-dbh",
+                    self.config.db_host,
+                    "--hardpy-dbu",
+                    self.config.db_user,
+                    "--hardpy-dbpw",
+                    self.config.db_pswd,
+                ],
+                cwd=self.config.tests_dir.absolute(),
+                creationflags=subprocess.CREATE_NEW_PROCESS_GROUP,
+            )
+
+        return True
+
+    def stop(self) -> bool:
+        """Stop pytest subprocess.
+
+        Returns True if pytest was running and stopped.
+        """
+        if self.is_running() and self._proc:
+            if system() == "Linux":
+                self._proc.terminate()
+            elif system() == "Windows":
+                self._proc.send_signal(signal.CTRL_BREAK_EVENT)
+            return True
+        return False
+
+    def collect(self) -> bool:
+        """Perform pytest collection.
+
+        Returns True if collection was started.
+        """
+        if self.python_executable is None:
+            return False
+
+        if self.is_running():
+            return False
+
+        subprocess.Popen(  # noqa: S603
+            [
+                self.python_executable,
+                "-m" "pytest",
+                "--collect-only",
+                "--hardpy-dbp",
+                str(self.config.db_port),
+                "--hardpy-dbh",
+                self.config.db_host,
+                "--hardpy-dbu",
+                self.config.db_user,
+                "--hardpy-dbpw",
+                self.config.db_pswd,
+            ],
+            cwd=self.config.tests_dir.absolute(),
+        )
+        return True
+
+    def is_running(self) -> bool | None:
+        """Check if pytest is running."""
+        return self._proc and self._proc.poll() is None

hardpy/pytest_hardpy/reporter/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) 2024 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from hardpy.pytest_hardpy.reporter.runner_reporter import RunnerReporter
+from hardpy.pytest_hardpy.reporter.hook_reporter import HookReporter
+
+__all__ = [
+    "RunnerReporter",
+    "HookReporter",
+]

hardpy/pytest_hardpy/reporter/base.py

@@ -0,0 +1,42 @@
+# Copyright (c) 2024 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from logging import getLogger
+
+from hardpy.pytest_hardpy.db import StateStore, RunStore
+
+
+class BaseReporter(object):
+    """Base class for test reporter."""
+
+    def __init__(self):
+        self._statestore = StateStore()
+        self._runstore = RunStore()
+        self._log = getLogger(__name__)
+
+    def set_db_value(self, key: str, value, is_statestore=True, is_runstore=True):
+        """Set value to database.
+
+        Args:
+            key (str): database key
+            value (_type_): database value
+            is_statestore (bool, optional): indicates whether data should
+                                             be written to StateStore. Defaults to True.
+            is_runstore (bool, optional): indicates whether data should
+                                            be written to RunStore. Defaults to True.
+        """
+        if is_statestore:
+            self._statestore.set_value(key, value)
+        if is_runstore:
+            self._runstore.set_value(key, value)
+
+    def generate_key(self, *args) -> str:
+        """Generate key for database.
+
+        Args:
+            args: list of database keys
+
+        Returns:
+            str: database key
+        """
+        return ".".join(args)