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

hardpy/pytest_hardpy/reporter/base.py

@@ -2,21 +2,30 @@
 # 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.db import StateStore, RunStore
+from hardpy.pytest_hardpy.db import (
+    DatabaseField as DF,  # noqa: N817
+    RunStore,
+    StateStore,
+)
 
 
 class BaseReporter:
     """Base class for test reporter."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._statestore = StateStore()
         self._runstore = RunStore()
         self._log = getLogger(__name__)
 
     def set_doc_value(
-        self, key: str, value, runstore_only=False, statestore_only=False
-    ):
+        self,
+        key: str,
+        value: Any,  # noqa: ANN401
+        runstore_only: bool = False,
+        statestore_only: bool = False,
+    ) -> None:
         """Set value to the document.
 
         Update a document without writing to the database.
@@ -33,7 +42,8 @@ class BaseReporter:
             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")
+            msg = "Both runstore_only and statestore_only cannot be True"
+            raise ValueError(msg)
         if runstore_only:
             self._runstore.update_doc(key, value)
             return
@@ -43,12 +53,12 @@ class BaseReporter:
         self._runstore.update_doc(key, value)
         self._statestore.update_doc(key, value)
 
-    def update_db_by_doc(self):
+    def update_db_by_doc(self) -> None:
         """Update database by current document."""
         self._statestore.update_db()
         self._runstore.update_db()
 
-    def generate_key(self, *args) -> str:
+    def generate_key(self, *args: Any) -> str:  # noqa: ANN401
         """Generate key for database.
 
         Args:
@@ -58,3 +68,18 @@ class BaseReporter:
             str: database key
         """
         return ".".join(args)
+
+    def get_current_attempt(self, module_id: str, case_id: str) -> int:
+        """Get current attempt.
+
+        Returns:
+            int: current attempt
+        """
+        key = self.generate_key(
+            DF.MODULES,
+            module_id,
+            DF.CASES,
+            case_id,
+            DF.ATTEMPT,
+        )
+        return self._statestore.get_field(key)

hardpy/pytest_hardpy/reporter/hook_reporter.py

@@ -1,27 +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 __future__ import annotations
 
-from time import time, tzname
-from logging import getLogger
 from copy import deepcopy
+from datetime import datetime
+from logging import getLogger
+from time import time
 
 from natsort import natsorted
 
-from hardpy.pytest_hardpy.db import DatabaseField as DF
+from hardpy.pytest_hardpy.db import DatabaseField as DF  # noqa: N817
 from hardpy.pytest_hardpy.reporter.base import BaseReporter
-from hardpy.pytest_hardpy.utils import TestStatus, NodeInfo
+from hardpy.pytest_hardpy.utils import NodeInfo, TestStatus, machine_id
 
 
 class HookReporter(BaseReporter):
     """Reporter for using in the hook HardPy plugin's hooks."""
 
-    def __init__(self, is_clear_database: bool = False):  # noqa: WPS612
+    def __init__(self, is_clear_database: bool = False) -> None:
         super().__init__()
         if is_clear_database:
             self._statestore.clear()
         self._log = getLogger(__name__)
 
-    def init_doc(self, doc_name: str):
+    def init_doc(self, doc_name: str) -> None:
         """Initialize document.
 
         Args:
@@ -30,23 +32,26 @@ class HookReporter(BaseReporter):
         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.PROGRESS, 0, statestore_only=True)
         self.set_doc_value(DF.ARTIFACT, {}, runstore_only=True)
         self.set_doc_value(DF.OPERATOR_MSG, {}, statestore_only=True)
 
-    def start(self):
+        test_stand_tz = self.generate_key(DF.TEST_STAND, DF.TIMEZONE)
+        self.set_doc_value(test_stand_tz, datetime.now().astimezone().tzname())
+
+        test_stand_id_key = self.generate_key(DF.TEST_STAND, DF.HW_ID)
+        self.set_doc_value(test_stand_id_key, machine_id())
+
+    def start(self) -> None:
         """Start test."""
         self._log.debug("Starting test run.")
         start_time = int(time())
         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)
+        self.set_doc_value(DF.PROGRESS, 0, statestore_only=True)
 
-    def finish(self, status: TestStatus):
+    def finish(self, status: TestStatus) -> None:
         """Finish test.
 
         This method must be called at the end of test run.
