hardpy 0.1.0__py3-none-any.whl

hardpy/pytest_hardpy/reporter/hook_reporter.py

@@ -0,0 +1,307 @@
+# Copyright (c) 2024 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from time import time, tzname
+from logging import getLogger
+from copy import deepcopy
+
+from natsort import natsorted
+
+from hardpy.pytest_hardpy.db import DatabaseField as DF
+from hardpy.pytest_hardpy.reporter.base import BaseReporter
+from hardpy.pytest_hardpy.utils import TestStatus, RunStatus, NodeInfo
+
+
+class HookReporter(BaseReporter):
+    """Reporter for using in the hook HardPy plugin's hooks."""
+
+    def __init__(self):  # noqa: WPS612
+        super().__init__()
+        self._log = getLogger(__name__)
+
+    def init_doc(self, doc_name: str):
+        """Initialize document.
+
+        Args:
+            doc_name (str): test run name
+        """
+        self.set_db_value(DF.NAME, doc_name)
+        self.set_db_value(DF.STATUS, TestStatus.READY)
+        self.set_db_value(DF.START_TIME, None)
+        self.set_db_value(DF.TIMEZONE, None)
+        self.set_db_value(DF.STOP_TIME, None)
+        self.set_db_value(DF.PROGRESS, 0)
+        self.set_db_value(DF.DRIVERS, {})
+        self.set_db_value(DF.ARTIFACT, {}, is_statestore=False)
+
+    def start(self):
+        """Start test."""
+        self._log.debug("Starting test run.")
+        start_time = int(time())
+        self.set_db_value(DF.START_TIME, start_time)
+        self.set_db_value(DF.STATUS, TestStatus.RUN)
+        self.set_db_value(DF.TIMEZONE, tzname)  # noqa: WPS432
+        self.set_db_value(DF.PROGRESS, 0)
+
+    def finish(self, status: RunStatus):
+        """Finish test.
+
+        This method must be called at the end of test run.
+        """
+        self._log.debug("Finishing test run.")
+        stop_time = int(time())
+        self.set_db_value(DF.STOP_TIME, stop_time)
+        self.set_db_value(DF.STATUS, status)
+
+        if self._statestore.get_document():
+            self._log.debug("Report StateStore has been successfully validated.")
+
+        if self._runstore.get_document():
+            self._log.debug("Report RunStore has been successfully validated.")
+
+        self._statestore.compact()
+        self._runstore.compact()
+
+    def set_progress(self, progress: int):
+        """Set test progress.
+
+        Args:
+            progress (int): test progress
+        """
+        self.set_db_value(DF.PROGRESS, progress)
+
+    def set_assertion_msg(self, module_id: str, case_id: str, msg: str | None):
+        """Set case assertion message.
+
+        Args:
+            module_id (str): test module id
+            case_id (str): test case id
+            msg (str): assertion message
+        """
+        key = self.generate_key(
+            DF.MODULES, module_id, DF.CASES, case_id, DF.ASSERTION_MSG
+        )
+        self.set_db_value(key, msg)
+
+    def add_case(self, node_info: NodeInfo):
+        """Add test case to document.
+
+        Args:
+            node_info (NodeInfo): node info
+        """
+        key = DF.MODULES
+        item_statestore = self._statestore.get_field(key)
+        item_runstore = self._runstore.get_field(key)
+
+        new_item_statestore = self._init_case(item_statestore, node_info)
+        new_item_runstore = self._init_case(
+            item_runstore,
+            node_info,
+            is_use_artifact=True,
+        )
+
+        self.set_db_value(key, new_item_statestore, is_runstore=False)
+        self.set_db_value(key, new_item_runstore, is_statestore=False)
+
+    def set_case_status(self, module_id: str, case_id: str, status: TestStatus):
+        """Set test case status.
+
+        Args:
+            module_id (str): module id
+            case_id (str): case id
+            status (TestStatus): test case status
+        """
+        key = self.generate_key(DF.MODULES, module_id, DF.CASES, case_id, DF.STATUS)
+        self.set_db_value(key, status)
+
+    def set_case_start_time(self, module_id: str, case_id: str):
+        """Set test case start_time.
+
+        Args:
+            module_id (str): module id
+            case_id (str): case id
+        """
+        key = self.generate_key(DF.MODULES, module_id, DF.CASES, case_id, DF.START_TIME)
+        self._set_time(key)
+
+    def set_case_stop_time(self, module_id: str, case_id: str):
+        """Set test case start_time.
+
+        Args:
+            module_id (str): module id
+            case_id (str): case id
+        """
+        key = self.generate_key(DF.MODULES, module_id, DF.CASES, case_id, DF.STOP_TIME)
+        self._set_time(key)
+
+    def set_module_status(self, module_id: str, status: TestStatus):
+        """Set test module status.
+
+        Args:
+            module_id (str): module id
+            status (TestStatus): test module status
+        """
+        key = self.generate_key(DF.MODULES, module_id, DF.STATUS)
+        self.set_db_value(key, status)
+
+    def set_module_start_time(self, module_id: str):
+        """Set test module status.
+
+        Args:
+            module_id (str): module id
+        """
+        key = self.generate_key(DF.MODULES, module_id, DF.START_TIME)
+        self._set_time(key)
+
+    def set_module_stop_time(self, module_id: str):
+        """Set test module status.
+
+        Args:
+            module_id (str): module id
+        """
+        key = self.generate_key(DF.MODULES, module_id, DF.STOP_TIME)
+        self._set_time(key)
+
+    def update_node_order(self, nodes: dict) -> None:
+        """Update node order.
+
+        Args:
+            nodes (dict): modules and cases.
+        """
+        key = DF.MODULES
+        old_modules = self._statestore.get_field(key)
+        modules_copy = deepcopy(old_modules)
+
+        rm_outdated_nodes = self._remove_outdate_node(old_modules, modules_copy, nodes)
+        updated_case_order = self._update_case_order(rm_outdated_nodes, nodes)
+        updated_module_order = self._update_module_order(updated_case_order)
+        self.set_db_value(key, updated_module_order, is_runstore=False)
+
+    def _set_time(self, key: str):
+        current_time = self._statestore.get_field(key)
+        if current_time is None:
+            self.set_db_value(key, int(time()))
+
+    def _init_case(
+        self, item: dict, node_info: NodeInfo, is_use_artifact: bool = False
+    ) -> dict:
+        module_default = {  # noqa: WPS204
+            DF.STATUS: TestStatus.READY,
+            DF.NAME: self._get_module_name(node_info),
+            DF.START_TIME: None,
+            DF.STOP_TIME: None,
+            DF.CASES: {},
+        }
+        case_default = {
+            DF.STATUS: TestStatus.READY,
+            DF.NAME: self._get_case_name(node_info),
+            DF.START_TIME: None,
+            DF.STOP_TIME: None,
+            DF.ASSERTION_MSG: None,
+            DF.MSG: None,
+        }
+
+        if item.get(node_info.module_id) is None:  # noqa: WPS204
+            if is_use_artifact:
+                module_default[DF.ARTIFACT] = {}
+            item[node_info.module_id] = module_default  # noqa: WPS204
+        else:
+            item[node_info.module_id][DF.STATUS] = TestStatus.READY
+            item[node_info.module_id][DF.NAME] = self._get_module_name(node_info)
+            item[node_info.module_id][DF.START_TIME] = None
+            item[node_info.module_id][DF.STOP_TIME] = None
+        item[node_info.module_id][DF.NAME] = self._get_module_name(node_info)
+
+        if is_use_artifact:
+            case_default[DF.ARTIFACT] = {}
+        item[node_info.module_id][DF.CASES][node_info.case_id] = case_default
+
+        return item
+
+    def _remove_outdate_node(
+        self, old_modules: dict, new_modules: dict, nodes: dict
+    ) -> dict:
+        """Remove outdated nodes from StateStore database.
+
+        Args:
+            old_modules (dict): list of modules and cases.
+            new_modules (dict): list of modules and cases.
+            nodes (dict): modules and cases.
+
+        Returns:
+            dict: list of modules and cases.
+        """
+        for module_id, module in old_modules.items():
+            # remove outdated modules
+            if module_id not in nodes:
+                new_modules.pop(module_id)
+                continue
+            # remove outdated cases in module
+            for case_id in module[DF.CASES]:
+                if case_id not in nodes[module_id]:
+                    new_modules[module_id][DF.CASES].pop(case_id)
+
+        return new_modules
+
+    def _update_case_order(self, modules: dict, nodes: dict) -> dict:
+        """Update test order for StateStore database.
+
+        Args:
+            modules (dict): list of modules and cases.
+            nodes (dict): modules and cases.
+
+        Returns:
+            dict: list of modules and cases.
+        """
+        for module_id, module in modules.items():
+            nodes_order = nodes.get(module_id, [])
+            modules_order = list(module.get(DF.CASES).keys())
+            if nodes_order != modules_order:
+                # sort cases in module
+                sorted_cases = {}
+                for case_name in nodes_order:
+                    case_data = module[DF.CASES].get(case_name, {})
+                    sorted_cases[case_name] = case_data
+                module[DF.CASES] = sorted_cases
+
+        return modules
+
+    def _update_module_order(self, modules: dict) -> dict:
+        """Update test order for StateStore database.
+
+        Args:
+            modules (dict): list of modules and cases.
+
+        Returns:
+            dict: list of modules and cases.
+        """
+
+        sorted_modules = natsorted(modules.items(), key=lambda item: item[0])
+
+        new_modules = {}
+        for module_id, module in sorted_modules:
+            new_modules[module_id] = module
+
+        return new_modules
+
+    def _get_module_name(self, node_info) -> str:
+        """Get module name from markers or use default.
+
+        Args:
+            node_info (NodeInfo): node info
+
+        Returns:
+            str: module name
+        """
+        return node_info.module_name if node_info.module_name else node_info.module_id
+
+    def _get_case_name(self, node_info) -> str:
+        """Get case name from markers or use default.
+
+        Args:
+            node_info (NodeInfo): node info
+
+        Returns:
+            str: case name
+        """
+        return node_info.case_name if node_info.case_name else node_info.case_id

