Merge branch 'Elizaveta239-master' closes #908

AUTHORS

@@ -28,6 +28,7 @@ Dave Hunt
 David Mohr
 Edison Gustavo Muenz
 Eduardo Schettino
+Elizaveta Shashkova
 Eric Hunsberger
 Eric Siegerman
 Florian Bruhin

CHANGELOG

@@ -148,6 +148,14 @@
 
 - add ``file`` and ``line`` attributes to JUnit-XML output.
 
+- fix issue890: changed extension of all documentation files from ``txt`` to
+  ``rst``. Thanks to Abhijeet for the PR.
+
+- fix issue714: add ability to apply indirect=True parameter on particular argnames.
+  Thanks Elizaveta239.
+
+- fix issue714: add ability to apply indirect=True parameter on particular argnames.
+
 - fix issue890: changed extension of all documentation files from ``txt`` to
   ``rst``. Thanks to Abhijeet for the PR.
 

_pytest/python.py

@@ -813,11 +813,12 @@ class CallSpec2(object):
     def id(self):
         return "-".join(map(str, filter(None, self._idlist)))
 
-    def setmulti(self, valtype, argnames, valset, id, keywords, scopenum,
+    def setmulti(self, valtypes, argnames, valset, id, keywords, scopenum,
                  param_index):
         for arg,val in zip(argnames, valset):
             self._checkargnotcontained(arg)
-            getattr(self, valtype)[arg] = val
+            valtype_for_arg = valtypes[arg]
+            getattr(self, valtype_for_arg)[arg] = val
             self.indices[arg] = param_index
             self._arg2scopenum[arg] = scopenum
             if val is _notexists:
@@ -884,7 +885,7 @@ class Metafunc(FuncargnamesCompatAttr):
         """ Add new invocations to the underlying test function using the list
         of argvalues for the given argnames.  Parametrization is performed
         during the collection phase.  If you need to setup expensive resources
-        see about setting indirect=True to do it rather at test setup time.
+        see about setting indirect to do it rather at test setup time.
 
         :arg argnames: a comma-separated string denoting one or more argument
                        names, or a list/tuple of argument strings.
@@ -896,7 +897,9 @@ class Metafunc(FuncargnamesCompatAttr):
             where each tuple-element specifies a value for its respective
             argname.
 
-        :arg indirect: if True each argvalue corresponding to an argname will
+        :arg indirect: The list of argnames or boolean. A list of arguments'
+            names (subset of argnames). If True the list contains all names from
+            the argnames. Each argvalue corresponding to an argname in this list will
             be passed as request.param to its respective argname fixture
             function so that it can perform more expensive setups during the
             setup phase of a test rather than at collection time.
@@ -941,13 +944,22 @@ class Metafunc(FuncargnamesCompatAttr):
         if scope is None:
             scope = "function"
         scopenum = scopes.index(scope)
-        if not indirect:
-            #XXX should we also check for the opposite case?
-            for arg in argnames:
-                if arg not in self.fixturenames:
-                    raise ValueError("%r uses no fixture %r" %(
+        valtypes = {}
+        for arg in argnames:
+            if arg not in self.fixturenames:
+                raise ValueError("%r uses no fixture %r" %(self.function, arg))
+
+        if indirect is True:
+            valtypes = dict.fromkeys(argnames, "params")
+        elif indirect is False:
+            valtypes = dict.fromkeys(argnames, "funcargs")
+        elif isinstance(indirect, (tuple, list)):
+            valtypes = dict.fromkeys(argnames, "funcargs")
+            for arg in indirect:
+                if arg not in argnames:
+                    raise ValueError("indirect given to %r: fixture %r doesn't exist" %(
                                      self.function, arg))
-        valtype = indirect and "params" or "funcargs"
+                valtypes[arg] = "params"
         idfn = None
         if callable(ids):
             idfn = ids
@@ -962,7 +974,7 @@ class Metafunc(FuncargnamesCompatAttr):
             for param_index, valset in enumerate(argvalues):
                 assert len(valset) == len(argnames)
                 newcallspec = callspec.copy(self)
-                newcallspec.setmulti(valtype, argnames, valset, ids[param_index],
+                newcallspec.setmulti(valtypes, argnames, valset, ids[param_index],
                                      newkeywords.get(param_index, {}), scopenum,
                                      param_index)
                 newcalls.append(newcallspec)

doc/en/example/parametrize.rst

@@ -280,6 +280,46 @@ The first invocation with ``db == "DB1"`` passed while the second with ``db == "
 
 .. regendoc:wipe
 
+Apply indirect on particular arguments
+---------------------------------------------------
+
+Very often parametrization uses more than one argument name. There is opportunity to apply ``indirect``
+parameter on particular arguments. It can be done by passing list or tuple of
+arguments' names to ``indirect``. In the example below there is a function ``test_indirect`` which uses
+two fixtures: ``x`` and ``y``. Here we give to indirect the list, which contains the name of the
+fixture ``x``. The indirect parameter will be applied to this argument only, and the value ``a``
+will be passed to respective fixture function.
+
+    # content of test_indirect_list.py
+
+    import pytest
+    @pytest.fixture(scope='function')
+    def x(request):
+        return request.param * 3
+
+    @pytest.fixture(scope='function')
+    def y(request):
+        return request.param * 2
+
+    @pytest.mark.parametrize('x, y', [('a', 'b')], indirect=['x'])
+    def test_indirect(x,y):
+        assert x == 'aaa'
+        assert y == 'b'
+
+The result of this test will be successful:
+
+    $ py.test test_indirect_list.py --collect-only
+    ============================= test session starts ==============================
+    platform linux2 -- Python 2.7.3, pytest-2.8.0.dev4, py-1.4.30, pluggy-0.3.0
+    rootdir: /home/elizabeth/work/pytest, inifile: tox.ini
+    collected 1 items
+    <Module 'testing/test_argnames.py'>
+      <Function 'test_simple[a-b]'>
+
+    ===============================  in 0.02 seconds ===============================
+
+.. regendoc:wipe
+
 Parametrizing test methods through per-class configuration
 --------------------------------------------------------------
 

testing/python/metafunc.py

@@ -220,17 +220,136 @@ class TestMetafunc:
         assert metafunc._calls[0].id == "0-2"
         assert metafunc._calls[1].id == "0-3"
 
+    @pytest.mark.issue714
     def test_parametrize_indirect(self):
         def func(x, y): pass
         metafunc = self.Metafunc(func)
         metafunc.parametrize('x', [1], indirect=True)
         metafunc.parametrize('y', [2,3], indirect=True)
-        metafunc.parametrize('unnamed', [1], indirect=True)
         assert len(metafunc._calls) == 2
         assert metafunc._calls[0].funcargs == {}
         assert metafunc._calls[1].funcargs == {}
-        assert metafunc._calls[0].params == dict(x=1,y=2, unnamed=1)
-        assert metafunc._calls[1].params == dict(x=1,y=3, unnamed=1)
+        assert metafunc._calls[0].params == dict(x=1,y=2)
+        assert metafunc._calls[1].params == dict(x=1,y=3)
+
+    @pytest.mark.issue714
+    def test_parametrize_indirect_list(self):
+        def func(x, y): pass
+        metafunc = self.Metafunc(func)
+        metafunc.parametrize('x, y', [('a', 'b')], indirect=['x'])
+        assert metafunc._calls[0].funcargs == dict(y='b')
+        assert metafunc._calls[0].params == dict(x='a')
+
+    @pytest.mark.issue714
+    def test_parametrize_indirect_list_all(self):
+        def func(x, y): pass
+        metafunc = self.Metafunc(func)
+        metafunc.parametrize('x, y', [('a', 'b')], indirect=['x', 'y'])
+        assert metafunc._calls[0].funcargs == {}
+        assert metafunc._calls[0].params == dict(x='a', y='b')
+
+    @pytest.mark.issue714
+    def test_parametrize_indirect_list_empty(self):
+        def func(x, y): pass
+        metafunc = self.Metafunc(func)
+        metafunc.parametrize('x, y', [('a', 'b')], indirect=[])
+        assert metafunc._calls[0].funcargs == dict(x='a', y='b')
+        assert metafunc._calls[0].params == {}
+
+    @pytest.mark.issue714
+    def test_parametrize_indirect_list_functional(self, testdir):
+        """
+        Test parametrization with 'indirect' parameter applied on
+        particular arguments. As y is is direct, its value should
+        be used directly rather than being passed to the fixture
+        y.
+
+        :param testdir: the instance of Testdir class, a temporary
+        test directory.
+        """
+        testdir.makepyfile("""
+            import pytest
+            @pytest.fixture(scope='function')
+            def x(request):
+                return request.param * 3
+            @pytest.fixture(scope='function')
+            def y(request):
+                return request.param * 2
+            @pytest.mark.parametrize('x, y', [('a', 'b')], indirect=['x'])
+            def test_simple(x,y):
+                assert len(x) == 3
+                assert len(y) == 1
+        """)
+        result = testdir.runpytest("-v")
+        result.stdout.fnmatch_lines([
+            "*test_simple*a-b*",
+            "*1 passed*",
+        ])
+
+    @pytest.mark.issue714
+    def test_parametrize_indirect_list_error(self, testdir):
+        def func(x, y): pass
+        metafunc = self.Metafunc(func)
+        with pytest.raises(ValueError):
+            metafunc.parametrize('x, y', [('a', 'b')], indirect=['x', 'z'])
+
+    @pytest.mark.issue714
+    def test_parametrize_uses_no_fixture_error_indirect_false(self, testdir):
+        """The 'uses no fixture' error tells the user at collection time
+        that the parametrize data they've set up doesn't correspond to the
+        fixtures in their test function, rather than silently ignoring this
+        and letting the test potentially pass.
+        """
+        testdir.makepyfile("""
+            import pytest
+
+            @pytest.mark.parametrize('x, y', [('a', 'b')], indirect=False)
+            def test_simple(x):
+                assert len(x) == 3
+        """)
+        result = testdir.runpytest("--collect-only")
+        result.stdout.fnmatch_lines([
+            "*uses no fixture 'y'*",
+        ])
+
+    @pytest.mark.xfail
+    @pytest.mark.issue714
+    def test_parametrize_uses_no_fixture_error_indirect_true(self, testdir):
+        testdir.makepyfile("""
+            import pytest
+            @pytest.fixture(scope='function')
+            def x(request):
+                return request.param * 3
+            @pytest.fixture(scope='function')
+            def y(request):
+                return request.param * 2
+
+            @pytest.mark.parametrize('x, y', [('a', 'b')], indirect=True)
+            def test_simple(x):
+                assert len(x) == 3
+        """)
+        result = testdir.runpytest("--collect-only")
+        result.stdout.fnmatch_lines([
+            "*uses no fixture 'y'*",
+        ])
+
+    @pytest.mark.xfail
+    @pytest.mark.issue714
+    def test_parametrize_indirect_uses_no_fixture_error_indirect_list(self, testdir):
+        testdir.makepyfile("""
+            import pytest
+            @pytest.fixture(scope='function')
+            def x(request):
+                return request.param * 3
+
+            @pytest.mark.parametrize('x, y', [('a', 'b')], indirect=['x'])
+            def test_simple(x):
+                assert len(x) == 3
+        """)
+        result = testdir.runpytest("--collect-only")
+        result.stdout.fnmatch_lines([
+            "*uses no fixture 'y'*",
+        ])
 
     def test_addcalls_and_parametrize_indirect(self):
         def func(x, y): pass