hardpy 0.2.0__tar.gz → 0.3.0__tar.gz

{hardpy-0.2.0 → hardpy-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hardpy
-Version: 0.2.0
+Version: 0.3.0
 Summary: HardPy library for device testing
 Project-URL: repository, https://github.com/everypindevices/hardpy
 Author: Everypin
@@ -84,6 +84,7 @@ For Windows, follow the instructions from the
 [documentation](https://everypinio.github.io/hardpy/documentation/database/#couchdb-instance).
 
 Launch CouchDB with Docker.
+The Docker version must be 24.0.0 or higher.
 Create `couchdb.ini` file:
 
 ```ini
@@ -103,6 +104,12 @@ Run the Docker container from folder with couchdb.ini file:
 docker run --rm --name couchdb -p 5984:5984 -e COUCHDB_USER=dev -e COUCHDB_PASSWORD=dev -v ./couchdb.ini:/opt/couchdb/etc/local.ini couchdb:3.3
 ```
 
+Command for Windows:
+
+```bash
+docker run --rm --name couchdb -p 5984:5984 -e COUCHDB_USER=dev -e COUCHDB_PASSWORD=dev -v .\couchdb.ini:/opt/couchdb/etc/local.ini couchdb:3.3.2
+```
+
 #### Test steps
 
 Add simple test to `tests` folder

{hardpy-0.2.0 → hardpy-0.3.0}/README.md

@@ -47,6 +47,7 @@ For Windows, follow the instructions from the
 [documentation](https://everypinio.github.io/hardpy/documentation/database/#couchdb-instance).
 
 Launch CouchDB with Docker.
+The Docker version must be 24.0.0 or higher.
 Create `couchdb.ini` file:
 
 ```ini
@@ -66,6 +67,12 @@ Run the Docker container from folder with couchdb.ini file:
 docker run --rm --name couchdb -p 5984:5984 -e COUCHDB_USER=dev -e COUCHDB_PASSWORD=dev -v ./couchdb.ini:/opt/couchdb/etc/local.ini couchdb:3.3
 ```
 
+Command for Windows:
+
+```bash
+docker run --rm --name couchdb -p 5984:5984 -e COUCHDB_USER=dev -e COUCHDB_PASSWORD=dev -v .\couchdb.ini:/opt/couchdb/etc/local.ini couchdb:3.3.2
+```
+
 #### Test steps
 
 Add simple test to `tests` folder

{hardpy-0.2.0 → hardpy-0.3.0}/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-0.2.0 → hardpy-0.3.0}/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):
@@ -40,6 +42,7 @@ def pytest_addoption(parser: Parser):
     parser.addoption("--hardpy-pt", action="store_true", default=False, help="enable pytest-hardpy plugin")  # noqa: E501
     # fmt: on
 
+
 # Bootstrapping hooks
 def pytest_load_initial_conftests(early_config, parser, args):
     if "--hardpy-pt" in args:
@@ -57,6 +60,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 +68,6 @@ class HardpyPlugin(object):
             signal.signal(signal.SIGBREAK, self._stop_handler)
         self._log = getLogger(__name__)
 
-
     # Initialization hooks
 
     def pytest_configure(self, config: Config):
@@ -77,6 +80,7 @@ class HardpyPlugin(object):
 
         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 +96,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 +113,7 @@ class HardpyPlugin(object):
         self._reporter.init_doc(str(PurePath(config.rootpath).name))
 
         nodes = {}
+        modules = set()
 
         session.items = natsorted(
             session.items,
@@ -115,18 +122,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 +154,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 +164,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 +177,7 @@ class HardpyPlugin(object):
             node_info.module_id,
             node_info.case_id,
         )
+        self._reporter.update_db_by_doc()
 
     # Reporting hooks
 
@@ -188,6 +207,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 +270,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-0.2.0 → hardpy-0.3.0}/hardpy/pytest_hardpy/pytest_call.py

@@ -52,7 +52,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 +69,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 +82,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 +114,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 +138,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 +160,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,7 +179,8 @@ 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:
@@ -192,7 +199,8 @@ 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 _get_current_test() -> CurrentTestInfo:

hardpy-0.3.0/hardpy/pytest_hardpy/reporter/base.py