@@ -56,20 +61,20 @@ class HookReporter(BaseReporter):
         self.set_doc_value(DF.STOP_TIME, stop_time)
         self.set_doc_value(DF.STATUS, status)
 
-    def compact_all(self):
-        """Compact all databases"""
+    def compact_all(self) -> None:
+        """Compact all databases."""
         self._statestore.compact()
         self._runstore.compact()
 
-    def set_progress(self, progress: int):
+    def set_progress(self, progress: int) -> None:
         """Set test progress.
 
         Args:
             progress (int): test progress
         """
-        self.set_doc_value(DF.PROGRESS, progress)
+        self.set_doc_value(DF.PROGRESS, progress, statestore_only=True)
 
-    def set_assertion_msg(self, module_id: str, case_id: str, msg: str | None):
+    def set_assertion_msg(self, module_id: str, case_id: str, msg: str | None) -> None:
         """Set case assertion message.
 
         Args:
@@ -78,11 +83,15 @@ class HookReporter(BaseReporter):
             msg (str): assertion message
         """
         key = self.generate_key(
-            DF.MODULES, module_id, DF.CASES, case_id, DF.ASSERTION_MSG
+            DF.MODULES,
+            module_id,
+            DF.CASES,
+            case_id,
+            DF.ASSERTION_MSG,
         )
         self.set_doc_value(key, msg)
 
-    def add_case(self, node_info: NodeInfo):
+    def add_case(self, node_info: NodeInfo) -> None:
         """Add test case to document.
 
         Args:
@@ -99,7 +108,7 @@ class HookReporter(BaseReporter):
         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):
+    def set_case_status(self, module_id: str, case_id: str, status: TestStatus) -> None:
         """Set test case status.
 
         Args:
@@ -110,7 +119,7 @@ class HookReporter(BaseReporter):
         key = self.generate_key(DF.MODULES, module_id, DF.CASES, case_id, DF.STATUS)
         self.set_doc_value(key, status)
 
-    def set_case_start_time(self, module_id: str, case_id: str):
+    def set_case_start_time(self, module_id: str, case_id: str) -> None:
         """Set test case start_time.
 
         Args:
@@ -120,7 +129,7 @@ class HookReporter(BaseReporter):
         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):
+    def set_case_stop_time(self, module_id: str, case_id: str) -> None:
         """Set test case start_time.
 
         Args:
@@ -130,7 +139,7 @@ class HookReporter(BaseReporter):
         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):
+    def set_module_status(self, module_id: str, status: TestStatus) -> None:
         """Set test module status.
 
         Args:
@@ -140,7 +149,7 @@ class HookReporter(BaseReporter):
         key = self.generate_key(DF.MODULES, module_id, DF.STATUS)
         self.set_doc_value(key, status)
 
-    def set_module_start_time(self, module_id: str):
+    def set_module_start_time(self, module_id: str) -> None:
         """Set test module status.
 
         Args:
@@ -149,7 +158,7 @@ class HookReporter(BaseReporter):
         key = self.generate_key(DF.MODULES, module_id, DF.START_TIME)
         self._set_time(key)
 
-    def set_module_stop_time(self, module_id: str):
+    def set_module_stop_time(self, module_id: str) -> None:
         """Set test module status.
 
         Args:
@@ -158,6 +167,23 @@ class HookReporter(BaseReporter):
         key = self.generate_key(DF.MODULES, module_id, DF.STOP_TIME)
         self._set_time(key)
 
+    def set_case_attempt(self, module_id: str, case_id: str, attempt: int) -> None:
+        """Set test case current attempt.
+
+        Args:
+            module_id (str): module id
+            case_id (str): case id
+            attempt (int): test case current attempt
+        """
+        key = self.generate_key(
+            DF.MODULES,
+            module_id,
+            DF.CASES,
+            case_id,
+            DF.ATTEMPT,
+        )
+        self.set_doc_value(key, attempt, statestore_only=True)
+
     def update_node_order(self, nodes: dict) -> None:
         """Update node order.
 
