# mypy: allow-untyped-defs

from __future__ import annotations

from itertools import zip_longest

import os

from pathlib import Path

import sys

import textwrap

from _pytest.compat import getfuncargnames

from _pytest.config import ExitCode

from _pytest.fixtures import deduplicate_names

from _pytest.fixtures import ParamValueKey

from _pytest.fixtures import TopRequest

from _pytest.monkeypatch import MonkeyPatch

from _pytest.pytester import get_public_names

from _pytest.pytester import Pytester

from _pytest.python import Function

import pytest

def test_getfuncargnames_functions():

"""Test getfuncargnames for normal functions"""

def f():

raise NotImplementedError()

assert not getfuncargnames(f)

def g(arg):

raise NotImplementedError()

assert getfuncargnames(g) == ("arg",)

def h(arg1, arg2="hello"):

raise NotImplementedError()

assert getfuncargnames(h) == ("arg1",)

def j(arg1, arg2, arg3="hello"):

raise NotImplementedError()

assert getfuncargnames(j) == ("arg1", "arg2")

def test_getfuncargnames_methods():

"""Test getfuncargnames for normal methods"""

class A:

def f(self, arg1, arg2="hello"):

raise NotImplementedError()

def g(self, /, arg1, arg2="hello"):

raise NotImplementedError()

def h(self, *, arg1, arg2="hello"):

raise NotImplementedError()

def j(self, arg1, *, arg2, arg3="hello"):

raise NotImplementedError()

def k(self, /, arg1, *, arg2, arg3="hello"):

raise NotImplementedError()

assert getfuncargnames(A().f) == ("arg1",)

assert getfuncargnames(A().g) == ("arg1",)

assert getfuncargnames(A().h) == ("arg1",)

assert getfuncargnames(A().j) == ("arg1", "arg2")

assert getfuncargnames(A().k) == ("arg1", "arg2")

def test_getfuncargnames_staticmethod():

"""Test getfuncargnames for staticmethods"""

class A:

@staticmethod

def static(arg1, arg2, x=1):

raise NotImplementedError()

assert getfuncargnames(A.static, cls=A) == ("arg1", "arg2")

def test_getfuncargnames_staticmethod_inherited() -> None:

"""Test getfuncargnames for inherited staticmethods (#8061)"""

class A:

@staticmethod

def static(arg1, arg2, x=1):

raise NotImplementedError()

class B(A):

pass

assert getfuncargnames(B.static, cls=B) == ("arg1", "arg2")

@pytest.mark.skipif(

sys.version_info >= (3, 13),

reason="""\

In python 3.13, this will raise FutureWarning:

functools.partial will be a method descriptor in future Python versions;

wrap it in staticmethod() if you want to preserve the old behavior

But the wrapped 'functools.partial' is tested by 'test_getfuncargnames_staticmethod_partial' below.

""",

)

def test_getfuncargnames_partial():

"""Check getfuncargnames for methods defined with functools.partial (#5701)"""

import functools

def check(arg1, arg2, i):

raise NotImplementedError()

class T:

test_ok = functools.partial(check, i=2)

values = getfuncargnames(T().test_ok, name="test_ok")

assert values == ("arg1", "arg2")

def test_getfuncargnames_staticmethod_partial():

"""Check getfuncargnames for staticmethods defined with functools.partial (#5701)"""

import functools

def check(arg1, arg2, i):

raise NotImplementedError()

class T:

test_ok = staticmethod(functools.partial(check, i=2))

values = getfuncargnames(T().test_ok, name="test_ok")

assert values == ("arg1", "arg2")

@pytest.mark.pytester_example_path("fixtures/fill_fixtures")

class TestFillFixtures:

def test_funcarg_lookupfails(self, pytester: Pytester) -> None:

pytester.copy_example()

result = pytester.runpytest() # "--collect-only")

assert result.ret != 0

result.stdout.fnmatch_lines(

"""

*def test_func(some)*

*fixture*some*not found*

*xyzsomething*

"""

)

