In a previous post on unit testing I described the motivation behind our recent move to pytest as a unit testing framework and the experiences we made in the early phase of the migration. Here, I want to highlight a more advanced issue we encountered during the arduous work of porting our domain model unit tests to the new pytest
based framework: The issue of testing complex, hierarchical data structures.
The @pytest.parametrized decorator is very useful for setting up simple test objects on the fly, but since the decorator is called at module load time, you may not be able to create complex test objects with it. Also, the syntax is fairly cumbersome to read with more complex object initializations.
To illustrate the problem, consider the following simple test class diagram [1]:
Suppose we want to perform tests on MyEntity instances. Suppose further that we need also properly initialized MyEntityParent, MyEntityChild and MyEntityGrandchild instances attached to our test object. The standard way to achieve this would be a pytest fixture looking like this:
|
1 2 3 4 5 6 7 8 9 10 |
@pytest.fixture def entity(): my_entity_parent = MyEntityParent(id=0) my_entity_grandchild = MyEntityGrandchild(id=0) my_entity_child = MyEntityChild(id=0, children=[my_entity_grandchild]) my_entity = MyEntity(id=0, parent=my_entity_parent, children=[my_entity_child]) return my_entity |
However, if we now needed a differently configured MyEntity instance – say, with two MyEntityChild instances or a different id, we would end up with a lot of code duplication.
After some time playing around with various ideas on how to make the generation of complex test object trees more flexible, I had the idea to simply add one layer of indirection by defining test object factory fixtures for the individual test object classes like this:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 |
class TestObjectFactory(object): def __init__(self, entity_generator_func, args=None, kw=None): self.__entity_generator_func = entity_generator_func if args is None: args = () self.__init_args = args if kw is None: kw = {} self.__init_kw = kw self.__instances = {} def __call__(self, *args, **kw): _args = args + self.__init_args[len(args):] _kw = self.__init_kw.copy() _kw.update(kw) key = tuple(chain((id(arg) for arg in _args), ((k, id(v)) for (k, v) in sorted(_kw.items())))) try: obj = self.__instances[key] except KeyError: obj = self.__entity_generator_func(*_args, **_kw) self.__instances[key] = obj return obj @pytest.fixture def test_object_fac(): return TestObjectFactory @pytest.fixture def my_entity_parent_fac(test_object_fac): kw = dict(id=0, ) return test_object_fac(MyEntityParent, kw=kw) @pytest.fixture def my_entity_grandchild_fac(test_object_fac): kw = dict(id=0, ) return test_object_fac(MyEntityGrandchild, kw=kw) @pytest.fixture def my_entity_child_fac(test_object_fac, my_entity_grandchild_fac): kw = dict(id=0, children=[my_entity_grandchild_fac()]) return test_object_fac(MyEntityChild, kw=kw) @pytest.fixture def my_entity_fac(test_object_fac, my_entity_parent_fac, my_entity_child_fac): kw = dict(id=0, parent=my_entity_parent_fac(), children=[my_entity_child_fac()]) return test_object_fac(MyEntity, kw=kw) |
When used as a fixture parameter in a test function (or another fixture), calling these factories with no arguments always returns an instance fully initialized with the default arguments defined by the factory fixture:
|
1 2 3 4 5 6 |
class TestMyEntity: def test_init(self, my_entity_fac): ent = my_entity_fac() assert ent.id == 0 assert ent.parent.id == 0 assert ent.children[0].children[0].id == 0 |
Very convenient. However, it is also straightforward to create customized test object fixtures using these factories:
|
1 2 3 4 5 6 7 8 9 10 |
import pytest @pytest.fixture def my_entity_2_children(my_entity_fac, my_entity_child_fac): return my_entity_fac(children=[my_entity_child_fac(id=0), my_entity_child_fac(id=1)]) class TestMyEntity(object): def test_init(self, my_entity_2_children): assert len(my_entity_2_children.children) == 2 |
There is one thing to keep in mind here: The default behavior of the test object factories is to create only one instance for each unique combination of positional and keyword arguments. So, in the example above, since the children attribute was not customized in the calls to the my_entity_child_fac factory, both MyEntityChild instances created end up with the exact same MyEntityGrandchild instance in their children list. If you absolutely need new instances, you can either pass unique arguments to the factory or call its new method.
On another, perhaps slightly esoteric, side note I want to point out that the code above has the unnerving effect of immediately generating a pylint warning in line 10, code number W0621, informing you that a name from the outer scope in line 4 was just redefined. Getting rid of this warning without disabling it manually or moving the test fixture into a separate conftest module turned out to be not all that easy; I eventually resorted to the following way of declaring my fixtures at the top of my test modules:
|
1 2 3 4 |
class Fixtures: my_entity_2_children = lambda my_entity_fac, my_entity_child_fac: \ my_entity_fac(children=[my_entity_child_fac(id=0), my_entity_child_fac(id=1)]) |
and use one of the ingenious pytest hooks to pre-process the module at test collection time (this needs to go somewhere pytest can see it, e.g. in a conftest module in the test package):
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
import pytest def pytest_pycollect_makemodule(path, parent): mod = path.pyimport() fixtures = getattr(mod, 'Fixtures', None) if not fixtures is None: fixtures = [item for item in fixtures.__dict__.items() if (callable(item[1]) and not item[0].startswith('_'))] for (fx_name, func) in fixtures: fxt = pytest.fixture(scope='function')(func) setattr(mod, fx_name, fxt) return pytest.Module(path, parent) |
Again, I am happy to report that pytest gives me all the tools needed to cope with our sometimes complex testing scenarios and that I do not regret our decision to migrate to pytest at all.