@@ -173,7 +199,7 @@ class HookReporter(BaseReporter):
         updated_module_order = self._update_module_order(updated_case_order)
         self.set_doc_value(key, updated_module_order, statestore_only=True)
 
-    def _set_time(self, key: str):
+    def _set_time(self, key: str) -> None:
         current_time = self._statestore.get_field(key)
         if current_time is None:
             self.set_doc_value(key, int(time()))
@@ -184,8 +210,8 @@ class HookReporter(BaseReporter):
         node_info: NodeInfo,
         is_only_runstore: bool = False,
         is_only_statestore: bool = False,
-    ):
-        module_default = {  # noqa: WPS204
+    ) -> None:
+        module_default = {
             DF.STATUS: TestStatus.READY,
             DF.NAME: self._get_module_name(node_info),
             DF.START_TIME: None,
@@ -199,13 +225,12 @@ class HookReporter(BaseReporter):
             DF.STOP_TIME: None,
             DF.ASSERTION_MSG: None,
             DF.MSG: None,
-            DF.ATTEMPT: 0,
         }
 
-        if item.get(node_info.module_id) is None:  # noqa: WPS204
+        if item.get(node_info.module_id) is None:
             if is_only_runstore:
                 module_default[DF.ARTIFACT] = {}
-            item[node_info.module_id] = module_default  # noqa: WPS204
+            item[node_info.module_id] = module_default
         else:
             item[node_info.module_id][DF.STATUS] = TestStatus.READY
             item[node_info.module_id][DF.NAME] = self._get_module_name(node_info)
@@ -218,10 +243,14 @@ class HookReporter(BaseReporter):
 
         if is_only_statestore:
             case_default[DF.DIALOG_BOX] = {}
+            case_default[DF.ATTEMPT] = 0
         item[node_info.module_id][DF.CASES][node_info.case_id] = case_default
 
     def _remove_outdate_node(
-        self, old_modules: dict, new_modules: dict, nodes: dict
+        self,
+        old_modules: dict,
+        new_modules: dict,
+        nodes: dict,
     ) -> dict:
         """Remove outdated nodes from StateStore database.
 
@@ -277,16 +306,15 @@ class HookReporter(BaseReporter):
         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
+            new_modules[module_id] = module  # noqa: PERF403
 
         return new_modules
 
-    def _get_module_name(self, node_info) -> str:
+    def _get_module_name(self, node_info: NodeInfo) -> str:
         """Get module name from markers or use default.
 
         Args:
@@ -297,7 +325,7 @@ class HookReporter(BaseReporter):
         """
         return node_info.module_name if node_info.module_name else node_info.module_id
 
-    def _get_case_name(self, node_info) -> str:
+    def _get_case_name(self, node_info: NodeInfo) -> str:
         """Get case name from markers or use default.
 
         Args:

hardpy/pytest_hardpy/reporter/runner_reporter.py

@@ -5,19 +5,17 @@ from logging import getLogger
 from typing import Any
 
 from hardpy.pytest_hardpy.reporter.base import BaseReporter
-from hardpy.pytest_hardpy.utils import Singleton
+from hardpy.pytest_hardpy.utils import SingletonMeta
 
 
-class RunnerReporter(Singleton, BaseReporter):
+class RunnerReporter(BaseReporter, metaclass=SingletonMeta):
     """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 __init__(self) -> None:
+        super().__init__()
+        self._log = getLogger(__name__)
 
-    def get_field(self, key: str) -> Any:
+    def get_field(self, key: str) -> Any:  # noqa: ANN401
         """Get field from the statestore.
 
         Args:

hardpy/pytest_hardpy/result/__init__.py

@@ -1,8 +1,8 @@
 # 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
