Works a bit more on tests and adds some fixtures

src/pytest_static/parametric.py

@@ -58,14 +58,25 @@ class ExpandedType(Generic[T]):
     primary_type: Type[T]
     type_args: Tuple[Union[Any, "ExpandedType[Any]"], ...]
 
+    @staticmethod
+    def _get_parameter_combinations(
+        parameter_instance_sets: List[Tuple[T, ...]]
+    ) -> List[Tuple[Any, ...]]:
+        """Returns a list of parameter combinations."""
+        if len(parameter_instance_sets) > 1:
+            return list(itertools.product(*parameter_instance_sets))
+        return list(zip(*parameter_instance_sets, strict=True))
+
     def get_instances(self) -> Tuple[T, ...]:
         """Returns a tuple of all possible instances of the primary_type."""
         parameter_instance_sets: List[
             Tuple[T, ...]
         ] = self._get_parameter_instance_sets()
+
         parameter_combinations: List[
             Tuple[Any, ...]
         ] = self._get_parameter_combinations(parameter_instance_sets)
+
         instances: Tuple[T, ...] = self._instantiate_each_parameter_combination(
             parameter_combinations
         )
@@ -81,14 +92,6 @@ def _get_parameter_instance_sets(self) -> List[Tuple[T, ...]]:
                 parameter_instances.append(tuple(PREDEFINED_TYPE_SETS.get(arg, arg)))
         return parameter_instances
 
-    def _get_parameter_combinations(
-        self, parameter_instance_sets: List[Tuple[T, ...]]
-    ) -> List[Tuple[Any, ...]]:
-        """Returns a list of parameter combinations."""
-        if len(parameter_instance_sets) > 1:
-            return list(itertools.product(*parameter_instance_sets))
-        return list(zip(*parameter_instance_sets, strict=True))
-
     def _instantiate_each_parameter_combination(
         self, parameter_combinations: List[Tuple[Any, ...]]
     ) -> Tuple[T, ...]:

tests/unit_tests/conftest.py

@@ -0,0 +1,37 @@
+from typing import Any
+from typing import List
+from typing import Tuple
+from typing import Type
+from typing import Union
+
+import pytest
+from _pytest.fixtures import FixtureRequest
+
+from pytest_static.parametric import ExpandedType
+from pytest_static.parametric import T
+
+
+@pytest.fixture(scope="function")
+def expanded_type(
+    request: FixtureRequest,
+    primary_type: Type[T],
+    type_args: Tuple[Union[Any, ExpandedType[Any]], ...],
+) -> ExpandedType[T]:
+    return getattr(
+        request,
+        "param",
+        ExpandedType(
+            primary_type=primary_type,
+            type_args=type_args,
+        ),
+    )
+
+
+@pytest.fixture(scope="function")
+def primary_type(request: FixtureRequest) -> Type[T]:
+    return getattr(request, "param", List)
+
+
+@pytest.fixture(scope="function")
+def type_args(request: FixtureRequest) -> Tuple[Union[Any, ExpandedType[Any]], ...]:
+    return getattr(request, "param", (int,))

tests/unit_tests/test_parametric.py

@@ -69,6 +69,81 @@ def test_get_instances_with_multiple_nested(self, monkeypatch: MonkeyPatch) -> N
         for instance in expected_instances:
             assert instance in expanded_instances
 
+    @pytest.mark.parametrize(
+        argnames=["primary_type", "type_args", "expected_sets"],
+        argvalues=[
+            (
+                List,
+                (int,),
+                [
+                    PREDEFINED_TYPE_SETS[int],
+                ],
+            ),
+            (Union, (int, str), [PREDEFINED_TYPE_SETS[int], PREDEFINED_TYPE_SETS[str]]),
+            (Tuple, (int, str), [PREDEFINED_TYPE_SETS[int], PREDEFINED_TYPE_SETS[str]]),
+        ],
+        ids=["nested_param", "sum_param", "product_param"],
+    )
+    def test__get_parameter_instance_sets(
+        self,
+        primary_type: Type[T],
+        type_args: Type[T],
+        expected_sets: Tuple[Set[Any], ...],
+    ) -> None:
+        expected_sets = [tuple(expected_set) for expected_set in expected_sets]
+        assert (
+            ExpandedType(
+                primary_type=primary_type,
+                type_args=type_args,
+            )._get_parameter_instance_sets()
+            == expected_sets
+        )
+
+    @pytest.mark.parametrize(
+        argnames=["instance_sets", "expected_combinations"],
+        argvalues=[
+            ([(1, 2)], [(1,), (2,)]),
+            ([(1, 2), (3, 4)], [(1, 3), (1, 4), (2, 3), (2, 4)]),
+        ],
+        ids=[
+            "single_set",
+            "multiple_sets",
+        ],
+    )
+    def test__get_parameter_combinations(
+        self,
+        instance_sets: List[Tuple[T, ...]],
+        expected_combinations: List[Tuple[Any, ...]],
+    ) -> None:
+        assert (
+            ExpandedType._get_parameter_combinations(instance_sets)
+            == expected_combinations
+        )
+
+    def test__instantiate_each_parameter_combination(self) -> None:
+        pass
+
+    def test__instantiate_from_signature(self) -> None:
+        pass
+
+    def test__instantiate_from_trial_and_error(self) -> None:
+        pass
+
+    def test__instantiate_combinations_using_expanded(self) -> None:
+        pass
+
+    def test__instantiate_combinations_using_not_expanded(self) -> None:
+        pass
+
+    def test__instantiate_expanded(self) -> None:
+        pass
+
+    def test__instantiate_not_expanded(
+        self,
+        expanded_type: ExpandedType,
+    ) -> None:
+        pass
+
 
 @pytest.mark.parametrize(
     argnames=["type_arg", "expected"],