hardpy 0.5.1__py3-none-any.whl → 0.6.1__py3-none-any.whl

hardpy/pytest_hardpy/db/base_connector.py

@@ -1,8 +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 requests.exceptions import ConnectionError
+
 from pycouchdb.client import Database
-from pycouchdb.exceptions import Conflict
+from pycouchdb.exceptions import Conflict, GenericError
 
 from hardpy.pytest_hardpy.db.base_server import BaseServer
 
@@ -22,3 +24,7 @@ class BaseConnector(BaseServer):
         except Conflict:
             # database is already created
             return self._db_srv.database(self._db_name)
+        except GenericError as exc:
+            raise RuntimeError(f"Error initializing database {exc}") from exc
+        except ConnectionError as exc:
+            raise RuntimeError(f"Error initializing database: {exc}") from exc

hardpy/pytest_hardpy/db/base_server.py

@@ -3,12 +3,12 @@
 
 from pycouchdb import Server as DbServer
 
-from hardpy.pytest_hardpy.utils import ConfigData
+from hardpy.pytest_hardpy.utils import ConnectionData
 
 
-class BaseServer(object):
+class BaseServer:
     """Base class for CouchDB server."""
 
     def __init__(self):
-        config = ConfigData()
-        self._db_srv = DbServer(config.connection_string)
+        con_data = ConnectionData()
+        self._db_srv = DbServer(con_data.database_url)

hardpy/pytest_hardpy/db/base_store.py

@@ -78,20 +78,30 @@ class BaseStore(BaseConnector):
                 DF.MODULES: {},
                 DF.DUT: {
                     DF.SERIAL_NUMBER: None,
+                    DF.PART_NUMBER: None,
+                    DF.INFO: {},
+                },
+                DF.TEST_STAND: {
+                    DF.NAME: None,
                     DF.INFO: {},
                 },
-                DF.TEST_STAND: {},
                 DF.DRIVERS: {},
             }
 
+        # init document
         if DF.MODULES not in doc:
             doc[DF.MODULES] = {}
 
-        for item in (DF.TEST_STAND, DF.DRIVERS):
-            doc[item] = {}
+        doc[DF.DRIVERS] = {}
 
         doc[DF.DUT] = {
             DF.SERIAL_NUMBER: None,
+            DF.PART_NUMBER: None,
+            DF.INFO: {},
+        }
+
+        doc[DF.TEST_STAND] = {
+            DF.NAME: None,
             DF.INFO: {},
         }
 

hardpy/pytest_hardpy/db/const.py

@@ -19,8 +19,11 @@ class DatabaseField(str, Enum):  # noqa: WPS600
     PROGRESS = "progress"
     ARTIFACT = "artifact"
     DUT = "dut"
+    PART_NUMBER = "part_number"
     INFO = "info"
     TEST_STAND = "test_stand"
     SERIAL_NUMBER = "serial_number"
     DRIVERS = "drivers"
     DIALOG_BOX = "dialog_box"
+    OPERATOR_MSG = "operator_msg"
+    ATTEMPT = "attempt"

hardpy/pytest_hardpy/db/schema.py

@@ -1,8 +1,6 @@
 # Copyright (c) 2024 Everypin
 # GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
 
-from typing import Optional
-
 from pydantic import BaseModel, Field, ConfigDict
 
 from hardpy.pytest_hardpy.utils import TestStatus as Status
@@ -30,6 +28,7 @@ class CaseStateStore(IBaseResult):
         "stop_time": 1695817189,
         "assertion_msg": null,
         "msg": null,
