Merge pull request #1711 from nicoddemus/invocation-scoped-fixtures

Invocation scoped fixtures

CHANGELOG.rst

@@ -135,9 +135,17 @@ time or change existing behaviors in order to make them less surprising/more use
  never fail because tuples are always truthy and are usually a mistake
  (see `#1562`_). Thanks `@kvas-it`_, for the PR.
 
+* Experimentally introduce new ``"invocation"`` fixture scope. At invocation scope a
+ fixture function is cached in the same way as the fixture or test function that requests it.
+ You can now use the builtin ``monkeypatch`` fixture from ``session``-scoped fixtures
+ where previously you would get an error that you can not use a ``function``-scoped fixture from a
+ ``session``-scoped one.*
+ Thanks `@nicoddemus`_ for the PR.
+
 * Allow passing a custom debugger class (e.g. ``--pdbcls=IPython.core.debugger:Pdb``).
  Thanks to `@anntzer`_ for the PR.
 
+
 *
 
 *

_pytest/capture.py

@@ -161,7 +161,7 @@ def capsys(request):
  captured output available via ``capsys.readouterr()`` method calls
  which return a ``(out, err)`` tuple.
  """
- if "capfd" in request._funcargs:
+ if "capfd" in request.fixturenames:
  raise request.raiseerror(error_capsysfderror)
  request.node._capfuncarg = c = CaptureFixture(SysCapture, request)
  return c
@@ -172,7 +172,7 @@ def capfd(request):
  captured output available via ``capfd.readouterr()`` method calls
  which return a ``(out, err)`` tuple.
  """
- if "capsys" in request._funcargs:
+ if "capsys" in request.fixturenames:
  request.raiseerror(error_capsysfderror)
  if not hasattr(os, 'dup'):
  pytest.skip("capfd funcarg needs os.dup")

_pytest/fixtures.py

@@ -260,8 +260,6 @@ def __init__(self, argnames, names_closure, name2fixturedefs):
  self.name2fixturedefs = name2fixturedefs
 
 
