263 lines
9.5 KiB
Python
263 lines
9.5 KiB
Python
import py
|
|
from py.__.test import funcargs
|
|
|
|
def test_getfuncargnames():
|
|
def f(): pass
|
|
assert not funcargs.getfuncargnames(f)
|
|
def g(arg): pass
|
|
assert funcargs.getfuncargnames(g) == ['arg']
|
|
def h(arg1, arg2="hello"): pass
|
|
assert funcargs.getfuncargnames(h) == ['arg1']
|
|
def h(arg1, arg2, arg3="hello"): pass
|
|
assert funcargs.getfuncargnames(h) == ['arg1', 'arg2']
|
|
class A:
|
|
def f(self, arg1, arg2="hello"):
|
|
pass
|
|
assert funcargs.getfuncargnames(A().f) == ['arg1']
|
|
assert funcargs.getfuncargnames(A.f) == ['arg1']
|
|
|
|
class TestFillFuncArgs:
|
|
def test_funcarg_lookupfails(self, testdir):
|
|
testdir.makeconftest("""
|
|
class ConftestPlugin:
|
|
def pytest_funcarg__xyzsomething(self, request):
|
|
return 42
|
|
""")
|
|
item = testdir.getitem("def test_func(some): pass")
|
|
exc = py.test.raises(LookupError, "funcargs.fillfuncargs(item)")
|
|
s = str(exc.value)
|
|
assert s.find("xyzsomething") != -1
|
|
|
|
def test_funcarg_lookup_default(self, testdir):
|
|
item = testdir.getitem("def test_func(some, other=42): pass")
|
|
class Provider:
|
|
def pytest_funcarg__some(self, request):
|
|
return request.function.__name__
|
|
item.config.pluginmanager.register(Provider())
|
|
funcargs.fillfuncargs(item)
|
|
assert len(item.funcargs) == 1
|
|
|
|
def test_funcarg_basic(self, testdir):
|
|
item = testdir.getitem("def test_func(some, other): pass")
|
|
class Provider:
|
|
def pytest_funcarg__some(self, request):
|
|
return request.function.__name__
|
|
def pytest_funcarg__other(self, request):
|
|
return 42
|
|
item.config.pluginmanager.register(Provider())
|
|
funcargs.fillfuncargs(item)
|
|
assert len(item.funcargs) == 2
|
|
assert item.funcargs['some'] == "test_func"
|
|
assert item.funcargs['other'] == 42
|
|
|
|
def test_funcarg_lookup_modulelevel(self, testdir):
|
|
modcol = testdir.getmodulecol("""
|
|
def pytest_funcarg__something(request):
|
|
return request.function.__name__
|
|
|
|
class TestClass:
|
|
def test_method(self, something):
|
|
pass
|
|
def test_func(something):
|
|
pass
|
|
""")
|
|
item1, item2 = testdir.genitems([modcol])
|
|
funcargs.fillfuncargs(item1)
|
|
assert item1.funcargs['something'] == "test_method"
|
|
funcargs.fillfuncargs(item2)
|
|
assert item2.funcargs['something'] == "test_func"
|
|
|
|
class TestRequest:
|
|
def test_request_attributes(self, testdir):
|
|
item = testdir.getitem("""
|
|
def pytest_funcarg__something(request): pass
|
|
def test_func(something): pass
|
|
""")
|
|
req = funcargs.FuncargRequest(item, argname="other")
|
|
assert req.argname == "other"
|
|
assert req.function == item.obj
|
|
assert hasattr(req.module, 'test_func')
|
|
assert req.cls is None
|
|
assert req.function.__name__ == "test_func"
|
|
assert req.config == item.config
|
|
assert repr(req).find(req.function.__name__) != -1
|
|
|
|
def test_request_attributes_method(self, testdir):
|
|
item, = testdir.getitems("""
|
|
class TestB:
|
|
def test_func(self, something):
|
|
pass
|
|
""")
|
|
req = funcargs.FuncargRequest(item, argname="something")
|
|
assert req.cls.__name__ == "TestB"
|
|
|
|
def test_request_contains_funcargs_provider(self, testdir):
|
|
modcol = testdir.getmodulecol("""
|
|
def pytest_funcarg__something(request):
|
|
pass
|
|
class TestClass:
|
|
def test_method(self, something):
|
|
pass
|
|
""")
|
|
item1, = testdir.genitems([modcol])
|
|
assert item1.name == "test_method"
|
|
provider = funcargs.FuncargRequest(item1, "something")._provider
|
|
assert len(provider) == 1
|
|
assert provider[0].__name__ == "pytest_funcarg__something"
|
|
|
|
def test_request_call_next_provider(self, testdir):
|
|
item = testdir.getitem("""
|
|
def pytest_funcarg__something(request): pass
|
|
def test_func(something): pass
|
|
""")
|
|
req = funcargs.FuncargRequest(item, "something")
|
|
val = req.call_next_provider()
|
|
assert val is None
|
|
py.test.raises(req.Error, "req.call_next_provider()")
|
|
|
|
def test_request_addfinalizer(self, testdir):
|
|
item = testdir.getitem("""
|
|
def pytest_funcarg__something(request): pass
|
|
def test_func(something): pass
|
|
""")
|
|
req = funcargs.FuncargRequest(item, "something")
|
|
l = [1]
|
|
req.addfinalizer(l.pop)
|
|
item.teardown()
|
|
|
|
def test_request_getmodulepath(self, testdir):
|
|
modcol = testdir.getmodulecol("def test_somefunc(): pass")
|
|
item, = testdir.genitems([modcol])
|
|
req = funcargs.FuncargRequest(item, "xxx")
|
|
assert req.fspath == modcol.fspath
|
|
|
|
class TestFuncSpecs:
|
|
def test_no_funcargs(self, testdir):
|
|
def function(): pass
|
|
funcspec = funcargs.FuncSpecs(function)
|
|
assert not funcspec.funcargnames
|
|
|
|
def test_function_basic(self):
|
|
def func(arg1, arg2="qwe"): pass
|
|
funcspec = funcargs.FuncSpecs(func)
|
|
assert len(funcspec.funcargnames) == 1
|
|
assert 'arg1' in funcspec.funcargnames
|
|
assert funcspec.function is func
|
|
assert funcspec.cls is None
|
|
|
|
def test_addcall_with_id(self):
|
|
def func(arg1): pass
|
|
funcspec = funcargs.FuncSpecs(func)
|
|
py.test.raises(TypeError, """
|
|
funcspec.addcall(_xyz=10)
|
|
""")
|
|
funcspec.addcall(_id="hello", arg1=100)
|
|
py.test.raises(ValueError, "funcspec.addcall(_id='hello', arg1=100)")
|
|
call = funcspec._calls[0]
|
|
assert call.id == "hello"
|
|
assert call.funcargs == {'arg1': 100}
|
|
|
|
def test_addcall_basic(self):
|
|
def func(arg1): pass
|
|
funcspec = funcargs.FuncSpecs(func)
|
|
py.test.raises(ValueError, """
|
|
funcspec.addcall(notexists=100)
|
|
""")
|
|
funcspec.addcall(arg1=100)
|
|
assert len(funcspec._calls) == 1
|
|
assert funcspec._calls[0].funcargs == {'arg1': 100}
|
|
|
|
def test_addcall_two(self):
|
|
def func(arg1): pass
|
|
funcspec = funcargs.FuncSpecs(func)
|
|
funcspec.addcall(arg1=100)
|
|
funcspec.addcall(arg1=101)
|
|
assert len(funcspec._calls) == 2
|
|
assert funcspec._calls[0].funcargs == {'arg1': 100}
|
|
assert funcspec._calls[1].funcargs == {'arg1': 101}
|
|
|
|
class TestGenfuncFunctional:
|
|
def test_attributes(self, testdir):
|
|
p = testdir.makepyfile("""
|
|
import py
|
|
def pytest_genfunc(funcspec):
|
|
funcspec.addcall(funcspec=funcspec)
|
|
|
|
def test_function(funcspec):
|
|
assert funcspec.config == py.test.config
|
|
assert funcspec.module.__name__ == __name__
|
|
assert funcspec.function == test_function
|
|
assert funcspec.cls is None
|
|
class TestClass:
|
|
def test_method(self, funcspec):
|
|
assert funcspec.config == py.test.config
|
|
assert funcspec.module.__name__ == __name__
|
|
# XXX actually have the unbound test function here?
|
|
assert funcspec.function == TestClass.test_method.im_func
|
|
assert funcspec.cls == TestClass
|
|
""")
|
|
result = testdir.runpytest(p, "-v")
|
|
result.stdout.fnmatch_lines([
|
|
"*2 passed in*",
|
|
])
|
|
|
|
def test_arg_twice(self, testdir):
|
|
testdir.makeconftest("""
|
|
class ConftestPlugin:
|
|
def pytest_genfunc(self, funcspec):
|
|
assert "arg" in funcspec.funcargnames
|
|
funcspec.addcall(arg=10)
|
|
funcspec.addcall(arg=20)
|
|
""")
|
|
p = testdir.makepyfile("""
|
|
def test_myfunc(arg):
|
|
assert arg == 10
|
|
""")
|
|
result = testdir.runpytest("-v", p)
|
|
assert result.stdout.fnmatch_lines([
|
|
"*test_myfunc*PASS*", # case for 10
|
|
"*test_myfunc*FAIL*", # case for 20
|
|
"*1 failed, 1 passed*"
|
|
])
|
|
|
|
def test_two_functions(self, testdir):
|
|
p = testdir.makepyfile("""
|
|
def pytest_genfunc(funcspec):
|
|
funcspec.addcall(arg1=10)
|
|
funcspec.addcall(arg1=20)
|
|
|
|
def test_func1(arg1):
|
|
assert arg1 == 10
|
|
def test_func2(arg1):
|
|
assert arg1 in (10, 20)
|
|
""")
|
|
result = testdir.runpytest("-v", p)
|
|
assert result.stdout.fnmatch_lines([
|
|
"*test_func1*0*PASS*",
|
|
"*test_func1*1*FAIL*",
|
|
"*test_func2*PASS*",
|
|
"*1 failed, 3 passed*"
|
|
])
|
|
|
|
def test_genfuncarg_inmodule(self, testdir):
|
|
testdir.makeconftest("""
|
|
class ConftestPlugin:
|
|
def pytest_genfunc(self, funcspec):
|
|
assert "arg1" in funcspec.funcargnames
|
|
funcspec.addcall(_id="world", arg1=1, arg2=2)
|
|
""")
|
|
p = testdir.makepyfile("""
|
|
def pytest_genfunc(funcspec):
|
|
funcspec.addcall(_id="hello", arg1=10, arg2=10)
|
|
|
|
class TestClass:
|
|
def test_myfunc(self, arg1, arg2):
|
|
assert arg1 == arg2
|
|
""")
|
|
result = testdir.runpytest("-v", p)
|
|
assert result.stdout.fnmatch_lines([
|
|
"*test_myfunc*hello*PASS*",
|
|
"*test_myfunc*world*FAIL*",
|
|
"*1 failed, 1 passed*"
|
|
])
|