hardpy/pytest_hardpy/reporter/runner_reporter.py

@@ -0,0 +1,29 @@
+# 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 typing import Any
+
+from hardpy.pytest_hardpy.reporter.base import BaseReporter
+from hardpy.pytest_hardpy.utils import Singleton
+
+
+class RunnerReporter(Singleton, BaseReporter):
+    """Reporter for using in direct call from test runner with HardPy plugin."""
+
+    def __init__(self):
+        if not self._initialized:
+            super().__init__()
+            self._log = getLogger(__name__)
+            self._initialized = True
+
+    def get_field(self, key: str) -> Any:
+        """Get field from the statestore.
+
+        Args:
+            key (str): field name
+
+        Returns:
+            Any: field value
+        """
+        return self._statestore.get_field(key)

hardpy/pytest_hardpy/result/__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.result.report_reader.couchdb_reader import CouchdbReader
+from hardpy.pytest_hardpy.result.report_loader.couchdb_loader import CouchdbLoader
+
+__all__ = [
+    "CouchdbReader",
+    "CouchdbLoader",
+]

hardpy/pytest_hardpy/result/couchdb_config.py

@@ -0,0 +1,22 @@
+# Copyright (c) 2024 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from dataclasses import dataclass
+
+
+@dataclass
+class CouchdbConfig:  # noqa: WPS306
+    """CouchDB loader config."""
+
+    db_name: str = "report"
+    user: str = "dev"
+    password: str = "dev"
+    host: str = "localhost"
+    port: int = 5984
+
+    @property
+    def connection_string(self) -> str:
+        """Get couchdb connection string."""
+        credentials = f"{self.user}:{self.password}"
+        uri = f"{self.host}:{str(self.port)}"
+        return f"http://{credentials}@{uri}/"

