775 lines
24 KiB
Python
775 lines
24 KiB
Python
try:
|
|
# installed by bootstrap.py
|
|
import sqla_plugin_base as plugin_base
|
|
except ImportError:
|
|
# assume we're a package, use traditional import
|
|
from . import plugin_base
|
|
|
|
import argparse
|
|
import collections
|
|
from functools import update_wrapper
|
|
import inspect
|
|
import itertools
|
|
import operator
|
|
import os
|
|
import re
|
|
import sys
|
|
|
|
import pytest
|
|
|
|
try:
|
|
import xdist # noqa
|
|
|
|
has_xdist = True
|
|
except ImportError:
|
|
has_xdist = False
|
|
|
|
|
|
py2k = sys.version_info < (3, 0)
|
|
if py2k:
|
|
try:
|
|
import sqla_reinvent_fixtures as reinvent_fixtures_py2k
|
|
except ImportError:
|
|
from . import reinvent_fixtures_py2k
|
|
|
|
|
|
def pytest_addoption(parser):
|
|
group = parser.getgroup("sqlalchemy")
|
|
|
|
def make_option(name, **kw):
|
|
callback_ = kw.pop("callback", None)
|
|
if callback_:
|
|
|
|
class CallableAction(argparse.Action):
|
|
def __call__(
|
|
self, parser, namespace, values, option_string=None
|
|
):
|
|
callback_(option_string, values, parser)
|
|
|
|
kw["action"] = CallableAction
|
|
|
|
zeroarg_callback = kw.pop("zeroarg_callback", None)
|
|
if zeroarg_callback:
|
|
|
|
class CallableAction(argparse.Action):
|
|
def __init__(
|
|
self,
|
|
option_strings,
|
|
dest,
|
|
default=False,
|
|
required=False,
|
|
help=None, # noqa
|
|
):
|
|
super(CallableAction, self).__init__(
|
|
option_strings=option_strings,
|
|
dest=dest,
|
|
nargs=0,
|
|
const=True,
|
|
default=default,
|
|
required=required,
|
|
help=help,
|
|
)
|
|
|
|
def __call__(
|
|
self, parser, namespace, values, option_string=None
|
|
):
|
|
zeroarg_callback(option_string, values, parser)
|
|
|
|
kw["action"] = CallableAction
|
|
|
|
group.addoption(name, **kw)
|
|
|
|
plugin_base.setup_options(make_option)
|
|
plugin_base.read_config()
|
|
|
|
|
|
def pytest_configure(config):
|
|
if hasattr(config, "workerinput"):
|
|
plugin_base.restore_important_follower_config(config.workerinput)
|
|
plugin_base.configure_follower(config.workerinput["follower_ident"])
|
|
else:
|
|
if config.option.write_idents and os.path.exists(
|
|
config.option.write_idents
|
|
):
|
|
os.remove(config.option.write_idents)
|
|
|
|
plugin_base.pre_begin(config.option)
|
|
|
|
plugin_base.set_coverage_flag(
|
|
bool(getattr(config.option, "cov_source", False))
|
|
)
|
|
|
|
plugin_base.set_fixture_functions(PytestFixtureFunctions)
|
|
|
|
if config.option.dump_pyannotate:
|
|
global DUMP_PYANNOTATE
|
|
DUMP_PYANNOTATE = True
|
|
|
|
|
|
DUMP_PYANNOTATE = False
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def collect_types_fixture():
|
|
if DUMP_PYANNOTATE:
|
|
from pyannotate_runtime import collect_types
|
|
|
|
collect_types.start()
|
|
yield
|
|
if DUMP_PYANNOTATE:
|
|
collect_types.stop()
|
|
|
|
|
|
def pytest_sessionstart(session):
|
|
from sqlalchemy.testing import asyncio
|
|
|
|
asyncio._assume_async(plugin_base.post_begin)
|
|
|
|
|
|
def pytest_sessionfinish(session):
|
|
from sqlalchemy.testing import asyncio
|
|
|
|
asyncio._maybe_async_provisioning(plugin_base.final_process_cleanup)
|
|
|
|
if session.config.option.dump_pyannotate:
|
|
from pyannotate_runtime import collect_types
|
|
|
|
collect_types.dump_stats(session.config.option.dump_pyannotate)
|
|
|
|
|
|
def pytest_collection_finish(session):
|
|
if session.config.option.dump_pyannotate:
|
|
from pyannotate_runtime import collect_types
|
|
|
|
lib_sqlalchemy = os.path.abspath("lib/sqlalchemy")
|
|
|
|
def _filter(filename):
|
|
filename = os.path.normpath(os.path.abspath(filename))
|
|
if "lib/sqlalchemy" not in os.path.commonpath(
|
|
[filename, lib_sqlalchemy]
|
|
):
|
|
return None
|
|
if "testing" in filename:
|
|
return None
|
|
|
|
return filename
|
|
|
|
collect_types.init_types_collection(filter_filename=_filter)
|
|
|
|
|
|
if has_xdist:
|
|
import uuid
|
|
|
|
def pytest_configure_node(node):
|
|
from sqlalchemy.testing import provision
|
|
from sqlalchemy.testing import asyncio
|
|
|
|
# the master for each node fills workerinput dictionary
|
|
# which pytest-xdist will transfer to the subprocess
|
|
|
|
plugin_base.memoize_important_follower_config(node.workerinput)
|
|
|
|
node.workerinput["follower_ident"] = "test_%s" % uuid.uuid4().hex[0:12]
|
|
|
|
asyncio._maybe_async_provisioning(
|
|
provision.create_follower_db, node.workerinput["follower_ident"]
|
|
)
|
|
|
|
def pytest_testnodedown(node, error):
|
|
from sqlalchemy.testing import provision
|
|
from sqlalchemy.testing import asyncio
|
|
|
|
asyncio._maybe_async_provisioning(
|
|
provision.drop_follower_db, node.workerinput["follower_ident"]
|
|
)
|
|
|
|
|
|
def pytest_collection_modifyitems(session, config, items):
|
|
|
|
# look for all those classes that specify __backend__ and
|
|
# expand them out into per-database test cases.
|
|
|
|
# this is much easier to do within pytest_pycollect_makeitem, however
|
|
# pytest is iterating through cls.__dict__ as makeitem is
|
|
# called which causes a "dictionary changed size" error on py3k.
|
|
# I'd submit a pullreq for them to turn it into a list first, but
|
|
# it's to suit the rather odd use case here which is that we are adding
|
|
# new classes to a module on the fly.
|
|
|
|
from sqlalchemy.testing import asyncio
|
|
|
|
rebuilt_items = collections.defaultdict(
|
|
lambda: collections.defaultdict(list)
|
|
)
|
|
|
|
items[:] = [
|
|
item
|
|
for item in items
|
|
if isinstance(item.parent, pytest.Instance)
|
|
and not item.parent.parent.name.startswith("_")
|
|
]
|
|
|
|
test_classes = set(item.parent for item in items)
|
|
|
|
def setup_test_classes():
|
|
for test_class in test_classes:
|
|
for sub_cls in plugin_base.generate_sub_tests(
|
|
test_class.cls, test_class.parent.module
|
|
):
|
|
if sub_cls is not test_class.cls:
|
|
per_cls_dict = rebuilt_items[test_class.cls]
|
|
|
|
# support pytest 5.4.0 and above pytest.Class.from_parent
|
|
ctor = getattr(pytest.Class, "from_parent", pytest.Class)
|
|
for inst in ctor(
|
|
name=sub_cls.__name__, parent=test_class.parent.parent
|
|
).collect():
|
|
for t in inst.collect():
|
|
per_cls_dict[t.name].append(t)
|
|
|
|
# class requirements will sometimes need to access the DB to check
|
|
# capabilities, so need to do this for async
|
|
asyncio._maybe_async_provisioning(setup_test_classes)
|
|
|
|
newitems = []
|
|
for item in items:
|
|
if item.parent.cls in rebuilt_items:
|
|
newitems.extend(rebuilt_items[item.parent.cls][item.name])
|
|
else:
|
|
newitems.append(item)
|
|
|
|
if py2k:
|
|
for item in newitems:
|
|
reinvent_fixtures_py2k.scan_for_fixtures_to_use_for_class(item)
|
|
|
|
# seems like the functions attached to a test class aren't sorted already?
|
|
# is that true and why's that? (when using unittest, they're sorted)
|
|
items[:] = sorted(
|
|
newitems,
|
|
key=lambda item: (
|
|
item.parent.parent.parent.name,
|
|
item.parent.parent.name,
|
|
item.name,
|
|
),
|
|
)
|
|
|
|
|
|
def pytest_pycollect_makeitem(collector, name, obj):
|
|
if inspect.isclass(obj) and plugin_base.want_class(name, obj):
|
|
from sqlalchemy.testing import config
|
|
|
|
if config.any_async:
|
|
obj = _apply_maybe_async(obj)
|
|
|
|
ctor = getattr(pytest.Class, "from_parent", pytest.Class)
|
|
return [
|
|
ctor(name=parametrize_cls.__name__, parent=collector)
|
|
for parametrize_cls in _parametrize_cls(collector.module, obj)
|
|
]
|
|
elif (
|
|
inspect.isfunction(obj)
|
|
and isinstance(collector, pytest.Instance)
|
|
and plugin_base.want_method(collector.cls, obj)
|
|
):
|
|
# None means, fall back to default logic, which includes
|
|
# method-level parametrize
|
|
return None
|
|
else:
|
|
# empty list means skip this item
|
|
return []
|
|
|
|
|
|
def _is_wrapped_coroutine_function(fn):
|
|
while hasattr(fn, "__wrapped__"):
|
|
fn = fn.__wrapped__
|
|
|
|
return inspect.iscoroutinefunction(fn)
|
|
|
|
|
|
def _apply_maybe_async(obj, recurse=True):
|
|
from sqlalchemy.testing import asyncio
|
|
|
|
for name, value in vars(obj).items():
|
|
if (
|
|
(callable(value) or isinstance(value, classmethod))
|
|
and not getattr(value, "_maybe_async_applied", False)
|
|
and (name.startswith("test_"))
|
|
and not _is_wrapped_coroutine_function(value)
|
|
):
|
|
is_classmethod = False
|
|
if isinstance(value, classmethod):
|
|
value = value.__func__
|
|
is_classmethod = True
|
|
|
|
@_pytest_fn_decorator
|
|
def make_async(fn, *args, **kwargs):
|
|
return asyncio._maybe_async(fn, *args, **kwargs)
|
|
|
|
do_async = make_async(value)
|
|
if is_classmethod:
|
|
do_async = classmethod(do_async)
|
|
do_async._maybe_async_applied = True
|
|
|
|
setattr(obj, name, do_async)
|
|
if recurse:
|
|
for cls in obj.mro()[1:]:
|
|
if cls != object:
|
|
_apply_maybe_async(cls, False)
|
|
return obj
|
|
|
|
|
|
def _parametrize_cls(module, cls):
|
|
"""implement a class-based version of pytest parametrize."""
|
|
|
|
if "_sa_parametrize" not in cls.__dict__:
|
|
return [cls]
|
|
|
|
_sa_parametrize = cls._sa_parametrize
|
|
classes = []
|
|
for full_param_set in itertools.product(
|
|
*[params for argname, params in _sa_parametrize]
|
|
):
|
|
cls_variables = {}
|
|
|
|
for argname, param in zip(
|
|
[_sa_param[0] for _sa_param in _sa_parametrize], full_param_set
|
|
):
|
|
if not argname:
|
|
raise TypeError("need argnames for class-based combinations")
|
|
argname_split = re.split(r",\s*", argname)
|
|
for arg, val in zip(argname_split, param.values):
|
|
cls_variables[arg] = val
|
|
parametrized_name = "_".join(
|
|
# token is a string, but in py2k pytest is giving us a unicode,
|
|
# so call str() on it.
|
|
str(re.sub(r"\W", "", token))
|
|
for param in full_param_set
|
|
for token in param.id.split("-")
|
|
)
|
|
name = "%s_%s" % (cls.__name__, parametrized_name)
|
|
newcls = type.__new__(type, name, (cls,), cls_variables)
|
|
setattr(module, name, newcls)
|
|
classes.append(newcls)
|
|
return classes
|
|
|
|
|
|
_current_class = None
|
|
|
|
|
|
def pytest_runtest_setup(item):
|
|
from sqlalchemy.testing import asyncio
|
|
|
|
if not isinstance(item, pytest.Function):
|
|
return
|
|
|
|
# pytest_runtest_setup runs *before* pytest fixtures with scope="class".
|
|
# plugin_base.start_test_class_outside_fixtures may opt to raise SkipTest
|
|
# for the whole class and has to run things that are across all current
|
|
# databases, so we run this outside of the pytest fixture system altogether
|
|
# and ensure asyncio greenlet if any engines are async
|
|
|
|
global _current_class
|
|
|
|
if _current_class is None:
|
|
asyncio._maybe_async_provisioning(
|
|
plugin_base.start_test_class_outside_fixtures,
|
|
item.parent.parent.cls,
|
|
)
|
|
_current_class = item.parent.parent
|
|
|
|
def finalize():
|
|
global _current_class
|
|
_current_class = None
|
|
|
|
asyncio._maybe_async_provisioning(
|
|
plugin_base.stop_test_class_outside_fixtures,
|
|
item.parent.parent.cls,
|
|
)
|
|
|
|
item.parent.parent.addfinalizer(finalize)
|
|
|
|
|
|
def pytest_runtest_call(item):
|
|
# runs inside of pytest function fixture scope
|
|
# before test function runs
|
|
|
|
from sqlalchemy.testing import asyncio
|
|
|
|
asyncio._maybe_async(
|
|
plugin_base.before_test,
|
|
item,
|
|
item.parent.module.__name__,
|
|
item.parent.cls,
|
|
item.name,
|
|
)
|
|
|
|
|
|
def pytest_runtest_teardown(item, nextitem):
|
|
# runs inside of pytest function fixture scope
|
|
# after test function runs
|
|
|
|
from sqlalchemy.testing import asyncio
|
|
|
|
asyncio._maybe_async(plugin_base.after_test, item)
|
|
|
|
|
|
@pytest.fixture(scope="class")
|
|
def setup_class_methods(request):
|
|
from sqlalchemy.testing import asyncio
|
|
|
|
cls = request.cls
|
|
|
|
if hasattr(cls, "setup_test_class"):
|
|
asyncio._maybe_async(cls.setup_test_class)
|
|
|
|
if py2k:
|
|
reinvent_fixtures_py2k.run_class_fixture_setup(request)
|
|
|
|
yield
|
|
|
|
if py2k:
|
|
reinvent_fixtures_py2k.run_class_fixture_teardown(request)
|
|
|
|
if hasattr(cls, "teardown_test_class"):
|
|
asyncio._maybe_async(cls.teardown_test_class)
|
|
|
|
asyncio._maybe_async(plugin_base.stop_test_class, cls)
|
|
|
|
|
|
@pytest.fixture(scope="function")
|
|
def setup_test_methods(request):
|
|
from sqlalchemy.testing import asyncio
|
|
|
|
# called for each test
|
|
|
|
self = request.instance
|
|
|
|
# 1. run outer xdist-style setup
|
|
if hasattr(self, "setup_test"):
|
|
asyncio._maybe_async(self.setup_test)
|
|
|
|
# alembic test suite is using setUp and tearDown
|
|
# xdist methods; support these in the test suite
|
|
# for the near term
|
|
if hasattr(self, "setUp"):
|
|
asyncio._maybe_async(self.setUp)
|
|
|
|
# 2. run homegrown function level "autouse" fixtures under py2k
|
|
if py2k:
|
|
reinvent_fixtures_py2k.run_fn_fixture_setup(request)
|
|
|
|
# inside the yield:
|
|
|
|
# 3. function level "autouse" fixtures under py3k (examples: TablesTest
|
|
# define tables / data, MappedTest define tables / mappers / data)
|
|
|
|
# 4. function level fixtures defined on test functions themselves,
|
|
# e.g. "connection", "metadata" run next
|
|
|
|
# 5. pytest hook pytest_runtest_call then runs
|
|
|
|
# 6. test itself runs
|
|
|
|
yield
|
|
|
|
# yield finishes:
|
|
|
|
# 7. pytest hook pytest_runtest_teardown hook runs, this is associated
|
|
# with fixtures close all sessions, provisioning.stop_test_class(),
|
|
# engines.testing_reaper -> ensure all connection pool connections
|
|
# are returned, engines created by testing_engine that aren't the
|
|
# config engine are disposed
|
|
|
|
# 8. function level fixtures defined on test functions
|
|
# themselves, e.g. "connection" rolls back the transaction, "metadata"
|
|
# emits drop all
|
|
|
|
# 9. function level "autouse" fixtures under py3k (examples: TablesTest /
|
|
# MappedTest delete table data, possibly drop tables and clear mappers
|
|
# depending on the flags defined by the test class)
|
|
|
|
# 10. run homegrown function-level "autouse" fixtures under py2k
|
|
if py2k:
|
|
reinvent_fixtures_py2k.run_fn_fixture_teardown(request)
|
|
|
|
asyncio._maybe_async(plugin_base.after_test_fixtures, self)
|
|
|
|
# 11. run outer xdist-style teardown
|
|
if hasattr(self, "tearDown"):
|
|
asyncio._maybe_async(self.tearDown)
|
|
|
|
if hasattr(self, "teardown_test"):
|
|
asyncio._maybe_async(self.teardown_test)
|
|
|
|
|
|
def getargspec(fn):
|
|
if sys.version_info.major == 3:
|
|
return inspect.getfullargspec(fn)
|
|
else:
|
|
return inspect.getargspec(fn)
|
|
|
|
|
|
def _pytest_fn_decorator(target):
|
|
"""Port of langhelpers.decorator with pytest-specific tricks."""
|
|
|
|
from sqlalchemy.util.langhelpers import format_argspec_plus
|
|
from sqlalchemy.util.compat import inspect_getfullargspec
|
|
|
|
def _exec_code_in_env(code, env, fn_name):
|
|
exec(code, env)
|
|
return env[fn_name]
|
|
|
|
def decorate(fn, add_positional_parameters=()):
|
|
|
|
spec = inspect_getfullargspec(fn)
|
|
if add_positional_parameters:
|
|
spec.args.extend(add_positional_parameters)
|
|
|
|
metadata = dict(
|
|
__target_fn="__target_fn", __orig_fn="__orig_fn", name=fn.__name__
|
|
)
|
|
metadata.update(format_argspec_plus(spec, grouped=False))
|
|
code = (
|
|
"""\
|
|
def %(name)s(%(args)s):
|
|
return %(__target_fn)s(%(__orig_fn)s, %(apply_kw)s)
|
|
"""
|
|
% metadata
|
|
)
|
|
decorated = _exec_code_in_env(
|
|
code, {"__target_fn": target, "__orig_fn": fn}, fn.__name__
|
|
)
|
|
if not add_positional_parameters:
|
|
decorated.__defaults__ = getattr(fn, "__func__", fn).__defaults__
|
|
decorated.__wrapped__ = fn
|
|
return update_wrapper(decorated, fn)
|
|
else:
|
|
# this is the pytest hacky part. don't do a full update wrapper
|
|
# because pytest is really being sneaky about finding the args
|
|
# for the wrapped function
|
|
decorated.__module__ = fn.__module__
|
|
decorated.__name__ = fn.__name__
|
|
if hasattr(fn, "pytestmark"):
|
|
decorated.pytestmark = fn.pytestmark
|
|
return decorated
|
|
|
|
return decorate
|
|
|
|
|
|
class PytestFixtureFunctions(plugin_base.FixtureFunctions):
|
|
def skip_test_exception(self, *arg, **kw):
|
|
return pytest.skip.Exception(*arg, **kw)
|
|
|
|
def mark_base_test_class(self):
|
|
return pytest.mark.usefixtures(
|
|
"setup_class_methods", "setup_test_methods"
|
|
)
|
|
|
|
_combination_id_fns = {
|
|
"i": lambda obj: obj,
|
|
"r": repr,
|
|
"s": str,
|
|
"n": lambda obj: obj.__name__
|
|
if hasattr(obj, "__name__")
|
|
else type(obj).__name__,
|
|
}
|
|
|
|
def combinations(self, *arg_sets, **kw):
|
|
"""Facade for pytest.mark.parametrize.
|
|
|
|
Automatically derives argument names from the callable which in our
|
|
case is always a method on a class with positional arguments.
|
|
|
|
ids for parameter sets are derived using an optional template.
|
|
|
|
"""
|
|
from sqlalchemy.testing import exclusions
|
|
|
|
if sys.version_info.major == 3:
|
|
if len(arg_sets) == 1 and hasattr(arg_sets[0], "__next__"):
|
|
arg_sets = list(arg_sets[0])
|
|
else:
|
|
if len(arg_sets) == 1 and hasattr(arg_sets[0], "next"):
|
|
arg_sets = list(arg_sets[0])
|
|
|
|
argnames = kw.pop("argnames", None)
|
|
|
|
def _filter_exclusions(args):
|
|
result = []
|
|
gathered_exclusions = []
|
|
for a in args:
|
|
if isinstance(a, exclusions.compound):
|
|
gathered_exclusions.append(a)
|
|
else:
|
|
result.append(a)
|
|
|
|
return result, gathered_exclusions
|
|
|
|
id_ = kw.pop("id_", None)
|
|
|
|
tobuild_pytest_params = []
|
|
has_exclusions = False
|
|
if id_:
|
|
_combination_id_fns = self._combination_id_fns
|
|
|
|
# because itemgetter is not consistent for one argument vs.
|
|
# multiple, make it multiple in all cases and use a slice
|
|
# to omit the first argument
|
|
_arg_getter = operator.itemgetter(
|
|
0,
|
|
*[
|
|
idx
|
|
for idx, char in enumerate(id_)
|
|
if char in ("n", "r", "s", "a")
|
|
]
|
|
)
|
|
fns = [
|
|
(operator.itemgetter(idx), _combination_id_fns[char])
|
|
for idx, char in enumerate(id_)
|
|
if char in _combination_id_fns
|
|
]
|
|
|
|
for arg in arg_sets:
|
|
if not isinstance(arg, tuple):
|
|
arg = (arg,)
|
|
|
|
fn_params, param_exclusions = _filter_exclusions(arg)
|
|
|
|
parameters = _arg_getter(fn_params)[1:]
|
|
|
|
if param_exclusions:
|
|
has_exclusions = True
|
|
|
|
tobuild_pytest_params.append(
|
|
(
|
|
parameters,
|
|
param_exclusions,
|
|
"-".join(
|
|
comb_fn(getter(arg)) for getter, comb_fn in fns
|
|
),
|
|
)
|
|
)
|
|
|
|
else:
|
|
|
|
for arg in arg_sets:
|
|
if not isinstance(arg, tuple):
|
|
arg = (arg,)
|
|
|
|
fn_params, param_exclusions = _filter_exclusions(arg)
|
|
|
|
if param_exclusions:
|
|
has_exclusions = True
|
|
|
|
tobuild_pytest_params.append(
|
|
(fn_params, param_exclusions, None)
|
|
)
|
|
|
|
pytest_params = []
|
|
for parameters, param_exclusions, id_ in tobuild_pytest_params:
|
|
if has_exclusions:
|
|
parameters += (param_exclusions,)
|
|
|
|
param = pytest.param(*parameters, id=id_)
|
|
pytest_params.append(param)
|
|
|
|
def decorate(fn):
|
|
if inspect.isclass(fn):
|
|
if has_exclusions:
|
|
raise NotImplementedError(
|
|
"exclusions not supported for class level combinations"
|
|
)
|
|
if "_sa_parametrize" not in fn.__dict__:
|
|
fn._sa_parametrize = []
|
|
fn._sa_parametrize.append((argnames, pytest_params))
|
|
return fn
|
|
else:
|
|
if argnames is None:
|
|
_argnames = getargspec(fn).args[1:]
|
|
else:
|
|
_argnames = re.split(r", *", argnames)
|
|
|
|
if has_exclusions:
|
|
_argnames += ["_exclusions"]
|
|
|
|
@_pytest_fn_decorator
|
|
def check_exclusions(fn, *args, **kw):
|
|
_exclusions = args[-1]
|
|
if _exclusions:
|
|
exlu = exclusions.compound().add(*_exclusions)
|
|
fn = exlu(fn)
|
|
return fn(*args[0:-1], **kw)
|
|
|
|
def process_metadata(spec):
|
|
spec.args.append("_exclusions")
|
|
|
|
fn = check_exclusions(
|
|
fn, add_positional_parameters=("_exclusions",)
|
|
)
|
|
|
|
return pytest.mark.parametrize(_argnames, pytest_params)(fn)
|
|
|
|
return decorate
|
|
|
|
def param_ident(self, *parameters):
|
|
ident = parameters[0]
|
|
return pytest.param(*parameters[1:], id=ident)
|
|
|
|
def fixture(self, *arg, **kw):
|
|
from sqlalchemy.testing import config
|
|
from sqlalchemy.testing import asyncio
|
|
|
|
# wrapping pytest.fixture function. determine if
|
|
# decorator was called as @fixture or @fixture().
|
|
if len(arg) > 0 and callable(arg[0]):
|
|
# was called as @fixture(), we have the function to wrap.
|
|
fn = arg[0]
|
|
arg = arg[1:]
|
|
else:
|
|
# was called as @fixture, don't have the function yet.
|
|
fn = None
|
|
|
|
# create a pytest.fixture marker. because the fn is not being
|
|
# passed, this is always a pytest.FixtureFunctionMarker()
|
|
# object (or whatever pytest is calling it when you read this)
|
|
# that is waiting for a function.
|
|
fixture = pytest.fixture(*arg, **kw)
|
|
|
|
# now apply wrappers to the function, including fixture itself
|
|
|
|
def wrap(fn):
|
|
if config.any_async:
|
|
fn = asyncio._maybe_async_wrapper(fn)
|
|
# other wrappers may be added here
|
|
|
|
if py2k and "autouse" in kw:
|
|
# py2k workaround for too-slow collection of autouse fixtures
|
|
# in pytest 4.6.11. See notes in reinvent_fixtures_py2k for
|
|
# rationale.
|
|
|
|
# comment this condition out in order to disable the
|
|
# py2k workaround entirely.
|
|
reinvent_fixtures_py2k.add_fixture(fn, fixture)
|
|
else:
|
|
# now apply FixtureFunctionMarker
|
|
fn = fixture(fn)
|
|
|
|
return fn
|
|
|
|
if fn:
|
|
return wrap(fn)
|
|
else:
|
|
return wrap
|
|
|
|
def get_current_test_name(self):
|
|
return os.environ.get("PYTEST_CURRENT_TEST")
|
|
|
|
def async_test(self, fn):
|
|
from sqlalchemy.testing import asyncio
|
|
|
|
@_pytest_fn_decorator
|
|
def decorate(fn, *args, **kwargs):
|
|
asyncio._run_coroutine_function(fn, *args, **kwargs)
|
|
|
|
return decorate(fn)
|