The current_cases fixture now contains case parameters if any. Fixes #214

Author: Sylvain MARIE

pytest_cases/__init__.py

@@ -16,7 +16,7 @@
 from .case_funcs import case, copy_case_info, set_case_id, get_case_id, get_case_marks, \
     get_case_tags, matches_tag_query, is_case_class, is_case_function
 from .case_parametrizer_new import parametrize_with_cases, THIS_MODULE, get_all_cases, get_parametrize_args, \
-    get_current_case_id, get_current_cases
+    get_current_case_id, get_current_cases, get_current_params
 
 try:
     # -- Distribution mode --
@@ -54,5 +54,5 @@
     'get_case_tags', 'matches_tag_query', 'is_case_class', 'is_case_function',
     # test functions
     'get_all_cases', 'parametrize_with_cases', 'THIS_MODULE', 'get_parametrize_args', 'get_current_case_id',
-    'get_current_cases'
+    'get_current_cases', 'get_current_params'
 ]

pytest_cases/case_parametrizer_new.py

@@ -136,6 +136,16 @@ def safe_isclass(obj  # type: object
         return False
 
 
+def safe_isinstance(obj,  # type: object
+                    cls):
+    # type: (...) -> bool
+    """Ignore any exception via isinstance"""
+    try:
+        return isinstance(obj, cls)
+    except Exception:  # noqa
+        return False
+
+
 def assert_is_fixture(fixture_fun  # type: Any
                       ):
     """
@@ -885,3 +895,16 @@ def apply(test_or_fixture_func):
         return apply_decorator(test_or_fixture_func, container)
 
     return apply
+
+
+def get_pytest_request_and_item(request_or_item):
+    """Return the `request` and `item` (node) from whatever is provided"""
+    try:
+        item = request_or_item.node
+    except AttributeError:
+        item = request_or_item
+        request = item._request
+    else:
+        request = request_or_item
+
+    return item, request

pytest_cases/common_pytest.py

@@ -15,18 +15,18 @@ def my_fixture(foo):
 def test_get_current_case(data, my_fixture, current_cases):
 
     # this is how to access the case function for a test parameter
-    actual_case_id, case_fun = current_cases["data"]
+    actual_case_id, case_fun, case_params = current_cases["data"]
 
     # this is how to access the case function for a fixture parameter
-    fix_actual_case_id, fix_case_fun = current_cases["my_fixture"]["foo"]
+    fix_actual_case_id, fix_case_fun, fix_case_params = current_cases["my_fixture"]["foo"]
 
     # let's print everything
     print(current_cases)
 
     assert current_cases == {
-        "data": ("a", case_a),
+        "data": ("a", case_a, {}),
         "my_fixture": {
-            "foo": ("a", case_a)
+            "foo": ("a", case_a, {})
         }
     }
 

pytest_cases/tests/cases/doc/test_doc_get_current_cases.py

@@ -7,6 +7,7 @@
 
 from pytest_cases.common_pytest_marks import PYTEST3_OR_GREATER
 
+
 @case(tags=("no_fix_needed",))
 def case_a():
     return 1, 2
@@ -68,23 +69,30 @@ def _assert_cases(current_cases, local=True):
         'a': case_a if local else casesfile.case_a,
         'b': case_b if local else casesfile.case_b
     }
+    assert len(current_cases["purelazy_a"]) == 3
     assert current_cases["purelazy_a"][1] is ref_dict[current_cases["purelazy_a"][0]]
+    assert current_cases["purelazy_a"][2] == {}
 
+    assert len(current_cases["purelazy_t1"]) == 3
     assert current_cases["purelazy_t1"][0] == "custom_id"
     assert current_cases["purelazy_t1"][1] is (tuplecase_a if local else casesfile.tuplecase_a)
+    assert current_cases["purelazy_t1"][2] == {}
     assert current_cases["purelazy_t1"] == current_cases["purelazy_t2"]
 
     ref_dict = {
         'a': case_a if local else casesfile.case_a,
         'b': case_b if local else casesfile.case_b,
         'custom_id': case_a_fixture if local else casesfile.case_a_fixture
     }
+    assert len(current_cases["withfixrefs_f"]) == 3
     assert current_cases["withfixrefs_f"][1] is ref_dict[current_cases["withfixrefs_f"][0]]
+    assert current_cases["withfixrefs_f"][2] == {}
 
     ref_dict = {
         'custom_id': tuplecase_a if local else casesfile.tuplecase_a,
         "a_fixture": tuplecase_a_fixture if local else casesfile.tuplecase_a_fixture
     }
+    assert len(current_cases["withfixrefs_f1"]) == 3
     assert current_cases["withfixrefs_f1"][1] is ref_dict[current_cases["withfixrefs_f1"][0]]
     assert current_cases["withfixrefs_f2"] == current_cases["withfixrefs_f1"]
 

pytest_cases/tests/cases/doc/test_get_current_cases.py

@@ -31,7 +31,7 @@ def case_foo2(name):
 
 @parametrize_with_cases("a", cases=case_foo2)
 def test_foo2(a, current_cases):
-    assert current_cases == {'a': ('foo2', case_foo2)}
+    assert current_cases == {'a': ('foo2', case_foo2, {'name': 'bar'})}
 
 
 # ----------- fix for issue 213 bis

pytest_cases/tests/cases/doc/test_get_current_cases_negative.py

@@ -0,0 +1,62 @@
+from pytest_cases import parametrize, parametrize_with_cases, fixture, get_current_params, get_current_cases
+
+
+@fixture
+@parametrize(FP_simple=('john',))
+def fixa(FP_simple):
+    return 0, FP_simple
+
+
+@parametrize(CP_simple=('joe',))
+def case_casea(CP_simple, fixa):
+    return CP_simple
+
+
+@parametrize_with_cases("CP_acase", cases=case_casea, idstyle="explicit")
+def case_caseb(CP_acase):
+    return CP_acase
+
+
+@fixture
+@parametrize_with_cases("FP_acase", cases=".", idstyle="explicit")
+def fixb(FP_acase):
+    return FP_acase
+
+
+i = 0
+
+
+@parametrize(TP_direct=(0,))
+@parametrize_with_cases("TP_acase", cases=".", idstyle="explicit")
+def test_foo(TP_acase, TP_direct, fixb, request):
+    global i
+    i += 1
+    current_cases = get_current_cases(request)
+    if i == 1:
+        assert current_cases == {
+            "TP_acase": ("casea", case_casea, {"CP_simple": "joe"}),
+            "fixb": {
+                "FP_acase": ("casea", case_casea, {"CP_simple": "joe"}),
+            }
+        }
+    elif i == 2:
+        assert current_cases == {
+            "TP_acase": ("casea", case_casea, {"CP_simple": "joe"}),
+            "fixb": {
+                "FP_acase": ("caseb", case_caseb, {"CP_acase": ("casea", case_casea, {"CP_simple": "joe"})}),
+            }
+        }
+    elif i == 3:
+        assert current_cases == {
+            "TP_acase": ("caseb", case_caseb, {"CP_acase": ("casea", case_casea, {"CP_simple": "joe"})}),
+            "fixb": {
+                "FP_acase": ("casea", case_casea, {"CP_simple": "joe"}),
+            }
+        }
+    elif i == 4:
+        assert current_cases == {
+            "TP_acase": ("caseb", case_caseb, {"CP_acase": ("casea", case_casea, {"CP_simple": "joe"})}),
+            "fixb": {
+                "FP_acase": ("caseb", case_caseb, {"CP_acase": ("casea", case_casea, {"CP_simple": "joe"})}),
+            }
+        }

pytest_cases/tests/cases/doc/test_get_current_cases_params.py

@@ -11,5 +11,9 @@ def case_y(x):
 
 
 @pytest_cases.parametrize_with_cases("y", case_y)
-def test_foo(y):
+def test_foo(y, current_cases):
     print(y)
+    # adding this as this example contains an interesting name conflict to challenge current_cases
+    assert current_cases == {
+        'y': ('y', case_y, {'x': ('x', case_x, {})})
+    }

pytest_cases/tests/cases/issues/test_issue_158.py

@@ -18,13 +18,15 @@ def case_foo(self):
 @parametrize_with_cases('val', cases=MyClassName)
 def test_function(val, current_cases, request):
     print(val)
-    case_id, case_func = current_cases['val']
-    print((case_id, case_func))
+    case_id, case_func, case_params = current_cases['val']
+    print((case_id, case_func, case_params))
 
     if (case_func is MyClassName.case_widget) if PY3 else (case_func == MyClassName.case_widget):
-        # workaround to get the parameter, but a bit dirty
-        if request.node.callspec.params['widget'].argvalues[0] == "joe":
+        if case_params['name'] == 'joe':
+            # two other ways to get the same detection :
+            assert request.node.callspec.params['widget'].argvalues[0] == "joe"
             assert request.node.name == 'test_function[widget-name=joe]'
+
             pytest.skip("joe skipped")
 
     assert request.node.name != 'test_function[widget-name=joe]'

pytest_cases/tests/cases/issues/test_issue_211.py

@@ -14,12 +14,13 @@ def case_foo(self):
 def test_function_basic_parametrize(val, current_cases):
     assert val == "fooval"
 
-    case_id, case_func = current_cases['val']
+    case_id, case_func, case_paramz = current_cases['val']
     assert case_id == "foo"
     if PY3:
         assert case_func is MyClassName.case_foo
     else:
         assert case_func == MyClassName.case_foo
+    assert case_paramz == {}
 
 
 class MyClassNameTuple:
@@ -31,14 +32,16 @@ def case_foo(self):
 def test_function_tuple_basic_parametrize(a, b, current_cases):
     assert (a, b) == (1, 2)
 
-    case_id, case_func = current_cases['a']
-    assert case_id, case_func == current_cases['b']
+    case_id, case_func, case_paramz = current_cases['a']
+    assert current_cases['a'] == current_cases['b']
     assert case_id == "foo"
     if PY3:
         assert case_func is MyClassNameTuple.case_foo
     else:
         assert case_func == MyClassNameTuple.case_foo
 
+    assert case_paramz == {}
+
 
 class MyClassName2:
     def case_bar(self):
@@ -52,14 +55,16 @@ def case_foo(self, dummy):
 @parametrize_with_cases('val', cases=MyClassName2)
 def test_function_nested_parametrize(val, current_cases):
     ref = {
-        "barval": MyClassName2.case_bar,
-        "fooval": MyClassName2.case_foo
+        "barval": (MyClassName2.case_bar, {}),
+        "fooval": (MyClassName2.case_foo, {"dummy": "a"})
     }
 
-    case_id, case_func = current_cases['val']
+    case_id, case_func, case_paramz = current_cases['val']
     assert case_id == val[:3]
 
     if PY3:
-        assert case_func is ref[val]
+        assert case_func is ref[val][0]
     else:
-        assert case_func == ref[val]
+        assert case_func == ref[val][0]
+
+    assert case_paramz == ref[val][1]