jiuyuan
/
test_ok1
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

rename pytest.factory usages into pytest.fixture ones

This commit is contained in:
holger krekel 2012-10-05 10:21:35 +02:00
parent 439cc1238f
commit 9251e747af
8 changed files with 92 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
_pytest/python.py
View File

@ -10,12 +10,12 @@ from py._code.code import TerminalRepr
import _pytest import _pytest
cutdir = py.path.local(_pytest.__file__).dirpath() cutdir = py.path.local(_pytest.__file__).dirpath()
class FactoryMarker: class FixtureFunctionMarker:
def __init__(self, scope, params): def __init__(self, scope, params):
self.scope = scope self.scope = scope
self.params = params self.params = params
def __call__(self, function): def __call__(self, function):
function._pytestfactory = self function._pytestfixturefunction = self
return function return function
class SetupMarker: class SetupMarker:
@ -26,18 +26,32 @@ class SetupMarker:
return function return function
# XXX a test fails when scope="function" how it should be, investigate # XXX a test fails when scope="function" how it should be, investigate
def factory(scope=None, params=None): def fixture(scope=None, params=None):
""" return a decorator to mark functions as resource factories. """ return a decorator to mark a fixture factory function.
:arg scope: the scope for which this resource is shared, one of The name of the fixture function can be referenced in a test context
to cause activation ahead of running tests. Test modules or classes
can use the pytest.mark.needsfixtures(fixturename) marker to specify
needed fixtures. Test functions can use fixture names as input arguments
in which case the object returned from the fixture function will be
injected.
:arg scope: the scope for which this fixture is shared, one of
"function", "class", "module", "session". Defaults to "function". "function", "class", "module", "session". Defaults to "function".
:arg params: an optional list of parameters which will cause multiple :arg params: an optional list of parameters which will cause multiple
invocations of tests depending on the resource. invocations of the fixture functions and their dependent
tests.
""" """
return FactoryMarker(scope, params) return FixtureFunctionMarker(scope, params)
def setup(scope="function"): def setup(scope="function"):
""" return a decorator to mark functions as setup functions. """ return a decorator to mark a function as providing a fixture for
a testcontext. A fixture function is executed for each scope and may
receive funcargs which allows it to initialise and provide implicit
test state. A fixture function may receive the "testcontext" object
and register a finalizer via "testcontext.addfinalizer(finalizer)"
which will be called when the last test in the testcontext has
executed.
:arg scope: the scope for which the setup function will be active, one :arg scope: the scope for which the setup function will be active, one
of "function", "class", "module", "session". of "function", "class", "module", "session".
@ -112,7 +126,7 @@ def pytest_sessionstart(session):
def pytest_namespace(): def pytest_namespace():
raises.Exception = pytest.fail.Exception raises.Exception = pytest.fail.Exception
return { return {
'factory': factory, 'fixture': fixture,
'setup': setup, 'setup': setup,
'raises' : raises, 'raises' : raises,
'collect': { 'collect': {
@ -1377,9 +1391,9 @@ class FuncargManager:
continue continue
# resource factories either have a pytest_funcarg__ prefix # resource factories either have a pytest_funcarg__ prefix
# or are "funcarg" marked # or are "funcarg" marked
marker = getattr(obj, "_pytestfactory", None) marker = getattr(obj, "_pytestfixturefunction", None)
if marker is not None: if marker is not None:
if not isinstance(marker, FactoryMarker): if not isinstance(marker, FixtureFunctionMarker):
# magic globals with __getattr__ # magic globals with __getattr__
# give us something thats wrong for that case # give us something thats wrong for that case
continue continue

2
doc/en/example/costlysetup/conftest.py
View File

@ -1,7 +1,7 @@
import pytest import pytest
@pytest.factory("session") @pytest.fixture("session")
def setup(request): def setup(request):
setup = CostlySetup() setup = CostlySetup()
request.addfinalizer(setup.finalize) request.addfinalizer(setup.finalize)

4
doc/en/example/multipython.py
View File

@ -5,12 +5,12 @@ serialization via the pickle module.
import py, pytest import py, pytest
pythonlist = ['python2.4', 'python2.5', 'python2.6', 'python2.7', 'python2.8'] pythonlist = ['python2.4', 'python2.5', 'python2.6', 'python2.7', 'python2.8']
@pytest.factory(params=pythonlist) @pytest.fixture(params=pythonlist)
def python1(request, tmpdir): def python1(request, tmpdir):
picklefile = tmpdir.join("data.pickle") picklefile = tmpdir.join("data.pickle")
return Python(request.param, picklefile) return Python(request.param, picklefile)
@pytest.factory(params=pythonlist) @pytest.fixture(params=pythonlist)
def python2(request, python1): def python2(request, python1):
return Python(request.param, python1.picklefile) return Python(request.param, python1.picklefile)

4
doc/en/faq.txt
View File

@ -125,7 +125,7 @@ the ``MYARG`` function argument.
.. note:: .. note::
With pytest-2.3 you can use the :ref:`@pytest.factory` decorator With pytest-2.3 you can use the :ref:`@pytest.fixture` decorator
to mark a function as a funcarg factory. to mark a function as a funcarg factory.
.. _`Convention over Configuration`: http://en.wikipedia.org/wiki/Convention_over_Configuration .. _`Convention over Configuration`: http://en.wikipedia.org/wiki/Convention_over_Configuration
@ -146,7 +146,7 @@ is not possible:
policy - in real-world examples some combinations policy - in real-world examples some combinations
often should not run. often should not run.
However, with pytest-2.3 you can use the :ref:`@pytest.factory` decorator However, with pytest-2.3 you can use the :ref:`@pytest.fixture` decorator
and specify ``params`` so that all tests depending on the factory-created and specify ``params`` so that all tests depending on the factory-created
resource will run multiple times with different parameters. resource will run multiple times with different parameters.

10
doc/en/funcarg_compare.txt
View File

@ -63,9 +63,9 @@ new facilities.
Direct scoping of funcarg factories Direct scoping of funcarg factories
-------------------------------------------------------- --------------------------------------------------------
Instead of calling cached_setup(), you can use the :ref:`@pytest.factory <@pytest.factory>` decorator and directly state the scope:: Instead of calling cached_setup(), you can use the :ref:`@pytest.fixture <@pytest.fixture>` decorator and directly state the scope::
@pytest.factory(scope="session") @pytest.fixture(scope="session")
def db(request): def db(request):
# factory will only be invoked once per session - # factory will only be invoked once per session -
db = DataBase() db = DataBase()
@ -87,7 +87,7 @@ or implement a ``pytest_generate_tests`` hook to perform
parametrization, i.e. calling a test multiple times with different value parametrization, i.e. calling a test multiple times with different value
sets. pytest-2.3 introduces a decorator for use on the factory itself:: sets. pytest-2.3 introduces a decorator for use on the factory itself::
@pytest.factory(params=["mysql", "pg"]) @pytest.fixture(params=["mysql", "pg"])
def db(request): def db(request):
... # use request.param ... # use request.param
@ -104,7 +104,7 @@ functions/classes were parametrized via
Of course it's perfectly fine to combine parametrization and scoping:: Of course it's perfectly fine to combine parametrization and scoping::
@pytest.factory(scope="session", params=["mysql", "pg"]) @pytest.fixture(scope="session", params=["mysql", "pg"])
def db(request): def db(request):
if request.param == "mysql": if request.param == "mysql":
db = MySQL() db = MySQL()
@ -125,7 +125,7 @@ When using the ``@factory`` decorator the name of the function
denotes the name under which the resource can be accessed as a function denotes the name under which the resource can be accessed as a function
argument:: argument::
@pytest.factory() @pytest.fixture()
def db(request): def db(request):
... ...

18
doc/en/funcargs.txt
View File

@ -51,7 +51,7 @@ inputs lead to certain outputs.
Concretely, there are three main means of funcarg management: Concretely, there are three main means of funcarg management:
* a `@pytest.factory`_ marker to define resource factories, * a `@pytest.fixture`_ marker to define resource factories,
their scoping and parametrization. Factories can themselves their scoping and parametrization. Factories can themselves
receive resources through their function arguments, easing receive resources through their function arguments, easing
the setup of `interdependent resources`_. Factories can use the setup of `interdependent resources`_. Factories can use
@ -77,9 +77,9 @@ be done with the classical xUnit style approach which encodes resource
setup statically into the test source code, leading to duplicate and setup statically into the test source code, leading to duplicate and
hard-to change fixtures. hard-to change fixtures.
.. _`@pytest.factory`: .. _`@pytest.fixture`:
``@pytest.factory``: Creating parametrized, scoped resources ``@pytest.fixture``: Creating parametrized, scoped resources
===================================================================== =====================================================================
Basic funcarg injection example Basic funcarg injection example
@ -91,7 +91,7 @@ and a funcarg::
# content of ./test_simplefactory.py # content of ./test_simplefactory.py
import pytest import pytest
@pytest.factory() @pytest.fixture()
def myfuncarg(): def myfuncarg():
return 42 return 42
@ -99,7 +99,7 @@ and a funcarg::
assert myfuncarg == 17 assert myfuncarg == 17
Here, the ``test_function`` needs an object named ``myfuncarg`` and thus Here, the ``test_function`` needs an object named ``myfuncarg`` and thus
py.test will discover and call the ``@pytest.factory`` marked ``myfuncarg`` py.test will discover and call the ``@pytest.fixture`` marked ``myfuncarg``
factory function. Running the tests looks like this:: factory function. Running the tests looks like this::
$ py.test test_simplefactory.py $ py.test test_simplefactory.py
@ -168,7 +168,7 @@ funcarg factories starts at test classes, then test modules, then
Parametrizing test functions Parametrizing test functions
========================================================================== ==========================================================================
While the `@pytest.factory`_ decorator allows to define parametrization While the `@pytest.fixture`_ decorator allows to define parametrization
of funcarg resources at the factory-level, there are also means to of funcarg resources at the factory-level, there are also means to
define parametrization at test functions directly: define parametrization at test functions directly:
@ -365,18 +365,18 @@ the mechanism was extended and refined:
* previously funcarg factories were specified with a special * previously funcarg factories were specified with a special
``pytest_funcarg__NAME`` prefix instead of using the ``pytest_funcarg__NAME`` prefix instead of using the
``@pytest.factory`` decorator. ``@pytest.fixture`` decorator.
* Factories received a `request`_ object which managed caching through * Factories received a `request`_ object which managed caching through
``request.cached_setup()`` calls and allowed using other funcargs via ``request.cached_setup()`` calls and allowed using other funcargs via
``request.getfuncargvalue()`` calls. These intricate APIs made it hard ``request.getfuncargvalue()`` calls. These intricate APIs made it hard
to do proper parametrization and implement resource caching. The to do proper parametrization and implement resource caching. The
new ``@pytest.factory`` decorator allows to simply declare the scope new ``@pytest.fixture`` decorator allows to simply declare the scope
and let pytest figure things out for you. and let pytest figure things out for you.
* if you used parametrization and funcarg factories which made use of * if you used parametrization and funcarg factories which made use of
``request.cached_setup()`` it is recommeneded to invest a few minutes ``request.cached_setup()`` it is recommeneded to invest a few minutes
and simplify your funcarg factory code to use the `@pytest.factory`_ and simplify your funcarg factory code to use the `@pytest.fixture`_
decorator instead. This will also allow to take advantage of decorator instead. This will also allow to take advantage of
the `automatic per-resource grouping`_ of tests. the `automatic per-resource grouping`_ of tests.

2
doc/en/unittest.txt
View File

@ -82,7 +82,7 @@ instances, based on a marker, you can do it using :ref:`pytest.mark`` and
import pytest import pytest
import unittest import unittest
@pytest.factory() @pytest.fixture()
def db(): def db():
class DummyDB: class DummyDB:
x = 1 x = 1

94
testing/test_python.py
View File

@ -744,7 +744,7 @@ class TestMarking:
def test_accessmarker_function(self, testdir): def test_accessmarker_function(self, testdir):
testdir.makepyfile(""" testdir.makepyfile("""
import pytest import pytest
@pytest.factory() @pytest.fixture()
def markers(request): def markers(request):
return request.node.markers return request.node.markers
@pytest.mark.XYZ @pytest.mark.XYZ
@ -758,7 +758,7 @@ class TestMarking:
def test_accessmarker_dynamic(self, testdir): def test_accessmarker_dynamic(self, testdir):
testdir.makeconftest(""" testdir.makeconftest("""
import pytest import pytest
@pytest.factory() @pytest.fixture()
def markers(request): def markers(request):
return request.node.markers return request.node.markers
@ -1674,11 +1674,11 @@ class TestFuncargFactory:
def test_receives_funcargs(self, testdir): def test_receives_funcargs(self, testdir):
testdir.makepyfile(""" testdir.makepyfile("""
import pytest import pytest
@pytest.factory() @pytest.fixture()
def arg1(): def arg1():
return 1 return 1
@pytest.factory() @pytest.fixture()
def arg2(arg1): def arg2(arg1):
return arg1 + 1 return arg1 + 1
@ -1694,11 +1694,11 @@ class TestFuncargFactory:
def test_receives_funcargs_scope_mismatch(self, testdir): def test_receives_funcargs_scope_mismatch(self, testdir):
testdir.makepyfile(""" testdir.makepyfile("""
import pytest import pytest
@pytest.factory(scope="function") @pytest.fixture(scope="function")
def arg1(): def arg1():
return 1 return 1
@pytest.factory(scope="module") @pytest.fixture(scope="module")
def arg2(arg1): def arg2(arg1):
return arg1 + 1 return arg1 + 1
@ -1717,12 +1717,12 @@ class TestFuncargFactory:
testdir.makepyfile(""" testdir.makepyfile("""
import pytest import pytest
l = [] l = []
@pytest.factory(params=[1,2]) @pytest.fixture(params=[1,2])
def arg1(request): def arg1(request):
l.append(1) l.append(1)
return request.param return request.param
@pytest.factory() @pytest.fixture()
def arg2(arg1): def arg2(arg1):
return arg1 + 1 return arg1 + 1
@ -1739,11 +1739,11 @@ class TestFuncargFactory:
testdir.makepyfile(""" testdir.makepyfile("""
import pytest import pytest
@pytest.factory() @pytest.fixture()
def fail(missing): def fail(missing):
return return
@pytest.factory() @pytest.fixture()
def call_fail(fail): def call_fail(fail):
return return
@ -1764,7 +1764,7 @@ class TestFuncargFactory:
class arg1: class arg1:
def __init__(self, request): def __init__(self, request):
self.x = 1 self.x = 1
arg1 = pytest.factory()(arg1) arg1 = pytest.fixture()(arg1)
class MySetup: class MySetup:
def __init__(self, request, arg1): def __init__(self, request, arg1):
@ -1781,7 +1781,7 @@ class TestFuncargFactory:
def test_request_can_be_overridden(self, testdir): def test_request_can_be_overridden(self, testdir):
testdir.makepyfile(""" testdir.makepyfile("""
import pytest import pytest
@pytest.factory() @pytest.fixture()
def request(request): def request(request):
request.a = 1 request.a = 1
return request return request
@ -1863,7 +1863,7 @@ class TestSetupDiscovery:
def perfunction(request, tmpdir): def perfunction(request, tmpdir):
pass pass
@pytest.factory() @pytest.fixture()
def arg1(tmpdir): def arg1(tmpdir):
pass pass
@pytest.setup() @pytest.setup()
@ -1918,7 +1918,7 @@ class TestSetupDiscovery:
def enabled(parentnode, markers): def enabled(parentnode, markers):
return "needsdb" in markers return "needsdb" in markers
@pytest.factory(params=[1,2]) @pytest.fixture(params=[1,2])
def db(request): def db(request):
return request.param return request.param
@ -1959,7 +1959,7 @@ class TestSetupManagement:
testdir.makepyfile(""" testdir.makepyfile("""
import pytest import pytest
l = [] l = []
@pytest.factory(scope="module") @pytest.fixture(scope="module")
def arg(): def arg():
l.append(1) l.append(1)
return 0 return 0
@ -1984,7 +1984,7 @@ class TestSetupManagement:
testdir.makepyfile(""" testdir.makepyfile("""
import pytest import pytest
l = [] l = []
@pytest.factory(params=[1,2]) @pytest.fixture(params=[1,2])
def arg(request): def arg(request):
return request.param return request.param
@ -2010,7 +2010,7 @@ class TestSetupManagement:
l = [] l = []
@pytest.factory(scope="session", params=[1,2]) @pytest.fixture(scope="session", params=[1,2])
def arg(request): def arg(request):
return request.param return request.param
@ -2036,11 +2036,11 @@ class TestSetupManagement:
l = [] l = []
@pytest.factory(scope="function", params=[1,2]) @pytest.fixture(scope="function", params=[1,2])
def farg(request): def farg(request):
return request.param return request.param
@pytest.factory(scope="class", params=list("ab")) @pytest.fixture(scope="class", params=list("ab"))
def carg(request): def carg(request):
return request.param return request.param
@ -2117,7 +2117,7 @@ class TestFuncargMarker:
def test_parametrize(self, testdir): def test_parametrize(self, testdir):
testdir.makepyfile(""" testdir.makepyfile("""
import pytest import pytest
@pytest.factory(params=["a", "b", "c"]) @pytest.fixture(params=["a", "b", "c"])
def arg(request): def arg(request):
return request.param return request.param
l = [] l = []
@ -2133,7 +2133,7 @@ class TestFuncargMarker:
testdir.makepyfile(""" testdir.makepyfile("""
import pytest import pytest
l = [] l = []
@pytest.factory(scope="module") @pytest.fixture(scope="module")
def arg(): def arg():
l.append(1) l.append(1)
return 1 return 1
@ -2155,7 +2155,7 @@ class TestFuncargMarker:
testdir.makepyfile(""" testdir.makepyfile("""
import pytest import pytest
l = [] l = []
@pytest.factory(scope="module") @pytest.fixture(scope="module")
def arg(): def arg():
l.append(1) l.append(1)
return 1 return 1
@ -2178,7 +2178,7 @@ class TestFuncargMarker:
import pytest import pytest
finalized = [] finalized = []
created = [] created = []
@pytest.factory(scope="module") @pytest.fixture(scope="module")
def arg(request): def arg(request):
created.append(1) created.append(1)
assert request.scope == "module" assert request.scope == "module"
@ -2217,14 +2217,14 @@ class TestFuncargMarker:
import pytest import pytest
finalized = [] finalized = []
created = [] created = []
@pytest.factory(scope="function") @pytest.fixture(scope="function")
def arg(request): def arg(request):
pass pass
""") """)
testdir.makepyfile( testdir.makepyfile(
test_mod1=""" test_mod1="""
import pytest import pytest
@pytest.factory(scope="session") @pytest.fixture(scope="session")
def arg(request): def arg(request):
%s %s
def test_1(arg): def test_1(arg):
@ -2239,14 +2239,14 @@ class TestFuncargMarker:
def test_register_only_with_mark(self, testdir): def test_register_only_with_mark(self, testdir):
testdir.makeconftest(""" testdir.makeconftest("""
import pytest import pytest
@pytest.factory() @pytest.fixture()
def arg(): def arg():
return 1 return 1
""") """)
testdir.makepyfile( testdir.makepyfile(
test_mod1=""" test_mod1="""
import pytest import pytest
@pytest.factory() @pytest.fixture()
def arg(arg): def arg(arg):
return arg + 1 return arg + 1
def test_1(arg): def test_1(arg):
@ -2258,7 +2258,7 @@ class TestFuncargMarker:
def test_parametrize_and_scope(self, testdir): def test_parametrize_and_scope(self, testdir):
testdir.makepyfile(""" testdir.makepyfile("""
import pytest import pytest
@pytest.factory(scope="module", params=["a", "b", "c"]) @pytest.fixture(scope="module", params=["a", "b", "c"])
def arg(request): def arg(request):
return request.param return request.param
l = [] l = []
@ -2276,13 +2276,13 @@ class TestFuncargMarker:
def test_scope_mismatch(self, testdir): def test_scope_mismatch(self, testdir):
testdir.makeconftest(""" testdir.makeconftest("""
import pytest import pytest
@pytest.factory(scope="function") @pytest.fixture(scope="function")
def arg(request): def arg(request):
pass pass
""") """)
testdir.makepyfile(""" testdir.makepyfile("""
import pytest import pytest
@pytest.factory(scope="session") @pytest.fixture(scope="session")
def arg(arg): def arg(arg):
pass pass
def test_mismatch(arg): def test_mismatch(arg):
@ -2298,7 +2298,7 @@ class TestFuncargMarker:
testdir.makepyfile(""" testdir.makepyfile("""
import pytest import pytest
@pytest.factory(scope="module", params=[1, 2]) @pytest.fixture(scope="module", params=[1, 2])
def arg(request): def arg(request):
return request.param return request.param
@ -2317,10 +2317,10 @@ class TestFuncargMarker:
testdir.makeconftest(""" testdir.makeconftest("""
import pytest import pytest
@pytest.factory(scope="session", params="s1 s2".split()) @pytest.fixture(scope="session", params="s1 s2".split())
def sarg(): def sarg():
pass pass
@pytest.factory(scope="module", params="m1 m2".split()) @pytest.fixture(scope="module", params="m1 m2".split())
def marg(): def marg():
pass pass
""") """)
@ -2365,11 +2365,11 @@ class TestFuncargMarker:
l = [] l = []
@pytest.factory(scope="function", params=[1,2]) @pytest.fixture(scope="function", params=[1,2])
def farg(request): def farg(request):
return request.param return request.param
@pytest.factory(scope="class", params=list("ab")) @pytest.fixture(scope="class", params=list("ab"))
def carg(request): def carg(request):
return request.param return request.param
@ -2411,14 +2411,14 @@ class TestFuncargMarker:
testdir.makepyfile(""" testdir.makepyfile("""
import pytest import pytest
@pytest.factory(scope="function", params=[1, 2]) @pytest.fixture(scope="function", params=[1, 2])
def arg(request): def arg(request):
param = request.param param = request.param
request.addfinalizer(lambda: l.append("fin:%s" % param)) request.addfinalizer(lambda: l.append("fin:%s" % param))
l.append("create:%s" % param) l.append("create:%s" % param)
return request.param return request.param
@pytest.factory(scope="module", params=["mod1", "mod2"]) @pytest.fixture(scope="module", params=["mod1", "mod2"])
def modarg(request): def modarg(request):
param = request.param param = request.param
request.addfinalizer(lambda: l.append("fin:%s" % param)) request.addfinalizer(lambda: l.append("fin:%s" % param))
@ -2455,7 +2455,7 @@ class TestFuncargMarker:
testdir.makepyfile(""" testdir.makepyfile("""
import pytest import pytest
@pytest.factory(scope="module", params=[1, 2]) @pytest.fixture(scope="module", params=[1, 2])
def arg(request): def arg(request):
request.config.l = l # to access from outer request.config.l = l # to access from outer
x = request.param x = request.param
@ -2484,7 +2484,7 @@ class TestFuncargMarker:
testdir.makepyfile(""" testdir.makepyfile("""
import pytest import pytest
@pytest.factory(scope="function", params=[1, 2]) @pytest.fixture(scope="function", params=[1, 2])
def arg(request): def arg(request):
x = request.param x = request.param
request.addfinalizer(lambda: l.append("fin%s" % x)) request.addfinalizer(lambda: l.append("fin%s" % x))
@ -2506,7 +2506,7 @@ class TestFuncargMarker:
testdir.makepyfile(""" testdir.makepyfile("""
import pytest import pytest
@pytest.factory(scope="module", params=[1, 2]) @pytest.fixture(scope="module", params=[1, 2])
def arg(request): def arg(request):
return request.param return request.param
@ -2562,7 +2562,7 @@ class TestTestContextScopeAccess:
def test_funcarg(self, testdir, scope, ok, error): def test_funcarg(self, testdir, scope, ok, error):
testdir.makepyfile(""" testdir.makepyfile("""
import pytest import pytest
@pytest.factory(scope=%r) @pytest.fixture(scope=%r)
def arg(request): def arg(request):
for x in %r: for x in %r:
assert hasattr(request, x) assert hasattr(request, x)
@ -2582,7 +2582,7 @@ class TestErrors:
def test_subfactory_missing_funcarg(self, testdir): def test_subfactory_missing_funcarg(self, testdir):
testdir.makepyfile(""" testdir.makepyfile("""
import pytest import pytest
@pytest.factory() @pytest.fixture()
def gen(qwe123): def gen(qwe123):
return 1 return 1
def test_something(gen): def test_something(gen):
@ -2618,7 +2618,7 @@ class TestTestContextVarious:
def test_newstyle_with_request(self, testdir): def test_newstyle_with_request(self, testdir):
testdir.makepyfile(""" testdir.makepyfile("""
import pytest import pytest
@pytest.factory() @pytest.fixture()
def arg(request): def arg(request):
pass pass
def test_1(arg): def test_1(arg):
@ -2630,7 +2630,7 @@ class TestTestContextVarious:
def test_setupcontext_no_param(self, testdir): def test_setupcontext_no_param(self, testdir):
testdir.makepyfile(""" testdir.makepyfile("""
import pytest import pytest
@pytest.factory(params=[1,2]) @pytest.fixture(params=[1,2])
def arg(request): def arg(request):
return request.param return request.param
@ -2683,7 +2683,7 @@ def test_setup_funcarg_order(testdir):
@pytest.setup() @pytest.setup()
def fix1(): def fix1():
l.append(1) l.append(1)
@pytest.factory() @pytest.fixture()
def arg1(): def arg1():
l.append(2) l.append(2)
def test_hello(arg1): def test_hello(arg1):
@ -2696,10 +2696,10 @@ def test_setup_funcarg_order(testdir):
def test_request_funcargnames(testdir): def test_request_funcargnames(testdir):
testdir.makepyfile(""" testdir.makepyfile("""
import pytest import pytest
@pytest.factory() @pytest.fixture()
def arg1(): def arg1():
pass pass
@pytest.factory() @pytest.fixture()
def farg(arg1): def farg(arg1):
pass pass
@pytest.setup() @pytest.setup()