| from __future__ import absolute_import, division, print_function |
| import sys |
| import textwrap |
| import pytest |
| |
| import _pytest._code |
| from _pytest.config.findpaths import getcfg, get_common_ancestor, determine_setup |
| from _pytest.config import _iter_rewritable_modules |
| from _pytest.main import EXIT_NOTESTSCOLLECTED |
| |
| |
| class TestParseIni(object): |
| |
| @pytest.mark.parametrize( |
| "section, filename", [("pytest", "pytest.ini"), ("tool:pytest", "setup.cfg")] |
| ) |
| def test_getcfg_and_config(self, testdir, tmpdir, section, filename): |
| sub = tmpdir.mkdir("sub") |
| sub.chdir() |
| tmpdir.join(filename).write( |
| _pytest._code.Source( |
| """ |
| [{section}] |
| name = value |
| """.format( |
| section=section |
| ) |
| ) |
| ) |
| rootdir, inifile, cfg = getcfg([sub]) |
| assert cfg["name"] == "value" |
| config = testdir.parseconfigure(sub) |
| assert config.inicfg["name"] == "value" |
| |
| def test_getcfg_empty_path(self): |
| """correctly handle zero length arguments (a la pytest '')""" |
| getcfg([""]) |
| |
| def test_append_parse_args(self, testdir, tmpdir, monkeypatch): |
| monkeypatch.setenv("PYTEST_ADDOPTS", '--color no -rs --tb="short"') |
| tmpdir.join("pytest.ini").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 |
| |
| 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( |
| "section, name", |
| [("tool:pytest", "setup.cfg"), ("pytest", "tox.ini"), ("pytest", "pytest.ini")], |
| ) |
| def test_ini_names(self, testdir, name, section): |
| testdir.tmpdir.join(name).write( |
| textwrap.dedent( |
| """ |
| [{section}] |
| minversion = 1.0 |
| """.format( |
| section=section |
| ) |
| ) |
| ) |
| 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( |
| textwrap.dedent( |
| """ |
| [pytest] |
| minversion = 2.0 |
| """ |
| ) |
| ) |
| testdir.tmpdir.join("pytest.ini").write( |
| 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(object): |
| |
| 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" |
| |
| testdir.makefile( |
| ".cfg", |
| custom_tool_pytest_section=""" |
| [tool:pytest] |
| custom = 1 |
| """, |
| ) |
| config = testdir.parseconfig("-c", "custom_tool_pytest_section.cfg") |
| assert config.getini("custom") == "1" |
| |
| def test_absolute_win32_path(self, testdir): |
| temp_cfg_file = testdir.makefile( |
| ".cfg", |
| custom=""" |
| [pytest] |
| addopts = --version |
| """, |
| ) |
| from os.path import normpath |
| |
| temp_cfg_file = normpath(str(temp_cfg_file)) |
| ret = pytest.main("-c " + temp_cfg_file) |
| assert ret == _pytest.main.EXIT_OK |
| |
| |
| class TestConfigAPI(object): |
| |
| def test_config_trace(self, testdir): |
| config = testdir.parseconfig() |
| values = [] |
| config.trace.root.setwriter(values.append) |
| config.trace("hello") |
| assert len(values) == 1 |
| assert values[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[0] < 3") |
| def test_config_getoption_unicode(self, testdir): |
| testdir.makeconftest( |
| """ |
| from __future__ import unicode_literals |
| |
| def pytest_addoption(parser): |
| parser.addoption('--hello', type=str) |
| """ |
| ) |
| 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() |
| 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): |
| 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() |
| 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( |
| """ |
| def pytest_addoption(parser): |
| parser.addini("xy", "", type="linelist") |
| parser.addini("a2", "", "linelist") |
| """ |
| ) |
| testdir.makeini( |
| """ |
| [pytest] |
| xy= 123 345 |
| second line |
| """ |
| ) |
| config = testdir.parseconfig() |
| 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)] |
| ) |
| 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() |
| values = config.getini("xy") |
| assert len(values) == 1 |
| assert values == ["123"] |
| config.addinivalue_line("xy", "456") |
| values = config.getini("xy") |
| assert len(values) == 2 |
| assert values == ["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") |
| values = config.getini("xy") |
| assert len(values) == 1 |
| assert values == ["456"] |
| config.addinivalue_line("xy", "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)""" |
| with pytest.raises(pytest.UsageError): |
| testdir.parseconfig( |
| "--confcutdir", testdir.tmpdir.join("file").ensure(file=1) |
| ) |
| with pytest.raises(pytest.UsageError): |
| testdir.parseconfig("--confcutdir", testdir.tmpdir.join("inexistant")) |
| config = testdir.parseconfig( |
| "--confcutdir", testdir.tmpdir.join("dir").ensure(dir=1) |
| ) |
| assert config.getoption("confcutdir") == str(testdir.tmpdir.join("dir")) |
| |
| @pytest.mark.parametrize( |
| "names, expected", |
| [ |
| (["bar.py"], ["bar"]), |
| (["foo", "bar.py"], []), |
| (["foo", "bar.pyc"], []), |
| (["foo", "__init__.py"], ["foo"]), |
| (["foo", "bar", "__init__.py"], []), |
| ], |
| ) |
| def test_iter_rewritable_modules(self, names, expected): |
| assert list(_iter_rewritable_modules(["/".join(names)])) == expected |
| |
| |
| class TestConfigFromdictargs(object): |
| |
| 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"], |
| ["--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 Dist(object): |
| project_name = "spam" |
| version = "1.0" |
| |
| def _get_metadata(self, name): |
| return ["foo.txt,sha256=abc,123"] |
| |
| class EntryPoint(object): |
| name = "mytestplugin" |
| dist = Dist() |
| |
| def load(self): |
| |
| class PseudoPlugin(object): |
| 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_setuptools_importerror_issue1479(testdir, monkeypatch): |
| pkg_resources = pytest.importorskip("pkg_resources") |
| |
| def my_iter(name): |
| assert name == "pytest11" |
| |
| class Dist(object): |
| project_name = "spam" |
| version = "1.0" |
| |
| def _get_metadata(self, name): |
| return ["foo.txt,sha256=abc,123"] |
| |
| class EntryPoint(object): |
| name = "mytestplugin" |
| dist = Dist() |
| |
| def load(self): |
| raise ImportError("Don't hide me!") |
| |
| return iter([EntryPoint()]) |
| |
| monkeypatch.setattr(pkg_resources, "iter_entry_points", my_iter) |
| with pytest.raises(ImportError): |
| testdir.parseconfig() |
| |
| |
| @pytest.mark.parametrize("block_it", [True, False]) |
| def test_plugin_preparse_prevents_setuptools_loading(testdir, monkeypatch, block_it): |
| pkg_resources = pytest.importorskip("pkg_resources") |
| |
| plugin_module_placeholder = object() |
| |
| def my_iter(name): |
| assert name == "pytest11" |
| |
| class Dist(object): |
| project_name = "spam" |
| version = "1.0" |
| |
| def _get_metadata(self, name): |
| return ["foo.txt,sha256=abc,123"] |
| |
| class EntryPoint(object): |
| name = "mytestplugin" |
| dist = Dist() |
| |
| def load(self): |
| return plugin_module_placeholder |
| |
| return iter([EntryPoint()]) |
| |
| monkeypatch.setattr(pkg_resources, "iter_entry_points", my_iter) |
| args = ("-p", "no:mytestplugin") if block_it else () |
| config = testdir.parseconfig(*args) |
| config.pluginmanager.import_plugin("mytestplugin") |
| if block_it: |
| assert "mytestplugin" not in sys.modules |
| assert config.pluginmanager.get_plugin("mytestplugin") is None |
| else: |
| assert config.pluginmanager.get_plugin( |
| "mytestplugin" |
| ) is plugin_module_placeholder |
| |
| |
| 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 |
| with root.as_cwd(): |
| 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_config_in_subdirectory_colon_command_line_issue2148(testdir): |
| conftest_source = """ |
| def pytest_addoption(parser): |
| parser.addini('foo', 'foo') |
| """ |
| |
| testdir.makefile( |
| ".ini", |
| **{"pytest": "[pytest]\nfoo = root", "subdir/pytest": "[pytest]\nfoo = subdir"} |
| ) |
| |
| testdir.makepyfile( |
| **{ |
| "conftest": conftest_source, |
| "subdir/conftest": conftest_source, |
| "subdir/test_foo": """ |
| def test_foo(pytestconfig): |
| assert pytestconfig.getini('foo') == 'subdir' |
| """, |
| } |
| ) |
| |
| result = testdir.runpytest("subdir/test_foo.py::test_foo") |
| assert result.ret == 0 |
| |
| |
| 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(object): |
| |
| 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(object): |
| |
| def pytest_load_initial_conftests(self): |
| pass |
| |
| m = My() |
| pm.register(m) |
| hc = pm.hook.pytest_load_initial_conftests |
| values = hc._nonwrappers + hc._wrappers |
| expected = ["_pytest.config", "test_config", "_pytest.capture"] |
| assert [x.function.__module__ for x in values] == expected |
| |
| |
| def test_get_plugin_specs_as_list(): |
| from _pytest.config import _get_plugin_specs_as_list |
| |
| with pytest.raises(pytest.UsageError): |
| _get_plugin_specs_as_list({"foo"}) |
| with pytest.raises(pytest.UsageError): |
| _get_plugin_specs_as_list(dict()) |
| |
| assert _get_plugin_specs_as_list(None) == [] |
| assert _get_plugin_specs_as_list("") == [] |
| assert _get_plugin_specs_as_list("foo") == ["foo"] |
| assert _get_plugin_specs_as_list("foo,bar") == ["foo", "bar"] |
| assert _get_plugin_specs_as_list(["foo", "bar"]) == ["foo", "bar"] |
| assert _get_plugin_specs_as_list(("foo", "bar")) == ["foo", "bar"] |
| |
| |
| class TestWarning(object): |
| |
| def test_warn_config(self, testdir): |
| testdir.makeconftest( |
| """ |
| values = [] |
| def pytest_configure(config): |
| config.warn("C1", "hello") |
| def pytest_logwarning(code, message): |
| if message == "hello" and code == "C1": |
| values.append(1) |
| """ |
| ) |
| testdir.makepyfile( |
| """ |
| def test_proper(pytestconfig): |
| import conftest |
| assert conftest.values == [1] |
| """ |
| ) |
| reprec = testdir.inline_run() |
| reprec.assertoutcome(passed=1) |
| |
| def test_warn_on_test_item_from_request(self, testdir, request): |
| testdir.makepyfile( |
| """ |
| import pytest |
| |
| @pytest.fixture |
| def fix(request): |
| request.node.warn("T1", "hello") |
| |
| def test_hello(fix): |
| pass |
| """ |
| ) |
| result = testdir.runpytest("--disable-pytest-warnings") |
| assert result.parseoutcomes()["warnings"] > 0 |
| assert "hello" not in result.stdout.str() |
| |
| result = testdir.runpytest() |
| result.stdout.fnmatch_lines( |
| """ |
| ===*warnings summary*=== |
| *test_warn_on_test_item_from_request.py::test_hello* |
| *hello* |
| """ |
| ) |
| |
| |
| class TestRootdir(object): |
| |
| def test_simple_noini(self, tmpdir): |
| assert get_common_ancestor([tmpdir]) == tmpdir |
| a = tmpdir.mkdir("a") |
| assert get_common_ancestor([a, tmpdir]) == tmpdir |
| assert get_common_ancestor([tmpdir, a]) == tmpdir |
| with tmpdir.as_cwd(): |
| assert get_common_ancestor([]) == tmpdir |
| no_path = tmpdir.join("does-not-exist") |
| assert get_common_ancestor([no_path]) == tmpdir |
| assert get_common_ancestor([no_path.join("a")]) == 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, monkeypatch): |
| monkeypatch.chdir(str(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 |
| |
| |
| class TestOverrideIniArgs(object): |
| |
| @pytest.mark.parametrize("name", "setup.cfg tox.ini pytest.ini".split()) |
| def test_override_ini_names(self, testdir, name): |
| testdir.tmpdir.join(name).write( |
| textwrap.dedent( |
| """ |
| [pytest] |
| custom = 1.0""" |
| ) |
| ) |
| testdir.makeconftest( |
| """ |
| def pytest_addoption(parser): |
| parser.addini("custom", "")""" |
| ) |
| testdir.makepyfile( |
| """ |
| def test_pass(pytestconfig): |
| ini_val = pytestconfig.getini("custom") |
| print('\\ncustom_option:%s\\n' % ini_val)""" |
| ) |
| |
| result = testdir.runpytest("--override-ini", "custom=2.0", "-s") |
| assert result.ret == 0 |
| result.stdout.fnmatch_lines(["custom_option:2.0"]) |
| |
| result = testdir.runpytest( |
| "--override-ini", "custom=2.0", "--override-ini=custom=3.0", "-s" |
| ) |
| assert result.ret == 0 |
| result.stdout.fnmatch_lines(["custom_option:3.0"]) |
| |
| def test_override_ini_pathlist(self, testdir): |
| testdir.makeconftest( |
| """ |
| def pytest_addoption(parser): |
| parser.addini("paths", "my new ini value", type="pathlist")""" |
| ) |
| testdir.makeini( |
| """ |
| [pytest] |
| paths=blah.py""" |
| ) |
| testdir.makepyfile( |
| """ |
| import py.path |
| def test_pathlist(pytestconfig): |
| config_paths = pytestconfig.getini("paths") |
| print(config_paths) |
| for cpf in config_paths: |
| print('\\nuser_path:%s' % cpf.basename)""" |
| ) |
| result = testdir.runpytest( |
| "--override-ini", "paths=foo/bar1.py foo/bar2.py", "-s" |
| ) |
| result.stdout.fnmatch_lines(["user_path:bar1.py", "user_path:bar2.py"]) |
| |
| def test_override_multiple_and_default(self, testdir): |
| testdir.makeconftest( |
| """ |
| def pytest_addoption(parser): |
| addini = parser.addini |
| addini("custom_option_1", "", default="o1") |
| addini("custom_option_2", "", default="o2") |
| addini("custom_option_3", "", default=False, type="bool") |
| addini("custom_option_4", "", default=True, type="bool")""" |
| ) |
| testdir.makeini( |
| """ |
| [pytest] |
| custom_option_1=custom_option_1 |
| custom_option_2=custom_option_2 |
| """ |
| ) |
| testdir.makepyfile( |
| """ |
| def test_multiple_options(pytestconfig): |
| prefix = "custom_option" |
| for x in range(1, 5): |
| ini_value=pytestconfig.getini("%s_%d" % (prefix, x)) |
| print('\\nini%d:%s' % (x, ini_value)) |
| """ |
| ) |
| result = testdir.runpytest( |
| "--override-ini", |
| "custom_option_1=fulldir=/tmp/user1", |
| "-o", |
| "custom_option_2=url=/tmp/user2?a=b&d=e", |
| "-o", |
| "custom_option_3=True", |
| "-o", |
| "custom_option_4=no", |
| "-s", |
| ) |
| result.stdout.fnmatch_lines( |
| [ |
| "ini1:fulldir=/tmp/user1", |
| "ini2:url=/tmp/user2?a=b&d=e", |
| "ini3:True", |
| "ini4:False", |
| ] |
| ) |
| |
| def test_override_ini_usage_error_bad_style(self, testdir): |
| testdir.makeini( |
| """ |
| [pytest] |
| xdist_strict=False |
| """ |
| ) |
| result = testdir.runpytest("--override-ini", "xdist_strict True", "-s") |
| result.stderr.fnmatch_lines(["*ERROR* *expects option=value*"]) |
| |
| @pytest.mark.parametrize("with_ini", [True, False]) |
| def test_override_ini_handled_asap(self, testdir, with_ini): |
| """-o should be handled as soon as possible and always override what's in ini files (#2238)""" |
| if with_ini: |
| testdir.makeini( |
| """ |
| [pytest] |
| python_files=test_*.py |
| """ |
| ) |
| testdir.makepyfile( |
| unittest_ini_handle=""" |
| def test(): |
| pass |
| """ |
| ) |
| result = testdir.runpytest("--override-ini", "python_files=unittest_*.py") |
| result.stdout.fnmatch_lines(["*1 passed in*"]) |
| |
| def test_with_arg_outside_cwd_without_inifile(self, tmpdir, monkeypatch): |
| monkeypatch.chdir(str(tmpdir)) |
| a = tmpdir.mkdir("a") |
| b = tmpdir.mkdir("b") |
| rootdir, inifile, inicfg = determine_setup(None, [a, b]) |
| assert rootdir == tmpdir |
| assert inifile is None |
| |
| def test_with_arg_outside_cwd_with_inifile(self, tmpdir): |
| a = tmpdir.mkdir("a") |
| b = tmpdir.mkdir("b") |
| inifile = a.ensure("pytest.ini") |
| rootdir, parsed_inifile, inicfg = determine_setup(None, [a, b]) |
| assert rootdir == a |
| assert inifile == parsed_inifile |
| |
| @pytest.mark.parametrize("dirs", ([], ["does-not-exist"], ["a/does-not-exist"])) |
| def test_with_non_dir_arg(self, dirs, tmpdir): |
| with tmpdir.ensure(dir=True).as_cwd(): |
| rootdir, inifile, inicfg = determine_setup(None, dirs) |
| assert rootdir == tmpdir |
| assert inifile is None |
| |
| def test_with_existing_file_in_subdir(self, tmpdir): |
| a = tmpdir.mkdir("a") |
| a.ensure("exist") |
| with tmpdir.as_cwd(): |
| rootdir, inifile, inicfg = determine_setup(None, ["a/exist"]) |
| assert rootdir == tmpdir |
| assert inifile is None |
| |
| def test_addopts_before_initini(self, monkeypatch): |
| cache_dir = ".custom_cache" |
| monkeypatch.setenv("PYTEST_ADDOPTS", "-o cache_dir=%s" % cache_dir) |
| from _pytest.config import get_config |
| |
| config = get_config() |
| config._preparse([], addopts=True) |
| assert config._override_ini == ["cache_dir=%s" % cache_dir] |
| |
| def test_override_ini_does_not_contain_paths(self): |
| """Check that -o no longer swallows all options after it (#3103)""" |
| from _pytest.config import get_config |
| |
| config = get_config() |
| config._preparse(["-o", "cache_dir=/cache", "/some/test/path"]) |
| assert config._override_ini == ["cache_dir=/cache"] |
| |
| def test_multiple_override_ini_options(self, testdir, request): |
| """Ensure a file path following a '-o' option does not generate an error (#3103)""" |
| testdir.makepyfile( |
| **{ |
| "conftest.py": """ |
| def pytest_addoption(parser): |
| parser.addini('foo', default=None, help='some option') |
| parser.addini('bar', default=None, help='some option') |
| """, |
| "test_foo.py": """ |
| def test(pytestconfig): |
| assert pytestconfig.getini('foo') == '1' |
| assert pytestconfig.getini('bar') == '0' |
| """, |
| "test_bar.py": """ |
| def test(): |
| assert False |
| """, |
| } |
| ) |
| result = testdir.runpytest("-o", "foo=1", "-o", "bar=0", "test_foo.py") |
| assert "ERROR:" not in result.stderr.str() |
| result.stdout.fnmatch_lines(["collected 1 item", "*= 1 passed in *="]) |