hardpy 0.19.1__py3-none-any.whl → 0.20.1__py3-none-any.whl

hardpy/pytest_hardpy/db/statestore.py

@@ -1,17 +1,402 @@
 # 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 json
+from abc import ABC, abstractmethod
+from json import dumps
 from logging import getLogger
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from glom import PathAccessError, assign, glom
 
+from hardpy.common.config import ConfigManager, StorageType
 from hardpy.common.singleton import SingletonMeta
-from hardpy.pytest_hardpy.db.base_store import BaseStore
+from hardpy.pytest_hardpy.db.const import DatabaseField as DF  # noqa: N817
 from hardpy.pytest_hardpy.db.schema import ResultStateStore
 
+if TYPE_CHECKING:
+    from pycouchdb.client import Database  # type: ignore[import-untyped]
+    from pydantic import BaseModel
+
+
+def _create_default_doc_structure(doc_id: str, doc_id_for_rev: str) -> dict:
+    """Create default document structure with standard fields.
+
+    Args:
+        doc_id (str): Document ID to use
+        doc_id_for_rev (str): Document ID for _rev field (for JSON compatibility)
+
+    Returns:
+        dict: Default document structure
+    """
+    return {
+        "_id": doc_id,
+        "_rev": doc_id_for_rev,
+        DF.MODULES: {},
+        DF.DUT: {
+            DF.TYPE: None,
+            DF.NAME: None,
+            DF.REVISION: None,
+            DF.SERIAL_NUMBER: None,
+            DF.PART_NUMBER: None,
+            DF.SUB_UNITS: [],
+            DF.INFO: {},
+        },
+        DF.TEST_STAND: {
+            DF.HW_ID: None,
+            DF.NAME: None,
+            DF.REVISION: None,
+            DF.TIMEZONE: None,
+            DF.LOCATION: None,
+            DF.NUMBER: None,
+            DF.INSTRUMENTS: [],
+            DF.DRIVERS: {},
+            DF.INFO: {},
+        },
+        DF.PROCESS: {
+            DF.NAME: None,
+            DF.NUMBER: None,
+            DF.INFO: {},
+        },
+    }
+
+
+class StateStoreInterface(ABC):
+    """Interface for state storage implementations."""
+
+    @abstractmethod
+    def get_field(self, key: str) -> Any:  # noqa: ANN401
+        """Get field from the state store.
+
+        Args:
+            key (str): Field key, supports nested access with dots
+
+        Returns:
+            Any: Field value
+        """
+
+    @abstractmethod
+    def update_doc_value(self, key: str, value: Any) -> None:  # noqa: ANN401
+        """Update document value in memory (does not persist).
+
+        Args:
+            key (str): Field key, supports nested access with dots
+            value (Any): Value to set
+        """
+
+    @abstractmethod
+    def update_db(self) -> None:
+        """Persist in-memory document to storage backend."""
+
+    @abstractmethod
+    def update_doc(self) -> None:
+        """Reload document from storage backend to memory."""
+
+    @abstractmethod
+    def get_document(self) -> BaseModel:
+        """Get full document with schema validation.
+
+        Returns:
+            BaseModel: Validated document model
+        """
+
+    @abstractmethod
+    def clear(self) -> None:
+        """Clear storage and reset to initial state."""
+
+    @abstractmethod
+    def compact(self) -> None:
+        """Optimize storage (implementation-specific, may be no-op)."""
 
-class StateStore(BaseStore, metaclass=SingletonMeta):
-    """HardPy state storage interface for CouchDB."""
+
+class JsonStateStore(StateStoreInterface):
+    """JSON file-based state storage implementation.
+
+    Stores test execution state using JSON files.
+    """
 
     def __init__(self) -> None:
-        super().__init__("statestore")
+        config_manager = ConfigManager()
+        self._store_name = "statestore"
+        config_storage_path = Path(config_manager.config.database.storage_path)
+        if config_storage_path.is_absolute():
+            self._storage_dir = config_storage_path / "storage" / self._store_name
+        else:
+            self._storage_dir = Path(
+                config_manager.tests_path
+                / config_manager.config.database.storage_path
+                / "storage"
+                / self._store_name,
+            )
+        self._storage_dir.mkdir(parents=True, exist_ok=True)
+        self._doc_id = config_manager.config.database.doc_id
+        self._file_path = self._storage_dir / f"{self._doc_id}.json"
         self._log = getLogger(__name__)