+        "attempt": 1,
         "dialog_box": {
           "title_bar": "Example of text input",
           "dialog_text": "Type some text and press the Confirm button",
@@ -46,6 +45,7 @@ class CaseStateStore(IBaseResult):
     assertion_msg: str | None = None
     msg: dict | None = None
     dialog_box: dict = {}
+    attempt: int = 0
 
 
 class CaseRunStore(IBaseResult):
@@ -59,13 +59,15 @@ class CaseRunStore(IBaseResult):
         "stop_time": 1695817189,
         "assertion_msg": null,
         "msg": null,
+        "attempt": 1,
         "artifact": {}
     }
     """
 
     assertion_msg: str | None = None
     msg: dict | None = None
-    artifact: Optional[dict] = {}
+    artifact: dict = {}
+    attempt: int = 0
 
 
 class ModuleStateStore(IBaseResult):
@@ -118,7 +120,7 @@ class ModuleRunStore(IBaseResult):
     """
 
     cases: dict[str, CaseRunStore] = {}
-    artifact: Optional[dict] = {}
+    artifact: dict = {}
 
 
 class Dut(BaseModel):
@@ -127,9 +129,10 @@ class Dut(BaseModel):
     Example:
     "dut": {
         "serial_number": "a9ad8dca-2c64-4df8-a358-c21e832a32e4",
+        "part_number": "part_number_1",
         "info": {
-        "batch": "test_batch",
-        "board_rev": "rev_1"
+          "batch": "test_batch",
+          "board_rev": "rev_1"
         }
     },
     """
@@ -137,6 +140,25 @@ class Dut(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
     serial_number: str | None
+    part_number: str | None
+    info: dict = {}
+
+
+class TestStand(BaseModel):
+    """Test stand description.
+
+    Example:
+    "test_stand": {
+        "name": "test_stand_1",
+        "info": {
+          "geo": "Belgrade",
+        }
+    },
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    name: str | None
     info: dict = {}
 
 
@@ -158,6 +180,7 @@ class ResultStateStore(IBaseResult):
       "name": "hardpy-stand",
       "dut": {
         "serial_number": "92c5a4bb-ecb0-42c5-89ac-e0caca0919fd",
+        "part_number": "part_1",
         "info": {
           "batch": "test_batch",
           "board_rev": "rev_1"
@@ -165,6 +188,7 @@ class ResultStateStore(IBaseResult):
       },
       "test_stand": {
         "name": "Test stand 1"
+        "info": {}
       },
       "drivers": {
         "driver_1": "driver info",
@@ -173,6 +197,11 @@ class ResultStateStore(IBaseResult):
           "port": 8000
         }
       },
