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

hardpy/pytest_hardpy/plugin.py

@@ -6,6 +6,7 @@ from typing import Any, Callable
 from logging import getLogger
 from pathlib import Path, PurePath
 from platform import system
+from re import compile as re_compile
 
 from natsort import natsorted
 from pytest import (
@@ -19,6 +20,13 @@ from pytest import (
     fixture,
     ExitCode,
 )
+from _pytest._code.code import (
+    ExceptionRepr,
+    ReprFileLocation,
+    ExceptionInfo,
+    ReprExceptionInfo,
+    TerminalRepr,
+)
 
 from hardpy.pytest_hardpy.reporter import HookReporter
 from hardpy.pytest_hardpy.utils import (
@@ -187,8 +195,9 @@ class HardpyPlugin(object):
 
     def pytest_runtest_logreport(self, report: TestReport):
         """Call after call of each test item."""
-        if report.when != "call":
+        if report.when != "call" and report.failed is False:
             # ignore setup and teardown phase
+            # or continue processing setup and teardown failure (fixture exception handler)
             return True
 
         module_id = Path(report.fspath).stem
@@ -204,7 +213,7 @@ class HardpyPlugin(object):
             case_id,
         )
 
-        assertion_msg = self._decode_assertion_msg(report.longreprtext)
+        assertion_msg = self._decode_assertion_msg(report.longrepr)
         self._reporter.set_assertion_msg(module_id, case_id, assertion_msg)
         self._reporter.set_progress(self._progress.calculate(report.nodeid))
         self._results[module_id][case_id] = report.outcome  # noqa: WPS204
@@ -265,15 +274,41 @@ class HardpyPlugin(object):
             case _:
                 return RunStatus.ERROR
 
-    def _decode_assertion_msg(self, msg: str) -> str | None:
-        assertion_str = "AssertionError: "
-
-        if assertion_str in msg:
-            index = msg.find(assertion_str)
-            report = msg[index + len(assertion_str) :]
-            index = report.find("\nE")
-            return report[:index]
-        return None
+    def _decode_assertion_msg(
+        self,
+        error: (  # noqa: WPS320
+            ExceptionInfo[BaseException]  # noqa: DAR101,DAR201
+            | tuple[str, int, str]
+            | str
+            | TerminalRepr
+            | None
+        ),
+    ) -> str | None:
+        """Parse pytest assertion error message."""
+        if error is None:
+            return None
+
+        match error:
+            case str():
+                return error
+            case tuple() if len(error) == 3:
+                return error[2]
+            case ExceptionInfo():
+                error_repr = error.getrepr()
+                if isinstance(error_repr, ReprExceptionInfo) and error_repr.reprcrash:
+                    return error_repr.reprcrash.message
+            case TerminalRepr():
+                if isinstance(error, ExceptionRepr) and isinstance(  # noqa: WPS337
+                    error.reprcrash, ReprFileLocation
+                ):
+                    # remove ansi codes
+                    ansi_pattern = re_compile(
+                        r"(?:\x1B[@-Z\\-_]|[\x80-\x9A\x9C-\x9F]|(?:\x1B\[|\x9B)[0-?]*[ -/]*[@-~])"  # noqa: E501
+                    )
+                    return ansi_pattern.sub("", error.reprcrash.message)
+                return str(error)
+            case _:
+                return None
 
     def _handle_dependency(self, node_info: NodeInfo):
         dependency = self._dependencies.get(

hardpy/pytest_hardpy/pytest_call.py

@@ -20,8 +20,6 @@ from hardpy.pytest_hardpy.utils import (
     DuplicateDialogBoxError,
     DialogBox,
     ConfigData,
-    generate_dialog_box_dict,
-    get_dialog_box_data,
 )
 from hardpy.pytest_hardpy.reporter import RunnerReporter
 
@@ -221,7 +219,7 @@ def run_dialog_box(dialog_box_data: DialogBox) -> Any:
 
         - dialog_text (str): The text of the dialog box.
         - title_bar (str | None): The title bar of the dialog box.
-        If the title_bar field is missing, it is the case name.
+          If the title_bar field is missing, it is the case name.
         - widget (DialogBoxWidget | None): Widget information.
 
     Returns:
@@ -229,9 +227,13 @@ def run_dialog_box(dialog_box_data: DialogBox) -> Any:
 
         The type of the return value depends on the widget type:
 
-        - Without widget: None.
+        - BASE: bool.
         - TEXT_INPUT: str.
         - NUMERIC_INPUT: float.
+        - RADIOBUTTON: str.
+        - CHECKBOX: list[str].
+        - IMAGE: bool.
+        - MULTISTEP: bool.
 
     Raises:
         ValueError: If the 'message' argument is empty.
@@ -251,14 +253,12 @@ def run_dialog_box(dialog_box_data: DialogBox) -> Any:
     )
     if reporter.get_field(key):
         raise DuplicateDialogBoxError
-    data_dict = generate_dialog_box_dict(dialog_box_data)
 
-    reporter.set_doc_value(key, data_dict, statestore_only=True)
+    reporter.set_doc_value(key, dialog_box_data.to_dict(), statestore_only=True)
     reporter.update_db_by_doc()
 
-    dialog_raw_data = _get_socket_raw_data()
-
-    return get_dialog_box_data(dialog_raw_data, dialog_box_data.widget)
+    input_dbx_data = _get_socket_raw_data()
+    return dialog_box_data.widget.convert_data(input_dbx_data)
 
 
 def _get_current_test() -> CurrentTestInfo:

hardpy/pytest_hardpy/result/couchdb_config.py

@@ -1,22 +1,96 @@
 # Copyright (c) 2024 Everypin
 # GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
 
+import ast
+import requests
+import socket
+
 from dataclasses import dataclass
+from urllib3 import disable_warnings
 
 
 @dataclass
 class CouchdbConfig:  # noqa: WPS306
-    """CouchDB loader config."""
+    """CouchDB loader config.
+
+    If `connection_str` arg is not set, it will be created from other args.
+    """
 
     db_name: str = "report"
     user: str = "dev"
     password: str = "dev"
     host: str = "localhost"
     port: int = 5984
+    connection_str: str | None = None
+
+    def __post_init__(self):
+        """Disable urllib3 warnings.
+
+        More info: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#tls-warnings
+        """
+        disable_warnings()
 
     @property
     def connection_string(self) -> str:
-        """Get couchdb connection string."""
+        """Get couchdb connection string.
+
+        Raises:
+            RuntimeError: CouchDB server is not available
+
+        Returns:
+            str: Database connection string.
+        """
+        if self.connection_str:
+            return self.connection_str
+
+        # TODO: 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
+        elif protocol == "https":
+            host_url = f"https://{self.host}"
+            uri = f"{self.host}"
+
+        try:
+            response = requests.get(host_url, timeout=5)
+        except requests.exceptions.RequestException:
+            raise RuntimeError(f"Error CouchDB connecting to {host_url}.")
+
+        # fmt: off
+        try:
+            couchdb_dict = ast.literal_eval(response._content.decode("utf-8"))  # noqa: WPS437,E501
+            couchdb_dict.get("couchdb", False)
+        except Exception:
+            raise RuntimeError(f"Address {host_url} does not provide CouchDB attributes.")
+        # fmt: on
+
         credentials = f"{self.user}:{self.password}"
-        uri = f"{self.host}:{str(self.port)}"
-        return f"http://{credentials}@{uri}/"
+        return f"{protocol}://{credentials}@{uri}/"
+
+    def _get_protocol(self) -> str:  # noqa: WPS231
+        success = 200
+        try:
+            # HTTPS attempt
+            sock = socket.create_connection((self.host, self.port))
+            sock.close()
+            request = f"https://{self.host}"
+            if requests.get(request, timeout=5).status_code == success:
+                return "https"
+            raise OSError
+        except OSError:
+            try:  # noqa: WPS505
+                # 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
+            except OSError:
+                raise RuntimeError(
+                    f"Error connecting to couchdb server {self.host}:{self.port}."
+                )

hardpy/pytest_hardpy/utils/__init__.py

@@ -9,15 +9,20 @@ from hardpy.pytest_hardpy.utils.config_data import ConfigData
 from hardpy.pytest_hardpy.utils.exception import (
     DuplicateSerialNumberError,
     DuplicateDialogBoxError,
+    WidgetInfoError,
 )
 from hardpy.pytest_hardpy.utils.dialog_box import (
     DialogBox,
-    DialogBoxWidget,
-    DialogBoxWidgetType,
-    generate_dialog_box_dict,
-    get_dialog_box_data,
+    TextInputWidget,
+    NumericInputWidget,
+    CheckboxWidget,
+    RadiobuttonWidget,
+    ImageWidget,
+    MultistepWidget,
+    StepWidget,
 )
 
+
 __all__ = [
     "NodeInfo",
     "ProgressCalculator",
@@ -27,9 +32,13 @@ __all__ = [
     "ConfigData",
     "DuplicateSerialNumberError",
     "DuplicateDialogBoxError",
+    "WidgetInfoError",
     "DialogBox",
-    "DialogBoxWidget",
-    "DialogBoxWidgetType",
-    "generate_dialog_box_dict",
-    "get_dialog_box_data",
+    "TextInputWidget",
+    "NumericInputWidget",
+    "CheckboxWidget",
+    "RadiobuttonWidget",
+    "ImageWidget",
+    "MultistepWidget",
+    "StepWidget"
 ]

hardpy/pytest_hardpy/utils/dialog_box.py

@@ -1,31 +1,275 @@
 # Copyright (c) 2024 Everypin
 # GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
 
-from enum import Enum
+import base64
+from abc import ABC, abstractmethod
+from ast import literal_eval
+from copy import deepcopy
 from dataclasses import dataclass
-from typing import Any
+from enum import Enum
+from typing import Any, Final
+
+from hardpy.pytest_hardpy.utils.exception import WidgetInfoError
 
 
-class DialogBoxWidgetType(Enum):
+class WidgetType(Enum):
     """Dialog box widget type."""
 
-    RADIOBUTTON = "radiobutton"
-    CHECKBOX = "checkbox"
+    BASE = "base"
     TEXT_INPUT = "textinput"
     NUMERIC_INPUT = "numericinput"
+    RADIOBUTTON = "radiobutton"
+    CHECKBOX = "checkbox"
+    IMAGE = "image"
+    STEP = "step"
+    MULTISTEP = "multistep"
 
 
-@dataclass
-class DialogBoxWidget:
-    """Dialog box widget.
+class IWidget(ABC):
+    """Dialog box widget interface."""
+
+    def __init__(self, widget_type: WidgetType):
+        self.type: Final[str] = widget_type.value
+        self.info: dict = {}
+
+    @abstractmethod
+    def convert_data(self, input_data: str | None) -> Any | None:
+        """Get the widget data in the correct format.
+
+        Args:
+            input_data (str | None): input string or nothing.
+
+        Returns:
+            Any: Widget data in the correct format
+        """
+        raise NotImplementedError
+
+
+class BaseWidget(IWidget):
+    """Widget info interface."""
+
+    def __init__(self, widget_type: WidgetType = WidgetType.BASE):
+        super().__init__(WidgetType.BASE)
+
+    def convert_data(self, input_data: str | None = None) -> bool:  # noqa: WPS324
+        """Get base widget data, i.e. None.
+
+        Args:
+            input_data (str): input string
+
+        Returns:
+            bool: True if confirm button is pressed
+        """
+        return True
+
+
+class TextInputWidget(IWidget):
+    """Text input widget."""
+
+    def __init__(self):
+        """Initialize the TextInputWidget."""
+        super().__init__(WidgetType.TEXT_INPUT)
+
+    def convert_data(self, input_data: str) -> str:
+        """Get the text input data in the string format.
+
+        Args:
+            input_data (str): input string
+
+        Returns:
+            str: Text input string data
+        """
+        return input_data
+
+
+class NumericInputWidget(IWidget):
+    """Numeric input widget."""
+
+    def __init__(self):
+        """Initialize the NumericInputWidget."""
+        super().__init__(WidgetType.NUMERIC_INPUT)
+
+    def convert_data(self, input_data: str) -> float | None:
+        """Get the numeric widget data in the correct format.
+
+        Args:
+            input_data (str): input string
+
+        Returns:
+            float | None: Numeric data or None if the input is not a number
+        """
+        try:
+            return float(input_data)
+        except ValueError:
+            return None
+
+
+class RadiobuttonWidget(IWidget):
+    """Radiobutton widget."""
+
+    def __init__(self, fields: list[str]):
+        """Initialize the RadiobuttonWidget.
+
+        Args:
+            fields (list[str]): Radiobutton fields.
+
+        Raises:
+            ValueError: If the fields list is empty.
+        """
+        super().__init__(WidgetType.RADIOBUTTON)
+        if not fields:
+            raise ValueError("RadiobuttonWidget must have at least one field")
+        self.info["fields"] = fields
+
+    def convert_data(self, input_data: str) -> str:
+        """Get the radiobutton widget data in the correct format.
+
+        Args:
+            input_data (str): input string
+
+        Returns:
+            str: Radiobutton string data
+        """
+        return input_data
+
+
+class CheckboxWidget(IWidget):
+    """Checkbox widget."""
+
+    def __init__(self, fields: list[str]):
+        """Initialize the CheckboxWidget.
+
+        Args:
+            fields (list[str]): Checkbox fields.
+
+        Raises:
+            ValueError: If the fields list is empty.
+        """
+        super().__init__(WidgetType.CHECKBOX)
+        if not fields:
+            raise ValueError("RadiobuttonWidget must have at least one field")
+        self.info["fields"] = fields
+
+    def convert_data(self, input_data: str) -> list[str] | None:
+        """Get the checkbox widget data in the correct format.
+
+        Args:
+            input_data (str): input string
+
+        Returns:
+            (list[str] | None): Checkbox string data or None if the input is not a list
+        """
+        try:
+            return literal_eval(input_data)
+        except ValueError:
+            return None
+
+
+class ImageWidget(IWidget):
+    """Image widget."""
+
+    def __init__(self, address: str, format: str = "image", width: int = 100):
+        """Validate the image fields and defines the base64 if it does not exist.
+
+        Args:
+            address (str): image address
+            format (str): image format
+            width (int): image width
+
+        Raises:
+            WidgetInfoError: If both address and base64 are specified.
+        """
+        super().__init__(WidgetType.IMAGE)
+
+        if width < 1:
+            raise WidgetInfoError("Width must be positive")
+
+        self.info["address"] = address
+        self.info["format"] = format
+        self.info["width"] = width
+
+        try:
+            with open(address, "rb") as file:
+                file_data = file.read()
+        except FileNotFoundError:
+            raise WidgetInfoError("The image address is invalid")
+        self.info["base64"] = base64.b64encode(file_data).decode("utf-8")
+
+    def convert_data(self, input_data: str | None = None) -> bool:
+        """Get the image widget data, i.e. None.
+
+        Args:
+            input_data (str | None): input string or nothing.
+
+        Returns:
+            bool: True if confirm button is pressed
+        """
+        return True
+
+
+class StepWidget(IWidget):
+    """Step widget.
 
     Args:
-        type (DialogBoxWidgetType): widget type
-        info (dict | None): widget info
+        title (str): Step title
+        text (str | None): Step text
+        widget (ImageWidget | None): Step widget
+
+    Raises:
+        WidgetInfoError: If the text or widget are not provided.
     """
 
-    type: DialogBoxWidgetType
-    info: dict | None = None
+    def __init__(self, title: str, text: str | None, widget: ImageWidget | None):
+        super().__init__(WidgetType.STEP)
+        if text is None and widget is None:
+            raise WidgetInfoError("Text or widget must be provided")
+        self.info["title"] = title
+        if isinstance(text, str):
+            self.info["text"] = text
+        if isinstance(widget, ImageWidget):
+            self.info["widget"] = widget.__dict__
+
+    def convert_data(self, input_data: str) -> bool:
+        """Get the step widget data in the correct format.
+
+        Args:
+            input_data (str): input string
+
+        Returns:
+            bool: True if confirm button is pressed
+        """
+        return True
+
+
+class MultistepWidget(IWidget):
+    """Multistep widget."""
+
+    def __init__(self, steps: list[StepWidget]):
+        """Initialize the MultistepWidget.
+
+        Args:
+            steps (list[StepWidget]): A list with info about the steps.
+
+        Raises:
+            ValueError: If the provided list of steps is empty.
+        """
+        super().__init__(WidgetType.MULTISTEP)
+        if not steps:
+            raise ValueError("MultistepWidget must have at least one step")
+        self.info["steps"] = []
+        for step in steps:
+            self.info["steps"].append(step.__dict__)
+
+    def convert_data(self, input_data: str) -> bool:
+        """Get the multistep widget data in the correct format.
+
+        Args:
+            input_data (str): input string
+
+        Returns:
+            bool: True if confirm button is pressed
+        """
+        return True
 
 
 @dataclass
@@ -35,66 +279,25 @@ class DialogBox:
     Args:
         dialog_text (str): dialog text
         title_bar (str | None): title bar
-        widget (DialogBoxWidget | None): widget info
+        widget (IWidget | None): widget info
     """
 
-    dialog_text: str
-    title_bar: str | None = None
-    widget: DialogBoxWidget | None = None
-
-
-def generate_dialog_box_dict(dialog_box_data: DialogBox) -> dict:
-    """Generate dialog box dictionary.
-
-    Args:
-        dialog_box_data (DialogBox): dialog box data
-
-    Returns:
-        dict: dialog box dictionary
-    """
-    if dialog_box_data.widget is None:
-        data_dict = {
-            "title_bar": dialog_box_data.title_bar,
-            "dialog_text": dialog_box_data.dialog_text,
-            "widget": None,
-        }
-    else:
-        data_dict = {
-            "title_bar": dialog_box_data.title_bar,
-            "dialog_text": dialog_box_data.dialog_text,
-            "widget": {
-                "info": dialog_box_data.widget.info,
-                "type": dialog_box_data.widget.type.value,
-            },
-        }
-    return data_dict
-
-
-def get_dialog_box_data(
-    input_data: str, widget: DialogBoxWidget | None
-) -> Any:
-    """Get the dialog box data in the correct format.
+    def __init__(
+        self,
+        dialog_text: str,
+        title_bar: str | None = None,
+        widget: IWidget | None = None,
+    ):
+        self.widget: IWidget = BaseWidget() if widget is None else widget
+        self.dialog_text: str = dialog_text
+        self.title_bar: str | None = title_bar
 
-    Args:
-        input_data (str): input string
-        widget (DialogBoxWidget | None): widget info
+    def to_dict(self) -> dict:
+        """Convert DialogBox to dictionary.
 
-    Returns:
-        Any: Dialog box data in the correct format
-    """
-    if widget is None:
-        return None
-
-    if widget.type is None:
-        raise ValueError("Widget type is `None`, but widget data is not empty")
-
-    match widget.type:
-        case DialogBoxWidgetType.NUMERIC_INPUT:
-            try:
-                return float(input_data)
-            except ValueError:
-                return None
-        case DialogBoxWidgetType.TEXT_INPUT:
-            return input_data
-        case _:
-            return None
+        Returns:
+            dict: DialogBox dictionary.
+        """
+        dbx_dict = deepcopy(self.__dict__)
+        dbx_dict["widget"] = deepcopy(self.widget.__dict__)
+        return dbx_dict

hardpy/pytest_hardpy/utils/exception.py

@@ -21,3 +21,10 @@ class DuplicateDialogBoxError(HardpyError):
 
     def __init__(self):
         super().__init__(self.__doc__)  # type: ignore
+
+
+class WidgetInfoError(HardpyError):
+    """The widget info is not correct."""
+
+    def __init__(self, message):
+        super().__init__(message)