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

hardpy/pytest_hardpy/pytest_wrapper.py

@@ -1,8 +1,9 @@
 # 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 signal
-import subprocess  # noqa: S404
+import subprocess
 import sys
 from platform import system
 from socket import socket
@@ -13,7 +14,7 @@ from hardpy.common.config import ConfigManager
 class PyTestWrapper:
     """Wrapper for pytest subprocess."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._proc = None
         self.python_executable = sys.executable
 
@@ -65,7 +66,7 @@ class PyTestWrapper:
                     "--hardpy-pt",
                 ],
                 cwd=ConfigManager().get_tests_path(),
-                creationflags=subprocess.CREATE_NEW_PROCESS_GROUP,
+                creationflags=subprocess.CREATE_NEW_PROCESS_GROUP,  # type: ignore
             )
 
         return True
@@ -80,11 +81,11 @@ class PyTestWrapper:
             if system() == "Linux":
                 self._proc.terminate()
             elif system() == "Windows":
-                self._proc.send_signal(signal.CTRL_BREAK_EVENT)
+                self._proc.send_signal(signal.CTRL_BREAK_EVENT)  # type: ignore
             return True
         return False
 
-    def collect(self, is_clear_database: bool = False) -> bool:
+    def collect(self, *, is_clear_database: bool = False) -> bool:
         """Perform pytest collection.
 
         Args:
@@ -115,7 +116,6 @@ class PyTestWrapper:
 
         if is_clear_database:
             args.append("--hardpy-clear-database")
-            args.append(str(is_clear_database))
 
         subprocess.Popen(  # noqa: S603
             [self.python_executable, *args],
@@ -123,7 +123,7 @@ class PyTestWrapper:
         )
         return True
 
-    def send_data(self, data: str):
+    def send_data(self, data: str) -> bool:
         """Send data to pytest subprocess.
 
         Args:
@@ -138,7 +138,7 @@ class PyTestWrapper:
             client.connect((self.config.socket.host, self.config.socket.port))
             client.sendall(data.encode("utf-8"))
             client.close()
-        except Exception:
+        except Exception:  # noqa: BLE001
             return False
         return True
 

hardpy/pytest_hardpy/reporter/__init__.py

@@ -1,10 +1,10 @@
 # Copyright (c) 2024 Everypin
 # GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
 
-from hardpy.pytest_hardpy.reporter.runner_reporter import RunnerReporter
 from hardpy.pytest_hardpy.reporter.hook_reporter import HookReporter
+from hardpy.pytest_hardpy.reporter.runner_reporter import RunnerReporter
 
 __all__ = [
-    "RunnerReporter",
     "HookReporter",
+    "RunnerReporter",
 ]

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,30 @@
 # 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 logging import getLogger
+from time import time
 
 from natsort import natsorted
+from tzlocal import get_localzone
 
-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._runstore.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 +33,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, str(get_localzone().key))
+
+        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 +62,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 +84,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 +109,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 +120,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 +130,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 +140,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 +150,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 +159,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 +168,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 +200,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 +211,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 +226,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 +244,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 +307,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 +326,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,10 +1,10 @@
 # Copyright (c) 2024 Everypin
 # GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
 
-from hardpy.pytest_hardpy.result.report_reader.couchdb_reader import CouchdbReader
 from hardpy.pytest_hardpy.result.report_loader.couchdb_loader import CouchdbLoader
+from hardpy.pytest_hardpy.result.report_reader.couchdb_reader import CouchdbReader
 
 __all__ = [
-    "CouchdbReader",
     "CouchdbLoader",
+    "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)