+from hardpy.pytest_hardpy.result.report_reader.couchdb_reader import CouchdbReader
 
 __all__ = [
     "CouchdbReader",

hardpy/pytest_hardpy/result/couchdb_config.py

@@ -1,16 +1,17 @@
 # Copyright (c) 2024 Everypin
 # GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+from __future__ import annotations
 
 import ast
-import requests
 import socket
-
 from dataclasses import dataclass
+
+import requests
 from urllib3 import disable_warnings
 
 
 @dataclass
-class CouchdbConfig:  # noqa: WPS306
+class CouchdbConfig:
     """CouchDB loader config.
 
     If `connection_str` arg is not set, it will be created from other args.
@@ -23,7 +24,7 @@ class CouchdbConfig:  # noqa: WPS306
     port: int = 5984
     connection_str: str | None = None
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         """Disable urllib3 warnings.
 
         More info: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#tls-warnings
@@ -43,14 +44,14 @@ class CouchdbConfig:  # noqa: WPS306
         if self.connection_str:
             return self.connection_str
 
-        # TODO: Modify connection string creating based on protocol.
+        # TODO(xorialexandrov): Modify connection string creating based on protocol.
         #       Some problems with http and https, different ports, local
         #       and cloud databases.
         protocol = self._get_protocol()
 
         if protocol == "http":
             host_url = f"http://{self.host}:{self.port}"
-            uri = f"{self.host}:{str(self.port)}"  # noqa: WPS237
+            uri = f"{self.host}:{self.port!s}"
         elif protocol == "https":
             host_url = f"https://{self.host}"
             uri = f"{self.host}"
@@ -58,20 +59,22 @@ class CouchdbConfig:  # noqa: WPS306
         try:
             response = requests.get(host_url, timeout=5)
         except requests.exceptions.RequestException:
-            raise RuntimeError(f"Error CouchDB connecting to {host_url}.")
+            msg = f"Error CouchDB connecting to {host_url}."
+            raise RuntimeError(msg)  # noqa: B904
 
         # fmt: off
         try:
-            couchdb_dict = ast.literal_eval(response._content.decode("utf-8"))  # noqa: WPS437,E501
+            couchdb_dict = ast.literal_eval(response._content.decode("utf-8"))  # type: ignore # noqa: SLF001
             couchdb_dict.get("couchdb", False)
-        except Exception:
-            raise RuntimeError(f"Address {host_url} does not provide CouchDB attributes.")
+        except Exception:  # noqa: BLE001
+            msg = f"Address {host_url} does not provide CouchDB attributes."
+            raise RuntimeError(msg)  # noqa: B904
         # fmt: on
 
         credentials = f"{self.user}:{self.password}"
         return f"{protocol}://{credentials}@{uri}/"
 
-    def _get_protocol(self) -> str:  # noqa: WPS231
+    def _get_protocol(self) -> str:
         success = 200
         try:
             # HTTPS attempt
@@ -80,17 +83,18 @@ class CouchdbConfig:  # noqa: WPS306
             request = f"https://{self.host}"
             if requests.get(request, timeout=5).status_code == success:
                 return "https"
-            raise OSError
+            raise OSError  # noqa: TRY301
         except OSError:
-            try:  # noqa: WPS505
+            try:
                 # HTTP attempt
                 sock = socket.create_connection((self.host, self.port))
                 sock.close()
                 request = f"http://{self.host}:{self.port}"
                 if requests.get(request, timeout=5).status_code == success:
                     return "http"
-                raise OSError
+                raise OSError  # noqa: TRY301
             except OSError:
-                raise RuntimeError(
-                    f"Error connecting to couchdb server {self.host}:{self.port}."
+                msg = f"Error connecting to couchdb server {self.host}:{self.port}."
+                raise RuntimeError(  # noqa: B904
+                    msg,
                 )

hardpy/pytest_hardpy/result/report_loader/couchdb_loader.py

@@ -5,8 +5,8 @@ from logging import getLogger
 from uuid import uuid4
 
 from pycouchdb import Server as DbServer
-from pycouchdb.exceptions import Conflict
 from pycouchdb.client import Database
+from pycouchdb.exceptions import Conflict
 
 from hardpy.pytest_hardpy.db.schema import ResultRunStore
 from hardpy.pytest_hardpy.result.couchdb_config import CouchdbConfig
@@ -15,7 +15,7 @@ from hardpy.pytest_hardpy.result.couchdb_config import CouchdbConfig
 class CouchdbLoader:
     """CouchDB report generator."""
 
-    def __init__(self, config: CouchdbConfig):
+    def __init__(self, config: CouchdbConfig) -> None:
         self._log = getLogger(__name__)
         self._config: CouchdbConfig = config
         self._db_srv = DbServer(config.connection_string)

hardpy/pytest_hardpy/result/report_reader/couchdb_reader.py

@@ -1,17 +1,21 @@
 # Copyright (c) 2024 Everypin
 # GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+from __future__ import annotations
 
-from logging import getLogger
 from dataclasses import dataclass
-from typing import List, Optional
+from logging import getLogger
+from typing import TYPE_CHECKING
 
 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.db import DatabaseField as DF  # noqa: N817
 from hardpy.pytest_hardpy.utils.const import TestStatus
-from hardpy.pytest_hardpy.result.couchdb_config import CouchdbConfig
+
+if TYPE_CHECKING:
+    from pycouchdb.client import Database
+
+    from hardpy.pytest_hardpy.result.couchdb_config import CouchdbConfig
 
 
 @dataclass
@@ -22,14 +26,14 @@ class ReportInfo:
     status: str
     start_time: str
     end_time: str
-    first_failed_test_name: Optional[str]
-    first_failed_test_id: Optional[str]
+    first_failed_test_name: str | None
+    first_failed_test_id: str | None
 
 
 class CouchdbReader:
     """CouchDB report info reader."""
 
-    def __init__(self, config: CouchdbConfig):
+    def __init__(self, config: CouchdbConfig) -> None:
         self._log = getLogger(__name__)
         self._config = config
         self._db_srv = DbServer(config.connection_string)
@@ -58,13 +62,14 @@ class CouchdbReader:
             int: number of reports
         """
         if start_time < 0 or end_time < 0:
-            raise ValueError("Start time and end time must be positive values")
+            msg = "Start time and end time must be positive values"
+            raise ValueError(msg)
         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]),
+                self._get_start_time_from_db(report[self._doc_id]),  # type: ignore
+                self._get_stop_time_from_db(report[self._doc_id]),  # type: ignore
                 start_time,
                 end_time,
             )
@@ -85,10 +90,11 @@ class CouchdbReader:
         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")
+            msg = "Invalid report status"
+            raise ValueError(msg)
         return status
 
-    def get_report_infos(self) -> List[ReportInfo]:
+    def get_report_infos(self) -> list[ReportInfo]:
         """Get a list of information about all reports in the database.
 
         Returns:
@@ -102,8 +108,10 @@ class CouchdbReader:
         return reports_info
 
     def get_report_infos_in_timeframe(
-        self, start_time: int, end_time: int
-    ) -> List[ReportInfo]:
+        self,
+        start_time: int,
+        end_time: int,
+    ) -> list[ReportInfo]:
         """Get a list of information about reports in a timeframe in the database.
 
         Args:
@@ -117,14 +125,15 @@ class CouchdbReader:
             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")
+            msg = "Start time and end time must be positive values"
+            raise ValueError(msg)
 
         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):
+            if self._is_in_timeframe(start_t_db, stop_t_db, start_time, end_time):  # type: ignore
                 report_info = self._get_single_report_info(report)
                 reports_info.append(report_info)
         return reports_info
@@ -134,7 +143,8 @@ class CouchdbReader:
             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
+            msg = "Error initializing database"
+            raise RuntimeError(msg) from exc
 
     def _get_start_time_from_db(self, doc: dict) -> str:
         return doc[DF.START_TIME]
@@ -146,7 +156,7 @@ class CouchdbReader:
         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 module_info in report_doc[DF.MODULES].values():
             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]
@@ -160,5 +170,11 @@ class CouchdbReader:
             first_failed_test_id=first_failed_test_id,
         )
 
-    def _is_in_timeframe(self, start, end, timeframe_start, timeframe_end):
+    def _is_in_timeframe(
+        self,
+        start: int,
+        end: int,
+        timeframe_start: int,
+        timeframe_end: int,
+    ) -> bool:
         return timeframe_start <= start and end <= timeframe_end