-
-
 class FixtureRequest(FuncargnamesCompatAttr):
  """ A request for a fixture from a test or fixture function.
 
@@ -276,34 +274,51 @@ def __init__(self, pyfuncitem):
  self.fixturename = None
  #: Scope string, one of "function", "class", "module", "session"
  self.scope = "function"
- self._funcargs = {}
- self._fixturedefs = {}
+ # rename both attributes below because their key has changed; better an attribute error
+ # than subtle key misses; also backward incompatibility
+ self._fixture_values = {} # (argname, scope) -> fixture value
+ self._fixture_defs = {} # (argname, scope) -> FixtureDef
  fixtureinfo = pyfuncitem._fixtureinfo
  self._arg2fixturedefs = fixtureinfo.name2fixturedefs.copy()
  self._arg2index = {}
- self.fixturenames = fixtureinfo.names_closure
  self._fixturemanager = pyfuncitem.session._fixturemanager
 
+ @property
+ def fixturenames(self):
+ # backward incompatible note: now a readonly property
+ return list(self._pyfuncitem._fixtureinfo.names_closure)
+
  @property
  def node(self):
  """ underlying collection node (depends on current request scope)"""
  return self._getscopeitem(self.scope)
 
 
- def _getnextfixturedef(self, argname):
- fixturedefs = self._arg2fixturedefs.get(argname, None)
+ def _getnextfixturedef(self, argname, scope):
+ def trygetfixturedefs(argname):
+ fixturedefs = self._arg2fixturedefs.get(argname, None)
+ if fixturedefs is None:
+ fixturedefs = self._arg2fixturedefs.get(argname + ':' + scope, None)
+ return fixturedefs
+
+ fixturedefs = trygetfixturedefs(argname)
  if fixturedefs is None:
  # we arrive here because of a a dynamic call to
  # getfixturevalue(argname) usage which was naturally
  # not known at parsing/collection time
- fixturedefs = self._fixturemanager.getfixturedefs(
- argname, self._pyfuncitem.parent.nodeid)
- self._arg2fixturedefs[argname] = fixturedefs
+ parentid = self._pyfuncitem.parent.nodeid
+ fixturedefs = self._fixturemanager.getfixturedefs(argname, parentid)
+ if fixturedefs:
+ self._arg2fixturedefs[argname] = fixturedefs
+ fixturedefs_by_argname = self._fixturemanager.getfixturedefs_multiple_scopes(argname, parentid)
+ if fixturedefs_by_argname:
+ self._arg2fixturedefs.update(fixturedefs_by_argname)
+ fixturedefs = trygetfixturedefs(argname)
  # fixturedefs list is immutable so we maintain a decreasing index
- index = self._arg2index.get(argname, 0) - 1
+ index = self._arg2index.get((argname, scope), 0) - 1
  if fixturedefs is None or (-index > len(fixturedefs)):
  raise FixtureLookupError(argname, self)
- self._arg2index[argname] = index
+ self._arg2index[(argname, scope)] = index
  return fixturedefs[index]
 
  @property
@@ -442,10 +457,10 @@ def getfuncargvalue(self, argname):
 
  def _get_active_fixturedef(self, argname):
  try:
- return self._fixturedefs[argname]
+ return self._fixture_defs[(argname, self.scope)]
  except KeyError:
  try:
- fixturedef = self._getnextfixturedef(argname)
+ fixturedef = self._getnextfixturedef(argname, self.scope)
  except FixtureLookupError:
  if argname == "request":
  class PseudoFixtureDef:
@@ -456,8 +471,8 @@ class PseudoFixtureDef:
  # remove indent to prevent the python3 exception
  # from leaking into the call
  result = self._getfixturevalue(fixturedef)
- self._funcargs[argname] = result
- self._fixturedefs[argname] = fixturedef
+ self._fixture_values[(argname, self.scope)] = result
+ self._fixture_defs[(argname, self.scope)] = fixturedef
  return fixturedef
 
  def _get_fixturestack(self):
@@ -578,11 +593,10 @@ def __init__(self, request, scope, param, param_index, fixturedef):
  self._fixturedef = fixturedef
  self.addfinalizer = fixturedef.addfinalizer
  self._pyfuncitem = request._pyfuncitem
- self._funcargs = request._funcargs
- self._fixturedefs = request._fixturedefs
+ self._fixture_values = request._fixture_values
+ self._fixture_defs = request._fixture_defs
  self._arg2fixturedefs = request._arg2fixturedefs
  self._arg2index = request._arg2index
- self.fixturenames = request.fixturenames
  self._fixturemanager = request._fixturemanager
 
  def __repr__(self):
@@ -622,7 +636,7 @@ def formatrepr(self):
  fspath, lineno = getfslineno(function)
  try:
  lines, _ = inspect.getsourcelines(get_real_func(function))
- except (IOError, IndexError):
+ except (IOError, IndexError, TypeError):
  error_msg = "file %s, line %s: source code not available"
  addline(error_msg % (fspath, lineno+1))
  else:
@@ -636,9 +650,9 @@ def formatrepr(self):
  if msg is None:
  fm = self.request._fixturemanager
  available = []
- for name, fixturedef in fm._arg2fixturedefs.items():
-  parentid = self.request._pyfuncitem.parent.nodeid
- faclist = list(fm._matchfactories(fixturedef, parentid))
+ parentid = self.request._pyfuncitem.parent.nodeid
+ for name, fixturedefs in fm._arg2fixturedefs.items():
+ faclist = list(fm._matchfactories(fixturedefs, parentid))
  if faclist:
  available.append(name)
  msg = "fixture %r not found" % (self.argname,)
@@ -749,7 +763,7 @@ def execute(self, request):
  assert not hasattr(self, "cached_result")
 
  ihook = self._fixturemanager.session.ihook
- ihook.pytest_fixture_setup(fixturedef=self, request=request)
+ return ihook.pytest_fixture_setup(fixturedef=self, request=request)
 
  def __repr__(self):
  return ("<FixtureDef name=%r scope=%r baseid=%r >" %
@@ -984,10 +998,12 @@ def getfixtureclosure(self, fixturenames, parentnode):
 
  parentid = parentnode.nodeid
  fixturenames_closure = self._getautousenames(parentid)
+
  def merge(otherlist):
  for arg in otherlist:
  if arg not in fixturenames_closure:
  fixturenames_closure.append(arg)
+
  merge(fixturenames)
  arg2fixturedefs = {}
  lastlen = -1
@@ -1000,6 +1016,11 @@ def merge(otherlist):
  if fixturedefs:
  arg2fixturedefs[argname] = fixturedefs
  merge(fixturedefs[-1].argnames)
+ fixturedefs_by_argname = self.getfixturedefs_multiple_scopes(argname, parentid)
+ if fixturedefs_by_argname:
+ arg2fixturedefs.update(fixturedefs_by_argname)
+ for fixturedefs in fixturedefs_by_argname.values():
+ merge(fixturedefs[-1].argnames)
  return fixturenames_closure, arg2fixturedefs
 
  def pytest_generate_tests(self, metafunc):
@@ -1018,7 +1039,7 @@ def pytest_generate_tests(self, metafunc):
  indirect=True, scope=fixturedef.scope,
  ids=fixturedef.ids)
  else:
- continue # will raise FixtureLookupError at setup time
+ continue  # will raise FixtureLookupError at setup time
 
  def pytest_collection_modifyitems(self, items):
  # separate parametrized setups
@@ -1057,25 +1078,43 @@ def parsefactories(self, node_or_obj, nodeid=NOTSET, unittest=False):
  msg = 'fixtures cannot have "pytest_funcarg__" prefix ' \
  'and be decorated with @pytest.fixture:\n%s' % name
  assert not name.startswith(self._argprefix), msg
- fixturedef = FixtureDef(self, nodeid, name, obj,
- marker.scope, marker.params,
- unittest=unittest, ids=marker.ids)
- faclist = self._arg2fixturedefs.setdefault(name, [])
- if fixturedef.has_location:
- faclist.append(fixturedef)
+
+ def new_fixture_def(name, scope):
+ """Create and registers a new FixtureDef with given name and scope."""
+ fixture_def = FixtureDef(self, nodeid, name, obj,
+ scope, marker.params,
+ unittest=unittest, ids=marker.ids)
+
+ faclist = self._arg2fixturedefs.setdefault(name, [])
+ if fixture_def.has_location:
+ faclist.append(fixture_def)
+ else:
+ # fixturedefs with no location are at the front
+ # so this inserts the current fixturedef after the
+ # existing fixturedefs from external plugins but
+ # before the fixturedefs provided in conftests.
+ i = len([f for f in faclist if not f.has_location])
+ faclist.insert(i, fixture_def)
+ if marker.autouse:
+ autousenames.append(name)
+
+ if marker.scope == 'invocation':
+ for new_scope in scopes:
+ new_fixture_def(name + ':{0}'.format(new_scope), new_scope)
  else:
- # fixturedefs with no location are at the front
- # so this inserts the current fixturedef after the
- # existing fixturedefs from external plugins but
- # before the fixturedefs provided in conftests.
- i = len([f for f in faclist if not f.has_location])
- faclist.insert(i, fixturedef)
- if marker.autouse:
- autousenames.append(name)
+ new_fixture_def(name, marker.scope)
+
  if autousenames:
  self._nodeid_and_autousenames.append((nodeid or '', autousenames))
 
  def getfixturedefs(self, argname, nodeid):
+ """
+ Gets a list of fixtures which are applicable to the given node id.
+
+ :param str argname: name of the fixture to search for
+ :param str nodeid: full node id of the requesting test.
+ :return: list[FixtureDef]
+ """
  try:
  fixturedefs = self._arg2fixturedefs[argname]
  except KeyError:
@@ -1087,3 +1126,24 @@ def _matchfactories(self, fixturedefs, nodeid):
  for fixturedef in fixturedefs:
  if nodeid.startswith(fixturedef.baseid):
  yield fixturedef
+
+ def getfixturedefs_multiple_scopes(self, argname, nodeid):
+ """
+ Gets multiple scoped fixtures which are applicable to the given nodeid. Multiple scoped
+ fixtures are created by "invocation" scoped fixtures and have argnames in
+ the form: "<argname>:<scope>" (for example "tmpdir:session").
+
+ :return: dict of "argname" -> [FixtureDef].
+
+ Arguments similar to ``getfixturedefs``.
+ """
+ prefix = argname + ':'
+ fixturedefs_by_argname = dict((k, v) for k, v in self._arg2fixturedefs.items()
+ if k.startswith(prefix))
+ if fixturedefs_by_argname:
+ result = {}
+ for argname, fixturedefs in fixturedefs_by_argname.items():
+ result[argname] = tuple(self._matchfactories(fixturedefs, nodeid))
+ return result
+ else:
+ return None

_pytest/monkeypatch.py

@@ -10,7 +10,7 @@
 RE_IMPORT_ERROR_NAME = re.compile("^No module named (.*)$")
 
 
-@pytest.fixture
+@pytest.fixture(scope='invocation')
 def monkeypatch(request):
  """The returned ``monkeypatch`` fixture provides these
  helper methods to modify objects, dictionaries or os.environ::
