implement index-based mechanizm for collection of parametrized tests

--HG--
branch : parametrize-hashable

CHANGELOG

@@ -1,6 +1,9 @@
 Unreleased
 -----------------------------------
 
+- fix issue244 by implementing special index for parameters to only use
+  indices for paramentrized test ids
+
 - fix issue287 by running all finalizers but saving the exception
   from the first failing finalizer and re-raising it so teardown will
   still have failed.  We reraise the first failing exception because

_pytest/python.py

@@ -594,12 +594,14 @@ def __init__(self, metafunc):
         self._globalparam = _notexists
         self._arg2scopenum = {}  # used for sorting parametrized resources
         self.keywords = {}
+        self.indices = {}
 
     def copy(self, metafunc):
         cs = CallSpec2(self.metafunc)
         cs.funcargs.update(self.funcargs)
         cs.params.update(self.params)
         cs.keywords.update(self.keywords)
+        cs.indices.update(self.indices)
         cs._arg2scopenum.update(self._arg2scopenum)
         cs._idlist = list(self._idlist)
         cs._globalid = self._globalid
@@ -623,14 +625,16 @@ def getparam(self, name):
     def id(self):
         return "-".join(map(str, filter(None, self._idlist)))
 
-    def setmulti(self, valtype, argnames, valset, id, keywords, scopenum=0):
+    def setmulti(self, valtype, argnames, valset, id, keywords, scopenum,
+                 param_index):
         for arg,val in zip(argnames, valset):
             self._checkargnotcontained(arg)
             getattr(self, valtype)[arg] = val
             # we want self.params to be always set because of
             # parametrize_sorted() which groups tests by params/scope
             if valtype == "funcargs":
                 self.params[arg] = id
+            self.indices[arg] = param_index
             self._arg2scopenum[arg] = scopenum
             if val is _notexists:
                 self._emptyparamspecified = True
@@ -740,11 +744,12 @@ def parametrize(self, argnames, argvalues, indirect=False, ids=None,
             ids = idmaker(argnames, argvalues)
         newcalls = []
         for callspec in self._calls or [CallSpec2(self)]:
-            for i, valset in enumerate(argvalues):
+            for param_index, valset in enumerate(argvalues):
                 assert len(valset) == len(argnames)
                 newcallspec = callspec.copy(self)
-                newcallspec.setmulti(valtype, argnames, valset, ids[i],
-                                     newkeywords.get(i, {}), scopenum)
+                newcallspec.setmulti(valtype, argnames, valset, ids[param_index],
+                                     newkeywords.get(param_index, {}), scopenum,
+                                     param_index)
                 newcalls.append(newcallspec)
         self._calls = newcalls
 
@@ -1862,33 +1867,33 @@ def getfuncargparams(item, ignore, scopenum, cache):
     except AttributeError:
         return []
     if scopenum == 0:
-        argparams = [x for x in cs.params.items() if x not in ignore
+        argparams = [x for x in cs.indices.items() if x not in ignore
                         and cs._arg2scopenum[x[0]] == scopenum]
     elif scopenum == 1:  # module
         argparams = []
-        for argname, param in cs.params.items():
+        for argname, valindex in cs.indices.items():
             if cs._arg2scopenum[argname] == scopenum:
-                key = (argname, param, item.fspath)
+                key = (argname, valindex, item.fspath)
                 if key in ignore:
                     continue
                 argparams.append(key)
     elif scopenum == 2:  # class
         argparams = []
-        for argname, param in cs.params.items():
+        for argname, valindex in cs.indices.items():
             if cs._arg2scopenum[argname] == scopenum:
                 l = cache.setdefault(item.fspath, [])
                 try:
                     i = l.index(item.cls)
                 except ValueError:
                     i = len(l)
                     l.append(item.cls)
-                key = (argname, param, item.fspath, i)
+                key = (argname, valindex, item.fspath, i)
                 if key in ignore:
                     continue
                 argparams.append(key)
     #elif scopenum == 3:
     #    argparams = []
-    #    for argname, param in cs.params.items():
+    #    for argname, param in cs.indices.items():
     #        if cs._arg2scopenum[argname] == scopenum:
     #            key = (argname, param, getfslineno(item.obj))
     #            if key in ignore:

testing/python/collect.py

@@ -355,6 +355,35 @@ def test_archival_to_version(key, value):
         rec = testdir.inline_run()
         rec.assertoutcome(passed=2)
 
+
+    def test_parametrize_with_non_hashable_values_indirect(self, testdir):
+        """Test parametrization with non-hashable values with indirect parametrization."""
+        testdir.makepyfile("""
+            archival_mapping = {
+                '1.0': {'tag': '1.0'},
+                '1.2.2a1': {'tag': 'release-1.2.2a1'},
+            }
+
+            import pytest
+
+            @pytest.fixture
+            def key(request):
+                return request.param
+
+            @pytest.fixture
+            def value(request):
+                return request.param
+
+            @pytest.mark.parametrize('key value'.split(),
+                                     archival_mapping.items(), indirect=True)
+            def test_archival_to_version(key, value):
+                assert key in archival_mapping
+                assert value == archival_mapping[key]
+        """)
+        rec = testdir.inline_run()
+        rec.assertoutcome(passed=2)
+
+
     def test_parametrize_with_mark(selfself, testdir):
         items = testdir.getitems("""
             import pytest