def test_detect_recursive_dependency_error(self, pytester: Pytester) -> None:

pytester.copy_example()

result = pytester.runpytest()

result.stdout.fnmatch_lines(

["*recursive dependency involving fixture 'fix1' detected*"]

)

def test_funcarg_basic(self, pytester: Pytester) -> None:

pytester.copy_example()

item = pytester.getitem(Path("test_funcarg_basic.py"))

assert isinstance(item, Function)

# Execute's item's setup, which fills fixtures.

item.session._setupstate.setup(item)

del item.funcargs["request"]

assert len(get_public_names(item.funcargs)) == 2

assert item.funcargs["some"] == "test_func"

assert item.funcargs["other"] == 42

def test_funcarg_lookup_modulelevel(self, pytester: Pytester) -> None:

pytester.copy_example()

reprec = pytester.inline_run()

reprec.assertoutcome(passed=2)

def test_funcarg_lookup_classlevel(self, pytester: Pytester) -> None:

p = pytester.copy_example()

result = pytester.runpytest(p)

result.stdout.fnmatch_lines(["*1 passed*"])

def test_conftest_funcargs_only_available_in_subdir(

self, pytester: Pytester

) -> None:

pytester.copy_example()

result = pytester.runpytest("-v")

result.assert_outcomes(passed=2)

def test_extend_fixture_module_class(self, pytester: Pytester) -> None:

testfile = pytester.copy_example()

result = pytester.runpytest()

result.stdout.fnmatch_lines(["*1 passed*"])

result = pytester.runpytest(testfile)

result.stdout.fnmatch_lines(["*1 passed*"])

def test_extend_fixture_conftest_module(self, pytester: Pytester) -> None:

p = pytester.copy_example()

result = pytester.runpytest()

result.stdout.fnmatch_lines(["*1 passed*"])

result = pytester.runpytest(str(next(Path(str(p)).rglob("test_*.py"))))

result.stdout.fnmatch_lines(["*1 passed*"])

def test_extend_fixture_conftest_conftest(self, pytester: Pytester) -> None:

p = pytester.copy_example()

result = pytester.runpytest()

result.stdout.fnmatch_lines(["*1 passed*"])

result = pytester.runpytest(str(next(Path(str(p)).rglob("test_*.py"))))

result.stdout.fnmatch_lines(["*1 passed*"])

def test_extend_fixture_conftest_plugin(self, pytester: Pytester) -> None:

pytester.makepyfile(

testplugin="""

import pytest

@pytest.fixture

def foo():

return 7

"""

)

pytester.syspathinsert()

pytester.makeconftest(

"""

import pytest

pytest_plugins = 'testplugin'

@pytest.fixture

def foo(foo):

return foo + 7

"""

)

pytester.makepyfile(

"""

def test_foo(foo):

assert foo == 14

"""

)

result = pytester.runpytest("-s")

assert result.ret == 0

def test_extend_fixture_plugin_plugin(self, pytester: Pytester) -> None:

# Two plugins should extend each order in loading order

pytester.makepyfile(

testplugin0="""

import pytest

@pytest.fixture

def foo():

return 7

"""

)

pytester.makepyfile(

testplugin1="""

import pytest

@pytest.fixture

def foo(foo):

return foo + 7

"""

)

pytester.syspathinsert()

pytester.makepyfile(

"""

pytest_plugins = ['testplugin0', 'testplugin1']

def test_foo(foo):

assert foo == 14

"""

)

result = pytester.runpytest()

assert result.ret == 0

def test_override_parametrized_fixture_conftest_module(

self, pytester: Pytester

) -> None:

"""Test override of the parametrized fixture with non-parametrized one on the test module level."""

pytester.makeconftest(

"""

import pytest

@pytest.fixture(params=[1, 2, 3])

def spam(request):

return request.param

"""

)

testfile = pytester.makepyfile(

"""

import pytest

@pytest.fixture

def spam():

return 'spam'

def test_spam(spam):

assert spam == 'spam'

"""

)

result = pytester.runpytest()