@@ -25,9 +25,11 @@ def monkeypatch(request):
  monkeypatch.chdir(path)
 
  All modifications will be undone after the requesting
- test function has finished. The ``raising``
+ test function or fixture has finished. The ``raising``
  parameter determines if a KeyError or AttributeError
  will be raised if the set/deletion operation has no target.
+
+ This fixture is ``invocation``-scoped.
  """
  mpatch = MonkeyPatch()
  request.addfinalizer(mpatch.undo)
@@ -97,7 +99,8 @@ def __repr__(self):
 
 
 class MonkeyPatch:
- """ Object keeping a record of setattr/item/env/syspath changes. """
+ """ Object returned by the ``monkeypatch`` fixture keeping a record of setattr/item/env/syspath changes.
+ """
 
  def __init__(self):
  self._setattr = []

_pytest/python.py

@@ -1506,4 +1506,3 @@ def setup(self):
  super(Function, self).setup()
  fixtures.fillfixtures(self)
 
-

doc/en/fixture.rst

@@ -603,7 +603,7 @@ first execute with one instance and then finalizers are called
 before the next fixture instance is created. Among other things,
 this eases testing of applications which create and use global state.
 
-The following example uses two parametrized funcargs, one of which is
+The following example uses two parametrized fixture, one of which is
 scoped on a per-module basis, and all the functions perform ``print`` calls
 to show the setup/teardown flow::
 
@@ -863,6 +863,14 @@ All test methods in this TestClass will use the transaction fixture while
 other test classes or functions in the module will not use it unless
 they also add a ``transact`` reference.
 
+invocation-scoped fixtures
+--------------------------
+
+pytest 3.0 introduced a new advanced scope for fixtures: ``"invocation"``. Fixtures marked with
+this scope can be requested from any other scope, providing a version of the fixture for that scope.
+
+See more in :ref:`invocation_scoped_fixture`.
+
 Shifting (visibility of) fixture functions
 ----------------------------------------------------