189 lines
6.8 KiB
Python
189 lines
6.8 KiB
Python
""" monkeypatching and mocking functionality. """
|
|
|
|
import os, sys, inspect
|
|
|
|
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)
|
|
monkeypatch.syspath_prepend(path)
|
|
monkeypatch.chdir(path)
|
|
|
|
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()
|
|
request.addfinalizer(mpatch.undo)
|
|
return mpatch
|
|
|
|
notset = object()
|
|
|
|
if sys.version_info < (3,0):
|
|
def derive_obj_and_name(obj):
|
|
name = obj.__name__
|
|
real_obj = getattr(obj, "im_self", None)
|
|
if real_obj is None:
|
|
real_obj = getattr(obj, "im_class", None)
|
|
if real_obj is None:
|
|
real_obj = sys.modules[obj.__module__]
|
|
assert getattr(real_obj, name) == obj, \
|
|
"could not derive object/name pair"
|
|
return name, real_obj
|
|
|
|
else:
|
|
def derive_obj_and_name(obj):
|
|
name = obj.__name__
|
|
real_obj = getattr(obj, "__self__", None)
|
|
if real_obj is None:
|
|
current = sys.modules[obj.__module__]
|
|
for name in obj.__qualname__.split("."):
|
|
real_obj = current
|
|
current = getattr(current, name)
|
|
assert getattr(real_obj, name) == obj, \
|
|
"could not derive object/name pair"
|
|
return name, real_obj
|
|
|
|
def derive_from_string(target):
|
|
rest = []
|
|
while target:
|
|
try:
|
|
obj = __import__(target, None, None, "__doc__")
|
|
except ImportError:
|
|
if "." not in target:
|
|
raise
|
|
target, name = target.rsplit(".", 1)
|
|
rest.append(name)
|
|
else:
|
|
assert len(rest) >= 1
|
|
while len(rest) != 1:
|
|
obj = getattr(obj, rest.pop())
|
|
return rest[0], obj
|
|
|
|
class monkeypatch:
|
|
""" object keeping a record of setattr/item/env/syspath changes. """
|
|
def __init__(self):
|
|
self._setattr = []
|
|
self._setitem = []
|
|
self._cwd = None
|
|
|
|
def replace(self, target, value):
|
|
""" derive monkeypatching location from ``target`` and call
|
|
setattr(derived_obj, derived_name, value).
|
|
|
|
This function can usually derive monkeypatch locations
|
|
for function, method or class targets. It also accepts
|
|
a string which is taken as a python path which is then
|
|
tried to be imported. For example the target "os.path.abspath"
|
|
will lead to a call to setattr(os.path, "abspath", value)
|
|
without the need to import "os.path" yourself.
|
|
"""
|
|
if isinstance(target, str):
|
|
name, obj = derive_from_string(target)
|
|
else:
|
|
name, obj = derive_obj_and_name(target)
|
|
return self.setattr(obj, name, value)
|
|
|
|
def setattr(self, obj, name, value, raising=True):
|
|
""" set attribute ``name`` on ``obj`` to ``value``, by default
|
|
raise AttributeEror if the attribute did not exist.
|
|
|
|
"""
|
|
oldval = getattr(obj, name, notset)
|
|
if raising and oldval is notset:
|
|
raise AttributeError("%r has no attribute %r" %(obj, name))
|
|
|
|
# avoid class descriptors like staticmethod/classmethod
|
|
if inspect.isclass(obj):
|
|
oldval = obj.__dict__.get(name, notset)
|
|
self._setattr.insert(0, (obj, name, oldval))
|
|
setattr(obj, name, value)
|
|
|
|
def delattr(self, obj, name, raising=True):
|
|
""" delete attribute ``name`` from ``obj``, by default raise
|
|
AttributeError it the attribute did not previously exist. """
|
|
if not hasattr(obj, name):
|
|
if raising:
|
|
raise AttributeError(name)
|
|
else:
|
|
self._setattr.insert(0, (obj, name, getattr(obj, name, notset)))
|
|
delattr(obj, name)
|
|
|
|
def setitem(self, dic, name, value):
|
|
""" set dictionary entry ``name`` to value. """
|
|
self._setitem.insert(0, (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 name not in dic:
|
|
if raising:
|
|
raise KeyError(name)
|
|
else:
|
|
self._setitem.insert(0, (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 environment, raise KeyError it not exists."""
|
|
self.delitem(os.environ, name, raising=raising)
|
|
|
|
def syspath_prepend(self, path):
|
|
""" prepend ``path`` to ``sys.path`` list of import locations. """
|
|
if not hasattr(self, '_savesyspath'):
|
|
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"):
|
|
path.chdir()
|
|
else:
|
|
os.chdir(path)
|
|
|
|
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."""
|
|
for obj, name, value in self._setattr:
|
|
if value is not notset:
|
|
setattr(obj, name, value)
|
|
else:
|
|
delattr(obj, name)
|
|
self._setattr[:] = []
|
|
for dictionary, name, value in self._setitem:
|
|
if value is notset:
|
|
try:
|
|
del dictionary[name]
|
|
except KeyError:
|
|
pass # was already deleted, so we have the desired state
|
|
else:
|
|
dictionary[name] = value
|
|
self._setitem[:] = []
|
|
if hasattr(self, '_savesyspath'):
|
|
sys.path[:] = self._savesyspath
|
|
del self._savesyspath
|
|
|
|
if self._cwd is not None:
|
|
os.chdir(self._cwd)
|
|
self._cwd = None
|