371 lines
13 KiB
Python
371 lines
13 KiB
Python
# encoding: UTF-8
|
|
import pytest
|
|
import py
|
|
import os
|
|
|
|
from _pytest.config import get_config, PytestPluginManager
|
|
from _pytest.main import EXIT_NOTESTSCOLLECTED, Session
|
|
|
|
|
|
@pytest.fixture
|
|
def pytestpm():
|
|
return PytestPluginManager()
|
|
|
|
class TestPytestPluginInteractions:
|
|
def test_addhooks_conftestplugin(self, testdir):
|
|
testdir.makepyfile(newhooks="""
|
|
def pytest_myhook(xyz):
|
|
"new hook"
|
|
""")
|
|
conf = testdir.makeconftest("""
|
|
import sys ; sys.path.insert(0, '.')
|
|
import newhooks
|
|
def pytest_addhooks(pluginmanager):
|
|
pluginmanager.addhooks(newhooks)
|
|
def pytest_myhook(xyz):
|
|
return xyz + 1
|
|
""")
|
|
config = get_config()
|
|
pm = config.pluginmanager
|
|
pm.hook.pytest_addhooks.call_historic(
|
|
kwargs=dict(pluginmanager=config.pluginmanager))
|
|
config.pluginmanager._importconftest(conf)
|
|
#print(config.pluginmanager.get_plugins())
|
|
res = config.hook.pytest_myhook(xyz=10)
|
|
assert res == [11]
|
|
|
|
def test_addhooks_nohooks(self, testdir):
|
|
testdir.makeconftest("""
|
|
import sys
|
|
def pytest_addhooks(pluginmanager):
|
|
pluginmanager.addhooks(sys)
|
|
""")
|
|
res = testdir.runpytest()
|
|
assert res.ret != 0
|
|
res.stderr.fnmatch_lines([
|
|
"*did not find*sys*"
|
|
])
|
|
|
|
def test_namespace_early_from_import(self, testdir):
|
|
p = testdir.makepyfile("""
|
|
from pytest import Item
|
|
from pytest import Item as Item2
|
|
assert Item is Item2
|
|
""")
|
|
result = testdir.runpython(p)
|
|
assert result.ret == 0
|
|
|
|
def test_do_ext_namespace(self, testdir):
|
|
testdir.makeconftest("""
|
|
def pytest_namespace():
|
|
return {'hello': 'world'}
|
|
""")
|
|
p = testdir.makepyfile("""
|
|
from pytest import hello
|
|
import pytest
|
|
def test_hello():
|
|
assert hello == "world"
|
|
assert 'hello' in pytest.__all__
|
|
""")
|
|
reprec = testdir.inline_run(p)
|
|
reprec.assertoutcome(passed=1)
|
|
|
|
def test_do_option_postinitialize(self, testdir):
|
|
config = testdir.parseconfigure()
|
|
assert not hasattr(config.option, 'test123')
|
|
p = testdir.makepyfile("""
|
|
def pytest_addoption(parser):
|
|
parser.addoption('--test123', action="store_true",
|
|
default=True)
|
|
""")
|
|
config.pluginmanager._importconftest(p)
|
|
assert config.option.test123
|
|
|
|
def test_configure(self, testdir):
|
|
config = testdir.parseconfig()
|
|
l = []
|
|
|
|
class A:
|
|
def pytest_configure(self, config):
|
|
l.append(self)
|
|
|
|
config.pluginmanager.register(A())
|
|
assert len(l) == 0
|
|
config._do_configure()
|
|
assert len(l) == 1
|
|
config.pluginmanager.register(A()) # leads to a configured() plugin
|
|
assert len(l) == 2
|
|
assert l[0] != l[1]
|
|
|
|
config._ensure_unconfigure()
|
|
config.pluginmanager.register(A())
|
|
assert len(l) == 2
|
|
|
|
def test_hook_tracing(self):
|
|
pytestpm = get_config().pluginmanager # fully initialized with plugins
|
|
saveindent = []
|
|
|
|
class api1:
|
|
def pytest_plugin_registered(self):
|
|
saveindent.append(pytestpm.trace.root.indent)
|
|
|
|
class api2:
|
|
def pytest_plugin_registered(self):
|
|
saveindent.append(pytestpm.trace.root.indent)
|
|
raise ValueError()
|
|
|
|
l = []
|
|
pytestpm.trace.root.setwriter(l.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]
|
|
|
|
l[:] = []
|
|
with pytest.raises(ValueError):
|
|
pytestpm.register(api2())
|
|
assert pytestpm.trace.root.indent == indent
|
|
assert saveindent[0] > indent
|
|
finally:
|
|
undo()
|
|
|
|
def test_hook_proxy(self, testdir):
|
|
"""Test the gethookproxy function(#2016)"""
|
|
config = testdir.parseconfig()
|
|
session = Session(config)
|
|
testdir.makepyfile(**{
|
|
'tests/conftest.py': '',
|
|
'tests/subdir/conftest.py': '',
|
|
})
|
|
|
|
conftest1 = testdir.tmpdir.join('tests/conftest.py')
|
|
conftest2 = testdir.tmpdir.join('tests/subdir/conftest.py')
|
|
|
|
config.pluginmanager._importconftest(conftest1)
|
|
ihook_a = session.gethookproxy(testdir.tmpdir.join('tests'))
|
|
assert ihook_a is not None
|
|
config.pluginmanager._importconftest(conftest2)
|
|
ihook_b = session.gethookproxy(testdir.tmpdir.join('tests'))
|
|
assert ihook_a is not ihook_b
|
|
|
|
def test_warn_on_deprecated_multicall(self, pytestpm):
|
|
warnings = []
|
|
|
|
class get_warnings:
|
|
def pytest_logwarning(self, message):
|
|
warnings.append(message)
|
|
|
|
class Plugin:
|
|
def pytest_configure(self, __multicall__):
|
|
pass
|
|
|
|
pytestpm.register(get_warnings())
|
|
before = list(warnings)
|
|
pytestpm.register(Plugin())
|
|
assert len(warnings) == len(before) + 1
|
|
assert "deprecated" in warnings[-1]
|
|
|
|
def test_warn_on_deprecated_addhooks(self, pytestpm):
|
|
warnings = []
|
|
|
|
class get_warnings:
|
|
def pytest_logwarning(self, code, fslocation, message, nodeid):
|
|
warnings.append(message)
|
|
|
|
class Plugin:
|
|
def pytest_testhook():
|
|
pass
|
|
|
|
pytestpm.register(get_warnings())
|
|
before = list(warnings)
|
|
pytestpm.addhooks(Plugin())
|
|
assert len(warnings) == len(before) + 1
|
|
assert "deprecated" in warnings[-1]
|
|
|
|
|
|
def test_namespace_has_default_and_env_plugins(testdir):
|
|
p = testdir.makepyfile("""
|
|
import pytest
|
|
pytest.mark
|
|
""")
|
|
result = testdir.runpython(p)
|
|
assert result.ret == 0
|
|
|
|
def test_default_markers(testdir):
|
|
result = testdir.runpytest("--markers")
|
|
result.stdout.fnmatch_lines([
|
|
"*tryfirst*first*",
|
|
"*trylast*last*",
|
|
])
|
|
|
|
|
|
def test_importplugin_error_message(testdir, pytestpm):
|
|
"""Don't hide import errors when importing plugins and provide
|
|
an easy to debug message.
|
|
|
|
See #375 and #1998.
|
|
"""
|
|
testdir.syspathinsert(testdir.tmpdir)
|
|
testdir.makepyfile(qwe="""
|
|
# encoding: UTF-8
|
|
raise ImportError(u'Not possible to import: ☺')
|
|
""")
|
|
with pytest.raises(ImportError) as excinfo:
|
|
pytestpm.import_plugin("qwe")
|
|
expected = '.*Error importing plugin "qwe": Not possible to import: .'
|
|
assert py.std.re.match(expected, str(excinfo.value))
|
|
|
|
|
|
class TestPytestPluginManager:
|
|
def test_register_imported_modules(self):
|
|
pm = PytestPluginManager()
|
|
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
|
|
pytest.raises(ValueError, "pm.register(mod)")
|
|
pytest.raises(ValueError, lambda: pm.register(mod))
|
|
#assert not pm.is_registered(mod2)
|
|
assert pm.get_plugins() == l
|
|
|
|
def test_canonical_import(self, monkeypatch):
|
|
mod = py.std.types.ModuleType("pytest_xyz")
|
|
monkeypatch.setitem(py.std.sys.modules, 'pytest_xyz', mod)
|
|
pm = PytestPluginManager()
|
|
pm.import_plugin('pytest_xyz')
|
|
assert pm.get_plugin('pytest_xyz') == mod
|
|
assert pm.is_registered(mod)
|
|
|
|
def test_consider_module(self, testdir, pytestpm):
|
|
testdir.syspathinsert()
|
|
testdir.makepyfile(pytest_p1="#")
|
|
testdir.makepyfile(pytest_p2="#")
|
|
mod = py.std.types.ModuleType("temp")
|
|
mod.pytest_plugins = ["pytest_p1", "pytest_p2"]
|
|
pytestpm.consider_module(mod)
|
|
assert pytestpm.get_plugin("pytest_p1").__name__ == "pytest_p1"
|
|
assert pytestpm.get_plugin("pytest_p2").__name__ == "pytest_p2"
|
|
|
|
def test_consider_module_import_module(self, testdir):
|
|
pytestpm = get_config().pluginmanager
|
|
mod = py.std.types.ModuleType("x")
|
|
mod.pytest_plugins = "pytest_a"
|
|
aplugin = testdir.makepyfile(pytest_a="#")
|
|
reprec = testdir.make_hook_recorder(pytestpm)
|
|
#syspath.prepend(aplugin.dirpath())
|
|
py.std.sys.path.insert(0, str(aplugin.dirpath()))
|
|
pytestpm.consider_module(mod)
|
|
call = reprec.getcall(pytestpm.hook.pytest_plugin_registered.name)
|
|
assert call.plugin.__name__ == "pytest_a"
|
|
|
|
# check that it is not registered twice
|
|
pytestpm.consider_module(mod)
|
|
l = reprec.getcalls("pytest_plugin_registered")
|
|
assert len(l) == 1
|
|
|
|
def test_consider_env_fails_to_import(self, monkeypatch, pytestpm):
|
|
monkeypatch.setenv('PYTEST_PLUGINS', 'nonexisting', prepend=",")
|
|
with pytest.raises(ImportError):
|
|
pytestpm.consider_env()
|
|
|
|
def test_plugin_skip(self, testdir, monkeypatch):
|
|
p = testdir.makepyfile(skipping1="""
|
|
import pytest
|
|
pytest.skip("hello")
|
|
""")
|
|
p.copy(p.dirpath("skipping2.py"))
|
|
monkeypatch.setenv("PYTEST_PLUGINS", "skipping2")
|
|
result = testdir.runpytest("-rw", "-p", "skipping1", syspathinsert=True)
|
|
assert result.ret == EXIT_NOTESTSCOLLECTED
|
|
result.stdout.fnmatch_lines([
|
|
"WI1*skipped plugin*skipping1*hello*",
|
|
"WI1*skipped plugin*skipping2*hello*",
|
|
])
|
|
|
|
def test_consider_env_plugin_instantiation(self, testdir, monkeypatch, pytestpm):
|
|
testdir.syspathinsert()
|
|
testdir.makepyfile(xy123="#")
|
|
monkeypatch.setitem(os.environ, 'PYTEST_PLUGINS', 'xy123')
|
|
l1 = len(pytestpm.get_plugins())
|
|
pytestpm.consider_env()
|
|
l2 = len(pytestpm.get_plugins())
|
|
assert l2 == l1 + 1
|
|
assert pytestpm.get_plugin('xy123')
|
|
pytestpm.consider_env()
|
|
l3 = len(pytestpm.get_plugins())
|
|
assert l2 == l3
|
|
|
|
def test_pluginmanager_ENV_startup(self, testdir, monkeypatch):
|
|
testdir.makepyfile(pytest_x500="#")
|
|
p = testdir.makepyfile("""
|
|
import pytest
|
|
def test_hello(pytestconfig):
|
|
plugin = pytestconfig.pluginmanager.get_plugin('pytest_x500')
|
|
assert plugin is not None
|
|
""")
|
|
monkeypatch.setenv('PYTEST_PLUGINS', 'pytest_x500', prepend=",")
|
|
result = testdir.runpytest(p, syspathinsert=True)
|
|
assert result.ret == 0
|
|
result.stdout.fnmatch_lines(["*1 passed*"])
|
|
|
|
def test_import_plugin_importname(self, testdir, pytestpm):
|
|
pytest.raises(ImportError, 'pytestpm.import_plugin("qweqwex.y")')
|
|
pytest.raises(ImportError, 'pytestpm.import_plugin("pytest_qweqwx.y")')
|
|
|
|
testdir.syspathinsert()
|
|
pluginname = "pytest_hello"
|
|
testdir.makepyfile(**{pluginname: ""})
|
|
pytestpm.import_plugin("pytest_hello")
|
|
len1 = len(pytestpm.get_plugins())
|
|
pytestpm.import_plugin("pytest_hello")
|
|
len2 = len(pytestpm.get_plugins())
|
|
assert len1 == len2
|
|
plugin1 = pytestpm.get_plugin("pytest_hello")
|
|
assert plugin1.__name__.endswith('pytest_hello')
|
|
plugin2 = pytestpm.get_plugin("pytest_hello")
|
|
assert plugin2 is plugin1
|
|
|
|
def test_import_plugin_dotted_name(self, testdir, pytestpm):
|
|
pytest.raises(ImportError, 'pytestpm.import_plugin("qweqwex.y")')
|
|
pytest.raises(ImportError, 'pytestpm.import_plugin("pytest_qweqwex.y")')
|
|
|
|
testdir.syspathinsert()
|
|
testdir.mkpydir("pkg").join("plug.py").write("x=3")
|
|
pluginname = "pkg.plug"
|
|
pytestpm.import_plugin(pluginname)
|
|
mod = pytestpm.get_plugin("pkg.plug")
|
|
assert mod.x == 3
|
|
|
|
def test_consider_conftest_deps(self, testdir, pytestpm):
|
|
mod = testdir.makepyfile("pytest_plugins='xyz'").pyimport()
|
|
with pytest.raises(ImportError):
|
|
pytestpm.consider_conftest(mod)
|
|
|
|
|
|
class TestPytestPluginManagerBootstrapming:
|
|
def test_preparse_args(self, pytestpm):
|
|
pytest.raises(ImportError, lambda:
|
|
pytestpm.consider_preparse(["xyz", "-p", "hello123"]))
|
|
|
|
def test_plugin_prevent_register(self, pytestpm):
|
|
pytestpm.consider_preparse(["xyz", "-p", "no:abc"])
|
|
l1 = pytestpm.get_plugins()
|
|
pytestpm.register(42, name="abc")
|
|
l2 = pytestpm.get_plugins()
|
|
assert len(l2) == len(l1)
|
|
assert 42 not in l2
|
|
|
|
def test_plugin_prevent_register_unregistered_alredy_registered(self, pytestpm):
|
|
pytestpm.register(42, name="abc")
|
|
l1 = pytestpm.get_plugins()
|
|
assert 42 in l1
|
|
pytestpm.consider_preparse(["xyz", "-p", "no:abc"])
|
|
l2 = pytestpm.get_plugins()
|
|
assert 42 not in l2
|