fixture_union now supports unpack_into. Fixed #51

Author: Sylvain MARIE

docs/api_reference.md

@@ -245,7 +245,7 @@ Lists all desired cases for a given user query. This function may be convenient
 
 ### `@pytest_fixture_plus`
 
-`pytest_fixture_plus(scope="function", autouse=False, name=None, **kwargs)`
+`pytest_fixture_plus(scope="function", autouse=False, name=None, unpack_into=None, **kwargs)`
 
 Identical to `@pytest.fixture` decorator, except that 
 
@@ -255,6 +255,14 @@ Identical to `@pytest.fixture` decorator, except that
 
 As a consequence it does not support the `params` and `ids` arguments anymore.
 
+**Parameters:**
+
+ - **scope**: the scope for which this fixture is shared, one of "function" (default), "class", "module" or "session".
+ - **autouse**: if True, the fixture func is activated for all tests that can see it.  If False (the default) then an explicitreference is needed to activate the fixture.
+ - **name**: the name of the fixture. This defaults to the name of the decorated function. Note: If a fixture is used in the same module in which it is defined, the function name of the fixture will be shadowed by the function arg that requests the fixture; one wayto resolve this is to name the decorated function ``fixture_<fixturename>`` and then use ``@pytest.fixture(name='<fixturename>')``.
+ - **unpack_into**: an optional iterable of names, or string containing coma-separated names, for additional fixtures to create to represent parts of this fixture. See `unpack_fixture` for details.
+ - **kwargs**: other keyword arguments for `@pytest.fixture`
+
 ### `unpack_fixture`
 
 `unpack_fixture(argnames, fixture) -> Tuple[<Fixture>]`
@@ -273,7 +281,7 @@ The created fixtures are automatically registered into the callers' module, but
 ### `fixture_union`
 
 `fixture_union(name, fixtures, scope="function", idstyle='explicit',
-               ids=fixture_alternative_to_str, autouse=False, **kwargs)
+               ids=fixture_alternative_to_str, autouse=False, unpack_into=None, **kwargs)
                -> <Fixture>`
 
 Creates a fixture that will take all values of the provided fixtures in order. That fixture is automatically registered into the callers' module, but you may wish to assign it to a variable for convenience. In that case make sure that you use the same name, e.g. `a = fixture_union('a', ['b', 'c'])`
@@ -290,6 +298,7 @@ The style of test ids corresponding to the union alternatives can be changed wit
  - `fixtures`: an array-like containing fixture names and/or fixture symbols
  - `scope`: the scope of the union. Since the union depends on the sub-fixtures, it should be smaller than the smallest scope of fixtures referenced.
  - `idstyle`: The style of test ids corresponding to the union alternatives. One of `'explicit'` (default), `'compact'`, or `None`.
+ - `unpack_into`: an optional iterable of names, or string containing coma-separated names, for additional fixtures to create to represent parts of this fixture. See `unpack_fixture` for details.
  - `ids`: as in pytest. The default value returns the correct fixture
  - `autouse`: as in pytest
  - `kwargs`: other pytest fixture options. They might not be supported correctly.

docs/index.md

