hardpy 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

hardpy/hardpy_panel/runner.py

@@ -21,6 +21,8 @@ def run():
     parser.add_argument("-dbh", "--db_host", type=str, default=config.db_host, help="database hostname")  # noqa: E501
     parser.add_argument("-wh", "--web_host", type=str, default=config.web_host, help="web operator panel hostname")  # noqa: E501
     parser.add_argument("-wp", "--web_port", type=str, default=config.web_port, help="web operator panel port")  # noqa: E501
+    parser.add_argument("-sp", "--sck_port", type=int, default=config.socket_port, help="internal socket port")  # noqa: E501
+    parser.add_argument("-sa", "--sck_addr", type=int, default=config.socket_port, help="internal socket address")  # noqa: E501
     parser.add_argument("path", type=str, nargs='?', help="path to test directory")
     # fmt: on
 

hardpy/pytest_hardpy/db/base_store.py

@@ -36,19 +36,29 @@ class BaseStore(BaseConnector):
         """
         return glom(self._doc, key)
 
-    def set_value(self, key: str, value):
-        """Set a value in the state store."""
-        assign(self._doc, key, value)
+    def update_doc(self, key: str, value):
+        """Update document.
+
+        HardPy collecting uses a simple key without dots.
+        Assign is used to update a document.
+        Assign is a longer function.
+
+        Args:
+            key (str): document key
+            value: document value
+        """
+        if "." in key:
+            assign(self._doc, key, value)
+        else:
+            self._doc[key] = value
+
+    def update_db(self):
+        """Update database by current document."""
         try:
             self._doc = self._db.save(self._doc)
-        except Conflict as exc:
-            self._log.error(
-                f"Error while saving runner document: {exc} "
-                f"when trying to save key={key}, value={value}. "
-                "Current document will be changed by "
-                "document from database."
-            )
-            self._doc = self._db.get(self._doc_id)
+        except Conflict:
+            self._doc["_rev"] = self._db.get(self._doc_id)["_rev"]
+            self._doc = self._db.save(self._doc)
 
     def get_document(self) -> ModelMetaclass:
         """Get document by schema.

hardpy/pytest_hardpy/db/const.py

@@ -23,3 +23,4 @@ class DatabaseField(str, Enum):  # noqa: WPS600
     TEST_STAND = "test_stand"
     SERIAL_NUMBER = "serial_number"
     DRIVERS = "drivers"
+    DIALOG_BOX = "dialog_box"

hardpy/pytest_hardpy/db/schema.py

@@ -29,12 +29,23 @@ class CaseStateStore(IBaseResult):
         "start_time": 1695817188,
         "stop_time": 1695817189,
         "assertion_msg": null,
