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 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187
|
# -*- coding: utf-8 -*-
import copy
import sys
import types
from collections import defaultdict
import pytest
PY3 = sys.version_info[0] == 3
string_type = str if PY3 else basestring
def pytest_configure():
pytest.lazy_fixture = lazy_fixture
@pytest.hookimpl(tryfirst=True)
def pytest_runtest_setup(item):
if hasattr(item, '_request'):
item._request._fillfixtures = types.MethodType(
fillfixtures(item._request._fillfixtures), item._request
)
def fillfixtures(_fillfixtures):
def fill(request):
item = request._pyfuncitem
fixturenames = item.fixturenames
autousenames = item.session._fixturemanager._getautousenames(item.nodeid)
for fname in fixturenames:
if fname not in item.funcargs and fname in autousenames:
item.funcargs[fname] = request.getfixturevalue(fname)
if hasattr(item, 'callspec'):
for param, val in sorted_by_dependency(item.callspec.params, fixturenames):
if is_lazy_fixture(val):
item.callspec.params[param] = request.getfixturevalue(val.name)
_fillfixtures()
return fill
@pytest.hookimpl(tryfirst=True)
def pytest_fixture_setup(fixturedef, request):
val = getattr(request, 'param', None)
if is_lazy_fixture(val):
request.param = request.getfixturevalue(val.name)
def pytest_runtest_call(item):
if hasattr(item, 'funcargs'):
for arg, val in item.funcargs.items():
if is_lazy_fixture(val):
item.funcargs[arg] = item._request.getfixturevalue(val.name)
@pytest.hookimpl(hookwrapper=True)
def pytest_pycollect_makeitem(collector, name, obj):
global current_node
current_node = collector
yield
current_node = None
@pytest.hookimpl(hookwrapper=True)
def pytest_generate_tests(metafunc):
yield
normalize_metafunc_calls(metafunc, 'funcargs')
normalize_metafunc_calls(metafunc, 'params')
def normalize_metafunc_calls(metafunc, valtype, used_keys=None):
newcalls = []
for callspec in metafunc._calls:
calls = normalize_call(callspec, metafunc, valtype, used_keys)
newcalls.extend(calls)
metafunc._calls = newcalls
def copy_metafunc(metafunc):
copied = copy.copy(metafunc)
copied.fixturenames = copy.copy(metafunc.fixturenames)
copied._calls = []
copied._ids = copy.copy(metafunc._ids)
copied._arg2fixturedefs = copy.copy(metafunc._arg2fixturedefs)
return copied
def normalize_call(callspec, metafunc, valtype, used_keys):
fm = metafunc.config.pluginmanager.get_plugin('funcmanage')
used_keys = used_keys or set()
valtype_keys = set(getattr(callspec, valtype).keys()) - used_keys
for arg in valtype_keys:
val = getattr(callspec, valtype)[arg]
if is_lazy_fixture(val):
try:
_, fixturenames_closure, arg2fixturedefs = fm.getfixtureclosure([val.name], metafunc.definition.parent)
except ValueError:
# 3.6.0 <= pytest < 3.7.0; `FixtureManager.getfixtureclosure` returns 2 values
fixturenames_closure, arg2fixturedefs = fm.getfixtureclosure([val.name], metafunc.definition.parent)
except AttributeError:
# pytest < 3.6.0; `Metafunc` has no `definition` attribute
fixturenames_closure, arg2fixturedefs = fm.getfixtureclosure([val.name], current_node)
extra_fixturenames = [fname for fname in fixturenames_closure
if fname not in callspec.params and fname not in callspec.funcargs]
newmetafunc = copy_metafunc(metafunc)
newmetafunc.fixturenames = extra_fixturenames
newmetafunc._arg2fixturedefs.update(arg2fixturedefs)
newmetafunc._calls = [callspec]
fm.pytest_generate_tests(newmetafunc)
normalize_metafunc_calls(newmetafunc, valtype, used_keys | set([arg]))
return newmetafunc._calls
used_keys.add(arg)
return [callspec]
def sorted_by_dependency(params, fixturenames):
free_fm = []
non_free_fm = defaultdict(list)
for key in _sorted_argnames(params, fixturenames):
val = params[key]
if not is_lazy_fixture(val) or val.name not in params:
free_fm.append(key)
else:
non_free_fm[val.name].append(key)
non_free_fm_list = []
for free_key in free_fm:
non_free_fm_list.extend(
_tree_to_list(non_free_fm, free_key)
)
return [(key, params[key]) for key in (free_fm + non_free_fm_list)]
def _sorted_argnames(params, fixturenames):
argnames = set(params.keys())
for name in fixturenames:
if name in argnames:
argnames.remove(name)
yield name
if argnames:
for name in argnames:
yield name
def _tree_to_list(trees, leave):
lst = []
for l in trees[leave]:
lst.append(l)
lst.extend(
_tree_to_list(trees, l)
)
return lst
def lazy_fixture(names):
if isinstance(names, string_type):
return LazyFixture(names)
else:
return [LazyFixture(name) for name in names]
def is_lazy_fixture(val):
return isinstance(val, LazyFixture)
class LazyFixture(object):
def __init__(self, name):
self.name = name
def __repr__(self):
return '<{} "{}">'.format(self.__class__.__name__, self.name)
def __eq__(self, other):
return self.name == other.name
|