author Anjana Vakil <>
Wed, 10 Aug 2016 13:34:59 +0200
changeset 309149 62f855e872506e80a209d6d3415a1c45922ab72a
permissions -rw-r--r--
Bug 1253359 - Vendor in Pytest 2.9.2 and Py 1.4.31 r=gps Vendor in Pytest (2.9.2) and its requirement Py (1.4.31), so that it can be used for e.g. the Marionette harness unit tests and a pytest plugin for mozlog. Copy pytest and py package directories (extracted from tars on Pip) into `mozilla-central/python/`, removing some support files (e.g. changelog, docs, tests). Add both `.pth` entries to `virtualenv_packages.txt`. Add both paths to `SEARCH_PATHS` in ``. MozReview-Commit-ID: IOTCOUxX8R9

""" monkeypatching and mocking functionality.  """

import os, sys
import re

from py.builtin import _basestring

RE_IMPORT_ERROR_NAME = re.compile("^No module named (.*)$")

def pytest_funcarg__monkeypatch(request):
    """The returned ``monkeypatch`` funcarg provides these
    helper methods to modify objects, dictionaries or os.environ::

        monkeypatch.setattr(obj, name, value, raising=True)
        monkeypatch.delattr(obj, name, raising=True)
        monkeypatch.setitem(mapping, name, value)
        monkeypatch.delitem(obj, name, raising=True)
        monkeypatch.setenv(name, value, prepend=False)
        monkeypatch.delenv(name, value, raising=True)

    All modifications will be undone after the requesting
    test function has finished. The ``raising``
    parameter determines if a KeyError or AttributeError
    will be raised if the set/deletion operation has no target.
    mpatch = monkeypatch()
    return mpatch

def resolve(name):
    # simplified from zope.dottedname
    parts = name.split('.')

    used = parts.pop(0)
    found = __import__(used)
    for part in parts:
        used += '.' + part
            found = getattr(found, part)
        except AttributeError:
        # we use explicit un-nesting of the handling block in order
        # to avoid nested exceptions on python 3
        except ImportError as ex:
            # str is used for py2 vs py3
            expected = str(ex).split()[-1]
            if expected == used:
                raise ImportError(
                    'import error in %s: %s' % (used, ex)
        found = annotated_getattr(found, part, used)
    return found

def annotated_getattr(obj, name, ann):
        obj = getattr(obj, name)
    except AttributeError:
        raise AttributeError(
                '%r object at %s has no attribute %r' % (
                    type(obj).__name__, ann, name
    return obj

def derive_importpath(import_path, raising):
    if not isinstance(import_path, _basestring) or "." not in import_path:
        raise TypeError("must be absolute import path string, not %r" %
    module, attr = import_path.rsplit('.', 1)
    target = resolve(module)
    if raising:
        annotated_getattr(target, attr, ann=module)
    return attr, target

class Notset:
    def __repr__(self):
        return "<notset>"

notset = Notset()

class monkeypatch:
    """ Object keeping a record of setattr/item/env/syspath changes. """

    def __init__(self):
        self._setattr = []
        self._setitem = []
        self._cwd = None
        self._savesyspath = None

    def setattr(self, target, name, value=notset, raising=True):
        """ Set attribute value on target, memorizing the old value.
        By default raise AttributeError if the attribute did not exist.

        For convenience you can specify a string as ``target`` which
        will be interpreted as a dotted import path, with the last part
        being the attribute name.  Example:
        ``monkeypatch.setattr("os.getcwd", lambda x: "/")``
        would set the ``getcwd`` function of the ``os`` module.

        The ``raising`` value determines if the setattr should fail
        if the attribute is not already present (defaults to True
        which means it will raise).
        __tracebackhide__ = True
        import inspect

        if value is notset:
            if not isinstance(target, _basestring):
                raise TypeError("use setattr(target, name, value) or "
                                "setattr(target, value) with target being a dotted "
                                "import string")
            value = name
            name, target = derive_importpath(target, raising)

        oldval = getattr(target, name, notset)
        if raising and oldval is notset:
            raise AttributeError("%r has no attribute %r" % (target, name))

        # avoid class descriptors like staticmethod/classmethod
        if inspect.isclass(target):
            oldval = target.__dict__.get(name, notset)
        self._setattr.append((target, name, oldval))
        setattr(target, name, value)

    def delattr(self, target, name=notset, raising=True):
        """ Delete attribute ``name`` from ``target``, by default raise
        AttributeError it the attribute did not previously exist.

        If no ``name`` is specified and ``target`` is a string
        it will be interpreted as a dotted import path with the
        last part being the attribute name.

        If ``raising`` is set to False, no exception will be raised if the
        attribute is missing.
        __tracebackhide__ = True
        if name is notset:
            if not isinstance(target, _basestring):
                raise TypeError("use delattr(target, name) or "
                                "delattr(target) with target being a dotted "
                                "import string")
            name, target = derive_importpath(target, raising)

        if not hasattr(target, name):
            if raising:
                raise AttributeError(name)
            self._setattr.append((target, name, getattr(target, name, notset)))
            delattr(target, name)

    def setitem(self, dic, name, value):
        """ Set dictionary entry ``name`` to value. """
        self._setitem.append((dic, name, dic.get(name, notset)))
        dic[name] = value

    def delitem(self, dic, name, raising=True):
        """ Delete ``name`` from dict. Raise KeyError if it doesn't exist.

        If ``raising`` is set to False, no exception will be raised if the
        key is missing.
        if name not in dic:
            if raising:
                raise KeyError(name)
            self._setitem.append((dic, name, dic.get(name, notset)))
            del dic[name]

    def setenv(self, name, value, prepend=None):
        """ Set environment variable ``name`` to ``value``.  If ``prepend``
        is a character, read the current environment variable value
        and prepend the ``value`` adjoined with the ``prepend`` character."""
        value = str(value)
        if prepend and name in os.environ:
            value = value + prepend + os.environ[name]
        self.setitem(os.environ, name, value)

    def delenv(self, name, raising=True):
        """ Delete ``name`` from the environment. Raise KeyError it does not

        If ``raising`` is set to False, no exception will be raised if the
        environment variable is missing.
        self.delitem(os.environ, name, raising=raising)

    def syspath_prepend(self, path):
        """ Prepend ``path`` to ``sys.path`` list of import locations. """
        if self._savesyspath is None:
            self._savesyspath = sys.path[:]
        sys.path.insert(0, str(path))

    def chdir(self, path):
        """ Change the current working directory to the specified path.
        Path can be a string or a py.path.local object.
        if self._cwd is None:
            self._cwd = os.getcwd()
        if hasattr(path, "chdir"):

    def undo(self):
        """ Undo previous changes.  This call consumes the
        undo stack. Calling it a second time has no effect unless
        you do more monkeypatching after the undo call.
        There is generally no need to call `undo()`, since it is
        called automatically during tear-down.
        Note that the same `monkeypatch` fixture is used across a
        single test function invocation. If `monkeypatch` is used both by
        the test function itself and one of the test fixtures,
        calling `undo()` will undo all of the changes made in
        both functions.
        for obj, name, value in reversed(self._setattr):
            if value is not notset:
                setattr(obj, name, value)
                delattr(obj, name)
        self._setattr[:] = []
        for dictionary, name, value in reversed(self._setitem):
            if value is notset:
                    del dictionary[name]
                except KeyError:
                    pass  # was already deleted, so we have the desired state
                dictionary[name] = value
        self._setitem[:] = []
        if self._savesyspath is not None:
            sys.path[:] = self._savesyspath
            self._savesyspath = None

        if self._cwd is not None:
            self._cwd = None