+      "operator_msg": {
+        "msg": "Operator message",
+        "title": "Message",
+        "visible": "True"
+      },
       "modules": {
         "test_1_a": {
           "status": "failed",
@@ -187,6 +216,7 @@ class ResultStateStore(IBaseResult):
               "stop_time": 1695817264,
               "assertion_msg": null,
               "msg": null,
+              "attempt": 1,
               "dialog_box": {
                 "title_bar": "Example of text input",
                 "dialog_text": "Type some text and press the Confirm button",
@@ -204,6 +234,7 @@ class ResultStateStore(IBaseResult):
               "start_time": 1695817264,
               "stop_time": 1695817264,
               "assertion_msg": "The test failed because minute 21 is odd! Try again!",
+              "attempt": 1,
               "msg": [
                 "Current minute 21"
               ]
@@ -220,10 +251,11 @@ class ResultStateStore(IBaseResult):
     id: str = Field(..., alias="_id")
     progress: int
     timezone: tuple[str, str] | None = None
-    test_stand: dict = {}
+    test_stand: TestStand
     dut: Dut
     modules: dict[str, ModuleStateStore] = {}
-    drivers: Optional[dict] = {}
+    drivers: dict = {}
+    operator_msg: dict = {}
 
 
 class ResultRunStore(IBaseResult):
@@ -244,6 +276,7 @@ class ResultRunStore(IBaseResult):
       "name": "hardpy-stand",
       "dut": {
         "serial_number": "92c5a4bb-ecb0-42c5-89ac-e0caca0919fd",
+        "part_number": "part_1",
         "info": {
           "batch": "test_batch",
           "board_rev": "rev_1"
@@ -251,6 +284,7 @@ class ResultRunStore(IBaseResult):
       },
       "test_stand": {
         "name": "Test stand 1"
+        "info": {}
       },
       "drivers": {
         "driver_1": "driver info",
@@ -275,6 +309,7 @@ class ResultRunStore(IBaseResult):
               "stop_time": 1695817264,
               "assertion_msg": null,
               "msg": null,
+              "attempt": 1,
               "artifact": {}
             },
             "test_minute_parity": {
@@ -286,6 +321,7 @@ class ResultRunStore(IBaseResult):
               "msg": [
                 "Current minute 21"
               ],
+              "attempt": 1,
               "artifact": {
                 "data_str": "123DATA",
                 "data_int": 12345,
@@ -306,8 +342,8 @@ class ResultRunStore(IBaseResult):
     id: str = Field(..., alias="_id")
     progress: int
     timezone: tuple[str, str] | None = None
-    test_stand: dict = {}
+    test_stand: TestStand
     dut: Dut
     modules: dict[str, ModuleRunStore] = {}
-    drivers: Optional[dict] = {}
-    artifact: Optional[dict] = {}
+    drivers: dict = {}
+    artifact: dict = {}

hardpy/pytest_hardpy/db/statestore.py

@@ -3,6 +3,8 @@
 
 from logging import getLogger
 
+from pycouchdb.exceptions import Conflict, NotFound
+
 from hardpy.pytest_hardpy.db.base_store import BaseStore
 from hardpy.pytest_hardpy.db import ResultStateStore
 from hardpy.pytest_hardpy.utils import Singleton
@@ -17,3 +19,12 @@ class StateStore(Singleton, BaseStore):
             self._log = getLogger(__name__)
             self._schema = ResultStateStore
             self._initialized = True
+
+    def clear(self):
+        """Clear database."""
+        try:
+            # Clear the statestore database before each launch
+            self._db.delete(self._doc_id)
+        except (Conflict, NotFound):
+            self._log.debug("Statestore database will be created for the first time")
+        self._doc: dict = self._init_doc()

hardpy/pytest_hardpy/plugin.py

@@ -2,11 +2,11 @@
 # 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 re import compile as re_compile
+from typing import Any, Callable
 
 from natsort import natsorted
 from pytest import (
@@ -31,26 +31,46 @@ from _pytest._code.code import (
 from hardpy.pytest_hardpy.reporter import HookReporter
 from hardpy.pytest_hardpy.utils import (
     TestStatus,
-    RunStatus,
     NodeInfo,
     ProgressCalculator,
-    ConfigData,
+    ConnectionData,
 )
 from hardpy.pytest_hardpy.utils.node_info import TestDependencyInfo
 
 
 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
-    parser.addoption("--hardpy-pt", action="store_true", default=False, help="enable pytest-hardpy plugin")  # noqa: E501
-    parser.addoption("--hardpy-sp", action="store", default=config_data.socket_port, help="internal socket port")  # noqa: E501
-    parser.addoption("--hardpy-sa", action="store", default=config_data.socket_addr, help="internal socket address")  # noqa: E501
-    # fmt: on
+    con_data = ConnectionData()
+    parser.addoption(
+        "--hardpy-db-url",
+        action="store",
+        default=con_data.database_url,
+        help="database url",
+    )
+    parser.addoption(
+        "--hardpy-sp",
+        action="store",
+        default=con_data.socket_port,
+        help="internal socket port",
+    )
+    parser.addoption(
+        "--hardpy-sh",
+        action="store",
+        default=con_data.socket_host,
+        help="internal socket host",
+    )
+    parser.addoption(
+        "--hardpy-clear-database",
+        action="store",
+        default=False,
+        help="clear hardpy local database",
+    )
+    parser.addoption(
+        "--hardpy-pt",
+        action="store_true",
+        default=False,
+        help="enable pytest-hardpy plugin",
+    )
 
 
 # Bootstrapping hooks
@@ -60,7 +80,7 @@ def pytest_load_initial_conftests(early_config, parser, args):
         early_config.pluginmanager.register(plugin)
 
 
-class HardpyPlugin(object):
+class HardpyPlugin:
     """HardPy integration plugin for pytest.
 
     Extends hook functions from pytest API.
@@ -82,28 +102,35 @@ class HardpyPlugin(object):
 
     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_data.socket_port = int(config.getoption("--hardpy-sp"))
-        config_data.socket_addr = config.getoption("--hardpy-sa")
+        con_data = ConnectionData()
+
+        database_url = config.getoption("--hardpy-db-url")
+        if database_url:
+            con_data.database_url = str(database_url)
+
+        is_clear_database = config.getoption("--hardpy-clear-database")
+        is_clear_statestore = is_clear_database == str(True)
+
+        socket_port = config.getoption("--hardpy-sp")
+        if socket_port:
+            con_data.socket_port = int(socket_port)  # type: ignore
+
+        socket_host = config.getoption("--hardpy-sh")
+        if socket_host:
+            con_data.socket_host = str(socket_host)
 
         config.addinivalue_line("markers", "case_name")
         config.addinivalue_line("markers", "module_name")
         config.addinivalue_line("markers", "dependency")
 
         # must be init after config data is set
-        self._reporter = HookReporter()
+        try:
+            self._reporter = HookReporter(is_clear_statestore)
+        except RuntimeError as exc:
+            exit(str(exc), 1)
 
     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
-        """
+        """Call at the end of test session."""
         if "--collect-only" in session.config.invocation_params.args:
             return
         status = self._get_run_status(exitstatus)
@@ -263,16 +290,46 @@ class HardpyPlugin(object):
         self._reporter.set_module_status(module_id, status)
         self._reporter.set_module_stop_time(module_id)
 
-    def _get_run_status(self, exitstatus: int) -> RunStatus:
+    def _get_run_status(self, exitstatus: int) -> TestStatus:
         match exitstatus:
             case ExitCode.OK:
-                return RunStatus.PASSED
+                return TestStatus.PASSED
             case ExitCode.TESTS_FAILED:
-                return RunStatus.FAILED
+                return TestStatus.FAILED
             case ExitCode.INTERRUPTED:
-                return RunStatus.STOPPED
+                self._stop_tests()
+                return TestStatus.STOPPED
             case _:
-                return RunStatus.ERROR
+                return TestStatus.ERROR
+
+    def _stop_tests(self):  # noqa: WPS231
+        """Update module and case statuses from READY or RUN to STOPPED."""
+        for module_id, module_data in self._results.items():
+            module_status = module_data["module_status"]
+
+            # skip not ready and running modules
+            if module_status not in {TestStatus.READY, TestStatus.RUN}:
+                continue
+
+            # update module statuses
+            self._results[module_id]["module_status"] = TestStatus.STOPPED
+            self._reporter.set_module_status(module_id, TestStatus.STOPPED)
+
+            # update case statuses
+            for module_key, module_value in module_data.items():
+                # module status is not a case_id
+                if module_key == "module_status":
+                    continue
+                # case value is empty - case is not finished
+                if module_value is None:
+                    case_id = module_key
+                    self._results[module_id][case_id] = TestStatus.STOPPED
+                    self._reporter.set_case_status(
+                        module_id,
+                        case_id,
+                        TestStatus.STOPPED,
+                    )
+        self._reporter.update_db_by_doc()
 
     def _decode_assertion_msg(
         self,
@@ -320,6 +377,9 @@ class HardpyPlugin(object):
         if dependency and self._is_dependency_failed(dependency):
             self._log.debug(f"Skipping test due to dependency: {dependency}")
             self._results[node_info.module_id][node_info.case_id] = TestStatus.SKIPPED
+            self._reporter.set_progress(
+                self._progress.calculate(f"{node_info.module_id}::{node_info.case_id}")
+            )
             skip(f"Test {node_info.module_id}::{node_info.case_id} is skipped")
 
     def _is_dependency_failed(self, dependency) -> bool:

hardpy/pytest_hardpy/pytest_call.py

@@ -16,16 +16,18 @@ from hardpy.pytest_hardpy.db import (
     RunStore,
 )
 from hardpy.pytest_hardpy.utils import (
+    ConnectionData,
     DuplicateSerialNumberError,
+    DuplicatePartNumberError,
+    DuplicateTestStandNameError,
     DuplicateDialogBoxError,
     DialogBox,
-    ConfigData,
 )
 from hardpy.pytest_hardpy.reporter import RunnerReporter
 
 
 @dataclass
-class CurrentTestInfo(object):
+class CurrentTestInfo:
     """Current test info."""
 
     module_id: str
@@ -79,6 +81,40 @@ def set_dut_serial_number(serial_number: str):
     reporter.update_db_by_doc()
 
 
+def set_dut_part_number(part_number: str):
+    """Add DUT part number to document.
+
+    Args:
+        part_number (str): DUT part number
+
+    Raises:
+        DuplicatePartNumberError: if part number is already set
+    """
+    reporter = RunnerReporter()
+    key = reporter.generate_key(DF.DUT, DF.PART_NUMBER)
+    if reporter.get_field(key):
+        raise DuplicatePartNumberError
+    reporter.set_doc_value(key, part_number)
+    reporter.update_db_by_doc()
+
+
+def set_stand_name(name: str):
+    """Add test stand name to document.
+
+    Args:
+        name (str): test stand name
+
+    Raises:
+        DuplicateTestStandNameError: if test stand name is already set
+    """
+    reporter = RunnerReporter()
+    key = reporter.generate_key(DF.TEST_STAND, DF.NAME)
+    if reporter.get_field(key):
+        raise DuplicateTestStandNameError
+    reporter.set_doc_value(key, name)
+    reporter.update_db_by_doc()
+
+
 def set_stand_info(info: dict):
     """Add test stand info to document.
 
@@ -87,7 +123,7 @@ def set_stand_info(info: dict):
     """
     reporter = RunnerReporter()
     for stand_key, stand_value in info.items():
-        key = reporter.generate_key(DF.TEST_STAND, stand_key)
+        key = reporter.generate_key(DF.TEST_STAND, DF.INFO, stand_key)
         reporter.set_doc_value(key, stand_value)
     reporter.update_db_by_doc()
 
@@ -261,6 +297,29 @@ def run_dialog_box(dialog_box_data: DialogBox) -> Any:
     return dialog_box_data.widget.convert_data(input_dbx_data)
 
 
+def set_operator_message(msg: str, title: str | None = None) -> None:
+    """Set operator message.
+
+    The function should be used to handle events outside of testing.
+    For messages to the operator during testing, there is the function `run_dialog_box`.
+
+    Args:
+        msg (str): Message
+        title (str | None): Title
+    """
+    reporter = RunnerReporter()
+    key = reporter.generate_key(
+        DF.OPERATOR_MSG,
+    )
+    msg_data = {"msg": msg, "title": title, "visible": True}
+    reporter.set_doc_value(key, msg_data, statestore_only=True)
+    reporter.update_db_by_doc()
+    is_msg_visible = _get_socket_raw_data()
+    msg_data["visible"] = is_msg_visible
+    reporter.set_doc_value(key, msg_data, statestore_only=True)
+    reporter.update_db_by_doc()
+
+
 def _get_current_test() -> CurrentTestInfo:
     current_node = environ.get("PYTEST_CURRENT_TEST")
 
@@ -288,9 +347,10 @@ def _get_socket_raw_data() -> str:
     # create socket connection
     server = socket.socket()
     server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-    config_data = ConfigData()
+    con_data = ConnectionData()
+
     try:
-        server.bind((config_data.socket_addr, config_data.socket_port))
+        server.bind((con_data.socket_host, con_data.socket_port))
     except socket.error as exc:
         raise RuntimeError(f"Error creating socket: {exc}")
     server.listen(1)