hardpy/pytest_hardpy/result/report_loader/__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.result.report_loader.couchdb_loader import (
+    CouchdbLoader,
+)
+
+__all__ = [
+    "CouchdbLoader",
+]

hardpy/pytest_hardpy/result/report_loader/couchdb_loader.py

@@ -0,0 +1,62 @@
+# 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 pycouchdb import Server as DbServer
+from pycouchdb.exceptions import Conflict
+from pycouchdb.client import Database
+
+from hardpy.pytest_hardpy.db.schema import ResultRunStore
+from hardpy.pytest_hardpy.result.couchdb_config import CouchdbConfig
+
+
+class CouchdbLoader(object):
+    """CouchDB report generator."""
+
+    def __init__(self, config: CouchdbConfig):
+        self._log = getLogger(__name__)
+        self._config: CouchdbConfig = config
+        self._db_srv = DbServer(config.connection_string)
+        self._db: Database = self._init_db()
+
+    def load(self, report: ResultRunStore) -> bool:
+        """Load report to the report database.
+
+        Args:
+            report (ResultRunStore): report
+
+        Returns:
+            bool: True if success, else False
+        """
+        report_id = self._get_report_id(report)
+        report_dict = self._schema_to_dict(report, report_id)
+        try:
+            self._db.save(report_dict)
+        except Conflict as exc:
+            self._log.error(f"Error while saving report {report_id}: {exc}")
+            return False
+        self._log.debug(f"Report saved with id: {report_id}")
+        return True
+
+    def _init_db(self) -> Database:
+        try:
+            return self._db_srv.create(self._config.db_name)  # type: ignore
+        except Conflict:
+            # database is already created
+            return self._db_srv.database(self._config.db_name)
+
+    def _get_report_id(self, report: ResultRunStore) -> str:
+        timestamp = report.stop_time
+        device_serial_number = report.dut.serial_number
+        if not device_serial_number:
+            self._log.warning("Device serial number is not provided in the report.")
+            return f"report_{timestamp}"
+        return f"report_{timestamp}_{device_serial_number}"
+
+    def _schema_to_dict(self, report: ResultRunStore, report_id: str) -> dict:
+        report_dict = report.model_dump()
+        report_dict.pop("rev")
+        report_dict.pop("id")
+        report_dict["_id"] = report_id
+        return report_dict

