p53209761
/
test_ok2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix linting E741: ambiguous variable name

This commit is contained in:
Bruno Oliveira 2017-11-04 13:17:20 -02:00
parent 2e2f72156a
commit 03829fde8a
34 changed files with 457 additions and 459 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
_pytest/_code/code.py
View File

@ -338,16 +338,16 @@ class Traceback(list):
# XXX needs a test
key = entry.frame.code.path, id(entry.frame.code.raw), entry.lineno
# print "checking for recursion at", key
l = cache.setdefault(key, [])
if l:
values = cache.setdefault(key, [])
if values:
f = entry.frame
loc = f.f_locals
for otherloc in l:
for otherloc in values:
if f.is_true(f.eval(co_equal,
__recursioncache_locals_1=loc,
__recursioncache_locals_2=otherloc)):
return i
l.append(entry.frame.f_locals)
values.append(entry.frame.f_locals)
return None

16
_pytest/_code/source.py
View File

@ -319,22 +319,22 @@ def get_statement_startend2(lineno, node):
import ast
# flatten all statements and except handlers into one lineno-list
# AST's line numbers start indexing at 1
l = []
values = []
for x in ast.walk(node):
if isinstance(x, _ast.stmt) or isinstance(x, _ast.ExceptHandler):
l.append(x.lineno - 1)
values.append(x.lineno - 1)
for name in "finalbody", "orelse":
val = getattr(x, name, None)
if val:
# treat the finally/orelse part as its own statement
l.append(val[0].lineno - 1 - 1)
l.sort()
insert_index = bisect_right(l, lineno)
start = l[insert_index - 1]
if insert_index >= len(l):
values.append(val[0].lineno - 1 - 1)
values.sort()
insert_index = bisect_right(values, lineno)
start = values[insert_index - 1]
if insert_index >= len(values):
end = None
else:
end = l[insert_index]
end = values[insert_index]
return start, end

8
_pytest/assertion/util.py
View File

@ -53,11 +53,11 @@ def _split_explanation(explanation):
"""
raw_lines = (explanation or u('')).split('\n')
lines = [raw_lines[0]]
for l in raw_lines[1:]:
if l and l[0] in ['{', '}', '~', '>']:
lines.append(l)
for values in raw_lines[1:]:
if values and values[0] in ['{', '}', '~', '>']:
lines.append(values)
else:
lines[-1] += '\\n' + l
lines[-1] += '\\n' + values
return lines

12
_pytest/config.py
View File

@ -1170,10 +1170,10 @@ class Config(object):
return []
if type == "pathlist":
dp = py.path.local(self.inicfg.config.path).dirpath()
l = []
values = []
for relpath in shlex.split(value):
l.append(dp.join(relpath, abs=True))
return l
values.append(dp.join(relpath, abs=True))
return values
elif type == "args":
return shlex.split(value)
elif type == "linelist":
@ -1190,13 +1190,13 @@ class Config(object):
except KeyError:
return None
modpath = py.path.local(mod.__file__).dirpath()
l = []
values = []
for relroot in relroots:
if not isinstance(relroot, py.path.local):
relroot = relroot.replace("/", py.path.local.sep)
relroot = modpath.join(relroot, abs=True)
l.append(relroot)
return l
values.append(relroot)
return values
def _get_override_ini_value(self, name):
value = None

8
_pytest/fixtures.py
View File

@ -460,13 +460,13 @@ class FixtureRequest(FuncargnamesCompatAttr):
def _get_fixturestack(self):
current = self
l = []
values = []
while 1:
fixturedef = getattr(current, "_fixturedef", None)
if fixturedef is None:
l.reverse()
return l
l.append(fixturedef)
values.reverse()
return values
values.append(fixturedef)
current = current._parent_request
def _getfixturevalue(self, fixturedef):

4
_pytest/mark.py
View File

@ -270,12 +270,12 @@ class MarkGenerator:
return
except AttributeError:
pass
self._markers = l = set()
self._markers = values = set()
for line in self._config.getini("markers"):
marker, _ = line.split(":", 1)
marker = marker.rstrip()
x = marker.split("(", 1)[0]
l.add(x)
values.add(x)
if name not in self._markers:
raise AttributeError("%r not a registered marker" % (name,))

28
_pytest/pytester.py
View File

@ -182,9 +182,9 @@ class PytestArg:
return hookrecorder
def get_public_names(l):
"""Only return names from iterator l without a leading underscore."""
return [x for x in l if x[0] != "_"]
def get_public_names(values):
"""Only return names from iterator values without a leading underscore."""
return [x for x in values if x[0] != "_"]
class ParsedCall:
@ -258,9 +258,9 @@ class HookRecorder:
pytest.fail("\n".join(lines))
def getcall(self, name):
l = self.getcalls(name)
assert len(l) == 1, (name, l)
return l[0]
values = self.getcalls(name)
assert len(values) == 1, (name, values)
return values[0]
# functionality for test reports
@ -271,7 +271,7 @@ class HookRecorder:
def matchreport(self, inamepart="",
names="pytest_runtest_logreport pytest_collectreport", when=None):
""" return a testreport whose dotted import path matches """
l = []
values = []
for rep in self.getreports(names=names):
try:
if not when and rep.when != "call" and rep.passed:
@ -282,14 +282,14 @@ class HookRecorder:
if when and getattr(rep, 'when', None) != when:
continue
if not inamepart or inamepart in rep.nodeid.split("::"):
l.append(rep)
if not l:
values.append(rep)
if not values:
raise ValueError("could not find test report matching %r: "
"no test reports at all!" % (inamepart,))
if len(l) > 1:
if len(values) > 1:
raise ValueError(
"found 2 or more testreports matching %r: %s" % (inamepart, l))
return l[0]
"found 2 or more testreports matching %r: %s" % (inamepart, values))
return values[0]
def getfailures(self,
names='pytest_runtest_logreport pytest_collectreport'):
@ -673,8 +673,8 @@ class Testdir:
"""
p = self.makepyfile(source)
l = list(cmdlineargs) + [p]
return self.inline_run(*l)
values = list(cmdlineargs) + [p]
return self.inline_run(*values)
def inline_genitems(self, *args):
"""Run ``pytest.main(['--collectonly'])`` in-process.

14
_pytest/python.py
View File

@ -321,7 +321,7 @@ class PyCollector(PyobjMixin, main.Collector):
for basecls in inspect.getmro(self.obj.__class__):
dicts.append(basecls.__dict__)
seen = {}
l = []
values = []
for dic in dicts:
for name, obj in list(dic.items()):
if name in seen:
@ -332,9 +332,9 @@ class PyCollector(PyobjMixin, main.Collector):
continue
if not isinstance(res, list):
res = [res]
l.extend(res)
l.sort(key=lambda item: item.reportinfo()[:2])
return l
values.extend(res)
values.sort(key=lambda item: item.reportinfo()[:2])
return values
def makeitem(self, name, obj):
# assert self.ihook.fspath == self.fspath, self
@ -592,7 +592,7 @@ class Generator(FunctionMixin, PyCollector):
self.session._setupstate.prepare(self)
# see FunctionMixin.setup and test_setupstate_is_preserved_134
self._preservedparent = self.parent.obj
l = []
values = []
seen = {}
for i, x in enumerate(self.obj()):
name, call, args = self.getcallargs(x)
@ -605,9 +605,9 @@ class Generator(FunctionMixin, PyCollector):
if name in seen:
raise ValueError("%r generated tests with non-unique name %r" % (self, name))
seen[name] = True
l.append(self.Function(name, self, args=args, callobj=call))
values.append(self.Function(name, self, args=args, callobj=call))
self.warn('C1', deprecated.YIELD_TESTS)
return l
return values
def getcallargs(self, obj):
if not isinstance(obj, (tuple, list)):

6
_pytest/skipping.py
View File

@ -346,10 +346,10 @@ def folded_skips(skipped):
key = event.longrepr
assert len(key) == 3, (event, key)
d.setdefault(key, []).append(event)
l = []
values = []
for key, events in d.items():
l.append((len(events),) + key)
return l
values.append((len(events),) + key)
return values
def show_skipped(terminalreporter, lines):

24
_pytest/terminal.py
View File

@ -445,9 +445,9 @@ class TerminalReporter:
line = self.config.cwd_relative_nodeid(nodeid)
if domain and line.endswith(domain):
line = line[:-len(domain)]
l = domain.split("[")
l[0] = l[0].replace('.', '::') # don't replace '.' in params
line += "[".join(l)
values = domain.split("[")
values[0] = values[0].replace('.', '::') # don't replace '.' in params
line += "[".join(values)
return line
# collect_fspath comes from testid which has a "/"-normalized path
@ -479,11 +479,11 @@ class TerminalReporter:
# summaries for sessionfinish
#
def getreports(self, name):
l = []
values = []
for x in self.stats.get(name, []):
if not hasattr(x, '_pdbshown'):
l.append(x)
return l
values.append(x)
return values
def summary_warnings(self):
if self.hasopt("w"):
@ -594,8 +594,8 @@ def repr_pythonversion(v=None):
return str(v)
def flatten(l):
for x in l:
def flatten(values):
for x in values:
if isinstance(x, (list, tuple)):
for y in flatten(x):
yield y
@ -636,7 +636,7 @@ def build_summary_stats_line(stats):
def _plugin_nameversions(plugininfo):
l = []
values = []
for plugin, dist in plugininfo:
# gets us name and version!
name = '{dist.project_name}-{dist.version}'.format(dist=dist)
@ -645,6 +645,6 @@ def _plugin_nameversions(plugininfo):
name = name[7:]
# we decided to print python package names
# they can have more than one plugin
if name not in l:
l.append(name)
return l
if name not in values:
values.append(name)
return values

8
_pytest/unittest.py
View File

@ -109,10 +109,10 @@ class TestCaseFunction(Function):
except TypeError:
try:
try:
l = traceback.format_exception(*rawexcinfo)
l.insert(0, "NOTE: Incompatible Exception Representation, "
"displaying natively:\n\n")
fail("".join(l), pytrace=False)
values = traceback.format_exception(*rawexcinfo)
values.insert(0, "NOTE: Incompatible Exception Representation, "
"displaying natively:\n\n")
fail("".join(values), pytrace=False)
except (fail.Exception, KeyboardInterrupt):
raise
except:

4
testing/code/test_excinfo.py
View File

@ -77,8 +77,8 @@ def test_excinfo_getstatement():
linenumbers = [_pytest._code.getrawcode(f).co_firstlineno - 1 + 4,
_pytest._code.getrawcode(f).co_firstlineno - 1 + 1,
_pytest._code.getrawcode(g).co_firstlineno - 1 + 1, ]
l = list(excinfo.traceback)
foundlinenumbers = [x.lineno for x in l]
values = list(excinfo.traceback)
foundlinenumbers = [x.lineno for x in values]
assert foundlinenumbers == linenumbers
# for x in info:
# print "%s:%d %s" %(x.path.relto(root), x.lineno, x.statement)

8
testing/code/test_source.py
View File

@ -155,8 +155,8 @@ class TestAccesses(object):
assert len(self.source) == 4
def test_iter(self):
l = [x for x in self.source]
assert len(l) == 4
values = [x for x in self.source]
assert len(values) == 4
class TestSourceParsingAndCompiling(object):
@ -331,8 +331,8 @@ def test_getstartingblock_singleline():
x = A('x', 'y')
l = [i for i in x.source.lines if i.strip()]
assert len(l) == 1
values = [i for i in x.source.lines if i.strip()]
assert len(values) == 1
def test_getline_finally():

4
testing/code/test_source_multiline_block.py
View File

@ -22,5 +22,5 @@ def test_getstartingblock_multiline():
,
'z')
l = [i for i in x.source.lines if i.strip()]
assert len(l) == 4
values = [i for i in x.source.lines if i.strip()]
assert len(values) == 4

8
testing/python/collect.py
View File

@ -873,11 +873,11 @@ class TestConftestCustomization(object):
def test_makeitem_non_underscore(self, testdir, monkeypatch):
modcol = testdir.getmodulecol("def _hello(): pass")
l = []
values = []
monkeypatch.setattr(pytest.Module, 'makeitem',
lambda self, name, obj: l.append(name))
l = modcol.collect()
assert '_hello' not in l
lambda self, name, obj: values.append(name))
values = modcol.collect()
assert '_hello' not in values
def test_issue2369_collect_module_fileext(self, testdir):
"""Ensure we can collect files with weird file extensions as Python