result.stdout.fnmatch_lines(["*1 passed*"])

result = pytester.runpytest(testfile)

result.stdout.fnmatch_lines(["*1 passed*"])

def test_override_parametrized_fixture_conftest_conftest(

self, pytester: Pytester

) -> None:

"""Test override of the parametrized fixture with non-parametrized one on the conftest level."""

pytester.makeconftest(

"""

import pytest

@pytest.fixture(params=[1, 2, 3])

def spam(request):

return request.param

"""

)

subdir = pytester.mkpydir("subdir")

subdir.joinpath("conftest.py").write_text(

textwrap.dedent(

"""\

import pytest

@pytest.fixture

def spam():

return 'spam'

"""

),

encoding="utf-8",

)

testfile = subdir.joinpath("test_spam.py")

testfile.write_text(

textwrap.dedent(

"""\

def test_spam(spam):

assert spam == "spam"

"""

),

encoding="utf-8",

)

result = pytester.runpytest()

result.stdout.fnmatch_lines(["*1 passed*"])

result = pytester.runpytest(testfile)

result.stdout.fnmatch_lines(["*1 passed*"])

def test_override_non_parametrized_fixture_conftest_module(

self, pytester: Pytester

) -> None:

"""Test override of the non-parametrized fixture with parametrized one on the test module level."""

pytester.makeconftest(

"""

import pytest

@pytest.fixture

def spam():

return 'spam'

"""

)

testfile = pytester.makepyfile(

"""

import pytest

@pytest.fixture(params=[1, 2, 3])

def spam(request):

return request.param

params = {'spam': 1}

def test_spam(spam):

assert spam == params['spam']

params['spam'] += 1

"""

)

result = pytester.runpytest()

result.stdout.fnmatch_lines(["*3 passed*"])

result = pytester.runpytest(testfile)

result.stdout.fnmatch_lines(["*3 passed*"])

def test_override_non_parametrized_fixture_conftest_conftest(

self, pytester: Pytester

) -> None:

"""Test override of the non-parametrized fixture with parametrized one on the conftest level."""

pytester.makeconftest(

"""

import pytest

@pytest.fixture

def spam():

return 'spam'

"""

)

subdir = pytester.mkpydir("subdir")

subdir.joinpath("conftest.py").write_text(

textwrap.dedent(

"""\

import pytest

@pytest.fixture(params=[1, 2, 3])

def spam(request):

return request.param

"""

),

encoding="utf-8",

)

testfile = subdir.joinpath("test_spam.py")

testfile.write_text(

textwrap.dedent(

"""\

params = {'spam': 1}

def test_spam(spam):

assert spam == params['spam']

params['spam'] += 1

"""

),

encoding="utf-8",

)

result = pytester.runpytest()

result.stdout.fnmatch_lines(["*3 passed*"])

result = pytester.runpytest(testfile)

result.stdout.fnmatch_lines(["*3 passed*"])

def test_override_autouse_fixture_with_parametrized_fixture_conftest_conftest(

self, pytester: Pytester

) -> None:

"""Test override of the autouse fixture with parametrized one on the conftest level.

This test covers the issue explained in issue 1601

"""

pytester.makeconftest(

"""

import pytest

@pytest.fixture(autouse=True)

def spam():

return 'spam'

"""

)

subdir = pytester.mkpydir("subdir")

subdir.joinpath("conftest.py").write_text(

textwrap.dedent(

"""\

import pytest

@pytest.fixture(params=[1, 2, 3])

def spam(request):

return request.param

"""

),

encoding="utf-8",

)

testfile = subdir.joinpath("test_spam.py")

testfile.write_text(

textwrap.dedent(

"""\

params = {'spam': 1}

def test_spam(spam):

assert spam == params['spam']

params['spam'] += 1

"""

),

encoding="utf-8",

)

result = pytester.runpytest()

result.stdout.fnmatch_lines(["*3 passed*"])

result = pytester.runpytest(testfile)

result.stdout.fnmatch_lines(["*3 passed*"])