@@ -0,0 +1,60 @@
+# 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_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): 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 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.
+
+        Args:
+            args: list of database keys
+
+        Returns:
+            str: database key
+        """
+        return ".".join(args)

{hardpy-0.2.0 → hardpy-0.3.0}/hardpy/pytest_hardpy/reporter/hook_reporter.py

@@ -25,23 +25,23 @@ class HookReporter(BaseReporter):
         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)
+        self.set_doc_value(DF.NAME, doc_name)
+        self.set_doc_value(DF.STATUS, TestStatus.READY)
+        self.set_doc_value(DF.START_TIME, None)
+        self.set_doc_value(DF.TIMEZONE, None)
+        self.set_doc_value(DF.STOP_TIME, None)
+        self.set_doc_value(DF.PROGRESS, 0)
+        self.set_doc_value(DF.DRIVERS, {})
+        self.set_doc_value(DF.ARTIFACT, {}, runstore_only=True)
 
     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)
+        self.set_doc_value(DF.START_TIME, start_time)
+        self.set_doc_value(DF.STATUS, TestStatus.RUN)
+        self.set_doc_value(DF.TIMEZONE, tzname)  # noqa: WPS432
+        self.set_doc_value(DF.PROGRESS, 0)
 
     def finish(self, status: RunStatus):
         """Finish test.
@@ -50,15 +50,11 @@ class HookReporter(BaseReporter):
         """
         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.set_doc_value(DF.STOP_TIME, stop_time)
+        self.set_doc_value(DF.STATUS, status)
 
+    def compact_all(self):
+        """Compact all databases"""
         self._statestore.compact()
         self._runstore.compact()
 
@@ -68,7 +64,7 @@ class HookReporter(BaseReporter):
         Args:
             progress (int): test progress
         """
-        self.set_db_value(DF.PROGRESS, progress)
+        self.set_doc_value(DF.PROGRESS, progress)
 
     def set_assertion_msg(self, module_id: str, case_id: str, msg: str | None):
         """Set case assertion message.
@@ -81,7 +77,7 @@ class HookReporter(BaseReporter):
         key = self.generate_key(
             DF.MODULES, module_id, DF.CASES, case_id, DF.ASSERTION_MSG
         )
-        self.set_db_value(key, msg)
+        self.set_doc_value(key, msg)
 
     def add_case(self, node_info: NodeInfo):
         """Add test case to document.
@@ -90,18 +86,15 @@ class HookReporter(BaseReporter):
             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._init_case(item_statestore, node_info)
+        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)
+        self.set_doc_value(key, item_statestore, statestore_only=True)
+        self.set_doc_value(key, item_runstore, runstore_only=True)
 
     def set_case_status(self, module_id: str, case_id: str, status: TestStatus):
         """Set test case status.
@@ -112,7 +105,7 @@ class HookReporter(BaseReporter):
             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)
+        self.set_doc_value(key, status)
 
     def set_case_start_time(self, module_id: str, case_id: str):
         """Set test case start_time.
@@ -142,7 +135,7 @@ class HookReporter(BaseReporter):
             status (TestStatus): test module status
         """
         key = self.generate_key(DF.MODULES, module_id, DF.STATUS)
-        self.set_db_value(key, status)
+        self.set_doc_value(key, status)
 
     def set_module_start_time(self, module_id: str):
         """Set test module status.
@@ -175,16 +168,16 @@ class HookReporter(BaseReporter):
         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)
+        self.set_doc_value(key, updated_module_order, statestore_only=True)
 
     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()))
+            self.set_doc_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),
@@ -216,8 +209,6 @@ class HookReporter(BaseReporter):
             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:

hardpy-0.3.0/hardpy/pytest_hardpy/utils/node_info.py