402
testing/python/fixture.py
View File

@ -548,12 +548,12 @@ class TestRequestBasic(object):
def test_getfixturevalue(self, testdir, getfixmethod):
item = testdir.getitem("""
import pytest
l = [2]
values = [2]
@pytest.fixture
def something(request): return 1
@pytest.fixture
def other(request):
return l.pop()
return values.pop()
def test_func(something): pass
""")
import contextlib
@ -622,15 +622,15 @@ class TestRequestBasic(object):
def test_request_addfinalizer_failing_setup(self, testdir):
testdir.makepyfile("""
import pytest
l = [1]
values = [1]
@pytest.fixture
def myfix(request):
request.addfinalizer(l.pop)
request.addfinalizer(values.pop)
assert 0
def test_fix(myfix):
pass
def test_finalizer_ran():
assert not l
assert not values
""")
reprec = testdir.inline_run("-s")
reprec.assertoutcome(failed=1, passed=1)
@ -638,30 +638,30 @@ class TestRequestBasic(object):
def test_request_addfinalizer_failing_setup_module(self, testdir):
testdir.makepyfile("""
import pytest
l = [1, 2]
values = [1, 2]
@pytest.fixture(scope="module")
def myfix(request):
request.addfinalizer(l.pop)
request.addfinalizer(l.pop)
request.addfinalizer(values.pop)
request.addfinalizer(values.pop)
assert 0
def test_fix(myfix):
pass
""")
reprec = testdir.inline_run("-s")
mod = reprec.getcalls("pytest_runtest_setup")[0].item.module
assert not mod.l
assert not mod.values
def test_request_addfinalizer_partial_setup_failure(self, testdir):
p = testdir.makepyfile("""
import pytest
l = []
values = []
@pytest.fixture
def something(request):
request.addfinalizer(lambda: l.append(None))
request.addfinalizer(lambda: values.append(None))
def test_func(something, missingarg):
pass
def test_second():
assert len(l) == 1
assert len(values) == 1
""")
result = testdir.runpytest(p)
result.stdout.fnmatch_lines([
@ -675,7 +675,7 @@ class TestRequestBasic(object):
"""
testdir.makepyfile("""
import pytest
l = []
values = []
def _excepts(where):
raise Exception('Error in %s fixture' % where)
@pytest.fixture
@ -683,17 +683,17 @@ class TestRequestBasic(object):
return request
@pytest.fixture
def something(subrequest):
subrequest.addfinalizer(lambda: l.append(1))
subrequest.addfinalizer(lambda: l.append(2))
subrequest.addfinalizer(lambda: values.append(1))
subrequest.addfinalizer(lambda: values.append(2))
subrequest.addfinalizer(lambda: _excepts('something'))
@pytest.fixture
def excepts(subrequest):
subrequest.addfinalizer(lambda: _excepts('excepts'))
subrequest.addfinalizer(lambda: l.append(3))
subrequest.addfinalizer(lambda: values.append(3))
def test_first(something, excepts):
pass
def test_second():
assert l == [3, 2, 1]
assert values == [3, 2, 1]
""")
result = testdir.runpytest()
result.stdout.fnmatch_lines([
@ -748,13 +748,13 @@ class TestRequestBasic(object):
def test_setupdecorator_and_xunit(self, testdir):
testdir.makepyfile("""
import pytest
l = []
values = []
@pytest.fixture(scope='module', autouse=True)
def setup_module():
l.append("module")
values.append("module")
@pytest.fixture(autouse=True)
def setup_function():
l.append("function")
values.append("function")
def test_func():
pass
@ -762,14 +762,14 @@ class TestRequestBasic(object):
class TestClass(object):
@pytest.fixture(scope="class", autouse=True)
def setup_class(self):
l.append("class")
values.append("class")
@pytest.fixture(autouse=True)
def setup_method(self):
l.append("method")
values.append("method")
def test_method(self):
pass
def test_all():
assert l == ["module", "function", "class",
assert values == ["module", "function", "class",
"function", "method", "function"]
""")
reprec = testdir.inline_run("-v")
@ -930,10 +930,10 @@ class TestRequestCachedSetup(object):
def test_request_cachedsetup_extrakey(self, testdir):
item1 = testdir.getitem("def test_func(): pass")
req1 = fixtures.FixtureRequest(item1)
l = ["hello", "world"]
values = ["hello", "world"]
def setup():
return l.pop()
return values.pop()
ret1 = req1.cached_setup(setup, extrakey=1)
ret2 = req1.cached_setup(setup, extrakey=2)
@ -947,24 +947,24 @@ class TestRequestCachedSetup(object):
def test_request_cachedsetup_cache_deletion(self, testdir):
item1 = testdir.getitem("def test_func(): pass")
req1 = fixtures.FixtureRequest(item1)
l = []
values = []
def setup():
l.append("setup")
values.append("setup")
def teardown(val):
l.append("teardown")
values.append("teardown")
req1.cached_setup(setup, teardown, scope="function")
assert l == ['setup']
assert values == ['setup']
# artificial call of finalizer
setupstate = req1._pyfuncitem.session._setupstate
setupstate._callfinalizers(item1)
assert l == ["setup", "teardown"]
assert values == ["setup", "teardown"]
req1.cached_setup(setup, teardown, scope="function")
assert l == ["setup", "teardown", "setup"]
assert values == ["setup", "teardown", "setup"]
setupstate._callfinalizers(item1)
assert l == ["setup", "teardown", "setup", "teardown"]
assert values == ["setup", "teardown", "setup", "teardown"]
def test_request_cached_setup_two_args(self, testdir):
testdir.makepyfile("""
@ -1006,17 +1006,17 @@ class TestRequestCachedSetup(object):
def test_request_cached_setup_functional(self, testdir):
testdir.makepyfile(test_0="""
import pytest
l = []
values = []
@pytest.fixture
def something(request):
val = request.cached_setup(fsetup, fteardown)
return val
def fsetup(mycache=[1]):
l.append(mycache.pop())
return l
values.append(mycache.pop())
return values
def fteardown(something):
l.remove(something[0])
l.append(2)
values.remove(something[0])
values.append(2)
def test_list_once(something):
assert something == [1]
def test_list_twice(something):
@ -1025,7 +1025,7 @@ class TestRequestCachedSetup(object):
testdir.makepyfile(test_1="""
import test_0 # should have run already
def test_check_test0_has_teardown_correct():
assert test_0.l == [2]
assert test_0.values == [2]
""")
result = testdir.runpytest("-v")
result.stdout.fnmatch_lines([
@ -1150,10 +1150,10 @@ class TestFixtureUsages(object):
def test_funcarg_parametrized_and_used_twice(self, testdir):
testdir.makepyfile("""
import pytest
l = []
values = []
@pytest.fixture(params=[1,2])
def arg1(request):
l.append(1)
values.append(1)
return request.param
@pytest.fixture()
@ -1162,7 +1162,7 @@ class TestFixtureUsages(object):
def test_add(arg1, arg2):
assert arg2 == arg1 + 1
assert len(l) == arg1
assert len(values) == arg1
""")
result = testdir.runpytest()
result.stdout.fnmatch_lines([
@ -1203,8 +1203,8 @@ class TestFixtureUsages(object):
""")
reprec = testdir.inline_run()
l = reprec.getfailedcollections()
assert len(l) == 1
values = reprec.getfailedcollections()
assert len(values) == 1
def test_request_can_be_overridden(self, testdir):
testdir.makepyfile("""
@ -1223,20 +1223,20 @@ class TestFixtureUsages(object):
testdir.makepyfile("""
import pytest
l = []
values = []
@pytest.fixture(scope="class")
def myfix(request):
request.cls.hello = "world"
l.append(1)
values.append(1)
class TestClass(object):
def test_one(self):
assert self.hello == "world"
assert len(l) == 1
assert len(values) == 1
def test_two(self):
assert self.hello == "world"
assert len(l) == 1
assert len(values) == 1
pytest.mark.usefixtures("myfix")(TestClass)
""")
reprec = testdir.inline_run()
@ -1290,7 +1290,7 @@ class TestFixtureUsages(object):
testdir.makepyfile("""
import pytest
l = []
values = []
def f():
yield 1
yield 2
@ -1304,14 +1304,14 @@ class TestFixtureUsages(object):
return request.param
def test_1(arg):
l.append(arg)
values.append(arg)
def test_2(arg2):
l.append(arg2*10)
values.append(arg2*10)
""")
reprec = testdir.inline_run("-v")
reprec.assertoutcome(passed=4)
l = reprec.getcalls("pytest_runtest_call")[0].item.module.l
assert l == [1, 2, 10, 20]
values = reprec.getcalls("pytest_runtest_call")[0].item.module.values
assert values == [1, 2, 10, 20]
class TestFixtureManagerParseFactories(object):
@ -1461,19 +1461,19 @@ class TestAutouseDiscovery(object):
testdir.makepyfile("""
import pytest
class TestA(object):
l = []
values = []
@pytest.fixture(autouse=True)
def setup1(self):
self.l.append(1)
self.values.append(1)
def test_setup1(self):
assert self.l == [1]
assert self.values == [1]
class TestB(object):
l = []
values = []
@pytest.fixture(autouse=True)
def setup2(self):
self.l.append(1)
self.values.append(1)
def test_setup2(self):
assert self.l == [1]
assert self.values == [1]
""")
reprec = testdir.inline_run()
reprec.assertoutcome(passed=2)
@ -1556,22 +1556,22 @@ class TestAutouseDiscovery(object):
def test_autouse_in_module_and_two_classes(self, testdir):
testdir.makepyfile("""
import pytest
l = []
values = []
@pytest.fixture(autouse=True)
def append1():
l.append("module")
values.append("module")
def test_x():
assert l == ["module"]
assert values == ["module"]
class TestA(object):
@pytest.fixture(autouse=True)
def append2(self):
l.append("A")
values.append("A")
def test_hello(self):
assert l == ["module", "module", "A"], l
assert values == ["module", "module", "A"], values
class TestA2(object):
def test_world(self):
assert l == ["module", "module", "A", "module"], l
assert values == ["module", "module", "A", "module"], values
""")
reprec = testdir.inline_run()
reprec.assertoutcome(passed=3)
@ -1615,23 +1615,23 @@ class TestAutouseManagement(object):
def test_funcarg_and_setup(self, testdir):
testdir.makepyfile("""
import pytest
l = []
values = []
@pytest.fixture(scope="module")
def arg():
l.append(1)
values.append(1)
return 0
@pytest.fixture(scope="module", autouse=True)
def something(arg):
l.append(2)
values.append(2)
def test_hello(arg):
assert len(l) == 2
assert l == [1,2]
assert len(values) == 2
assert values == [1,2]
assert arg == 0
def test_hello2(arg):
assert len(l) == 2
assert l == [1,2]
assert len(values) == 2
assert values == [1,2]
assert arg == 0
""")
reprec = testdir.inline_run()
@ -1640,20 +1640,20 @@ class TestAutouseManagement(object):
def test_uses_parametrized_resource(self, testdir):
testdir.makepyfile("""
import pytest
l = []
values = []
@pytest.fixture(params=[1,2])
def arg(request):
return request.param
@pytest.fixture(autouse=True)
def something(arg):
l.append(arg)
values.append(arg)
def test_hello():
if len(l) == 1:
assert l == [1]
elif len(l) == 2:
assert l == [1, 2]
if len(values) == 1:
assert values == [1]
elif len(values) == 2:
assert values == [1, 2]
else:
0/0
@ -1665,7 +1665,7 @@ class TestAutouseManagement(object):
testdir.makepyfile("""
import pytest
l = []
values = []
@pytest.fixture(scope="session", params=[1,2])
def arg(request):
@ -1674,14 +1674,14 @@ class TestAutouseManagement(object):
@pytest.fixture(scope="function", autouse=True)
def append(request, arg):
if request.function.__name__ == "test_some":
l.append(arg)
values.append(arg)
def test_some():
pass
def test_result(arg):
assert len(l) == arg
assert l[:arg] == [1,2][:arg]
assert len(values) == arg
assert values[:arg] == [1,2][:arg]
""")
reprec = testdir.inline_run("-v", "-s")
reprec.assertoutcome(passed=4)
@ -1691,7 +1691,7 @@ class TestAutouseManagement(object):
import pytest
import pprint
l = []
values = []
@pytest.fixture(scope="function", params=[1,2])
def farg(request):
@ -1704,7 +1704,7 @@ class TestAutouseManagement(object):
@pytest.fixture(scope="function", autouse=True)
def append(request, farg, carg):
def fin():
l.append("fin_%s%s" % (carg, farg))
values.append("fin_%s%s" % (carg, farg))
request.addfinalizer(fin)
""")
testdir.makepyfile("""
@ -1721,26 +1721,26 @@ class TestAutouseManagement(object):
reprec = testdir.inline_run("-v", "-s", confcut)
reprec.assertoutcome(passed=8)
config = reprec.getcalls("pytest_unconfigure")[0].config
l = config.pluginmanager._getconftestmodules(p)[0].l
assert l == ["fin_a1", "fin_a2", "fin_b1", "fin_b2"] * 2
values = config.pluginmanager._getconftestmodules(p)[0].values
assert values == ["fin_a1", "fin_a2", "fin_b1", "fin_b2"] * 2
def test_scope_ordering(self, testdir):
testdir.makepyfile("""
import pytest
l = []
values = []
@pytest.fixture(scope="function", autouse=True)
def fappend2():
l.append(2)
values.append(2)
@pytest.fixture(scope="class", autouse=True)
def classappend3():
l.append(3)
values.append(3)
@pytest.fixture(scope="module", autouse=True)
def mappend():
l.append(1)
values.append(1)
class TestHallo(object):
def test_method(self):
assert l == [1,3,2]
assert values == [1,3,2]
""")
reprec = testdir.inline_run()
reprec.assertoutcome(passed=1)
@ -1748,23 +1748,23 @@ class TestAutouseManagement(object):
def test_parametrization_setup_teardown_ordering(self, testdir):
testdir.makepyfile("""
import pytest
l = []
values = []
def pytest_generate_tests(metafunc):
if metafunc.cls is not None:
metafunc.parametrize("item", [1,2], scope="class")
class TestClass(object):
@pytest.fixture(scope="class", autouse=True)
def addteardown(self, item, request):
l.append("setup-%d" % item)
request.addfinalizer(lambda: l.append("teardown-%d" % item))
values.append("setup-%d" % item)
request.addfinalizer(lambda: values.append("teardown-%d" % item))
def test_step1(self, item):
l.append("step1-%d" % item)
values.append("step1-%d" % item)
def test_step2(self, item):
l.append("step2-%d" % item)
values.append("step2-%d" % item)
def test_finish():
print (l)
assert l == ["setup-1", "step1-1", "step2-1", "teardown-1",
print (values)
assert values == ["setup-1", "step1-1", "step2-1", "teardown-1",
"setup-2", "step1-2", "step2-2", "teardown-2",]
""")
reprec = testdir.inline_run()
@ -1774,15 +1774,15 @@ class TestAutouseManagement(object):
testdir.makepyfile("""
import pytest
l = []
values = []
@pytest.fixture(autouse=True)
def fix1():
l.append(1)
values.append(1)
@pytest.fixture()
def arg1():
l.append(2)
values.append(2)
def test_hello(arg1):
assert l == [1,2]
assert values == [1,2]
""")
reprec = testdir.inline_run()
reprec.assertoutcome(passed=1)
@ -1793,20 +1793,20 @@ class TestAutouseManagement(object):
def test_ordering_dependencies_torndown_first(self, testdir, param1, param2):
testdir.makepyfile("""
import pytest
l = []
values = []
@pytest.fixture(%(param1)s)
def arg1(request):
request.addfinalizer(lambda: l.append("fin1"))
l.append("new1")
request.addfinalizer(lambda: values.append("fin1"))
values.append("new1")
@pytest.fixture(%(param2)s)
def arg2(request, arg1):
request.addfinalizer(lambda: l.append("fin2"))
l.append("new2")
request.addfinalizer(lambda: values.append("fin2"))
values.append("new2")
def test_arg(arg2):
pass
def test_check():
assert l == ["new1", "new2", "fin2", "fin1"]
assert values == ["new1", "new2", "fin2", "fin1"]
""" % locals())
reprec = testdir.inline_run("-s")
reprec.assertoutcome(passed=2)
@ -1819,11 +1819,11 @@ class TestFixtureMarker(object):
@pytest.fixture(params=["a", "b", "c"])
def arg(request):
return request.param
l = []
values = []
def test_param(arg):
l.append(arg)
values.append(arg)
def test_result():
assert l == list("abc")
assert values == list("abc")
""")
reprec = testdir.inline_run()
reprec.assertoutcome(passed=4)
@ -1867,21 +1867,21 @@ class TestFixtureMarker(object):
def test_scope_session(self, testdir):
testdir.makepyfile("""
import pytest
l = []
values = []
@pytest.fixture(scope="module")
def arg():
l.append(1)
values.append(1)
return 1
def test_1(arg):
assert arg == 1
def test_2(arg):
assert arg == 1
assert len(l) == 1
assert len(values) == 1
class TestClass(object):
def test3(self, arg):
assert arg == 1
assert len(l) == 1
assert len(values) == 1
""")
reprec = testdir.inline_run()
reprec.assertoutcome(passed=3)
@ -1889,10 +1889,10 @@ class TestFixtureMarker(object):
def test_scope_session_exc(self, testdir):
testdir.makepyfile("""
import pytest
l = []
values = []
@pytest.fixture(scope="session")
def fix():
l.append(1)
values.append(1)
pytest.skip('skipping')
def test_1(fix):
@ -1900,7 +1900,7 @@ class TestFixtureMarker(object):
def test_2(fix):
pass
def test_last():
assert l == [1]
assert values == [1]
""")
reprec = testdir.inline_run()
reprec.assertoutcome(skipped=2, passed=1)
@ -1908,11 +1908,11 @@ class TestFixtureMarker(object):
def test_scope_session_exc_two_fix(self, testdir):
testdir.makepyfile("""
import pytest
l = []
values = []
m = []
@pytest.fixture(scope="session")
def a():
l.append(1)
values.append(1)
pytest.skip('skipping')
@pytest.fixture(scope="session")
def b(a):
@ -1923,7 +1923,7 @@ class TestFixtureMarker(object):
def test_2(b):
pass
def test_last():
assert l == [1]
assert values == [1]
assert m == []
""")
reprec = testdir.inline_run()
@ -1961,21 +1961,21 @@ class TestFixtureMarker(object):
def test_scope_module_uses_session(self, testdir):
testdir.makepyfile("""
import pytest
l = []
values = []
@pytest.fixture(scope="module")
def arg():
l.append(1)
values.append(1)
return 1
def test_1(arg):
assert arg == 1
def test_2(arg):
assert arg == 1
assert len(l) == 1
assert len(values) == 1
class TestClass(object):
def test3(self, arg):
assert arg == 1
assert len(l) == 1
assert len(values) == 1
""")
reprec = testdir.inline_run()
reprec.assertoutcome(passed=3)
@ -2070,17 +2070,17 @@ class TestFixtureMarker(object):
@pytest.fixture(scope="module", params=["a", "b", "c"])
def arg(request):
return request.param
l = []
values = []
def test_param(arg):
l.append(arg)
values.append(arg)
""")
reprec = testdir.inline_run("-v")
reprec.assertoutcome(passed=3)
l = reprec.getcalls("pytest_runtest_call")[0].item.module.l
assert len(l) == 3
assert "a" in l
assert "b" in l
assert "c" in l
values = reprec.getcalls("pytest_runtest_call")[0].item.module.values
assert len(values) == 3
assert "a" in values
assert "b" in values
assert "c" in values
def test_scope_mismatch(self, testdir):
testdir.makeconftest("""
@ -2111,16 +2111,16 @@ class TestFixtureMarker(object):
def arg(request):
return request.param
l = []
values = []
def test_1(arg):
l.append(arg)
values.append(arg)
def test_2(arg):
l.append(arg)
values.append(arg)
""")
reprec = testdir.inline_run("-v")
reprec.assertoutcome(passed=4)
l = reprec.getcalls("pytest_runtest_call")[0].item.module.l
assert l == [1, 1, 2, 2]
values = reprec.getcalls("pytest_runtest_call")[0].item.module.values
assert values == [1, 1, 2, 2]
def test_module_parametrized_ordering(self, testdir):
testdir.makeconftest("""
@ -2172,7 +2172,7 @@ class TestFixtureMarker(object):
testdir.makeconftest("""
import pytest
l = []
values = []
@pytest.fixture(scope="function", params=[1,2])
def farg(request):
@ -2185,7 +2185,7 @@ class TestFixtureMarker(object):
@pytest.fixture(scope="function", autouse=True)
def append(request, farg, carg):
def fin():
l.append("fin_%s%s" % (carg, farg))
values.append("fin_%s%s" % (carg, farg))
request.addfinalizer(fin)
""")
testdir.makepyfile("""
@ -2223,30 +2223,30 @@ class TestFixtureMarker(object):
@pytest.fixture(scope="function", params=[1, 2])
def arg(request):
param = request.param
request.addfinalizer(lambda: l.append("fin:%s" % param))
l.append("create:%s" % param)
request.addfinalizer(lambda: values.append("fin:%s" % param))
values.append("create:%s" % param)
return request.param
@pytest.fixture(scope="module", params=["mod1", "mod2"])
def modarg(request):
param = request.param
request.addfinalizer(lambda: l.append("fin:%s" % param))
l.append("create:%s" % param)
request.addfinalizer(lambda: values.append("fin:%s" % param))
values.append("create:%s" % param)
return request.param
l = []
values = []
def test_1(arg):
l.append("test1")
values.append("test1")
def test_2(modarg):
l.append("test2")
values.append("test2")
def test_3(arg, modarg):
l.append("test3")
values.append("test3")
def test_4(modarg, arg):
l.append("test4")
values.append("test4")
""")
reprec = testdir.inline_run("-v")
reprec.assertoutcome(passed=12)
l = reprec.getcalls("pytest_runtest_call")[0].item.module.l
values = reprec.getcalls("pytest_runtest_call")[0].item.module.values
expected = [
'create:1', 'test1', 'fin:1', 'create:2', 'test1',
'fin:2', 'create:mod1', 'test2', 'create:1', 'test3',
@ -2257,8 +2257,8 @@ class TestFixtureMarker(object):
'test4', 'fin:1', 'create:2', 'test4', 'fin:2',
'fin:mod2']
import pprint
pprint.pprint(list(zip(l, expected)))
assert l == expected
pprint.pprint(list(zip(values, expected)))
assert values == expected
def test_parametrized_fixture_teardown_order(self, testdir):
testdir.makepyfile("""
@ -2267,29 +2267,29 @@ class TestFixtureMarker(object):
def param1(request):
return request.param
l = []
values = []
class TestClass(object):
@classmethod
@pytest.fixture(scope="class", autouse=True)
def setup1(self, request, param1):
l.append(1)
values.append(1)
request.addfinalizer(self.teardown1)
@classmethod
def teardown1(self):
assert l.pop() == 1
assert values.pop() == 1
@pytest.fixture(scope="class", autouse=True)
def setup2(self, request, param1):
l.append(2)
values.append(2)
request.addfinalizer(self.teardown2)
@classmethod
def teardown2(self):
assert l.pop() == 2
assert values.pop() == 2
def test(self):
pass
def test_finish():
assert not l
assert not values
""")
result = testdir.runpytest("-v")
result.stdout.fnmatch_lines("""
@ -2354,42 +2354,42 @@ class TestFixtureMarker(object):
def test_request_is_clean(self, testdir):
testdir.makepyfile("""
import pytest
l = []
values = []
@pytest.fixture(params=[1, 2])
def fix(request):
request.addfinalizer(lambda: l.append(request.param))
request.addfinalizer(lambda: values.append(request.param))
def test_fix(fix):
pass
""")
reprec = testdir.inline_run("-s")
l = reprec.getcalls("pytest_runtest_call")[0].item.module.l
assert l == [1, 2]
values = reprec.getcalls("pytest_runtest_call")[0].item.module.values
assert values == [1, 2]
def test_parametrize_separated_lifecycle(self, testdir):
testdir.makepyfile("""
import pytest
l = []
values = []
@pytest.fixture(scope="module", params=[1, 2])
def arg(request):
x = request.param
request.addfinalizer(lambda: l.append("fin%s" % x))
request.addfinalizer(lambda: values.append("fin%s" % x))
return request.param
def test_1(arg):
l.append(arg)
values.append(arg)
def test_2(arg):
l.append(arg)
values.append(arg)
""")
reprec = testdir.inline_run("-vs")
reprec.assertoutcome(passed=4)
l = reprec.getcalls("pytest_runtest_call")[0].item.module.l
values = reprec.getcalls("pytest_runtest_call")[0].item.module.values
import pprint
pprint.pprint(l)
# assert len(l) == 6
assert l[0] == l[1] == 1
assert l[2] == "fin1"
assert l[3] == l[4] == 2
assert l[5] == "fin2"
pprint.pprint(values)
# assert len(values) == 6
assert values[0] == values[1] == 1
assert values[2] == "fin1"
assert values[3] == values[4] == 2
assert values[5] == "fin2"
def test_parametrize_function_scoped_finalizers_called(self, testdir):
testdir.makepyfile("""
@ -2398,17 +2398,17 @@ class TestFixtureMarker(object):
@pytest.fixture(scope="function", params=[1, 2])
def arg(request):
x = request.param
request.addfinalizer(lambda: l.append("fin%s" % x))
request.addfinalizer(lambda: values.append("fin%s" % x))
return request.param
l = []
values = []
def test_1(arg):
l.append(arg)
values.append(arg)
def test_2(arg):
l.append(arg)
values.append(arg)
def test_3():
assert len(l) == 8
assert l == [1, "fin1", 2, "fin2", 1, "fin1", 2, "fin2"]
assert len(values) == 8
assert values == [1, "fin1", 2, "fin2", 1, "fin1", 2, "fin2"]
""")
reprec = testdir.inline_run("-v")
reprec.assertoutcome(passed=5)
@ -2418,7 +2418,7 @@ class TestFixtureMarker(object):
def test_finalizer_order_on_parametrization(self, scope, testdir):
testdir.makepyfile("""
import pytest
l = []
values = []
@pytest.fixture(scope=%(scope)r, params=["1"])
def fix1(request):
@ -2427,13 +2427,13 @@ class TestFixtureMarker(object):
@pytest.fixture(scope=%(scope)r)
def fix2(request, base):
def cleanup_fix2():
assert not l, "base should not have been finalized"
assert not values, "base should not have been finalized"
request.addfinalizer(cleanup_fix2)
@pytest.fixture(scope=%(scope)r)
def base(request, fix1):
def cleanup_base():
l.append("fin_base")
values.append("fin_base")
print ("finalizing base")
request.addfinalizer(cleanup_base)
@ -2451,29 +2451,29 @@ class TestFixtureMarker(object):
def test_class_scope_parametrization_ordering(self, testdir):
testdir.makepyfile("""
import pytest
l = []
values = []
@pytest.fixture(params=["John", "Doe"], scope="class")
def human(request):
request.addfinalizer(lambda: l.append("fin %s" % request.param))
request.addfinalizer(lambda: values.append("fin %s" % request.param))
return request.param
class TestGreetings(object):
def test_hello(self, human):
l.append("test_hello")
values.append("test_hello")
class TestMetrics(object):
def test_name(self, human):
l.append("test_name")
values.append("test_name")
def test_population(self, human):
l.append("test_population")
values.append("test_population")
""")
reprec = testdir.inline_run()
reprec.assertoutcome(passed=6)
l = reprec.getcalls("pytest_runtest_call")[0].item.module.l
assert l == ["test_hello", "fin John", "test_hello", "fin Doe",
"test_name", "test_population", "fin John",
"test_name", "test_population", "fin Doe"]
values = reprec.getcalls("pytest_runtest_call")[0].item.module.values
assert values == ["test_hello", "fin John", "test_hello", "fin Doe",
"test_name", "test_population", "fin John",
"test_name", "test_population", "fin Doe"]
def test_parametrize_setup_function(self, testdir):
testdir.makepyfile("""
@ -2485,21 +2485,21 @@ class TestFixtureMarker(object):
@pytest.fixture(scope="module", autouse=True)
def mysetup(request, arg):
request.addfinalizer(lambda: l.append("fin%s" % arg))
l.append("setup%s" % arg)
request.addfinalizer(lambda: values.append("fin%s" % arg))
values.append("setup%s" % arg)
l = []
values = []
def test_1(arg):
l.append(arg)
values.append(arg)
def test_2(arg):
l.append(arg)
values.append(arg)
def test_3():
import pprint
pprint.pprint(l)
pprint.pprint(values)
if arg == 1:
assert l == ["setup1", 1, 1, ]
assert values == ["setup1", 1, 1, ]
elif arg == 2:
assert l == ["setup1", 1, 1, "fin1",
assert values == ["setup1", 1, 1, "fin1",
"setup2", 2, 2, ]
""")
@ -2660,13 +2660,13 @@ class TestErrors(object):
request.addfinalizer(f)
return object()
l = []
values = []
def test_1(fix1):
l.append(fix1)
values.append(fix1)
def test_2(fix1):
l.append(fix1)
values.append(fix1)
def test_3():
assert l[0] != l[1]
assert values[0] != values[1]
""")
result = testdir.runpytest()
result.stdout.fnmatch_lines("""

8
testing/python/integration.py
View File

@ -93,8 +93,8 @@ class TestMockDecoration(object):
def f(x):
pass
l = getfuncargnames(f)
assert l == ("x",)
values = getfuncargnames(f)
assert values == ("x",)
def test_wrapped_getfuncargnames_patching(self):
from _pytest.compat import getfuncargnames
@ -110,8 +110,8 @@ class TestMockDecoration(object):
def f(x, y, z):
pass
l = getfuncargnames(f)
assert l == ("y", "z")
values = getfuncargnames(f)
assert values == ("y", "z")
def test_unittest_mock(self, testdir):
pytest.importorskip("unittest.mock")

6
testing/python/metafunc.py
View File

@ -1071,21 +1071,21 @@ class TestMetafuncFunctional(object):
def test_parametrize_scope_overrides(self, testdir, scope, length):
testdir.makepyfile("""
import pytest
l = []
values = []
def pytest_generate_tests(metafunc):
if "arg" in metafunc.funcargnames:
metafunc.parametrize("arg", [1,2], indirect=True,
scope=%r)
@pytest.fixture
def arg(request):
l.append(request.param)
values.append(request.param)
return request.param
def test_hello(arg):
assert arg in (1,2)
def test_world(arg):
assert arg in (1,2)
def test_checklength():
assert len(l) == %d
assert len(values) == %d
""" % (scope, length))
reprec = testdir.inline_run()
reprec.assertoutcome(passed=5)

12
testing/test_assertion.py
View File

@ -229,9 +229,9 @@ class TestImportHookInstallation(object):
return pkg.helper.tool
""",
'pkg/other.py': """
l = [3, 2]
values = [3, 2]
def tool():
assert l.pop() == 3
assert values.pop() == 3
""",
'conftest.py': """
pytest_plugins = ['pkg.plugin']
@ -248,7 +248,7 @@ class TestImportHookInstallation(object):
result = testdir.runpytest_subprocess('--assert=rewrite')
result.stdout.fnmatch_lines(['>*assert a == b*',
'E*assert 2 == 3*',
'>*assert l.pop() == 3*',
'>*assert values.pop() == 3*',
'E*AssertionError'])
def test_register_assert_rewrite_checks_types(self):
@ -263,13 +263,13 @@ class TestBinReprIntegration(object):
def test_pytest_assertrepr_compare_called(self, testdir):
testdir.makeconftest("""
import pytest
l = []
values = []
def pytest_assertrepr_compare(op, left, right):
l.append((op, left, right))
values.append((op, left, right))
@pytest.fixture
def list(request):
return l
return values
""")
testdir.makepyfile("""
def test_hello():

4
testing/test_assertrewrite.py
View File

@ -473,8 +473,8 @@ class TestAssertionRewrite(object):
def test_len(self):
def f():
l = list(range(10))
assert len(l) == 11
values = list(range(10))
assert len(values) == 11
assert getmsg(f).startswith("""assert 10 == 11
+ where 10 = len([""")

6
testing/test_collection.py
View File

@ -703,9 +703,9 @@ class TestNodekeywords(object):
def test_pass(): pass
def test_fail(): assert 0
""")
l = list(modcol.keywords)
assert modcol.name in l
for x in l:
values = list(modcol.keywords)
assert modcol.name in values
for x in values:
assert not x.startswith("_")
assert modcol.name in repr(modcol.keywords)

70
testing/test_config.py
View File

@ -123,11 +123,11 @@ class TestConfigCmdlineParsing(object):
class TestConfigAPI(object):
def test_config_trace(self, testdir):
config = testdir.parseconfig()
l = []
config.trace.root.setwriter(l.append)
values = []
config.trace.root.setwriter(values.append)
config.trace("hello")
assert len(l) == 1
assert l[0] == "hello [config]\n"
assert len(values) == 1
assert values[0] == "hello [config]\n"
def test_config_getoption(self, testdir):
testdir.makeconftest("""
@ -209,10 +209,10 @@ class TestConfigAPI(object):
paths=hello world/sub.py
""")
config = testdir.parseconfig()
l = config.getini("paths")
assert len(l) == 2
assert l[0] == p.dirpath('hello')
assert l[1] == p.dirpath('world/sub.py')
values = config.getini("paths")
assert len(values) == 2
assert values[0] == p.dirpath('hello')
assert values[1] == p.dirpath('world/sub.py')
pytest.raises(ValueError, config.getini, 'other')
def test_addini_args(self, testdir):
@ -226,11 +226,11 @@ class TestConfigAPI(object):
args=123 "123 hello" "this"
""")
config = testdir.parseconfig()
l = config.getini("args")
assert len(l) == 3
assert l == ["123", "123 hello", "this"]
l = config.getini("a2")
assert l == list("123")
values = config.getini("args")
assert len(values) == 3
assert values == ["123", "123 hello", "this"]
values = config.getini("a2")
assert values == list("123")
def test_addini_linelist(self, testdir):
testdir.makeconftest("""
@ -244,11 +244,11 @@ class TestConfigAPI(object):
second line
""")
config = testdir.parseconfig()
l = config.getini("xy")
assert len(l) == 2
assert l == ["123 345", "second line"]
l = config.getini("a2")
assert l == []
values = config.getini("xy")
assert len(values) == 2
assert values == ["123 345", "second line"]
values = config.getini("a2")
assert values == []
@pytest.mark.parametrize('str_val, bool_val',
[('True', True), ('no', False), ('no-ini', True)])
@ -275,13 +275,13 @@ class TestConfigAPI(object):
xy= 123
""")
config = testdir.parseconfig()
l = config.getini("xy")
assert len(l) == 1
assert l == ["123"]
values = config.getini("xy")
assert len(values) == 1
assert values == ["123"]
config.addinivalue_line("xy", "456")
l = config.getini("xy")
assert len(l) == 2
assert l == ["123", "456"]
values = config.getini("xy")
assert len(values) == 2
assert values == ["123", "456"]
def test_addinivalue_line_new(self, testdir):
testdir.makeconftest("""
@ -291,13 +291,13 @@ class TestConfigAPI(object):
config = testdir.parseconfig()
assert not config.getini("xy")
config.addinivalue_line("xy", "456")
l = config.getini("xy")
assert len(l) == 1
assert l == ["456"]
values = config.getini("xy")
assert len(values) == 1
assert values == ["456"]
config.addinivalue_line("xy", "123")
l = config.getini("xy")
assert len(l) == 2
assert l == ["456", "123"]
values = config.getini("xy")
assert len(values) == 2
assert values == ["456", "123"]
def test_confcutdir_check_isdir(self, testdir):
"""Give an error if --confcutdir is not a valid directory (#2078)"""
@ -596,13 +596,13 @@ def test_load_initial_conftest_last_ordering(testdir):
m = My()
pm.register(m)
hc = pm.hook.pytest_load_initial_conftests
l = hc._nonwrappers + hc._wrappers
values = hc._nonwrappers + hc._wrappers
expected = [
"_pytest.config",
'test_config',
'_pytest.capture',
]
assert [x.function.__module__ for x in l] == expected
assert [x.function.__module__ for x in values] == expected
def test_get_plugin_specs_as_list():
@ -623,17 +623,17 @@ def test_get_plugin_specs_as_list():
class TestWarning(object):
def test_warn_config(self, testdir):
testdir.makeconftest("""
l = []
values = []
def pytest_configure(config):
config.warn("C1", "hello")
def pytest_logwarning(code, message):
if message == "hello" and code == "C1":
l.append(1)
values.append(1)
""")
testdir.makepyfile("""
def test_proper(pytestconfig):
import conftest
assert conftest.l == [1]
assert conftest.values == [1]
""")
reprec = testdir.inline_run()
reprec.assertoutcome(passed=1)

28
testing/test_conftest.py
View File

@ -87,8 +87,8 @@ def test_doubledash_considered(testdir):
conf.join("conftest.py").ensure()
conftest = PytestPluginManager()
conftest_setinitial(conftest, [conf.basename, conf.basename])
l = conftest._getconftestmodules(conf)
assert len(l) == 1
values = conftest._getconftestmodules(conf)
assert len(values) == 1
def test_issue151_load_all_conftests(testdir):
@ -130,28 +130,28 @@ def test_conftestcutdir(testdir):
p = testdir.mkdir("x")
conftest = PytestPluginManager()
conftest_setinitial(conftest, [testdir.tmpdir], confcutdir=p)
l = conftest._getconftestmodules(p)
assert len(l) == 0
l = conftest._getconftestmodules(conf.dirpath())
assert len(l) == 0
values = conftest._getconftestmodules(p)
assert len(values) == 0
values = conftest._getconftestmodules(conf.dirpath())
assert len(values) == 0
assert conf not in conftest._conftestpath2mod
# but we can still import a conftest directly
conftest._importconftest(conf)
l = conftest._getconftestmodules(conf.dirpath())
assert l[0].__file__.startswith(str(conf))
values = conftest._getconftestmodules(conf.dirpath())
assert values[0].__file__.startswith(str(conf))
# and all sub paths get updated properly
l = conftest._getconftestmodules(p)
assert len(l) == 1
assert l[0].__file__.startswith(str(conf))
values = conftest._getconftestmodules(p)
assert len(values) == 1
assert values[0].__file__.startswith(str(conf))
def test_conftestcutdir_inplace_considered(testdir):
conf = testdir.makeconftest("")
conftest = PytestPluginManager()
conftest_setinitial(conftest, [conf.dirpath()], confcutdir=conf.dirpath())
l = conftest._getconftestmodules(conf.dirpath())
assert len(l) == 1
assert l[0].__file__.startswith(str(conf))
values = conftest._getconftestmodules(conf.dirpath())
assert len(values) == 1
assert values[0].__file__.startswith(str(conf))
@pytest.mark.parametrize("name", 'test tests whatever .dotdir'.split())

28
testing/test_mark.py
View File

@ -468,11 +468,11 @@ class TestFunctional(object):
assert marker.kwargs == {'x': 1, 'y': 2, 'z': 4}
# test the new __iter__ interface
l = list(marker)
assert len(l) == 3
assert l[0].args == ("pos0",)
assert l[1].args == ()
assert l[2].args == ("pos1", )
values = list(marker)
assert len(values) == 3
assert values[0].args == ("pos0",)
assert values[1].args == ()
assert values[2].args == ("pos1", )
@pytest.mark.xfail(reason='unfixed')
def test_merging_markers_deep(self, testdir):
@ -564,9 +564,9 @@ class TestFunctional(object):
def test_func():
pass
""")
l = reprec.getfailedcollections()
assert len(l) == 1
assert "TypeError" in str(l[0].longrepr)
values = reprec.getfailedcollections()
assert len(values) == 1
assert "TypeError" in str(values[0].longrepr)
def test_mark_dynamically_in_funcarg(self, testdir):
testdir.makeconftest("""
@ -575,8 +575,8 @@ class TestFunctional(object):
def arg(request):
request.applymarker(pytest.mark.hello)
def pytest_terminal_summary(terminalreporter):
l = terminalreporter.stats['passed']
terminalreporter.writer.line("keyword: %s" % l[0].keywords)
values = terminalreporter.stats['passed']
terminalreporter.writer.line("keyword: %s" % values[0].keywords)
""")
testdir.makepyfile("""
def test_func(arg):
@ -599,10 +599,10 @@ class TestFunctional(object):
item, = items
keywords = item.keywords
marker = keywords['hello']
l = list(marker)
assert len(l) == 2
assert l[0].args == ("pos0",)
assert l[1].args == ("pos1",)
values = list(marker)
assert len(values) == 2
assert values[0].args == ("pos0",)
assert values[1].args == ("pos1",)
def test_no_marker_match_on_unmarked_names(self, testdir):
p = testdir.makepyfile("""

70
testing/test_nose.py
View File

@ -8,18 +8,18 @@ def setup_module(mod):
def test_nose_setup(testdir):
p = testdir.makepyfile("""
l = []
values = []
from nose.tools import with_setup
@with_setup(lambda: l.append(1), lambda: l.append(2))
@with_setup(lambda: values.append(1), lambda: values.append(2))
def test_hello():
assert l == [1]
assert values == [1]
def test_world():
assert l == [1,2]
assert values == [1,2]
test_hello.setup = lambda: l.append(1)
test_hello.teardown = lambda: l.append(2)
test_hello.setup = lambda: values.append(1)
test_hello.teardown = lambda: values.append(2)
""")
result = testdir.runpytest(p, '-p', 'nose')
result.assert_outcomes(passed=2)
@ -27,15 +27,15 @@ def test_nose_setup(testdir):
def test_setup_func_with_setup_decorator():
from _pytest.nose import call_optional
l = []
values = []
class A(object):
@pytest.fixture(autouse=True)
def f(self):
l.append(1)
values.append(1)
call_optional(A(), "f")
assert not l
assert not values
def test_setup_func_not_callable():
@ -51,24 +51,24 @@ def test_nose_setup_func(testdir):
p = testdir.makepyfile("""
from nose.tools import with_setup
l = []
values = []
def my_setup():
a = 1
l.append(a)
values.append(a)
def my_teardown():
b = 2
l.append(b)
values.append(b)
@with_setup(my_setup, my_teardown)
def test_hello():
print (l)
assert l == [1]
print (values)
assert values == [1]
def test_world():
print (l)
assert l == [1,2]
print (values)
assert values == [1,2]
""")
result = testdir.runpytest(p, '-p', 'nose')
@ -79,18 +79,18 @@ def test_nose_setup_func_failure(testdir):
p = testdir.makepyfile("""
from nose.tools import with_setup
l = []
values = []
my_setup = lambda x: 1
my_teardown = lambda x: 2
@with_setup(my_setup, my_teardown)
def test_hello():
print (l)
assert l == [1]
print (values)
assert values == [1]
def test_world():
print (l)
assert l == [1,2]
print (values)
assert values == [1,2]
""")
result = testdir.runpytest(p, '-p', 'nose')
@ -101,13 +101,13 @@ def test_nose_setup_func_failure(testdir):
def test_nose_setup_func_failure_2(testdir):
testdir.makepyfile("""
l = []
values = []
my_setup = 1
my_teardown = 2
def test_hello():
assert l == []
assert values == []
test_hello.setup = my_setup
test_hello.teardown = my_teardown
@ -121,26 +121,26 @@ def test_nose_setup_partial(testdir):
p = testdir.makepyfile("""
from functools import partial
l = []
values = []
def my_setup(x):
a = x
l.append(a)
values.append(a)
def my_teardown(x):
b = x
l.append(b)
values.append(b)
my_setup_partial = partial(my_setup, 1)
my_teardown_partial = partial(my_teardown, 2)
def test_hello():
print (l)
assert l == [1]
print (values)
assert values == [1]
def test_world():
print (l)
assert l == [1,2]
print (values)
assert values == [1,2]
test_hello.setup = my_setup_partial
test_hello.teardown = my_teardown_partial
@ -251,19 +251,19 @@ def test_module_level_setup(testdir):
def test_nose_style_setup_teardown(testdir):
testdir.makepyfile("""
l = []
values = []
def setup_module():
l.append(1)
values.append(1)
def teardown_module():
del l[0]
del values[0]
def test_hello():
assert l == [1]
assert values == [1]
def test_world():
assert l == [1]
assert values == [1]
""")
result = testdir.runpytest('-p', 'nose')
result.stdout.fnmatch_lines([

36
testing/test_pluginmanager.py
View File

@ -85,23 +85,23 @@ class TestPytestPluginInteractions(object):
def test_configure(self, testdir):
config = testdir.parseconfig()
l = []
values = []
class A(object):
def pytest_configure(self, config):
l.append(self)
values.append(self)
config.pluginmanager.register(A())
assert len(l) == 0
assert len(values) == 0
config._do_configure()
assert len(l) == 1
assert len(values) == 1
config.pluginmanager.register(A()) # leads to a configured() plugin
assert len(l) == 2
assert l[0] != l[1]
assert len(values) == 2
assert values[0] != values[1]
config._ensure_unconfigure()
config.pluginmanager.register(A())
assert len(l) == 2
assert len(values) == 2
def test_hook_tracing(self):
pytestpm = get_config().pluginmanager # fully initialized with plugins
@ -116,19 +116,19 @@ class TestPytestPluginInteractions(object):
saveindent.append(pytestpm.trace.root.indent)
raise ValueError()
l = []
pytestpm.trace.root.setwriter(l.append)
values = []
pytestpm.trace.root.setwriter(values.append)
undo = pytestpm.enable_tracing()
try:
indent = pytestpm.trace.root.indent
p = api1()
pytestpm.register(p)
assert pytestpm.trace.root.indent == indent
assert len(l) >= 2
assert 'pytest_plugin_registered' in l[0]
assert 'finish' in l[1]
assert len(values) >= 2
assert 'pytest_plugin_registered' in values[0]
assert 'finish' in values[1]
l[:] = []
values[:] = []
with pytest.raises(ValueError):
pytestpm.register(api2())
assert pytestpm.trace.root.indent == indent
@ -230,12 +230,12 @@ class TestPytestPluginManager(object):
mod = py.std.types.ModuleType("x.y.pytest_hello")
pm.register(mod)
assert pm.is_registered(mod)
l = pm.get_plugins()
assert mod in l
values = pm.get_plugins()
assert mod in values
pytest.raises(ValueError, "pm.register(mod)")
pytest.raises(ValueError, lambda: pm.register(mod))
# assert not pm.is_registered(mod2)
assert pm.get_plugins() == l
assert pm.get_plugins() == values
def test_canonical_import(self, monkeypatch):
mod = py.std.types.ModuleType("pytest_xyz")
@ -269,8 +269,8 @@ class TestPytestPluginManager(object):
# check that it is not registered twice
pytestpm.consider_module(mod)
l = reprec.getcalls("pytest_plugin_registered")
assert len(l) == 1
values = reprec.getcalls("pytest_plugin_registered")
assert len(values) == 1
def test_consider_env_fails_to_import(self, monkeypatch, pytestpm):
monkeypatch.setenv('PYTEST_PLUGINS', 'nonexisting', prepend=",")

4
testing/test_recwarn.py
View File

@ -30,10 +30,10 @@ class TestWarningsRecorderChecker(object):
assert len(rec.list) == 2
warn = rec.pop()
assert str(warn.message) == "hello"
l = rec.list
values = rec.list
rec.clear()
assert len(rec.list) == 0
assert l is rec.list
assert values is rec.list
pytest.raises(AssertionError, "rec.pop()")
def test_typechecking(self):

8
testing/test_runner.py
View File

@ -13,12 +13,12 @@ class TestSetupState(object):
def test_setup(self, testdir):
ss = runner.SetupState()
item = testdir.getitem("def test_func(): pass")
l = [1]
values = [1]
ss.prepare(item)
ss.addfinalizer(l.pop, colitem=item)
assert l
ss.addfinalizer(values.pop, colitem=item)
assert values
ss._pop_and_teardown()
assert not l
assert not values
def test_teardown_exact_stack_empty(self, testdir):
item = testdir.getitem("def test_func(): pass")

8
testing/test_runner_xunit.py
View File

@ -39,20 +39,20 @@ def test_module_and_function_setup(testdir):
def test_module_setup_failure_no_teardown(testdir):
reprec = testdir.inline_runsource("""
l = []
values = []
def setup_module(module):
l.append(1)
values.append(1)
0/0
def test_nothing():
pass
def teardown_module(module):
l.append(2)
values.append(2)
""")
reprec.assertoutcome(failed=1)
calls = reprec.getcalls("pytest_runtest_setup")
assert calls[0].item.module.l == [1]
assert calls[0].item.module.values == [1]
def test_setup_function_failure_no_teardown(testdir):

28
testing/test_session.py
View File

@ -45,9 +45,9 @@ class SessionTests(object):
a = 1
""")
reprec = testdir.inline_run(tfile)
l = reprec.getfailedcollections()
assert len(l) == 1
out = str(l[0].longrepr)
values = reprec.getfailedcollections()
assert len(values) == 1
out = str(values[0].longrepr)
assert out.find('does_not_work') != -1
def test_raises_output(self, testdir):
@ -75,9 +75,9 @@ class SessionTests(object):
def test_syntax_error_module(self, testdir):
reprec = testdir.inline_runsource("this is really not python")
l = reprec.getfailedcollections()
assert len(l) == 1
out = str(l[0].longrepr)
values = reprec.getfailedcollections()
assert len(values) == 1
out = str(values[0].longrepr)
assert out.find(str('not python')) != -1
def test_exit_first_problem(self, testdir):
@ -144,15 +144,15 @@ class TestNewSession(SessionTests):
def test_order_of_execution(self, testdir):
reprec = testdir.inline_runsource("""
l = []
values = []
def test_1():
l.append(1)
values.append(1)
def test_2():
l.append(2)
values.append(2)
def test_3():
assert l == [1,2]
assert values == [1,2]
class Testmygroup(object):
reslist = l
reslist = values
def test_1(self):
self.reslist.append(1)
def test_2(self):
@ -242,13 +242,13 @@ def test_exclude(testdir):
def test_sessionfinish_with_start(testdir):
testdir.makeconftest("""
import os
l = []
values = []
def pytest_sessionstart():
l.append(os.getcwd())
values.append(os.getcwd())
os.chdir("..")
def pytest_sessionfinish():
assert l[0] == os.getcwd()
assert values[0] == os.getcwd()
""")
res = testdir.runpytest("--collect-only")

6
testing/test_skipping.py
View File

@ -679,9 +679,9 @@ def test_skip_reasons_folding():
ev2.longrepr = longrepr
ev2.skipped = True
l = folded_skips([ev1, ev2])
assert len(l) == 1
num, fspath, lineno, reason = l[0]
values = folded_skips([ev1, ev2])
assert len(values) == 1
num, fspath, lineno, reason = values[0]
assert num == 2
assert fspath == path
assert lineno == lineno

8
testing/test_terminal.py
View File

@ -24,12 +24,12 @@ class Option(object):
@property
def args(self):
l = []
values = []
if self.verbose:
l.append('-v')
values.append('-v')
if self.fulltrace:
l.append('--fulltrace')
return l
values.append('--fulltrace')
return values
def pytest_generate_tests(metafunc):

22
testing/test_unittest.py
View File

@ -73,19 +73,19 @@ def test_setup(testdir):
def test_setUpModule(testdir):
testpath = testdir.makepyfile("""
l = []
values = []
def setUpModule():
l.append(1)
values.append(1)
def tearDownModule():
del l[0]
del values[0]
def test_hello():
assert l == [1]
assert values == [1]
def test_world():
assert l == [1]
assert values == [1]
""")
result = testdir.runpytest(testpath)
result.stdout.fnmatch_lines([
@ -95,13 +95,13 @@ def test_setUpModule(testdir):
def test_setUpModule_failing_no_teardown(testdir):
testpath = testdir.makepyfile("""
l = []
values = []
def setUpModule():
0/0
def tearDownModule():
l.append(1)
values.append(1)
def test_hello():
pass
@ -109,7 +109,7 @@ def test_setUpModule_failing_no_teardown(testdir):
reprec = testdir.inline_run(testpath)
reprec.assertoutcome(passed=0, failed=1)
call = reprec.getcalls("pytest_runtest_setup")[0]
assert not call.item.module.l
assert not call.item.module.values
def test_new_instances(testdir):
@ -129,14 +129,14 @@ def test_teardown(testdir):
testpath = testdir.makepyfile("""
import unittest
class MyTestCase(unittest.TestCase):
l = []
values = []
def test_one(self):
pass
def tearDown(self):
self.l.append(None)
self.values.append(None)
class Second(unittest.TestCase):
def test_check(self):
self.assertEqual(MyTestCase.l, [None])
self.assertEqual(MyTestCase.values, [None])
""")
reprec = testdir.inline_run(testpath)
passed, skipped, failed = reprec.countoutcomes()

2
tox.ini
View File

@ -218,5 +218,3 @@ exclude = _pytest/vendored_packages/pluggy.py
ignore=
# do not use bare except'
E722
# ambiguous variable name 'l'
E741