hardpy/pytest_hardpy/result/report_reader/couchdb_reader.py

@@ -0,0 +1,164 @@
+# 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 dataclasses import dataclass
+from typing import List, Optional
+
+from pycouchdb import Server as DbServer
+from pycouchdb.client import Database
+from pycouchdb.exceptions import NotFound
+
+from hardpy.pytest_hardpy.db import DatabaseField as DF
+from hardpy.pytest_hardpy.utils.const import TestStatus
+from hardpy.pytest_hardpy.result.couchdb_config import CouchdbConfig
+
+
+@dataclass
+class ReportInfo(object):
+    """CouchDB report info."""
+
+    name: str
+    status: str
+    start_time: str
+    end_time: str
+    first_failed_test_name: Optional[str]
+    first_failed_test_id: Optional[str]
+
+
+class CouchdbReader(object):
+    """CouchDB report info reader."""
+
+    def __init__(self, config: CouchdbConfig):
+        self._log = getLogger(__name__)
+        self._config = config
+        self._db_srv = DbServer(config.connection_string)
+        self._db: Database = self._init_db()
+        self._doc_id = "doc"
+
+    def get_report_total_count(self) -> int:
+        """Get the total number of reports in the database.
+
+        Returns:
+            int: total number of reports
+        """
+        return sum(1 for _ in self._db.all())
+
+    def get_report_count_in_timeframe(self, start_time: int, end_time: int) -> int:
+        """Get the number of reports in the database within the specified timeframe.
+
+        Args:
+            start_time (int): start time
+            end_time (int): end time
+
+        Raises:
+            ValueError: if start time or end time is negative
+
+        Returns:
+            int: number of reports
+        """
+        if start_time < 0 or end_time < 0:
+            raise ValueError("Start time and end time must be positive values")
+        return sum(
+            1
+            for report in self._db.all()
+            if self._is_in_timeframe(
+                self._get_start_time_from_db(report[self._doc_id]),
+                self._get_stop_time_from_db(report[self._doc_id]),
+                start_time,
+                end_time,
+            )
+        )
+
+    def get_report_status(self, report_name: str) -> str:
+        """Get the status of a report by its name.
+
+        Args:
+            report_name (str): report name
+
+        Raises:
+            ValueError: if the report status is not valid
+
+        Returns:
+            str: report status
+        """
+        doc = self._db.get(report_name)
+        status = doc[DF.STATUS]
+        if status not in {TestStatus.PASSED, TestStatus.FAILED, TestStatus.SKIPPED}:
+            raise ValueError("Invalid report status")
+        return status
+
+    def get_report_infos(self) -> List[ReportInfo]:
+        """Get a list of information about all reports in the database.
+
+        Returns:
+            List[ReportInfo]: list of report information
+        """
+        reports_info = []
+        reports = self._db.all()
+        for report in reports:
+            report_info = self._get_single_report_info(report)
+            reports_info.append(report_info)
+        return reports_info
+
+    def get_report_infos_in_timeframe(
+        self, start_time: int, end_time: int
+    ) -> List[ReportInfo]:
+        """Get a list of information about reports in a timeframe in the database.
+
+        Args:
+            start_time (int): start time
+            end_time (int): end time
+
+        Raises:
+            ValueError: if start time or end time is negative
+
+        Returns:
+            List[ReportInfo]: list of report information
+        """
+        if start_time < 0 or end_time < 0:
+            raise ValueError("Start time and end time must be positive values")
+
+        reports_info = []
+        reports = self._db.all()
+        for report in reports:
+            start_t_db = self._get_start_time_from_db(report[self._doc_id])
+            stop_t_db = self._get_stop_time_from_db(report[self._doc_id])
+            if self._is_in_timeframe(start_t_db, stop_t_db, start_time, end_time):
+                report_info = self._get_single_report_info(report)
+                reports_info.append(report_info)
+        return reports_info
+
+    def _init_db(self) -> Database:
+        try:
+            return self._db_srv.database(self._config.db_name)
+        except NotFound as exc:
+            self._log.error(f"Error initializing database: {exc}")
+            raise RuntimeError("Error initializing database") from exc
+
+    def _get_start_time_from_db(self, doc: dict) -> str:
+        return doc[DF.START_TIME]
+
+    def _get_stop_time_from_db(self, doc: dict) -> str:
+        return doc[DF.STOP_TIME]
+
+    def _get_single_report_info(self, report: dict) -> ReportInfo:
+        first_failed_test_name = None
+        first_failed_test_id = None
+        report_doc = report[self._doc_id]
+        for _module_name, module_info in report_doc[DF.MODULES].items():
+            for case_name, case_info in module_info[DF.CASES].items():
+                if case_info[DF.STATUS] == TestStatus.FAILED:
+                    first_failed_test_name = case_info[DF.NAME]
+                    first_failed_test_id = case_name
+        return ReportInfo(
+            name=report_doc["_id"],
+            status=report_doc[DF.STATUS],
+            start_time=self._get_start_time_from_db(report_doc),
+            end_time=self._get_stop_time_from_db(report_doc),
+            first_failed_test_name=first_failed_test_name,
+            first_failed_test_id=first_failed_test_id,
+        )
+
+    def _is_in_timeframe(self, start, end, timeframe_start, timeframe_end):
+        return timeframe_start <= start and end <= timeframe_end