def test_override_fixture_reusing_super_fixture_parametrization(

self, pytester: Pytester

) -> None:

"""Override a fixture at a lower level, reusing the higher-level fixture that

is parametrized (#1953).

"""

pytester.makeconftest(

"""

import pytest

@pytest.fixture(params=[1, 2])

def foo(request):

return request.param

"""

)

pytester.makepyfile(

"""

import pytest

@pytest.fixture

def foo(foo):

return foo * 2

def test_spam(foo):

assert foo in (2, 4)

"""

)

result = pytester.runpytest()

result.stdout.fnmatch_lines(["*2 passed*"])

def test_override_parametrize_fixture_and_indirect(

self, pytester: Pytester

) -> None:

"""Override a fixture at a lower level, reusing the higher-level fixture that

is parametrized, while also using indirect parametrization.

"""

pytester.makeconftest(

"""

import pytest

@pytest.fixture(params=[1, 2])

def foo(request):

return request.param

"""

)

pytester.makepyfile(

"""

import pytest

@pytest.fixture

def foo(foo):

return foo * 2

@pytest.fixture

def bar(request):

return request.param * 100

@pytest.mark.parametrize("bar", [42], indirect=True)

def test_spam(bar, foo):

assert bar == 4200

assert foo in (2, 4)

"""

)

result = pytester.runpytest()

result.stdout.fnmatch_lines(["*2 passed*"])

def test_override_top_level_fixture_reusing_super_fixture_parametrization(

self, pytester: Pytester

) -> None:

"""Same as the above test, but with another level of overwriting."""

pytester.makeconftest(

"""

import pytest

@pytest.fixture(params=['unused', 'unused'])

def foo(request):

return request.param

"""

)

pytester.makepyfile(

"""

import pytest

@pytest.fixture(params=[1, 2])

def foo(request):

return request.param

class Test:

@pytest.fixture

def foo(self, foo):

return foo * 2

def test_spam(self, foo):

assert foo in (2, 4)

"""

)

result = pytester.runpytest()

result.stdout.fnmatch_lines(["*2 passed*"])

def test_override_parametrized_fixture_with_new_parametrized_fixture(

self, pytester: Pytester

) -> None:

"""Overriding a parametrized fixture, while also parametrizing the new fixture and

simultaneously requesting the overwritten fixture as parameter, yields the same value

as ``request.param``.

"""

pytester.makeconftest(

"""

import pytest

@pytest.fixture(params=['ignored', 'ignored'])

def foo(request):

return request.param

"""

)

pytester.makepyfile(

"""

import pytest

@pytest.fixture(params=[10, 20])

def foo(foo, request):

assert request.param == foo

return foo * 2

def test_spam(foo):

assert foo in (20, 40)

"""

)

result = pytester.runpytest()

result.stdout.fnmatch_lines(["*2 passed*"])

@pytest.mark.xfail(reason="not handled currently")

def test_override_parametrized_fixture_via_transitive_fixture(

self, pytester: Pytester

) -> None:

"""Test that overriding a parametrized fixture works even the super

fixture is requested only transitively.

Regression test for #7737.

"""

pytester.makepyfile(

"""

import pytest

@pytest.fixture(params=[1, 2])

def foo(request):

return request.param

@pytest.fixture

def bar(foo):

return foo

class TestIt:

@pytest.fixture

def foo(self, bar):

return bar * 2

def test_it(self, foo):

pass

"""

)

result = pytester.runpytest()

assert result.ret == ExitCode.OK

result.assert_outcomes(passed=2)

def test_autouse_fixture_plugin(self, pytester: Pytester) -> None:

# A fixture from a plugin has no baseid set, which screwed up

# the autouse fixture handling.

pytester.makepyfile(

testplugin="""

import pytest

@pytest.fixture(autouse=True)

def foo(request):

request.function.foo = 7

"""

)

pytester.syspathinsert()

pytester.makepyfile(

"""

pytest_plugins = 'testplugin'

def test_foo(request):

assert request.function.foo == 7

"""

)

result = pytester.runpytest()