@@ -0,0 +1,125 @@
+# Copyright (c) 2024 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+import re
+from logging import getLogger
+from pathlib import Path
+from typing import NamedTuple
+
+from pytest import Item, Mark
+
+
+class TestDependencyInfo(NamedTuple):
+    """Test info."""
+
+    def __repr__(self) -> str:
+        return f"Dependency: {self.module_id}::{self.case_id}"
+
+    module_id: str
+    case_id: str | None
+
+
+class NodeInfo(object):
+    """Test node info."""
+
+    def __init__(self, item: Item):
+        self._item = item
+        self._log = getLogger(__name__)
+
+        self._case_name = self._get_human_name(
+            item.own_markers,
+            "case_name",
+        )
+        self._module_name = self._get_human_name(
+            item.parent.own_markers,
+            "module_name",
+        )
+
+        self._dependency = self._get_dependency_info(
+            item.own_markers + item.parent.own_markers
+        )
+
+        self._module_id = Path(item.parent.nodeid).stem
+        self._case_id = item.name
+
+    @property
+    def module_id(self):
+        """Get module id.
+
+        Returns:
+            str: module id
+        """
+        return self._module_id
+
+    @property
+    def case_id(self):
+        """Get case id.
+
+        Returns:
+            str: case id
+        """
+        return self._case_id
+
+    @property
+    def module_name(self):
+        """Get module name.
+
+        Returns:
+            str: module name
+        """
+        return self._module_name
+
+    @property
+    def case_name(self):
+        """Get case name.
+
+        Returns:
+            str: case name
+        """
+        return self._case_name
+
+    @property
+    def dependency(self):
+        """Get dependency information.
+
+        Returns:
+            TestDependencyInfo | str: Parsed dependency information.
+        """
+        return self._dependency
+
+    def _get_human_name(self, markers: list[Mark], marker_name: str) -> str:
+        """Get human name from markers.
+
+        Args:
+            markers (list[Mark]): item markers list
+            marker_name (str): marker name
+
+        Returns:
+            str: human name by user
+        """
+        for marker in markers:
+            if marker.name == marker_name:
+                if marker.args:
+                    return marker.args[0]
+
+        return ""
+
+    def _get_dependency_info(self, markers: list[Mark]) -> TestDependencyInfo | str:
+        """Extract and parse dependency information.
+
+        Args:
+            markers (list[Mark]): item markers list
+            marker_name (str): marker name
+
+        Returns:
+            TestDependencyInfo | str | None: Parsed dependency information.
+        """
+        dependency_value = self._get_human_name(markers, "dependency")
+        dependency_data = re.search(r"(\w+)::(\w+)", dependency_value)
+        if dependency_data:
+            return TestDependencyInfo(*dependency_data.groups())
+        elif re.search(r"^\w+$", dependency_value):
+            return TestDependencyInfo(dependency_value, None)
+        elif dependency_data is None and dependency_value == "":
+            return ""
+        raise ValueError

{hardpy-0.2.0 → hardpy-0.3.0}/pyproject.toml

@@ -3,7 +3,7 @@
 
 [project]
     name = "hardpy"
-    version = "0.2.0"
+    version = "0.3.0"
     description = "HardPy library for device testing"
     authors = [{ name = "Everypin" }]
     readme = "README.md"

hardpy-0.2.0/hardpy/pytest_hardpy/reporter/base.py

@@ -1,42 +0,0 @@
-# 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)

hardpy-0.2.0/hardpy/pytest_hardpy/utils/node_info.py

@@ -1,59 +0,0 @@
-# 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 pathlib import Path
-
-from pytest import Item, Mark
-
-
-class NodeInfo(object):
-    """Test node info."""
-
-    def __init__(self, item: Item):
-        self._item = item
-        self._log = getLogger(__name__)
-
-        self._case_name = self._get_human_name(
-            item.own_markers,
-            "case_name",
-        )
-        self._module_name = self._get_human_name(
-            item.parent.own_markers,
-            "module_name",
-        )
-        self._module_id = Path(item.parent.nodeid).stem
-        self._case_id = item.name
-
-    @property
-    def module_id(self):
-        return self._module_id
-
-    @property
-    def case_id(self):
-        return self._case_id
-
-    @property
-    def module_name(self):
-        return self._module_name
-
-    @property
-    def case_name(self):
-        return self._case_name
-
-    def _get_human_name(self, markers: list[Mark], marker_name: str) -> str:
-        """Get human name from markers.
-
-        Args:
-            markers (list[Mark]): item markers list
-            marker_name (str): marker name
-
-        Returns:
-            str: human name by user
-        """
-        for marker in markers:
-            if marker.name == marker_name:
-                if marker.args:
-                    return marker.args[0]
-
-        return ""