fix(allure-pytest): runtime overrides of parameter options

allure-pytest-bdd/src/allure_api_listener.py

@@ -1,10 +1,15 @@
+from __future__ import annotations
+
+from typing import Any
+
 import pytest
 
 import allure_commons
 
 from allure_commons.model2 import Label
 from allure_commons.model2 import Link
 from allure_commons.model2 import Parameter
+from allure_commons.types import ParameterMode
 from allure_commons.utils import represent
 
 from .utils import ALLURE_DESCRIPTION_HTML_MARK
@@ -85,7 +90,13 @@ def add_link(self, url, link_type, name):
             test_result.links.append(Link(url=url, name=name, type=link_type))
 
     @allure_commons.hookimpl
-    def add_parameter(self, name, value, excluded, mode):
+    def add_parameter(
+        self,
+        name: str,
+        value: Any,
+        excluded: bool | None,
+        mode: ParameterMode | None,
+    ) -> None:
         with self.lifecycle.update_test_case() as test_result:
             test_result.parameters.append(
                 Parameter(

allure-pytest/src/listener.py

@@ -1,3 +1,7 @@
+from __future__ import annotations
+
+from typing import Any
+
 import pytest
 import doctest
 
@@ -293,17 +297,26 @@ def add_label(self, label_type, labels):
             test_result.labels.append(Label(label_type, label))
 
     @allure_commons.hookimpl
-    def add_parameter(self, name, value, excluded, mode: ParameterMode):
+    def add_parameter(
+        self,
+        name: str,
+        value: Any,
+        excluded: bool | None,
+        mode: ParameterMode | None,
+    ) -> None:
         test_result: TestResult = self.allure_logger.get_test(None)
-        existing_param = next(filter(lambda x: x.name == name, test_result.parameters), None)
+        existing_param = next((p for p in test_result.parameters if p.name == name), None)
+
         if existing_param:
             existing_param.value = represent(value)
+            existing_param.excluded = excluded
+            existing_param.mode = mode.value if mode else None
         else:
             test_result.parameters.append(
                 Parameter(
                     name=name,
                     value=represent(value),
-                    excluded=excluded or None,
+                    excluded=excluded,
                     mode=mode.value if mode else None
                 )
             )

allure-python-commons-test/src/result.py

@@ -221,8 +221,8 @@ def with_trace_contains(string):
     return has_entry("trace", contains_string(string))
 
 
-def with_excluded():
-    return has_entry("excluded", True)
+def with_excluded(excluded: bool = True):
+    return has_entry("excluded", excluded)
 
 
 def with_mode(mode):

allure-python-commons/src/allure_commons/_allure.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 from functools import wraps
-from typing import Any, Callable, TypeVar, Union, overload
+from typing import Any, Callable, TypeVar, overload
 
 from allure_commons._core import plugin_manager
 from allure_commons.types import LabelType, LinkType, ParameterMode
@@ -133,7 +135,12 @@ def link(url, link_type=LinkType.LINK, name=None):
         plugin_manager.hook.add_link(url=url, link_type=link_type, name=name)
 
     @staticmethod
-    def parameter(name, value, excluded=None, mode: Union[ParameterMode, None] = None):
+    def parameter(
+        name: str,
+        value: Any,
+        excluded: bool | None = None,
+        mode: ParameterMode | None = None,
+    ) -> None:
         plugin_manager.hook.add_parameter(name=name, value=value, excluded=excluded, mode=mode)
 
     @staticmethod

allure-python-commons/src/allure_commons/_hooks.py

@@ -1,5 +1,11 @@
+from __future__ import annotations
+
+from typing import Any
+
 from pluggy import HookspecMarker, HookimplMarker
 
+from allure_commons.types import ParameterMode
+
 hookspec = HookspecMarker("allure")
 hookimpl = HookimplMarker("allure")
 
@@ -47,7 +53,13 @@ def add_link(self, url, link_type, name):
         """ url """
 
     @hookspec
-    def add_parameter(self, name, value, excluded, mode):
+    def add_parameter(
+        self,
+        name: str,
+        value: Any,
+        excluded: bool | None,
+        mode: ParameterMode | None,
+    ) -> None:
         """ parameter """
 
     @hookspec

tests/allure_pytest/acceptance/parametrization/parametrization_test.py

@@ -181,6 +181,29 @@ def test_dynamic_parameter_excluded(allure_pytest_runner: AllurePytestRunner):
     )
 
 
+def test_dynamic_parameter_excluded_false(allure_pytest_runner: AllurePytestRunner):
+    """
+    >>> import allure
+
+    >>> def test_parameter_excluded():
+    ...     allure.dynamic.parameter("param1", "param-value", excluded=False)
+    """
+
+    allure_results = allure_pytest_runner.run_docstring()
+
+    assert_that(
+        allure_results,
+        has_test_case(
+            "test_parameter_excluded",
+            has_parameter(
+                "param1",
+                "'param-value'",
+                with_excluded(False)
+            )
+        )
+    )
+
+
 def test_dynamic_parameter_mode(allure_pytest_runner: AllurePytestRunner):
     """
     >>> import allure
@@ -225,6 +248,56 @@ def test_dynamic_parameter_override(allure_pytest_runner: AllurePytestRunner):
     )
 
 
+def test_dynamic_parameter_override_excluded(allure_pytest_runner: AllurePytestRunner):
+    """
+    >>> import pytest
+    ... import allure
+
+    >>> @pytest.mark.parametrize("param1", [object()], ids=["param-id"])
+    ... def test_parameter_override(param1):
+    ...     allure.dynamic.parameter("param1", "readable-value", excluded=True)
+    """
+
+    allure_results = allure_pytest_runner.run_docstring()
+
+    assert_that(
+        allure_results,
+        has_test_case(
+            "test_parameter_override[param-id]",
+            has_parameter(
+                "param1",
+                "'readable-value'",
+                with_excluded(),
+            ),
+        )
+    )
+
+
+def test_dynamic_parameter_override_mode(allure_pytest_runner: AllurePytestRunner):
+    """
+    >>> import pytest
+    ... import allure
+
+    >>> @pytest.mark.parametrize("param1", [object()], ids=["param-id"])
+    ... def test_parameter_override(param1):
+    ...     allure.dynamic.parameter("param1", "readable-value", mode=allure.parameter_mode.MASKED)
+    """
+
+    allure_results = allure_pytest_runner.run_docstring()
+
+    assert_that(
+        allure_results,
+        has_test_case(
+            "test_parameter_override[param-id]",
+            has_parameter(
+                "param1",
+                "'readable-value'",
+                with_mode("masked"),
+            ),
+        )
+    )
+
+
 def test_dynamic_parameter_override_from_fixture(
     allure_pytest_runner: AllurePytestRunner
 ):