feat: add markers support in idf_parametrize

Author: horw

pytest-embedded-idf/pytest_embedded_idf/utils.py

@@ -24,36 +24,44 @@ def _expand_target_values(values: t.List[t.List[t.Any]], target_index: int) -> t
     return expanded_values
 
 
-def _process_pytest_value(value: t.Union[t.List[t.Any], t.Any], markers_index: int) -> t.Any:
+def _process_pytest_value(value: t.Union[t.List[t.Any], t.Any], param_count: int) -> t.Any:
     """
     Processes a single parameter value, converting it to pytest.param if needed.
     """
     if not isinstance(value, (list, tuple)):
         return value
 
+    if len(value) > param_count + 1:
+        raise ValueError(f'Expected at most {param_count + 1} elements (params + marks), got {len(value)}')
+
     params, marks = [], []
-    for i, element in enumerate(value):
-        if i == markers_index:
-            if not isinstance(element, tuple):
-                element = (element,)
-            if isinstance(element, tuple):
-                marks.extend(element)
-        else:
-            params.append(element)
+    if len(value) > param_count:
+        mark_values = value[-1]
+        marks.extend(mark_values if isinstance(mark_values, (tuple, list)) else (mark_values,))
+
+    params.extend(value[:param_count])
 
     return pytest.param(*params, marks=tuple(marks))
 
 
 def idf_parametrize(
-    param_names: str, values: t.List[t.Union[t.Any, t.Tuple[t.Any, ...]]], indirect: bool = False
+    param_names: str,
+    values: t.List[t.Union[t.Any, t.Tuple[t.Any, ...]]],
+    indirect: (t.Union[bool, t.Sequence[str]]) = False,
 ) -> t.Callable[..., None]:
     """
     A decorator to unify pytest.mark.parametrize usage in esp-idf.
 
     Args:
-        param_names (str): Comma-separated parameter names.
-        values (list): List of parameter values. Each value can be a string or a tuple.
-        indirect (bool): If True, marks parameters as indirect.
+        param_names: A comma-separated string of parameter names that will be passed to
+            the test function.
+        values: A list of parameter values where each value corresponds to the parameters
+            defined in param_names.
+        indirect: A list of arguments names (subset of argnames) or a boolean. If True
+            the list contains all names from the argnames. Each argvalue corresponding to an
+            argname in this list will be passed as request.param to its respective argname
+            fixture function so that it can perform more expensive setups during the setup
+            phase of a test rather than at collection time.
 
     Returns:
         Decorated test function with parametrization applied
@@ -63,19 +71,18 @@ def idf_parametrize(
         if not param:
             raise ValueError(f'One of the provided parameters name is empty: {param_list}')
 
-    markers_index = param_list.index('markers') if 'markers' in param_list else -1
+    param_count = len(param_list)
+    param_list[:] = [_p for _p in param_list if _p not in ('markers',)]
     target_index = param_list.index('target') if 'target' in param_list else -1
-
-    filtered_params = [name for name in param_list if name != 'markers']
-
-    normalized_values = [[value] if len(param_list) == 1 else list(value) for value in values]
+    normalized_values = [[value] if param_count == 1 else list(value) for value in values]
+    param_count = len(param_list)
 
     if target_index != -1:
         normalized_values = _expand_target_values(normalized_values, target_index)
 
-    processed_values = [_process_pytest_value(value, markers_index) for value in normalized_values]
+    processed_values = [_process_pytest_value(value, param_count) for value in normalized_values]
 
     def decorator(func):
-        return pytest.mark.parametrize(','.join(filtered_params), processed_values, indirect=indirect)(func)
+        return pytest.mark.parametrize(','.join(param_list), processed_values, indirect=indirect)(func)
 
     return decorator