hardpy/pytest_hardpy/utils/__init__.py

@@ -0,0 +1,19 @@
+# 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.utils.node_info import NodeInfo
+from hardpy.pytest_hardpy.utils.progress_calculator import ProgressCalculator
+from hardpy.pytest_hardpy.utils.const import TestStatus, RunStatus
+from hardpy.pytest_hardpy.utils.singleton import Singleton
+from hardpy.pytest_hardpy.utils.config_data import ConfigData
+from hardpy.pytest_hardpy.utils.exception import DuplicateSerialNumberError
+
+__all__ = [
+    "NodeInfo",
+    "ProgressCalculator",
+    "TestStatus",
+    "RunStatus",
+    "Singleton",
+    "ConfigData",
+    "DuplicateSerialNumberError",
+]

hardpy/pytest_hardpy/utils/config_data.py

@@ -0,0 +1,31 @@
+# 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.utils.singleton import Singleton
+from pathlib import Path
+
+
+class ConfigData(Singleton):
+    """Web connection data storage."""
+
+    def __init__(self):
+        if not self._initialized:
+            self.db_host: str = "localhost"
+            self.db_user: str = "dev"
+            self.db_pswd: str = "dev"
+            self.db_port: int = 5984
+            self.web_host: str = "0.0.0.0"
+            self.web_port: int = 8000
+            self.tests_dir = Path.cwd()
+            self._initialized = True
+
+    @property
+    def connection_string(self) -> str:
+        """Get couchdb connection string.
+
+        Returns:
+            str: couchdb connection string
+        """
+        credentials = f"{self.db_user}:{self.db_pswd}"
+        uri = f"{self.db_host}:{str(self.db_port)}"  # noqa: WPS237
+        return f"http://{credentials}@{uri}/"

hardpy/pytest_hardpy/utils/const.py

@@ -0,0 +1,29 @@
+# Copyright (c) 2024 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from enum import Enum
+
+
+class TestStatus(str, Enum):  # noqa: WPS600
+    """Pytest test status."""
+
+    PASSED = "passed"
+    FAILED = "failed"
+    SKIPPED = "skipped"
+    ERROR = "error"
+    RUN = "run"
+    READY = "ready"
+    STOPPED = "stopped"
+
+
+class RunStatus(str, Enum):  # noqa: WPS600
+    """Pytest run status."""
+
+    PASSED = "passed"
+    FAILED = "failed"
+    STOPPED = "stopped"
+    STARTED = "started"
+    COLLECTED = "collected"
+    BUSY = "busy"
+    READY = "ready"
+    ERROR = "error"