| import py, pytest |
| |
| import _pytest._code |
| from _pytest.config import getcfg, get_common_ancestor, determine_setup |
| from _pytest.main import EXIT_NOTESTSCOLLECTED |
| |
| class TestParseIni: |
| def test_getcfg_and_config(self, testdir, tmpdir): |
| sub = tmpdir.mkdir("sub") |
| sub.chdir() |
| tmpdir.join("setup.cfg").write(_pytest._code.Source(""" |
| [pytest] |
| name = value |
| """)) |
| rootdir, inifile, cfg = getcfg([sub], ["setup.cfg"]) |
| assert cfg['name'] == "value" |
| config = testdir.parseconfigure(sub) |
| assert config.inicfg['name'] == 'value' |
| |
| def test_getcfg_empty_path(self, tmpdir): |
| getcfg([''], ['setup.cfg']) #happens on py.test "" |
| |
| def test_append_parse_args(self, testdir, tmpdir, monkeypatch): |
| monkeypatch.setenv('PYTEST_ADDOPTS', '--color no -rs --tb="short"') |
| tmpdir.join("setup.cfg").write(_pytest._code.Source(""" |
| [pytest] |
| addopts = --verbose |
| """)) |
| config = testdir.parseconfig(tmpdir) |
| assert config.option.color == 'no' |
| assert config.option.reportchars == 's' |
| assert config.option.tbstyle == 'short' |
| assert config.option.verbose |
| #config = testdir.Config() |
| #args = [tmpdir,] |
| #config._preparse(args, addopts=False) |
| #assert len(args) == 1 |
| |
| def test_tox_ini_wrong_version(self, testdir): |
| testdir.makefile('.ini', tox=""" |
| [pytest] |
| minversion=9.0 |
| """) |
| result = testdir.runpytest() |
| assert result.ret != 0 |
| result.stderr.fnmatch_lines([ |
| "*tox.ini:2*requires*9.0*actual*" |
| ]) |
| |
| @pytest.mark.parametrize("name", "setup.cfg tox.ini pytest.ini".split()) |
| def test_ini_names(self, testdir, name): |
| testdir.tmpdir.join(name).write(py.std.textwrap.dedent(""" |
| [pytest] |
| minversion = 1.0 |
| """)) |
| config = testdir.parseconfig() |
| assert config.getini("minversion") == "1.0" |
| |
| def test_toxini_before_lower_pytestini(self, testdir): |
| sub = testdir.tmpdir.mkdir("sub") |
| sub.join("tox.ini").write(py.std.textwrap.dedent(""" |
| [pytest] |
| minversion = 2.0 |
| """)) |
| testdir.tmpdir.join("pytest.ini").write(py.std.textwrap.dedent(""" |
| [pytest] |
| minversion = 1.5 |
| """)) |
| config = testdir.parseconfigure(sub) |
| assert config.getini("minversion") == "2.0" |
| |
| @pytest.mark.xfail(reason="probably not needed") |
| def test_confcutdir(self, testdir): |
| sub = testdir.mkdir("sub") |
| sub.chdir() |
| testdir.makeini(""" |
| [pytest] |
| addopts = --qwe |
| """) |
| result = testdir.inline_run("--confcutdir=.") |
| assert result.ret == 0 |
| |
| class TestConfigCmdlineParsing: |
| def test_parsing_again_fails(self, testdir): |
| config = testdir.parseconfig() |
| pytest.raises(AssertionError, lambda: config.parse([])) |
| |
| def test_explicitly_specified_config_file_is_loaded(self, testdir): |
| testdir.makeconftest(""" |
| def pytest_addoption(parser): |
| parser.addini("custom", "") |
| """) |
| testdir.makeini(""" |
| [pytest] |
| custom = 0 |
| """) |
| testdir.makefile(".cfg", custom = """ |
| [pytest] |
| custom = 1 |
| """) |
| config = testdir.parseconfig("-c", "custom.cfg") |
| assert config.getini("custom") == "1" |
| |
| class TestConfigAPI: |
| def test_config_trace(self, testdir): |
| config = testdir.parseconfig() |
| l = [] |
| config.trace.root.setwriter(l.append) |
| config.trace("hello") |
| assert len(l) == 1 |
| assert l[0] == "hello [config]\n" |
| |
| def test_config_getoption(self, testdir): |
| testdir.makeconftest(""" |
| def pytest_addoption(parser): |
| parser.addoption("--hello", "-X", dest="hello") |
| """) |
| config = testdir.parseconfig("--hello=this") |
| for x in ("hello", "--hello", "-X"): |
| assert config.getoption(x) == "this" |
| pytest.raises(ValueError, "config.getoption('qweqwe')") |
| |
| @pytest.mark.skipif('sys.version_info[:2] not in [(2, 6), (2, 7)]') |
| def test_config_getoption_unicode(self, testdir): |
| testdir.makeconftest(""" |
| from __future__ import unicode_literals |
| |
| def pytest_addoption(parser): |
| parser.addoption('--hello', type='string') |
| """) |
| config = testdir.parseconfig('--hello=this') |
| assert config.getoption('hello') == 'this' |
| |
| def test_config_getvalueorskip(self, testdir): |
| config = testdir.parseconfig() |
| pytest.raises(pytest.skip.Exception, |
| "config.getvalueorskip('hello')") |
| verbose = config.getvalueorskip("verbose") |
| assert verbose == config.option.verbose |
| |
| def test_config_getvalueorskip_None(self, testdir): |
| testdir.makeconftest(""" |
| def pytest_addoption(parser): |
| parser.addoption("--hello") |
| """) |
| config = testdir.parseconfig() |
| with pytest.raises(pytest.skip.Exception): |
| config.getvalueorskip('hello') |
| |
| def test_getoption(self, testdir): |
| config = testdir.parseconfig() |
| with pytest.raises(ValueError): |
| config.getvalue('x') |
| assert config.getoption("x", 1) == 1 |
| |
| def test_getconftest_pathlist(self, testdir, tmpdir): |
| somepath = tmpdir.join("x", "y", "z") |
| p = tmpdir.join("conftest.py") |
| p.write("pathlist = ['.', %r]" % str(somepath)) |
| config = testdir.parseconfigure(p) |
| assert config._getconftest_pathlist('notexist', path=tmpdir) is None |
| pl = config._getconftest_pathlist('pathlist', path=tmpdir) |
| print(pl) |
| assert len(pl) == 2 |
| assert pl[0] == tmpdir |
| assert pl[1] == somepath |
| |
| def test_addini(self, testdir): |
| testdir.makeconftest(""" |
| def pytest_addoption(parser): |
| parser.addini("myname", "my new ini value") |
| """) |
| testdir.makeini(""" |
| [pytest] |
| myname=hello |
| """) |
| config = testdir.parseconfig() |
| val = config.getini("myname") |
| assert val == "hello" |
| pytest.raises(ValueError, config.getini, 'other') |
| |
| def test_addini_pathlist(self, testdir): |
| testdir.makeconftest(""" |
| def pytest_addoption(parser): |
| parser.addini("paths", "my new ini value", type="pathlist") |
| parser.addini("abc", "abc value") |
| """) |
| p = testdir.makeini(""" |
| [pytest] |
| 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') |
| pytest.raises(ValueError, config.getini, 'other') |
| |
| def test_addini_args(self, testdir): |
| testdir.makeconftest(""" |
| def pytest_addoption(parser): |
| parser.addini("args", "new args", type="args") |
| parser.addini("a2", "", "args", default="1 2 3".split()) |
| """) |
| testdir.makeini(""" |
| [pytest] |
| 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") |
| |
| def test_addini_linelist(self, testdir): |
| testdir.makeconftest(""" |
| def pytest_addoption(parser): |
| parser.addini("xy", "", type="linelist") |
| parser.addini("a2", "", "linelist") |
| """) |
| testdir.makeini(""" |
| [pytest] |
| xy= 123 345 |
| 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 == [] |
| |
| @pytest.mark.parametrize('str_val, bool_val', |
| [('True', True), ('no', False), ('no-ini', True)]) |
| def test_addini_bool(self, testdir, str_val, bool_val): |
| testdir.makeconftest(""" |
| def pytest_addoption(parser): |
| parser.addini("strip", "", type="bool", default=True) |
| """) |
| if str_val != 'no-ini': |
| testdir.makeini(""" |
| [pytest] |
| strip=%s |
| """ % str_val) |
| config = testdir.parseconfig() |
| assert config.getini("strip") is bool_val |
| |
| def test_addinivalue_line_existing(self, testdir): |
| testdir.makeconftest(""" |
| def pytest_addoption(parser): |
| parser.addini("xy", "", type="linelist") |
| """) |
| testdir.makeini(""" |
| [pytest] |
| xy= 123 |
| """) |
| config = testdir.parseconfig() |
| l = config.getini("xy") |
| assert len(l) == 1 |
| assert l == ["123"] |
| config.addinivalue_line("xy", "456") |
| l = config.getini("xy") |
| assert len(l) == 2 |
| assert l == ["123", "456"] |
| |
| def test_addinivalue_line_new(self, testdir): |
| testdir.makeconftest(""" |
| def pytest_addoption(parser): |
| parser.addini("xy", "", type="linelist") |
| """) |
| config = testdir.parseconfig() |
| assert not config.getini("xy") |
| config.addinivalue_line("xy", "456") |
| l = config.getini("xy") |
| assert len(l) == 1 |
| assert l == ["456"] |
| config.addinivalue_line("xy", "123") |
| l = config.getini("xy") |
| assert len(l) == 2 |
| assert l == ["456", "123"] |
| |
| |
| class TestConfigFromdictargs: |
| def test_basic_behavior(self): |
| from _pytest.config import Config |
| option_dict = { |
| 'verbose': 444, |
| 'foo': 'bar', |
| 'capture': 'no', |
| } |
| args = ['a', 'b'] |
| |
| config = Config.fromdictargs(option_dict, args) |
| with pytest.raises(AssertionError): |
| config.parse(['should refuse to parse again']) |
| assert config.option.verbose == 444 |
| assert config.option.foo == 'bar' |
| assert config.option.capture == 'no' |
| assert config.args == args |
| |
| def test_origargs(self): |
| """Show that fromdictargs can handle args in their "orig" format""" |
| from _pytest.config import Config |
| option_dict = {} |
| args = ['-vvvv', '-s', 'a', 'b'] |
| |
| config = Config.fromdictargs(option_dict, args) |
| assert config.args == ['a', 'b'] |
| assert config._origargs == args |
| assert config.option.verbose == 4 |
| assert config.option.capture == 'no' |
| |
| def test_inifilename(self, tmpdir): |
| tmpdir.join("foo/bar.ini").ensure().write(_pytest._code.Source(""" |
| [pytest] |
| name = value |
| """)) |
| |
| from _pytest.config import Config |
| inifile = '../../foo/bar.ini' |
| option_dict = { |
| 'inifilename': inifile, |
| 'capture': 'no', |
| } |
| |
| cwd = tmpdir.join('a/b') |
| cwd.join('pytest.ini').ensure().write(_pytest._code.Source(""" |
| [pytest] |
| name = wrong-value |
| should_not_be_set = true |
| """)) |
| with cwd.ensure(dir=True).as_cwd(): |
| config = Config.fromdictargs(option_dict, ()) |
| |
| assert config.args == [str(cwd)] |
| assert config.option.inifilename == inifile |
| assert config.option.capture == 'no' |
| |
| # this indicates this is the file used for getting configuration values |
| assert config.inifile == inifile |
| assert config.inicfg.get('name') == 'value' |
| assert config.inicfg.get('should_not_be_set') is None |
| |
| |
| def test_options_on_small_file_do_not_blow_up(testdir): |
| def runfiletest(opts): |
| reprec = testdir.inline_run(*opts) |
| passed, skipped, failed = reprec.countoutcomes() |
| assert failed == 2 |
| assert skipped == passed == 0 |
| path = testdir.makepyfile(""" |
| def test_f1(): assert 0 |
| def test_f2(): assert 0 |
| """) |
| |
| for opts in ([], ['-l'], ['-s'], ['--tb=no'], ['--tb=short'], |
| ['--tb=long'], ['--fulltrace'], ['--nomagic'], |
| ['--traceconfig'], ['-v'], ['-v', '-v']): |
| runfiletest(opts + [path]) |
| |
| def test_preparse_ordering_with_setuptools(testdir, monkeypatch): |
| pkg_resources = pytest.importorskip("pkg_resources") |
| def my_iter(name): |
| assert name == "pytest11" |
| class EntryPoint: |
| name = "mytestplugin" |
| class dist: |
| pass |
| def load(self): |
| class PseudoPlugin: |
| x = 42 |
| return PseudoPlugin() |
| return iter([EntryPoint()]) |
| monkeypatch.setattr(pkg_resources, 'iter_entry_points', my_iter) |
| testdir.makeconftest(""" |
| pytest_plugins = "mytestplugin", |
| """) |
| monkeypatch.setenv("PYTEST_PLUGINS", "mytestplugin") |
| config = testdir.parseconfig() |
| plugin = config.pluginmanager.getplugin("mytestplugin") |
| assert plugin.x == 42 |
| |
| def test_plugin_preparse_prevents_setuptools_loading(testdir, monkeypatch): |
| pkg_resources = pytest.importorskip("pkg_resources") |
| def my_iter(name): |
| assert name == "pytest11" |
| class EntryPoint: |
| name = "mytestplugin" |
| def load(self): |
| assert 0, "should not arrive here" |
| return iter([EntryPoint()]) |
| monkeypatch.setattr(pkg_resources, 'iter_entry_points', my_iter) |
| config = testdir.parseconfig("-p", "no:mytestplugin") |
| plugin = config.pluginmanager.getplugin("mytestplugin") |
| assert plugin is None |
| |
| def test_cmdline_processargs_simple(testdir): |
| testdir.makeconftest(""" |
| def pytest_cmdline_preparse(args): |
| args.append("-h") |
| """) |
| result = testdir.runpytest() |
| result.stdout.fnmatch_lines([ |
| "*pytest*", |
| "*-h*", |
| ]) |
| |
| def test_invalid_options_show_extra_information(testdir): |
| """display extra information when pytest exits due to unrecognized |
| options in the command-line""" |
| testdir.makeini(""" |
| [pytest] |
| addopts = --invalid-option |
| """) |
| result = testdir.runpytest() |
| result.stderr.fnmatch_lines([ |
| "*error: unrecognized arguments: --invalid-option*", |
| "* inifile: %s*" % testdir.tmpdir.join('tox.ini'), |
| "* rootdir: %s*" % testdir.tmpdir, |
| ]) |
| |
| |
| @pytest.mark.parametrize('args', [ |
| ['dir1', 'dir2', '-v'], |
| ['dir1', '-v', 'dir2'], |
| ['dir2', '-v', 'dir1'], |
| ['-v', 'dir2', 'dir1'], |
| ]) |
| def test_consider_args_after_options_for_rootdir_and_inifile(testdir, args): |
| """ |
| Consider all arguments in the command-line for rootdir and inifile |
| discovery, even if they happen to occur after an option. #949 |
| """ |
| # replace "dir1" and "dir2" from "args" into their real directory |
| root = testdir.tmpdir.mkdir('myroot') |
| d1 = root.mkdir('dir1') |
| d2 = root.mkdir('dir2') |
| for i, arg in enumerate(args): |
| if arg == 'dir1': |
| args[i] = d1 |
| elif arg == 'dir2': |
| args[i] = d2 |
| result = testdir.runpytest(*args) |
| result.stdout.fnmatch_lines(['*rootdir: *myroot, inifile: ']) |
| |
| |
| @pytest.mark.skipif("sys.platform == 'win32'") |
| def test_toolongargs_issue224(testdir): |
| result = testdir.runpytest("-m", "hello" * 500) |
| assert result.ret == EXIT_NOTESTSCOLLECTED |
| |
| def test_notify_exception(testdir, capfd): |
| config = testdir.parseconfig() |
| excinfo = pytest.raises(ValueError, "raise ValueError(1)") |
| config.notify_exception(excinfo) |
| out, err = capfd.readouterr() |
| assert "ValueError" in err |
| class A: |
| def pytest_internalerror(self, excrepr): |
| return True |
| config.pluginmanager.register(A()) |
| config.notify_exception(excinfo) |
| out, err = capfd.readouterr() |
| assert not err |
| |
| |
| def test_load_initial_conftest_last_ordering(testdir): |
| from _pytest.config import get_config |
| pm = get_config().pluginmanager |
| class My: |
| def pytest_load_initial_conftests(self): |
| pass |
| m = My() |
| pm.register(m) |
| hc = pm.hook.pytest_load_initial_conftests |
| l = hc._nonwrappers + hc._wrappers |
| assert l[-1].function.__module__ == "_pytest.capture" |
| assert l[-2].function == m.pytest_load_initial_conftests |
| assert l[-3].function.__module__ == "_pytest.config" |
| |
| class TestWarning: |
| def test_warn_config(self, testdir): |
| testdir.makeconftest(""" |
| l = [] |
| def pytest_configure(config): |
| config.warn("C1", "hello") |
| def pytest_logwarning(code, message): |
| if message == "hello" and code == "C1": |
| l.append(1) |
| """) |
| testdir.makepyfile(""" |
| def test_proper(pytestconfig): |
| import conftest |
| assert conftest.l == [1] |
| """) |
| reprec = testdir.inline_run() |
| reprec.assertoutcome(passed=1) |
| |
| def test_warn_on_test_item_from_request(self, testdir): |
| testdir.makepyfile(""" |
| import pytest |
| |
| @pytest.fixture |
| def fix(request): |
| request.node.warn("T1", "hello") |
| def test_hello(fix): |
| pass |
| """) |
| result = testdir.runpytest() |
| assert result.parseoutcomes()["pytest-warnings"] > 0 |
| assert "hello" not in result.stdout.str() |
| |
| result = testdir.runpytest("-rw") |
| result.stdout.fnmatch_lines(""" |
| ===*pytest-warning summary*=== |
| *WT1*test_warn_on_test_item*:5*hello* |
| """) |
| |
| class TestRootdir: |
| def test_simple_noini(self, tmpdir): |
| assert get_common_ancestor([tmpdir]) == tmpdir |
| assert get_common_ancestor([tmpdir.mkdir("a"), tmpdir]) == tmpdir |
| assert get_common_ancestor([tmpdir, tmpdir.join("a")]) == tmpdir |
| with tmpdir.as_cwd(): |
| assert get_common_ancestor([]) == tmpdir |
| |
| @pytest.mark.parametrize("name", "setup.cfg tox.ini pytest.ini".split()) |
| def test_with_ini(self, tmpdir, name): |
| inifile = tmpdir.join(name) |
| inifile.write("[pytest]\n") |
| |
| a = tmpdir.mkdir("a") |
| b = a.mkdir("b") |
| for args in ([tmpdir], [a], [b]): |
| rootdir, inifile, inicfg = determine_setup(None, args) |
| assert rootdir == tmpdir |
| assert inifile == inifile |
| rootdir, inifile, inicfg = determine_setup(None, [b,a]) |
| assert rootdir == tmpdir |
| assert inifile == inifile |
| |
| @pytest.mark.parametrize("name", "setup.cfg tox.ini".split()) |
| def test_pytestini_overides_empty_other(self, tmpdir, name): |
| inifile = tmpdir.ensure("pytest.ini") |
| a = tmpdir.mkdir("a") |
| a.ensure(name) |
| rootdir, inifile, inicfg = determine_setup(None, [a]) |
| assert rootdir == tmpdir |
| assert inifile == inifile |
| |
| def test_setuppy_fallback(self, tmpdir): |
| a = tmpdir.mkdir("a") |
| a.ensure("setup.cfg") |
| tmpdir.ensure("setup.py") |
| rootdir, inifile, inicfg = determine_setup(None, [a]) |
| assert rootdir == tmpdir |
| assert inifile is None |
| assert inicfg == {} |
| |
| def test_nothing(self, tmpdir): |
| rootdir, inifile, inicfg = determine_setup(None, [tmpdir]) |
| assert rootdir == tmpdir |
| assert inifile is None |
| assert inicfg == {} |
| |
| def test_with_specific_inifile(self, tmpdir): |
| inifile = tmpdir.ensure("pytest.ini") |
| rootdir, inifile, inicfg = determine_setup(inifile, [tmpdir]) |
| assert rootdir == tmpdir |