-        self._schema = ResultStateStore
+        self._schema: type[BaseModel] = ResultStateStore
+        self._doc: dict = self._init_doc()
+
+    def get_field(self, key: str) -> Any:  # noqa: ANN401
+        """Get field value from document using dot notation.
+
+        Args:
+            key (str): Field key, supports nested access with dots
+
+        Returns:
+            Any: Field value, or None if path does not exist
+        """
+        try:
+            return glom(self._doc, key)
+        except PathAccessError:
+            return None
+
+    def update_doc_value(self, key: str, value: Any) -> None:  # noqa: ANN401
+        """Update document value in memory (does not persist).
+
+        Args:
+            key (str): Field key, supports nested access with dots
+            value (Any): Value to set
+        """
+        try:
+            dumps(value)
+        except Exception:  # noqa: BLE001
+            value = dumps(value, default=str)
+
+        if "." in key:
+            assign(self._doc, key, value, missing=dict)
+        else:
+            self._doc[key] = value
+
+    def update_db(self) -> None:
+        """Persist in-memory document to JSON file with atomic write."""
+        self._storage_dir.mkdir(parents=True, exist_ok=True)
+        temp_file = self._file_path.with_suffix(".tmp")
+
+        try:
+            with temp_file.open("w") as f:
+                json.dump(self._doc, f, indent=2, default=str)
+            temp_file.replace(self._file_path)
+        except Exception as exc:
+            self._log.error(f"Error writing to storage file: {exc}")
+            if temp_file.exists():
+                temp_file.unlink()
+            raise
+
+    def update_doc(self) -> None:
+        """Reload document from JSON file to memory."""
+        if self._file_path.exists():
+            try:
+                with self._file_path.open("r") as f:
+                    self._doc = json.load(f)
+            except json.JSONDecodeError as exc:
+                self._log.error(f"Error reading storage file: {exc}")
+            except Exception as exc:
+                self._log.error(f"Error reading storage file: {exc}")
+                raise
+
+    def get_document(self) -> BaseModel:
+        """Get full document with schema validation.
+
+        Returns:
+            BaseModel: Validated document model
+        """
+        self.update_doc()
+        return self._schema(**self._doc)
+
+    def clear(self) -> None:
+        """Clear storage by resetting to initial state (in-memory only)."""
+        self._doc = _create_default_doc_structure(self._doc_id, self._doc_id)
+
+    def compact(self) -> None:
+        """Optimize storage (no-op for JSON file storage)."""
+
+    def _init_doc(self) -> dict:
+        """Initialize or load document structure."""
+        if self._file_path.exists():
+            try:
+                with self._file_path.open("r") as f:
+                    doc = json.load(f)
+
+                    if DF.MODULES not in doc:
+                        doc[DF.MODULES] = {}
+
+                    # Reset volatile fields for statestore
+                    default_doc = _create_default_doc_structure(doc["_id"],
+                                                                self._doc_id)
+                    doc[DF.DUT] = default_doc[DF.DUT]
+                    doc[DF.TEST_STAND] = default_doc[DF.TEST_STAND]
+                    doc[DF.PROCESS] = default_doc[DF.PROCESS]
+
+                    return doc
+            except json.JSONDecodeError:
+                self._log.warning(
+                    f"Corrupted storage file {self._file_path}, creating new",
+                )
+            except Exception as exc:  # noqa: BLE001
+                self._log.warning(f"Error loading storage file: {exc}, creating new")
+
+        return _create_default_doc_structure(self._doc_id, self._doc_id)
+
+
+class CouchDBStateStore(StateStoreInterface):
+    """CouchDB-based state storage implementation.
+
+    Stores test execution state using CouchDB.
+    """
+
+    def __init__(self) -> None:
+        from pycouchdb import Server as DbServer  # type: ignore[import-untyped]
+        from pycouchdb.exceptions import (  # type: ignore[import-untyped]
+            Conflict,
+            GenericError,
+        )
+        from requests.exceptions import ConnectionError  # noqa: A004
+
+        config_manager = ConfigManager()
+        config = config_manager.config
+        self._db_srv = DbServer(config.database.url)
+        self._db_name = "statestore"
+        self._doc_id = config.database.doc_id
+        self._log = getLogger(__name__)
+        self._schema: type[BaseModel] = ResultStateStore
+
+        # Initialize database
+        try:
+            self._db: Database = self._db_srv.create(self._db_name)  # type: ignore[name-defined]
+        except Conflict:
+            self._db = self._db_srv.database(self._db_name)
+        except GenericError as exc:
+            msg = f"Error initializing database {exc}"
+            raise RuntimeError(msg) from exc
+        except ConnectionError as exc:
+            msg = f"Error initializing database: {exc}"
+            raise RuntimeError(msg) from exc
+
+        self._doc: dict = self._init_doc()
+
+    def get_field(self, key: str) -> Any:  # noqa: ANN401
+        """Get field from the state store.
+
+        Args:
+            key (str): Field key, supports nested access with dots
+
+        Returns:
+            Any: Field value, or None if path does not exist
+        """
+        try:
+            return glom(self._doc, key)
+        except PathAccessError:
+            return None
+
+    def update_doc_value(self, key: str, value: Any) -> None:  # noqa: ANN401
+        """Update document value in memory (does not persist).
+
+        Args:
+            key (str): Field key, supports nested access with dots
+            value (Any): Value to set
+        """
+        try:
+            dumps(value)
+        except Exception:  # noqa: BLE001
+            value = dumps(value, default=str)
+
+        if "." in key:
+            assign(self._doc, key, value, missing=dict)
+        else:
+            self._doc[key] = value
+
+    def update_db(self) -> None:
+        """Persist in-memory document to storage backend."""
+        from pycouchdb.exceptions import Conflict  # type: ignore[import-untyped]
+
+        try:
+            self._doc = self._db.save(self._doc)
+        except Conflict:
+            self._doc["_rev"] = self._db.get(self._doc_id)["_rev"]
+            self._doc = self._db.save(self._doc)
+
+    def update_doc(self) -> None:
+        """Reload document from storage backend to memory."""
+        self._doc["_rev"] = self._db.get(self._doc_id)["_rev"]
+        self._doc = self._db.get(self._doc_id)
+
+    def get_document(self) -> BaseModel:
+        """Get full document with schema validation.
+
+        Returns:
+            BaseModel: Validated document model
+        """
+        self._doc = self._db.get(self._doc_id)
+        return self._schema(**self._doc)
+
+    def clear(self) -> None:
+        """Clear storage and reset to initial state."""
+        from pycouchdb.exceptions import (  # type: ignore[import-untyped]
+            Conflict,
+            NotFound,
+        )
+
+        try:
+            self._db.delete(self._doc_id)
+        except (Conflict, NotFound):
+            self._log.debug("Database will be created for the first time")
+        self._doc = self._init_doc()
+
+    def compact(self) -> None:
+        """Optimize storage (implementation-specific, may be no-op)."""
+        self._db.compact()
+
+    def _init_doc(self) -> dict:
+        """Initialize or load document structure."""
+        from pycouchdb.exceptions import NotFound  # type: ignore[import-untyped]
+
+        try:
+            doc = self._db.get(self._doc_id)
+        except NotFound:
+            # CouchDB doesn't need _rev field in the default structure
+            default = _create_default_doc_structure(self._doc_id, self._doc_id)
+            del default["_rev"]  # CouchDB manages _rev automatically
+            return default
+
+        if DF.MODULES not in doc:
+            doc[DF.MODULES] = {}
+
+        # Reset volatile fields
+        default_doc = _create_default_doc_structure(doc["_id"], self._doc_id)
+        doc[DF.DUT] = default_doc[DF.DUT]
+        doc[DF.TEST_STAND] = default_doc[DF.TEST_STAND]
+        doc[DF.PROCESS] = default_doc[DF.PROCESS]
+
+        return doc
+
+
+class StateStore(metaclass=SingletonMeta):
+    """HardPy state storage factory for test execution state.
+
+    Creates appropriate storage backend based on configuration:
+    - JSON file storage when storage_type is "json"
+    - CouchDB storage when storage_type is "couchdb"
+
+    This ensures state data is stored in the same backend as the main data.
+
+    Note: This class acts as a factory. When instantiated, it returns
+    the appropriate concrete implementation (JsonStateStore or CouchDBStateStore).
+    """
+
+    def __new__(cls) -> StateStoreInterface:  # type: ignore[misc]
+        """Create and return the appropriate storage implementation.
+
+        Returns:
+            StateStoreInterface: Concrete storage implementation based on config
+        """
+        config = ConfigManager()
+        storage_type = config.config.database.storage_type
+
+        if storage_type == StorageType.JSON:
+            return JsonStateStore()
+        if storage_type == StorageType.COUCHDB:
+            return CouchDBStateStore()
+        msg = f"Unknown storage type: {storage_type}"
+        raise ValueError(msg)

