388 lines
14 KiB
Python
388 lines
14 KiB
Python
import py
|
|
|
|
class TestModule:
|
|
def test_module_file_not_found(self, testdir):
|
|
tmpdir = testdir.tmpdir
|
|
fn = tmpdir.join('nada','no')
|
|
col = py.test.collect.Module(fn, config=testdir.parseconfig(tmpdir))
|
|
py.test.raises(py.error.ENOENT, col.collect)
|
|
|
|
def test_failing_import(self, testdir):
|
|
modcol = testdir.getmodulecol("import alksdjalskdjalkjals")
|
|
py.test.raises(ImportError, modcol.collect)
|
|
py.test.raises(ImportError, modcol.collect)
|
|
py.test.raises(ImportError, modcol.run)
|
|
|
|
def test_syntax_error_in_module(self, testdir):
|
|
modcol = testdir.getmodulecol("this is a syntax error")
|
|
py.test.raises(SyntaxError, modcol.collect)
|
|
py.test.raises(SyntaxError, modcol.collect)
|
|
py.test.raises(SyntaxError, modcol.run)
|
|
|
|
def test_module_assertion_setup(self, testdir):
|
|
modcol = testdir.getmodulecol("pass")
|
|
from py.__.magic import assertion
|
|
l = []
|
|
py.magic.patch(assertion, "invoke", lambda: l.append(None))
|
|
try:
|
|
modcol.setup()
|
|
finally:
|
|
py.magic.revert(assertion, "invoke")
|
|
x = l.pop()
|
|
assert x is None
|
|
py.magic.patch(assertion, "revoke", lambda: l.append(None))
|
|
try:
|
|
modcol.teardown()
|
|
finally:
|
|
py.magic.revert(assertion, "revoke")
|
|
x = l.pop()
|
|
assert x is None
|
|
|
|
def test_disabled_module(self, testdir):
|
|
modcol = testdir.getmodulecol("""
|
|
disabled = True
|
|
def setup_module(mod):
|
|
raise ValueError
|
|
""")
|
|
assert not modcol.collect()
|
|
assert not modcol.run()
|
|
|
|
def test_module_participates_as_plugin(self, testdir):
|
|
modcol = testdir.getmodulecol("")
|
|
modcol.setup()
|
|
assert modcol._config.pytestplugins.isregistered(modcol.obj)
|
|
modcol.teardown()
|
|
assert not modcol._config.pytestplugins.isregistered(modcol.obj)
|
|
|
|
def test_module_considers_pytestplugins_at_import(self, testdir):
|
|
modcol = testdir.getmodulecol("pytest_plugins='xasdlkj',")
|
|
py.test.raises(ImportError, "modcol.obj")
|
|
|
|
class TestClass:
|
|
def test_disabled_class(self, testdir):
|
|
modcol = testdir.getmodulecol("""
|
|
class TestClass:
|
|
disabled = True
|
|
def test_method(self):
|
|
pass
|
|
""")
|
|
l = modcol.collect()
|
|
assert len(l) == 1
|
|
modcol = l[0]
|
|
assert isinstance(modcol, py.test.collect.Class)
|
|
assert not modcol.collect()
|
|
|
|
class TestGenerator:
|
|
def test_generative_functions(self, testdir):
|
|
modcol = testdir.getmodulecol("""
|
|
def func1(arg, arg2):
|
|
assert arg == arg2
|
|
|
|
def test_gen():
|
|
yield func1, 17, 3*5
|
|
yield func1, 42, 6*7
|
|
""")
|
|
colitems = modcol.collect()
|
|
assert len(colitems) == 1
|
|
gencol = colitems[0]
|
|
assert isinstance(gencol, py.test.collect.Generator)
|
|
gencolitems = gencol.collect()
|
|
assert len(gencolitems) == 2
|
|
assert isinstance(gencolitems[0], py.test.collect.Function)
|
|
assert isinstance(gencolitems[1], py.test.collect.Function)
|
|
assert gencolitems[0].name == '[0]'
|
|
assert gencolitems[0].obj.func_name == 'func1'
|
|
|
|
def test_generative_methods(self, testdir):
|
|
modcol = testdir.getmodulecol("""
|
|
def func1(arg, arg2):
|
|
assert arg == arg2
|
|
class TestGenMethods:
|
|
def test_gen(self):
|
|
yield func1, 17, 3*5
|
|
yield func1, 42, 6*7
|
|
""")
|
|
gencol = modcol.collect()[0].collect()[0].collect()[0]
|
|
assert isinstance(gencol, py.test.collect.Generator)
|
|
gencolitems = gencol.collect()
|
|
assert len(gencolitems) == 2
|
|
assert isinstance(gencolitems[0], py.test.collect.Function)
|
|
assert isinstance(gencolitems[1], py.test.collect.Function)
|
|
assert gencolitems[0].name == '[0]'
|
|
assert gencolitems[0].obj.func_name == 'func1'
|
|
|
|
def test_generative_functions_with_explicit_names(self, testdir):
|
|
modcol = testdir.getmodulecol("""
|
|
def func1(arg, arg2):
|
|
assert arg == arg2
|
|
|
|
def test_gen():
|
|
yield "seventeen", func1, 17, 3*5
|
|
yield "fortytwo", func1, 42, 6*7
|
|
""")
|
|
colitems = modcol.collect()
|
|
assert len(colitems) == 1
|
|
gencol = colitems[0]
|
|
assert isinstance(gencol, py.test.collect.Generator)
|
|
gencolitems = gencol.collect()
|
|
assert len(gencolitems) == 2
|
|
assert isinstance(gencolitems[0], py.test.collect.Function)
|
|
assert isinstance(gencolitems[1], py.test.collect.Function)
|
|
assert gencolitems[0].name == "['seventeen']"
|
|
assert gencolitems[0].obj.func_name == 'func1'
|
|
assert gencolitems[1].name == "['fortytwo']"
|
|
assert gencolitems[1].obj.func_name == 'func1'
|
|
|
|
def test_generative_methods_with_explicit_names(self, testdir):
|
|
modcol = testdir.getmodulecol("""
|
|
def func1(arg, arg2):
|
|
assert arg == arg2
|
|
class TestGenMethods:
|
|
def test_gen(self):
|
|
yield "m1", func1, 17, 3*5
|
|
yield "m2", func1, 42, 6*7
|
|
""")
|
|
gencol = modcol.collect()[0].collect()[0].collect()[0]
|
|
assert isinstance(gencol, py.test.collect.Generator)
|
|
gencolitems = gencol.collect()
|
|
assert len(gencolitems) == 2
|
|
assert isinstance(gencolitems[0], py.test.collect.Function)
|
|
assert isinstance(gencolitems[1], py.test.collect.Function)
|
|
assert gencolitems[0].name == "['m1']"
|
|
assert gencolitems[0].obj.func_name == 'func1'
|
|
assert gencolitems[1].name == "['m2']"
|
|
assert gencolitems[1].obj.func_name == 'func1'
|
|
|
|
def test_order_of_execution_generator_same_codeline(self, testdir, tmpdir):
|
|
o = testdir.makepyfile("""
|
|
def test_generative_order_of_execution():
|
|
test_list = []
|
|
expected_list = range(6)
|
|
|
|
def list_append(item):
|
|
test_list.append(item)
|
|
|
|
def assert_order_of_execution():
|
|
print 'expected order', expected_list
|
|
print 'but got ', test_list
|
|
assert test_list == expected_list
|
|
|
|
for i in expected_list:
|
|
yield list_append, i
|
|
yield assert_order_of_execution
|
|
""")
|
|
sorter = testdir.inline_run(o)
|
|
passed, skipped, failed = sorter.countoutcomes()
|
|
assert passed == 7
|
|
assert not skipped and not failed
|
|
|
|
def test_order_of_execution_generator_different_codeline(self, testdir):
|
|
o = testdir.makepyfile("""
|
|
def test_generative_tests_different_codeline():
|
|
test_list = []
|
|
expected_list = range(3)
|
|
|
|
def list_append_2():
|
|
test_list.append(2)
|
|
|
|
def list_append_1():
|
|
test_list.append(1)
|
|
|
|
def list_append_0():
|
|
test_list.append(0)
|
|
|
|
def assert_order_of_execution():
|
|
print 'expected order', expected_list
|
|
print 'but got ', test_list
|
|
assert test_list == expected_list
|
|
|
|
yield list_append_0
|
|
yield list_append_1
|
|
yield list_append_2
|
|
yield assert_order_of_execution
|
|
""")
|
|
sorter = testdir.inline_run(o) # .events_from_cmdline([o])
|
|
passed, skipped, failed = sorter.countoutcomes()
|
|
assert passed == 4
|
|
assert not skipped and not failed
|
|
|
|
class TestFunction:
|
|
def test_function_equality(self, tmpdir):
|
|
config = py.test.config._reparse([tmpdir])
|
|
f1 = py.test.collect.Function(name="name", config=config,
|
|
args=(1,), callobj=isinstance)
|
|
f2 = py.test.collect.Function(name="name", config=config,
|
|
args=(1,), callobj=callable)
|
|
assert not f1 == f2
|
|
assert f1 != f2
|
|
f3 = py.test.collect.Function(name="name", config=config,
|
|
args=(1,2), callobj=callable)
|
|
assert not f3 == f2
|
|
assert f3 != f2
|
|
|
|
assert not f3 == f1
|
|
assert f3 != f1
|
|
|
|
f1_b = py.test.collect.Function(name="name", config=config,
|
|
args=(1,), callobj=isinstance)
|
|
assert f1 == f1_b
|
|
assert not f1 != f1_b
|
|
|
|
def test_pyfuncarg_lookupfails(self, testdir):
|
|
item = testdir.getitem("def test_func(some, other): pass")
|
|
kw = py.test.raises(LookupError, "item.lookup_allargs()")
|
|
|
|
def test_pyfuncarg_basic(self, testdir):
|
|
item = testdir.getitem("def test_func(some, other): pass")
|
|
class Provider:
|
|
def pytest_pyfuncarg_some(self, pyfuncitem):
|
|
return pyfuncitem.name
|
|
def pytest_pyfuncarg_other(self, pyfuncitem):
|
|
return 42
|
|
item._config.pytestplugins.register(Provider())
|
|
kw = item.lookup_allargs()
|
|
assert len(kw) == 2
|
|
assert kw['some'] == "test_func"
|
|
assert kw['other'] == 42
|
|
|
|
def test_pyfuncarg_addfinalizer(self, testdir):
|
|
item = testdir.getitem("def test_func(some): pass")
|
|
l = []
|
|
class Provider:
|
|
def pytest_pyfuncarg_some(self, pyfuncitem):
|
|
pyfuncitem.addfinalizer(lambda: l.append(42))
|
|
return 3
|
|
item._config.pytestplugins.register(Provider())
|
|
kw = item.lookup_allargs()
|
|
assert len(kw) == 1
|
|
assert kw['some'] == 3
|
|
assert len(l) == 0
|
|
item.teardown()
|
|
assert len(l) == 1
|
|
assert l[0] == 42
|
|
|
|
def test_pyfuncarg_lookup_modulelevel(self, testdir):
|
|
modcol = testdir.getmodulecol("""
|
|
def pytest_pyfuncarg_something(pyfuncitem):
|
|
return pyfuncitem.name
|
|
|
|
class TestClass:
|
|
def test_method(self, something):
|
|
pass
|
|
def test_func(something):
|
|
pass
|
|
""")
|
|
item1, item2 = testdir.genitems([modcol])
|
|
modcol.setup()
|
|
assert modcol._config.pytestplugins.isregistered(modcol.obj)
|
|
kwargs = item1.lookup_allargs()
|
|
assert kwargs['something'] == "test_method"
|
|
kwargs = item2.lookup_allargs()
|
|
assert kwargs['something'] == "test_func"
|
|
modcol.teardown()
|
|
assert not modcol._config.pytestplugins.isregistered(modcol.obj)
|
|
|
|
class TestSorting:
|
|
def test_check_equality_and_cmp_basic(self, testdir):
|
|
modcol = testdir.getmodulecol("""
|
|
def test_pass(): pass
|
|
def test_fail(): assert 0
|
|
""")
|
|
fn1 = modcol.collect_by_name("test_pass")
|
|
assert isinstance(fn1, py.test.collect.Function)
|
|
fn2 = modcol.collect_by_name("test_pass")
|
|
assert isinstance(fn2, py.test.collect.Function)
|
|
|
|
assert fn1 == fn2
|
|
assert fn1 != modcol
|
|
assert cmp(fn1, fn2) == 0
|
|
assert hash(fn1) == hash(fn2)
|
|
|
|
fn3 = modcol.collect_by_name("test_fail")
|
|
assert isinstance(fn3, py.test.collect.Function)
|
|
assert not (fn1 == fn3)
|
|
assert fn1 != fn3
|
|
assert cmp(fn1, fn3) == -1
|
|
|
|
assert cmp(fn1, 10) == -1
|
|
assert cmp(fn2, 10) == -1
|
|
assert cmp(fn3, 10) == -1
|
|
for fn in fn1,fn2,fn3:
|
|
assert fn != 3
|
|
assert fn != modcol
|
|
assert fn != [1,2,3]
|
|
assert [1,2,3] != fn
|
|
assert modcol != fn
|
|
|
|
def test_allow_sane_sorting_for_decorators(self, testdir):
|
|
modcol = testdir.getmodulecol("""
|
|
def dec(f):
|
|
g = lambda: f(2)
|
|
g.place_as = f
|
|
return g
|
|
|
|
|
|
def test_a(y):
|
|
pass
|
|
test_a = dec(test_a)
|
|
|
|
def test_b(y):
|
|
pass
|
|
test_b = dec(test_b)
|
|
""")
|
|
colitems = modcol.collect()
|
|
assert len(colitems) == 2
|
|
f1, f2 = colitems
|
|
assert cmp(f2, f1) > 0
|
|
|
|
class TestConftestCustomization:
|
|
def test_extra_python_files_and_functions(self, testdir):
|
|
testdir.makepyfile(conftest="""
|
|
import py
|
|
class MyFunction(py.test.collect.Function):
|
|
pass
|
|
class Directory(py.test.collect.Directory):
|
|
def consider_file(self, path):
|
|
if path.check(fnmatch="check_*.py"):
|
|
return self.Module(path, parent=self)
|
|
return super(Directory, self).consider_file(path)
|
|
class myfuncmixin:
|
|
Function = MyFunction
|
|
def funcnamefilter(self, name):
|
|
return name.startswith('check_')
|
|
class Module(myfuncmixin, py.test.collect.Module):
|
|
def classnamefilter(self, name):
|
|
return name.startswith('CustomTestClass')
|
|
class Instance(myfuncmixin, py.test.collect.Instance):
|
|
pass
|
|
""")
|
|
checkfile = testdir.makepyfile(check_file="""
|
|
def check_func():
|
|
assert 42 == 42
|
|
class CustomTestClass:
|
|
def check_method(self):
|
|
assert 23 == 23
|
|
""")
|
|
# check that directory collects "check_" files
|
|
config = testdir.parseconfig()
|
|
col = config.getfsnode(checkfile.dirpath())
|
|
colitems = col.collect()
|
|
assert len(colitems) == 1
|
|
assert isinstance(colitems[0], py.test.collect.Module)
|
|
|
|
# check that module collects "check_" functions and methods
|
|
config = testdir.parseconfig(checkfile)
|
|
col = config.getfsnode(checkfile)
|
|
assert isinstance(col, py.test.collect.Module)
|
|
colitems = col.collect()
|
|
assert len(colitems) == 2
|
|
funccol = colitems[0]
|
|
assert isinstance(funccol, py.test.collect.Function)
|
|
assert funccol.name == "check_func"
|
|
clscol = colitems[1]
|
|
assert isinstance(clscol, py.test.collect.Class)
|
|
colitems = clscol.collect()[0].collect()
|
|
assert len(colitems) == 1
|
|
assert colitems[0].name == "check_method"
|
|
|