[updated, thanks to marius].
I am currently preparing my testing tutorials for Pycon and here is an example i’d lke to share already.
The problem: In a test function we want to patch an Environment variable and see if our application handles something related to it correctly. The direct approach for doing this in a test function might look like this:
def test_envreading(self):
old = os.environ['ENV1']
os.environ['ENV1'] = 'myval'
try:
val = myapp().readenv()
assert val == "myval"
finally:
os.environ['ENV1'] = old
If we needed to do this several times for test functions we’d have a lot of repetetive boilerplatish code. The try-finally and undo-related code does not even take into account that ENV1 might not have been set originally.
Most experienced people would use setup/teardown methods to get less-repetetive testing code. We might end up with something slightly more general like this:
def setup_method(self, method):
self._oldenv = os.environ.copy()
def teardown_method(self, method):
os.environ.clear()
os.environ.update(self._oldenv)
def test_envreading(self):
os.environ['ENV1'] = "myval"
val = myapp().readenv()
assert val == "myval"
This avoids repetition of setup code but it scatters what belongs to the test function across three functions. All other functions in the Testcase class will get the service of a preserved environment although they might not need it. If i want to move away this testing function i will need to take care to copy the setup code as well. Or i start subclassing Test cases to share code. If we then start to need modifying other dicts or classes we have to add code in three places.
Monkeypatching the right way
Here is a version of the test function which uses pytest’s monkeypatch` plugin. The plugin does one thing: it provides a monkeypatch object for each test function that needs it. The resulting test function code then looks like this:
def test_envreading(self, monkeypatch):
monkeypatch.setitem(os.environ, 'ENV1', 'myval')
val = myapp().readenv()
assert val == "myval"
Here monkeypatch.setitem() will memorize old settings and modify the environment. When the test function finishes the monkeypatch object restores the original setting. This test function is free to get moved across files. No other test function or code place is affected or required to change when it moves.
Let’s take a quick look at the “providing” side, i.e. the pytest_monkeypatch.py plugin which provides “Monkeypatch” instances to test functions. It makes use of pytest’s new pyfuncarg protocol.
The plugin itself is free to get refined and changed as well, without affecting the existing test code. The following 71 lines of code make up the plugin, including tests:
class MonkeypatchPlugin:
""" setattr-monkeypatching with automatical reversal after test. """
def pytest_pyfuncarg_monkeypatch(self, pyfuncitem):
monkeypatch = MonkeyPatch()
pyfuncitem.addfinalizer(monkeypatch.finalize)
return monkeypatch
notset = object()
class MonkeyPatch:
def __init__(self):
self._setattr = []
self._setitem = []
def setattr(self, obj, name, value):
self._setattr.insert(0, (obj, name, getattr(obj, name, notset)))
setattr(obj, name, value)
def setitem(self, dictionary, name, value):
self._setitem.insert(0, (dictionary, name, dictionary.get(name, notset)))
dictionary[name] = value
def finalize(self):
for obj, name, value in self._setattr:
if value is not notset:
setattr(obj, name, value)
else:
delattr(obj, name)
for dictionary, name, value in self._setitem:
if value is notset:
del dictionary[name]
else:
dictionary[name] = value
def test_setattr():
class A:
x = 1
monkeypatch = MonkeyPatch()
monkeypatch.setattr(A, 'x', 2)
assert A.x == 2
monkeypatch.setattr(A, 'x', 3)
assert A.x == 3
monkeypatch.finalize()
assert A.x == 1
monkeypatch.setattr(A, 'y', 3)
assert A.y == 3
monkeypatch.finalize()
assert not hasattr(A, 'y')
def test_setitem():
d = {'x': 1}
monkeypatch = MonkeyPatch()
monkeypatch.setitem(d, 'x', 2)
monkeypatch.setitem(d, 'y', 1700)
assert d['x'] == 2
assert d['y'] == 1700
monkeypatch.setitem(d, 'x', 3)
assert d['x'] == 3
monkeypatch.finalize()
assert d['x'] == 1
assert 'y' not in d
def test_monkeypatch_plugin(testdir):
sorter = testdir.inline_runsource("""
pytest_plugins = 'pytest_monkeypatch',
def test_method(monkeypatch):
assert monkeypatch.__class__.__name__ == "MonkeyPatch"
""")
res = sorter.countoutcomes()
assert tuple(res) == (1, 0, 0), res
I can also imagine some nice plugin which supports mock objects – patching methods with some preset behaviour or tracing calls between components.
have fun, holger
Today I went live with shifting pytest development to be more community driven. During a discussion at FOSDEM 2015 a significant subset of pytest contributors decided to create two organisations at github and bitbucket and shift core pytest and several plugins to them, on the initial suggestion of Anatoly Bubenkoff. See the new pytest contribution page for details. The teams currently have a dozen members and we are looking forward to integrate more contributors which all get full access and commit rights to all repositories, can push to the website and release to pypi.
metaprogramming and politics 