hardpy/pytest_hardpy/db/tempstore.py

@@ -3,52 +3,254 @@
 
 from __future__ import annotations
 
+import json
+from abc import ABC, abstractmethod
 from logging import getLogger
+from pathlib import Path
 from typing import TYPE_CHECKING
 
-from pycouchdb.exceptions import Conflict, NotFound
+from uuid6 import uuid7
 
+from hardpy.common.config import ConfigManager, StorageType
 from hardpy.common.singleton import SingletonMeta
-from hardpy.pytest_hardpy.db.base_store import BaseStore
 from hardpy.pytest_hardpy.db.schema import ResultRunStore
 
 if TYPE_CHECKING:
     from collections.abc import Generator
 
 
-class TempStore(BaseStore, metaclass=SingletonMeta):
-    """HardPy temporary storage for data syncronization."""
+class TempStoreInterface(ABC):
+    """Interface for temporary storage implementations."""
+
+    @abstractmethod
+    def push_report(self, report: ResultRunStore) -> bool:
+        """Push report to the temporary storage.
+
+        Args:
+            report (ResultRunStore): report to store
+
+        Returns:
+            bool: True if successful, False otherwise
+        """
+
+    @abstractmethod
+    def reports(self) -> Generator[dict]:
+        """Get all reports from the temporary storage.
+
+        Yields:
+            dict: report from temporary storage
+        """
+
+    @abstractmethod
+    def delete(self, report_id: str) -> bool:
+        """Delete report from the temporary storage.
+
+        Args:
+            report_id (str): report ID to delete
+
+        Returns:
+            bool: True if successful, False otherwise
+        """
+
+    def dict_to_schema(self, report: dict) -> ResultRunStore:
+        """Convert report dict to report schema.
+
+        Args:
+            report (dict): report dictionary
+
+        Returns:
+            ResultRunStore: validated report schema
+        """
+        return ResultRunStore(**report)
+
+
+class JsonTempStore(TempStoreInterface):
+    """JSON file-based temporary storage implementation.
+
+    Stores reports temporarily when StandCloud sync fails using JSON files.
+    """
 
     def __init__(self) -> None:
-        super().__init__("tempstore")
         self._log = getLogger(__name__)
-        self._doc: dict = self._init_doc()
+        config = ConfigManager()
+        config_storage_path = Path(config.config.database.storage_path)
+        if config_storage_path.is_absolute():
+            self._storage_dir = config_storage_path / "storage" / "tempstore"
+        else:
+            self._storage_dir = Path(
+                config.tests_path
+                / config.config.database.storage_path
+                / "storage"
+                / "tempstore",
+            )
+        self._storage_dir.mkdir(parents=True, exist_ok=True)
         self._schema = ResultRunStore
 
     def push_report(self, report: ResultRunStore) -> bool:
-        """Push report to the report database."""
+        """Push report to the temporary storage.
+
+        Args:
+            report (ResultRunStore): report to store
+
+        Returns:
+            bool: True if successful, False otherwise
+        """
         report_dict = report.model_dump()
-        report_id = report_dict.pop("id")
+        report_dict.pop("id", None)
+        report_id = str(uuid7())
+        report_dict["_id"] = report_id
+        report_dict["_rev"] = report_id
+        report_file = self._storage_dir / f"{report_id}.json"
+
+        try:
+            with report_file.open("w") as f:
+                json.dump(report_dict, f, indent=2, default=str)
+        except Exception as exc:  # noqa: BLE001
+            self._log.error(f"Error while saving report {report_id}: {exc}")
+            return False
+        else:
+            self._log.debug(f"Report saved with id: {report_id}")
+            return True
+
+    def reports(self) -> Generator[dict]:
+        """Get all reports from the temporary storage.
+
+        Yields:
+            dict: report from temporary storage
+        """
+        for report_file in self._storage_dir.glob("*.json"):
+            try:
+                with report_file.open("r") as f:
+                    report_dict = json.load(f)
+                yield report_dict
+            except Exception as exc:  # noqa: BLE001, PERF203
+                self._log.error(f"Error loading report from {report_file}: {exc}")
+                continue
+
+    def delete(self, report_id: str) -> bool:
+        """Delete report from the temporary storage.
+
+        Args:
+            report_id (str): report ID to delete
+
+        Returns:
+            bool: True if successful, False otherwise
+        """
+        report_file = self._storage_dir / f"{report_id}.json"
+        try:
+            report_file.unlink()
+        except FileNotFoundError:
+            self._log.warning(f"Report {report_id} not found in temporary storage")
+            return False
+        except Exception as exc:  # noqa: BLE001
+            self._log.error(f"Error deleting report {report_id}: {exc}")
+            return False
+        else:
+            return True
+
+
+class CouchDBTempStore(TempStoreInterface):
+    """CouchDB-based temporary storage implementation.
+
+    Stores reports temporarily when StandCloud sync fails using CouchDB.
+    """
+
+    def __init__(self) -> None:
+        from pycouchdb import Server as DbServer  # type: ignore[import-untyped]
+        from pycouchdb.exceptions import Conflict  # type: ignore[import-untyped]
+
+        self._log = getLogger(__name__)
+        config = ConfigManager()
+        self._db_srv = DbServer(config.config.database.url)
+        self._db_name = "tempstore"
+        self._schema = ResultRunStore
+
+        try:
+            self._db = self._db_srv.create(self._db_name)
+        except Conflict:
+            # database already exists
+            self._db = self._db_srv.database(self._db_name)
+
+    def push_report(self, report: ResultRunStore) -> bool:
+        """Push report to the temporary storage.
+
+        Args:
+            report (ResultRunStore): report to store
+
+        Returns:
+            bool: True if successful, False otherwise
+        """
+        from pycouchdb.exceptions import Conflict  # type: ignore[import-untyped]
+
+        report_dict = report.model_dump()
+        report_id = report_dict.pop("id", None)
+        if not report_id:
+            self._log.error("Report missing required 'id' field")
+            return False
         try:
             self._db.save(report_dict)
         except Conflict as exc:
             self._log.error(f"Error while saving report {report_id}: {exc}")
             return False