-        "msg": null
+        "msg": null,
+        "dialog_box": {
+          "title_bar": "Example of text input",
+          "dialog_text": "Type some text and press the Confirm button",
+          "widget": {
+            "info": {
+              "text": "some text"
+            },
+            "type": "textinput"
+          }
+        }
     }
     """
 
     assertion_msg: str | None = None
     msg: dict | None = None
+    dialog_box: dict = {}
 
 
 class CaseRunStore(IBaseResult):
@@ -175,7 +186,17 @@ class ResultStateStore(IBaseResult):
               "start_time": 1695817263,
               "stop_time": 1695817264,
               "assertion_msg": null,
-              "msg": null
+              "msg": null,
+              "dialog_box": {
+                "title_bar": "Example of text input",
+                "dialog_text": "Type some text and press the Confirm button",
+                "widget": {
+                  "info": {
+                    "text": "some text"
+                  },
+                  "type": "textinput"
+                }
+              }
             },
             "test_minute_parity": {
               "status": "failed",

hardpy/pytest_hardpy/plugin.py

@@ -9,6 +9,7 @@ from platform import system
 
 from natsort import natsorted
 from pytest import (
+    skip,
     exit,
     TestReport,
     Item,
@@ -27,6 +28,7 @@ from hardpy.pytest_hardpy.utils import (
     ProgressCalculator,
     ConfigData,
 )
+from hardpy.pytest_hardpy.utils.node_info import TestDependencyInfo
 
 
 def pytest_addoption(parser: Parser):
@@ -38,8 +40,11 @@ def pytest_addoption(parser: Parser):
     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
 
+
 # Bootstrapping hooks
 def pytest_load_initial_conftests(early_config, parser, args):
     if "--hardpy-pt" in args:
@@ -57,6 +62,7 @@ class HardpyPlugin(object):
         self._progress = ProgressCalculator()
         self._results = {}
         self._post_run_functions: list[Callable] = []
+        self._dependencies = {}
 
         if system() == "Linux":
             signal.signal(signal.SIGTERM, self._stop_handler)
@@ -64,7 +70,6 @@ class HardpyPlugin(object):
             signal.signal(signal.SIGBREAK, self._stop_handler)
         self._log = getLogger(__name__)
 
-
     # Initialization hooks
 
     def pytest_configure(self, config: Config):
@@ -74,9 +79,12 @@ class HardpyPlugin(object):
         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")
 
         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()
@@ -92,6 +100,8 @@ class HardpyPlugin(object):
             return
         status = self._get_run_status(exitstatus)
         self._reporter.finish(status)
+        self._reporter.update_db_by_doc()
+        self._reporter.compact_all()
 
         # call post run methods
         if self._post_run_functions:
@@ -107,6 +117,7 @@ class HardpyPlugin(object):
         self._reporter.init_doc(str(PurePath(config.rootpath).name))
 
         nodes = {}
+        modules = set()
 
         session.items = natsorted(
             session.items,
@@ -115,18 +126,26 @@ class HardpyPlugin(object):
         for item in session.items:
             if item.parent is None:
                 continue
-            node_info = NodeInfo(item)
+            try:
+                node_info = NodeInfo(item)
+            except ValueError:
+                error_msg = f"Error creating NodeInfo for item: {item}\n"
+                exit(error_msg, 1)
 
             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._add_dependency(node_info, nodes)
+            modules.add(node_info.module_id)
+        for module_id in modules:
+            self._reporter.set_module_status(module_id, TestStatus.READY)
         self._reporter.update_node_order(nodes)
+        self._reporter.update_db_by_doc()
 
     # Test running (runtest) hooks
 
@@ -139,6 +158,7 @@ class HardpyPlugin(object):
 
         # testrun entrypoint
         self._reporter.start()
+        self._reporter.update_db_by_doc()
 
     def pytest_runtest_setup(self, item: Item):
         """Call before each test setup phase."""
@@ -148,6 +168,8 @@ class HardpyPlugin(object):
 
         node_info = NodeInfo(item)
 
+        self._handle_dependency(node_info)
+
         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(
@@ -159,6 +181,7 @@ class HardpyPlugin(object):
             node_info.module_id,
             node_info.case_id,
         )
+        self._reporter.update_db_by_doc()
 
     # Reporting hooks
 
@@ -188,6 +211,7 @@ class HardpyPlugin(object):
 
         if None not in self._results[module_id].values():
             self._collect_module_result(module_id)
+        self._reporter.update_db_by_doc()
 
     # Fixture
 
@@ -250,3 +274,47 @@ class HardpyPlugin(object):
             index = report.find("\nE")
             return report[:index]
         return None
+
+    def _handle_dependency(self, node_info: NodeInfo):
+        dependency = self._dependencies.get(
+            TestDependencyInfo(
+                node_info.module_id,
+                node_info.case_id,
+            )
+        )
+        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
+            skip(f"Test {node_info.module_id}::{node_info.case_id} is skipped")
+
+    def _is_dependency_failed(self, dependency) -> bool:
+        if isinstance(dependency, TestDependencyInfo):
+            incorrect_status = {
+                TestStatus.FAILED,
+                TestStatus.SKIPPED,
+                TestStatus.ERROR,
+            }
+            module_id, case_id = dependency
+            if case_id is not None:
+                return self._results[module_id][case_id] in incorrect_status
+            return any(
+                status in incorrect_status
+                for status in set(self._results[module_id].values())
+            )
+        return False
+
+    def _add_dependency(self, node_info, nodes):
+        dependency = node_info.dependency
+        if dependency is None or dependency == "":
+            return
+        module_id, case_id = dependency
+        if module_id not in nodes:
+            error_message = f"Error: Module dependency '{dependency}' not found."
+            exit(error_message, 1)
+        elif case_id not in nodes[module_id] and case_id is not None:
+            error_message = f"Error: Case dependency '{dependency}' not found."
+            exit(error_message, 1)
+
+        self._dependencies[
+            TestDependencyInfo(node_info.module_id, node_info.case_id)
+        ] = dependency

hardpy/pytest_hardpy/pytest_call.py

@@ -1,9 +1,10 @@
 # Copyright (c) 2024 Everypin
 # GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
 
+import socket
 from os import environ
 from dataclasses import dataclass
-from typing import Optional
+from typing import Optional, Any
 from uuid import uuid4
 
 from pycouchdb.exceptions import NotFound
@@ -14,7 +15,14 @@ from hardpy.pytest_hardpy.db import (
     ResultRunStore,
     RunStore,
 )
-from hardpy.pytest_hardpy.utils import DuplicateSerialNumberError
+from hardpy.pytest_hardpy.utils import (
+    DuplicateSerialNumberError,
+    DuplicateDialogBoxError,
+    DialogBox,
+    ConfigData,
+    generate_dialog_box_dict,
+    get_dialog_box_data,
+)
 from hardpy.pytest_hardpy.reporter import RunnerReporter
 
 
@@ -52,7 +60,8 @@ def set_dut_info(info: dict):
     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)
+        reporter.set_doc_value(key, dut_value)
+    reporter.update_db_by_doc()
 
 
 def set_dut_serial_number(serial_number: str):
@@ -68,7 +77,8 @@ def set_dut_serial_number(serial_number: str):
     key = reporter.generate_key(DF.DUT, DF.SERIAL_NUMBER)
     if reporter.get_field(key):
         raise DuplicateSerialNumberError
-    reporter.set_db_value(key, serial_number)
+    reporter.set_doc_value(key, serial_number)
+    reporter.update_db_by_doc()
 
 
 def set_stand_info(info: dict):
@@ -80,7 +90,8 @@ 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)
-        reporter.set_db_value(key, stand_value)
+        reporter.set_doc_value(key, stand_value)
+    reporter.update_db_by_doc()
 
 
 def set_message(msg: str, msg_key: Optional[str] = None) -> None:
@@ -111,7 +122,8 @@ def set_message(msg: str, msg_key: Optional[str] = None) -> None:
 
     msgs[msg_key] = msg
 
-    reporter.set_db_value(key, msgs)
+    reporter.set_doc_value(key, msgs)
+    reporter.update_db_by_doc()
 
 
 def set_case_artifact(data: dict):
@@ -134,7 +146,8 @@ def set_case_artifact(data: dict):
             DF.ARTIFACT,
             stand_key,
         )
-        reporter.set_db_value(key, stand_value, is_statestore=False)
+        reporter.set_doc_value(key, stand_value, runstore_only=True)
+    reporter.update_db_by_doc()
 
 
 def set_module_artifact(data: dict):
@@ -155,7 +168,8 @@ def set_module_artifact(data: dict):
             DF.ARTIFACT,
             artifact_key,
         )
-        reporter.set_db_value(key, artifact_value, is_statestore=False)
+        reporter.set_doc_value(key, artifact_value, runstore_only=True)
+    reporter.update_db_by_doc()
 
 
 def set_run_artifact(data: dict):
@@ -173,11 +187,12 @@ def set_run_artifact(data: dict):
             DF.ARTIFACT,
             artifact_key,
         )
-        reporter.set_db_value(key, artifact_value, is_statestore=False)
+        reporter.set_doc_value(key, artifact_value, runstore_only=True)
+    reporter.update_db_by_doc()
 
 
 def set_driver_info(drivers: dict) -> None:
-    """Adds or updates drivers data.
+    """Add or update drivers data.
 
     Driver data is stored in both StateStore and RunStore databases.
 
@@ -192,7 +207,58 @@ def set_driver_info(drivers: dict) -> None:
             DF.DRIVERS,
             driver_name,
         )
-        reporter.set_db_value(key, driver_data)
+        reporter.set_doc_value(key, driver_data)
+    reporter.update_db_by_doc()
+
+
+def run_dialog_box(dialog_box_data: DialogBox) -> Any:
+    """Display a dialog box.
+
+    Args:
+        dialog_box_data (DialogBox): Data for creating the dialog box.
+
+        DialogBox attributes:
+
+        - dialog_text (str): The text of the dialog box.
+        - title_bar (str | None): The title bar of the dialog box.
+        If the title_bar field is missing, it is the case name.
+        - widget (DialogBoxWidget | None): Widget information.
+
+    Returns:
+        Any: An object containing the user's response.
+
+        The type of the return value depends on the widget type:
+
+        - Without widget: None.
+        - TEXT_INPUT: str.
+        - NUMERIC_INPUT: float.
+
+    Raises:
+        ValueError: If the 'message' argument is empty.
+        DuplicateDialogBoxError: If the dialog box is already caused.
+    """
+    if not dialog_box_data.dialog_text:
+        raise ValueError("The 'dialog_text' argument cannot be empty.")
+
+    current_test = _get_current_test()
+    reporter = RunnerReporter()
+    key = reporter.generate_key(
+        DF.MODULES,
+        current_test.module_id,
+        DF.CASES,
+        current_test.case_id,
+        DF.DIALOG_BOX,
+    )
+    if reporter.get_field(key):
+        raise DuplicateDialogBoxError
+    data_dict = generate_dialog_box_dict(dialog_box_data)
+
+    reporter.set_doc_value(key, data_dict, statestore_only=True)
+    reporter.update_db_by_doc()
+
+    dialog_raw_data = _get_socket_raw_data()
+
+    return get_dialog_box_data(dialog_raw_data, dialog_box_data.widget)
 
 
 def _get_current_test() -> CurrentTestInfo:
@@ -216,3 +282,26 @@ def _get_current_test() -> CurrentTestInfo:
     case_id = case_with_stage[:case_id_end_index]
 
     return CurrentTestInfo(module_id=module_id, case_id=case_id)
+
+
+def _get_socket_raw_data() -> str:
+    # create socket connection
+    server = socket.socket()
+    server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    config_data = ConfigData()
+    try:
+        server.bind((config_data.socket_addr, config_data.socket_port))
+    except socket.error as exc:
+        raise RuntimeError(f"Error creating socket: {exc}")
+    server.listen(1)
+    client, _ = server.accept()
+
+    # receive data
+    max_input_data_len = 1024
+    socket_data = client.recv(max_input_data_len).decode("utf-8")
+
+    # close connection
+    client.close()
+    server.close()
+
+    return socket_data

hardpy/pytest_hardpy/pytest_wrapper.py

@@ -4,6 +4,7 @@
 import sys
 import signal
 import subprocess
+from socket import socket
 from platform import system
 
 from hardpy.pytest_hardpy.utils.config_data import ConfigData
@@ -46,6 +47,10 @@ class PyTestWrapper(object):
                     self.config.db_user,
                     "--hardpy-dbpw",
                     self.config.db_pswd,
+                    "--hardpy-sp",
+                    str(self.config.socket_port),
+                    "--hardpy-sa",
+                    self.config.socket_addr,
                     "--hardpy-pt",
                 ],
                 cwd=self.config.tests_dir.absolute(),
@@ -64,6 +69,10 @@ class PyTestWrapper(object):
                     self.config.db_user,
                     "--hardpy-dbpw",
                     self.config.db_pswd,
+                    "--hardpy-sp",
+                    str(self.config.socket_port),
+                    "--hardpy-sa",
+                    self.config.socket_addr,
                     "--hardpy-pt",
                 ],
                 cwd=self.config.tests_dir.absolute(),
@@ -115,6 +124,26 @@ class PyTestWrapper(object):
         )
         return True
 
+    def confirm_dialog_box(self, dialog_box_output: str):
+        """Set dialog box data to pytest subprocess.
+
+        Args:
+            dialog_box_output (str): dialog box output data
+
+        Returns:
+            bool: True if dialog box was confirmed, else False
+        """
+        config_data = ConfigData()
+
+        try:
+            client = socket()
+            client.connect((config_data.socket_addr, config_data.socket_port))
+            client.sendall(dialog_box_output.encode("utf-8"))
+            client.close()
+        except Exception:
+            return False
+        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/base.py

@@ -14,21 +14,39 @@ class BaseReporter(object):
         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.
+    def set_doc_value(
+        self, key: str, value, runstore_only=False, statestore_only=False
+    ):
+        """Set value to the document.
+
+        Update a document without writing to the 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.
+            key (str): document key
+            value: document value
+            runstore_only (bool, optional): indicates whether data should
+                                             be written to RunStore. Defaults to True.
+            statestore_only (bool, optional): indicates whether data should
+                                            be written to StateStore. Defaults to True.
+
+        Raises:
+            ValueError: if both runstore_only and statestore_only are True
         """
-        if is_statestore:
-            self._statestore.set_value(key, value)
-        if is_runstore:
-            self._runstore.set_value(key, value)
+        if runstore_only and statestore_only:
+            raise ValueError("Both runstore_only and statestore_only cannot be True")
+        if runstore_only:
+            self._runstore.update_doc(key, value)
+            return
+        if statestore_only:
+            self._statestore.update_doc(key, value)
+            return
+        self._runstore.update_doc(key, value)
+        self._statestore.update_doc(key, value)
+
+    def update_db_by_doc(self):
+        """Update database by current document."""
+        self._statestore.update_db()
+        self._runstore.update_db()
 
     def generate_key(self, *args) -> str:
         """Generate key for database.