assert result.ret == 0

def test_funcarg_lookup_error(self, pytester: Pytester) -> None:

pytester.makeconftest(

"""

import pytest

@pytest.fixture

def a_fixture(): pass

@pytest.fixture

def b_fixture(): pass

@pytest.fixture

def c_fixture(): pass

@pytest.fixture

def d_fixture(): pass

"""

)

pytester.makepyfile(

"""

def test_lookup_error(unknown):

pass

"""

)

result = pytester.runpytest()

result.stdout.fnmatch_lines(

[

"*ERROR at setup of test_lookup_error*",

" def test_lookup_error(unknown):*",

"E fixture 'unknown' not found",

"> available fixtures:*a_fixture,*b_fixture,*c_fixture,*d_fixture*monkeypatch,*",

# sorted

"> use 'py*test --fixtures *' for help on them.",

"*1 error*",

]

)

result.stdout.no_fnmatch_line("*INTERNAL*")

def test_fixture_excinfo_leak(self, pytester: Pytester) -> None:

# on python2 sys.excinfo would leak into fixture executions

pytester.makepyfile(

"""

import sys

import traceback

import pytest

@pytest.fixture

def leak():

if sys.exc_info()[0]: # python3 bug :)

traceback.print_exc()

#fails

assert sys.exc_info() == (None, None, None)

def test_leak(leak):

if sys.exc_info()[0]: # python3 bug :)

traceback.print_exc()

assert sys.exc_info() == (None, None, None)

"""

)

result = pytester.runpytest()

assert result.ret == 0

class TestRequestBasic:

def test_request_attributes(self, pytester: Pytester) -> None:

item = pytester.getitem(

"""

import pytest

@pytest.fixture

def something(request): pass

def test_func(something): pass

"""

)

assert isinstance(item, Function)

req = TopRequest(item, _ispytest=True)

assert req.function == item.obj

assert req.keywords == item.keywords

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, pytester: Pytester) -> None:

(item,) = pytester.getitems(

"""

import pytest

class TestB(object):

@pytest.fixture

def something(self, request):

return 1

def test_func(self, something):

pass

"""

)

assert isinstance(item, Function)

req = item._request

assert req.cls.__name__ == "TestB"

assert req.instance.__class__ == req.cls

def test_request_contains_funcarg_arg2fixturedefs(self, pytester: Pytester) -> None:

modcol = pytester.getmodulecol(

"""

import pytest

@pytest.fixture

def something(request):

pass

class TestClass(object):

def test_method(self, something):

pass

"""

)

(item1,) = pytester.genitems([modcol])

assert isinstance(item1, Function)

assert item1.name == "test_method"

arg2fixturedefs = TopRequest(item1, _ispytest=True)._arg2fixturedefs

assert len(arg2fixturedefs) == 1

assert arg2fixturedefs["something"][0].argname == "something"

@pytest.mark.skipif(

hasattr(sys, "pypy_version_info"),

reason="this method of test doesn't work on pypy",

)

def test_request_garbage(self, pytester: Pytester) -> None:

try:

import xdist # noqa: F401

except ImportError:

pass

else:

pytest.xfail("this test is flaky when executed with xdist")

pytester.makepyfile(

"""

import sys

import pytest

from _pytest.fixtures import RequestFixtureDef

import gc

@pytest.fixture(autouse=True)

def something(request):

original = gc.get_debug()

gc.set_debug(gc.DEBUG_SAVEALL)

gc.collect()

yield

try:

gc.collect()

leaked = [x for _ in gc.garbage if isinstance(_, RequestFixtureDef)]

assert leaked == []

finally:

gc.set_debug(original)

def test_func():

pass

"""

)

result = pytester.runpytest_subprocess()

result.stdout.fnmatch_lines(["* 1 passed in *"])

def test_getfixturevalue_recursive(self, pytester: Pytester) -> None:

pytester.makeconftest(

"""

import pytest

@pytest.fixture

def something(request):

return 1

"""

)