-        self._log.debug(f"Report saved with id: {report_id}")
-        return True
+        else:
+            self._log.debug(f"Report saved with id: {report_id}")
+            return True
+
+    def reports(self) -> Generator[dict]:
+        """Get all reports from the temporary storage.
 
-    def reports(self) -> Generator[ResultRunStore]:
-        """Get all reports from the report database."""
+        Yields:
+            dict: report from temporary storage
+        """
         yield from self._db.all()
 
     def delete(self, report_id: str) -> bool:
-        """Delete report from the report database."""
+        """Delete report from the temporary storage.
+
+        Args:
+            report_id (str): report ID to delete
+
+        Returns:
+            bool: True if successful, False otherwise
+        """
+        from pycouchdb.exceptions import (  # type: ignore[import-untyped]
+            Conflict,
+            NotFound,
+        )
+
         try:
             self._db.delete(report_id)
         except (NotFound, Conflict):
             return False
-        return True
+        else:
+            return True
 
-    def dict_to_schema(self, report: dict) -> ResultRunStore:
-        """Convert report dict to report schema."""
-        return self._schema(**report)
+
+class TempStore(metaclass=SingletonMeta):
+    """HardPy temporary storage factory for data synchronization.
+
+    Creates appropriate storage backend based on configuration:
+    - JSON file storage when storage_type is "json"
+    - CouchDB storage when storage_type is "couchdb"
+
+    This ensures temporary reports are stored in the same backend as the main data.
+
+    Note: This class acts as a factory. When instantiated, it returns
+    the appropriate concrete implementation (JsonTempStore or CouchDBTempStore).
+    """
+
+    def __new__(cls) -> TempStoreInterface:  # type: ignore[misc]
+        """Create and return the appropriate storage implementation.
+
+        Returns:
+            TempStoreInterface: Concrete storage implementation based on config
+        """
+        config = ConfigManager()
+        storage_type = config.config.database.storage_type
+
+        if storage_type == StorageType.JSON:
+            return JsonTempStore()
+        if storage_type == StorageType.COUCHDB:
+            return CouchDBTempStore()
+        msg = f"Unknown storage type: {storage_type}"
+        raise ValueError(msg)

hardpy/pytest_hardpy/plugin.py

@@ -496,7 +496,7 @@ class HardpyPlugin:
             module_start_time = self._reporter.get_module_start_time(module_id)
             module_stop_time = self._reporter.get_module_stop_time(module_id)
             if module_start_time and not module_stop_time:
-                self._reporter.set_module_stop_time(module_start_time)
+                self._reporter.set_module_stop_time(module_id)
             for module_data_key in module_data:
                 # skip module status
                 if module_data_key == "module_status":
@@ -505,7 +505,7 @@ class HardpyPlugin:
                 case_start_time = self._reporter.get_case_start_time(module_id, case_id)
                 case_stop_time = self._reporter.get_case_stop_time(module_id, case_id)
                 if case_start_time and not case_stop_time:
-                    self._reporter.set_case_stop_time(case_start_time)
+                    self._reporter.set_case_stop_time(module_id, case_id)
 
     def _stop_tests(self) -> None:
         """Update module and case statuses to stopped and skipped."""