@@ -251,6 +251,28 @@ def test_function(a, b):
     assert a[0] == b
 ```
 
+And it is also available in `fixture_union`:
+
+```python
+import pytest
+from pytest_cases import pytest_fixture_plus, fixture_union
+
+@pytest_fixture_plus
+@pytest.mark.parametrize("o", ['hello', 'world'])
+def c(o):
+    return o, o[0]
+
+@pytest_fixture_plus
+@pytest.mark.parametrize("o", ['yeepee', 'yay'])
+def d(o):
+    return o, o[0]
+
+fixture_union("c_or_d", [c, d], unpack_into="a, b")
+
+def test_function(a, b):
+    assert a[0] == b
+```
+
 ### `param_fixture[s]`
 
 If you wish to share some parameters across several fixtures and tests, it might be convenient to have a fixture representing this parameter. This is relatively easy for single parameters, but a bit harder for parameter tuples.

pytest_cases/main_fixtures.py

@@ -762,8 +762,14 @@ def fixture_alternative_to_str(fixture_alternative,  # type: UnionFixtureAlterna
     return fixture_alternative.fixture_name
 
 
-def fixture_union(name, fixtures, scope="function", idstyle='explicit',
-                  ids=fixture_alternative_to_str, autouse=False, **kwargs):
+def fixture_union(name,
+                  fixtures,
+                  scope="function",
+                  idstyle='explicit',
+                  ids=fixture_alternative_to_str,
+                  unpack_into=None,
+                  autouse=False,
+                  **kwargs):
     """
     Creates a fixture that will take all values of the provided fixtures in order. That fixture is automatically
     registered into the callers' module, but you may wish to assign it to a variable for convenience. In that case
@@ -784,18 +790,20 @@ def fixture_union(name, fixtures, scope="function", idstyle='explicit',
     :param idstyle: The style of test ids corresponding to the union alternatives. One of `'explicit'` (default),
         `'compact'`, or `None`.
     :param ids: as in pytest. The default value returns the correct fixture
+    :param unpack_into: an optional iterable of names, or string containing coma-separated names, for additional
+        fixtures to create to represent parts of this fixture. See `unpack_fixture` for details.
     :param autouse: as in pytest
     :param kwargs: other pytest fixture options. They might not be supported correctly.
     :return: the new fixture. Note: you do not need to capture that output in a symbol, since the fixture is
         automatically registered in your module. However if you decide to do so make sure that you use the same name.
     """
     caller_module = get_caller_module()
     return _fixture_union(caller_module, name, fixtures, scope=scope, idstyle=idstyle, ids=ids, autouse=autouse,
-                          **kwargs)
+                          unpack_into=unpack_into, **kwargs)
 
 
 def _fixture_union(caller_module, name, fixtures, idstyle, scope="function", ids=fixture_alternative_to_str,
-                   autouse=False, **kwargs):
+                   unpack_into=None, autouse=False, **kwargs):
     """
     Internal implementation for fixture_union
 
@@ -805,6 +813,7 @@ def _fixture_union(caller_module, name, fixtures, idstyle, scope="function", ids
     :param idstyle:
     :param scope:
     :param ids:
+    :param unpack_into:
     :param autouse:
     :param kwargs:
     :return:
@@ -853,6 +862,10 @@ def _new_fixture(request, **all_fixtures):
     check_name_available(caller_module, name, if_name_exists=WARN, caller=param_fixture)
     setattr(caller_module, name, fix)
 
+    # if unpacking is requested, do it here
+    if unpack_into is not None:
+        _unpack_fixture(caller_module, unpack_into, name)
+
     return fix
 
 

pytest_cases/tests/fixtures/test_fixture_unpacking2.py

@@ -1,17 +1,37 @@
 import pytest
-from pytest_cases import pytest_fixture_plus
+from pytest_cases import pytest_fixture_plus, fixture_union
 
 
 @pytest_fixture_plus(unpack_into="a,b")
 @pytest.mark.parametrize("o", ['hello', 'world'])
-def c(o):
+def root1(o):
     return o, o[0]
 
 
 def test_function(a, b):
     assert a[0] == b
+    assert a in ('hello', 'world')
+
+
+@pytest_fixture_plus
+@pytest.mark.parametrize("o", ['yeepee', 'yay'])
+def root2(o):
+    return o, o[0]
+
+
+fixture_union("root", [root1, root2], unpack_into="c,d")
+
+
+def test_function2(c, d):
+    assert c[0] == d
+    assert c in ('hello', 'world', 'yeepee', 'yay')
 
 
 def test_synthesis(module_results_dct):
     assert list(module_results_dct) == ['test_function[hello]',
-                                        'test_function[world]']
+                                        'test_function[world]',
+                                        'test_function2[root_is_root1-hello]',
+                                        'test_function2[root_is_root1-world]',
+                                        'test_function2[root_is_root2-yeepee]',
+                                        'test_function2[root_is_root2-yay]',
+                                        ]