feat: 改进parametrize_fixture/parametrize_test，并且共享装饰器参数值处理器

- 新增 argvalues.py 共享装饰器参数值处理器
- 增强 parametrize_fixture 功能：
    - 支持可调用的参数值源
    - 支持可选的cache=True / lazy=True参数
    - 避免将cache/lazy参数转发到pytest.fixture
    - 与@pytest.fixture结合使用时发出警告
    - test_decorators_extended.py中增加测试用例
- 修改 parametrize_test，以保留显式参数名并正确处理fixture值
- 更新 processor.py 中的参数化处理器：
    - 区分fixture注入与fixture作为数据源的情况
    -支持parametrize_fixture元数据和fixture params参数
- 审核更新 tests/integration/test_combo/test_combo_01/下的集成测试用例：
 - test_gen.py
 - test_param_fix.py
 - test_param_test.py
 - test_pytest.py

Author: ProgrammerChengPei

src/dynamic_params/engine/parametrize/processor.py

@@ -59,6 +59,13 @@ def process(self, metafunc: Metafunc) -> None:
 
                 # Get the underlying function
                 underlying = getattr(argvalues, "__wrapped__", None) or argvalues
+
+                # Check if fixture was created by parametrize_fixture decorator
+                # Check both the fixture function itself and the underlying function
+                fixture_parametrize_config = getattr(
+                    argvalues, "_dynamic_fixture_parametrize", None
+                ) or getattr(underlying, "_dynamic_fixture_parametrize", None)
+
                 # Check if fixture has params= defined (parametrized fixture)
                 fixture_marker = (
                     getattr(argvalues, "__pytestfixturefunction__", None)
@@ -67,14 +74,36 @@ def process(self, metafunc: Metafunc) -> None:
                 )
                 fixture_params = getattr(fixture_marker, "params", None)
 
-                if fixture_params is not None:
-                    # Fixture has params= - each param becomes one test case value
-                    remaining.append(
-                        {
-                            "argnames": argnames_str,
-                            "argvalues": list(fixture_params),
-                        }
-                    )
+                if fixture_parametrize_config is not None or fixture_params is not None:
+                    # Fixture was created by parametrize_fixture or has params=
+                    # If the requested argname matches the fixture name, inject it.
+                    # Otherwise use the fixture as a source of values.
+                    should_inject_fixture = fixture_name in argnames
+                    if should_inject_fixture:
+                        if fixture_name and fixture_name not in metafunc.fixturenames:
+                            metafunc.fixturenames.append(fixture_name)
+                    else:
+                        if fixture_params is not None:
+                            remaining.append(
+                                {
+                                    "argnames": argnames_str,
+                                    "argvalues": list(fixture_params),
+                                }
+                            )
+                        else:
+                            try:
+                                result = underlying()
+                                if not isinstance(result, list):
+                                    result = [result]
+                                remaining.append(
+                                    {
+                                        "argnames": argnames_str,
+                                        "argvalues": result,
+                                    }
+                                )
+                            except Exception:
+                                if fixture_name and fixture_name not in metafunc.fixturenames:
+                                    metafunc.fixturenames.append(fixture_name)
                 elif not params or params == ["request"]:
                     # Fixture takes no args - call directly to get values
                     if not params:
@@ -263,23 +292,33 @@ def generate_param_combinations(
             else:
                 # If argvalues is not a list, resolve it and use it directly
                 # This supports direct function/generator references
-                resolved_value = self._resolve_value(argvalues, {}, metafunc)
-                # If resolved_value is a list (e.g., from a generator), expand it into separate test cases
-                if isinstance(resolved_value, list):
-                    # Each item in the list becomes a separate test case
-                    # For single parameter, use the item directly
-                    # For multiple parameters, wrap in tuple
-                    for item in resolved_value:
-                        if len(argnames) == 1:
-                            # Single parameter, use item directly
-                            resolved_argvalues.append(item)
-                        else:
-                            # Multiple parameters, wrap in list/tuple
-                            resolved_argvalues.append(
-                                item if isinstance(item, (list, tuple)) else [item]
-                            )
+                # Check if argvalues is a fixture function
+                if self._is_fixture(argvalues):
+                    # Fixture function - let pytest inject it
+                    fixture_name = getattr(argvalues, "__name__", None)
+                    if fixture_name and fixture_name not in metafunc.fixturenames:
+                        metafunc.fixturenames.append(fixture_name)
+                    # Use fixture name as parameter value (pytest will replace it)
+                    # For now, use a placeholder - pytest will inject the actual fixture value
+                    resolved_argvalues.append([argvalues])
                 else:
-                    resolved_argvalues.append([resolved_value])
+                    resolved_value = self._resolve_value(argvalues, {}, metafunc)
+                    # If resolved_value is a list (e.g., from a generator), expand it into separate test cases
+                    if isinstance(resolved_value, list):
+                        # Each item in the list becomes a separate test case
+                        # For single parameter, use the item directly
+                        # For multiple parameters, wrap in tuple
+                        for item in resolved_value:
+                            if len(argnames) == 1:
+                                # Single parameter, use item directly
+                                resolved_argvalues.append(item)
+                            else:
+                                # Multiple parameters, wrap in list/tuple
+                                resolved_argvalues.append(
+                                    item if isinstance(item, (list, tuple)) else [item]
+                                )
+                    else:
+                        resolved_argvalues.append([resolved_value])
 
             processed_parametrizations.append(
                 {"argnames": argnames, "argvalues": resolved_argvalues}

src/dynamic_params/public/argvalues.py

@@ -0,0 +1,75 @@
+import inspect
+from typing import Any, Dict, Optional
+
+
+def _is_pytest_fixture(obj: Any) -> bool:
+    return (
+        hasattr(obj, "__pytestfixturefunction__")
+        or hasattr(obj, "_fixture_function_marker")
+        or hasattr(obj, "_pytestfixturefunction")
+    )
+
+
+def process_argvalues(argvalues: Any, options: Optional[Dict[str, Any]] = None) -> Any:
+    """Unified argvalues processing used by decorators.
+
+    Behavior:
+    - generator objects/functions -> evaluated to list (unless wrapped as GeneratorBase)
+    - callable fixtures -> returned as-is (pytest fixtures)
+    - callable normal functions -> if `cache`/`lazy` in options -> wrapped into
+      GeneratorBase/LazyGenerator; otherwise called and result returned (convert
+      generator results to list)
+
+    options: dict that may contain `cache`, `lazy`, `scope` keys.
+    """
+    opts = options or {}
+    cache = opts.get("cache", False)
+    lazy = opts.get("lazy", False)
+    scope = opts.get("scope", "function")
+
+    # generator object
+    if inspect.isgenerator(argvalues):
+        return list(argvalues)
+
+    # callable factory or fixture
+    if callable(argvalues) and not isinstance(argvalues, (list, tuple, type)):
+        # detect pytest fixture
+        if _is_pytest_fixture(argvalues):
+            return argvalues
+
+        # if already a GeneratorBase instance, return as-is
+        try:
+            from ..engine.generator.base import GeneratorBase
+        except Exception:
+            GeneratorBase = None
+
+        if GeneratorBase is not None and isinstance(argvalues, GeneratorBase):
+            return argvalues
+
+        # respect cache/lazy options: wrap as GeneratorBase/LazyGenerator
+        if cache or lazy:
+            if lazy:
+                from ..engine.generator.lazy import LazyGenerator
+
+                return LazyGenerator(argvalues, scope=scope, cache=cache)
+            else:
+                # fallback to base generator
+                from ..engine.generator.base import GeneratorBase as GB
+
+                return GB(argvalues, scope=scope, cache=cache)
+
+        # generator function (call to get generator)
+        if inspect.isgeneratorfunction(argvalues):
+            return list(argvalues())
+
+        # otherwise call the factory to obtain values
+        result = argvalues()
+        if inspect.isgenerator(result):
+            return list(result)
+        return result
+
+    return argvalues
+
+
+def is_pytest_fixture(obj: Any) -> bool:
+    return _is_pytest_fixture(obj)

src/dynamic_params/public/decorators/parametrize_fixture.py

@@ -1,43 +1,138 @@
 # Fixture parametrization decorator
 
+import inspect
+import warnings
 from typing import Any, Callable, List
 
 import pytest
 
+from ..argvalues import process_argvalues
+
 
 def parametrize_fixture(argnames: str, argvalues: List[Any], **kwargs: Any) -> Callable:
     """Decorator for parametrizing fixtures
 
-    This decorator allows you to parameterize fixtures with dynamic parameters,
-    including support for generators and DynRef references.
+    This decorator creates a parametrized fixture with the name specified in argnames,
+    and the decorated function receives this fixture as a parameter.
 
     Args:
-        argnames: Comma-separated string of parameter names
-        argvalues: List of parameter values
+        argnames: Comma-separated string of parameter names (these become fixture names)
+        argvalues: List of parameter values, generator object, or callable that returns a list
         **kwargs: Additional keyword arguments
 
     Returns:
         Decorator function
+
+    Example:
+        @parametrize_fixture("value", [1, 2, 3])
+        def my_fixture(value):
+            return value * 2
+
+        def test_example(my_fixture):
+            assert my_fixture in [2, 4, 6]
+
+        # Optional performance settings:
+        @parametrize_fixture("value", get_values, cache=True, scope="session")
+        def my_cached_fixture(value):
+            return value
+
+        @parametrize_fixture("value", get_values, lazy=True)
+        def my_lazy_fixture(value):
+            return value
     """
 
     def decorator(func: Callable) -> Callable:
-        # First apply the pytest fixture decorator
-        # Check both old and new pytest attribute names for fixture detection
+        # Process argvalues - use shared processor; this also supports optional
+        # cache/lazy when provided in kwargs (backwards compatible if not set)
+        processed_argvalues = process_argvalues(argvalues, kwargs)
+
+        # Warn when @pytest.fixture is combined with @parametrize_fixture,
+        # because the two decorators have overlapping semantics and may be
+        # ambiguous.
         is_fixture = (
             hasattr(func, "__pytestfixturefunction__")
             or hasattr(func, "_fixture_function_marker")
             or hasattr(func, "_pytestfixturefunction")
         )
+        if is_fixture:
+            warnings.warn(
+                "Combining @pytest.fixture with @parametrize_fixture is not supported "
+                "and may produce undefined behavior.",
+                UserWarning,
+            )
+
+        # Store parametrization info on the function for processor to use
+        if not hasattr(func, "_dynamic_fixture_parametrize"):
+            func._dynamic_fixture_parametrize = []
+
+        func._dynamic_fixture_parametrize.append({
+            "argnames": argnames,
+            "argvalues": processed_argvalues,
+            **kwargs
+        })
+
+        # Parse argnames to get the fixture names
+        fixture_names = [name.strip() for name in argnames.split(",")]
+
+        # Create parametrized fixtures for each argname
+        # Each fixture will be parametrized with the corresponding values
+        for i, fixture_name in enumerate(fixture_names):
+            # Create a simple fixture that yields the parametrized value
+            # The fixture will be parametrized via pytest_generate_tests hook
+            fixture_func = _create_parametrized_fixture(fixture_name, processed_argvalues, **kwargs)
+
+            # Register the fixture in the module's global namespace
+            # This makes it available to other fixtures and tests
+            module = inspect.getmodule(func)
+            if module and not hasattr(module, fixture_name):
+                setattr(module, fixture_name, fixture_func)
+
+        # Apply pytest.fixture decorator to the function if it is not already
+        # a fixture. Filter cache/lazy keys before passing kwargs to pytest.
+        fixture_kwargs = {
+            k: v for k, v in kwargs.items() if k not in ("cache", "lazy")
+        }
         if not is_fixture:
-            func = pytest.fixture(**kwargs)(func)
-
-        # Note: In pytest 9+, marks on fixtures have no effect and raise a warning
-        # We skip adding the mark for fixtures to avoid the warning
-        # pytest.mark.dynamic_parametrize(
-        #     argnames=argnames,
-        #     argvalues=argvalues,
-        #     **kwargs
-        # )(func)
+            func = pytest.fixture(**fixture_kwargs)(func)
+
         return func
 
     return decorator
+
+
+def _create_parametrized_fixture(name: str, values: List[Any], **kwargs: Any):
+    """Create a parametrized fixture
+
+    Args:
+        name: Fixture name
+        values: List of parameter values
+        **kwargs: Additional keyword arguments for pytest.fixture
+
+    Returns:
+        A pytest fixture function
+    """
+    # Create a fixture that receives request.param and returns it
+    def parametrized_fixture(request):
+        return request.param
+
+    parametrized_fixture.__name__ = name
+
+    # If values is a GeneratorBase-like instance, pass it directly to pytest.fixture
+    # so pytest can iterate it lazily. Do not execute it eagerly here.
+    try:
+        from ...engine.generator.base import GeneratorBase
+    except Exception:
+        GeneratorBase = None
+
+    if GeneratorBase is not None and isinstance(values, GeneratorBase):
+        params = values
+    else:
+        params = values
+
+    fixture_kwargs = {
+        k: v for k, v in kwargs.items() if k not in ("cache", "lazy")
+    }
+    return pytest.fixture(params=params, name=name, **fixture_kwargs)(parametrized_fixture)
+
+
+# processing delegated to public.argvalues.process_argvalues