pytester.makepyfile(

"""

import pytest

@pytest.fixture

def something(request):

return request.getfixturevalue("something") + 1

def test_func(something):

assert something == 2

"""

)

reprec = pytester.inline_run()

reprec.assertoutcome(passed=1)

def test_getfixturevalue_teardown(self, pytester: Pytester) -> None:

"""

Issue #1895

`test_inner` requests `inner` fixture, which in turn requests `resource`

using `getfixturevalue`. `test_func` then requests `resource`.

`resource` is teardown before `inner` because the fixture mechanism won't consider

`inner` dependent on `resource` when it is used via `getfixturevalue`: `test_func`

will then cause the `resource`'s finalizer to be called first because of this.

"""

pytester.makepyfile(

"""

import pytest

@pytest.fixture(scope='session')

def resource():

r = ['value']

yield r

r.pop()

@pytest.fixture(scope='session')

def inner(request):

resource = request.getfixturevalue('resource')

assert resource == ['value']

yield

assert resource == ['value']

def test_inner(inner):

pass

def test_func(resource):

pass

"""

)

result = pytester.runpytest()

result.stdout.fnmatch_lines(["* 2 passed in *"])

def test_getfixturevalue_teardown_previously_requested_does_not_warn(

self, pytester: Pytester

) -> None:

"""Test that requesting a fixture during teardown that was previously

requested is OK (#12882).

Note: this is still kinda dubious so don't let this test lock you in to

allowing this behavior forever...

"""

pytester.makepyfile(

"""

import pytest

@pytest.fixture

def fix(request, tmp_path):

yield

assert request.getfixturevalue("tmp_path") == tmp_path

def test_it(fix):

pass

"""

)

result = pytester.runpytest("-Werror")

result.assert_outcomes(passed=1)

def test_getfixturevalue_teardown_new_fixture_deprecated(

self, pytester: Pytester

) -> None:

"""Test that requesting a fixture during teardown that was not

previously requested raises a deprecation warning (#12882).

Note: this is a case that previously worked but will become a hard

error after the deprecation is completed.

"""

pytester.makepyfile(

"""

import pytest

@pytest.fixture(scope="session")

def resource():

return "value"

@pytest.fixture

def fix(request):

yield

with pytest.warns(

pytest.PytestRemovedIn10Warning,

match=r'Calling request\\.getfixturevalue\\("resource"\\) during teardown is deprecated',

):

assert request.getfixturevalue("resource") == "value"

def test_it(fix):

pass

"""

)

result = pytester.runpytest()

result.assert_outcomes(passed=1)

def test_getfixturevalue_teardown_new_inactive_fixture_errors(

self, pytester: Pytester

) -> None:

"""Test that requesting a fixture during teardown that was not

previously requested raises an error (#12882)."""

pytester.makepyfile(

"""

import pytest

@pytest.fixture

def fix(request):

yield

request.getfixturevalue("tmp_path")

def test_it(fix):

pass

"""

)

result = pytester.runpytest()

result.assert_outcomes(passed=1, errors=1)

result.stdout.fnmatch_lines(

[

(

'*The fixture value for "tmp_path" is not available during '

"teardown because it was not previously requested.*"

),

]

)

def test_getfixturevalue_teardown_new_inactive_fixture_errors_top_request(

self, pytester: Pytester

) -> None:

"""Test that requesting a fixture during teardown that was not

previously requested raises an error (tricky case) (#12882)."""

pytester.makepyfile(

"""

def test_it(request):

request.addfinalizer(lambda: request.getfixturevalue("tmp_path"))

"""

)

result = pytester.runpytest()

result.assert_outcomes(passed=1, errors=1)

result.stdout.fnmatch_lines(

[

(

'*The fixture value for "tmp_path" is not available during '

"teardown because it was not previously requested.*"

),

]

)

def test_getfixturevalue(self, pytester: Pytester) -> None:

item = pytester.getitem(

"""

import pytest

@pytest.fixture

def something(request):

return 1

values = [2]

@pytest.fixture

def other(request):

return values.pop()

def test_func(something): pass

"""

)