def pytest_generate_tests(metafunc):
from pytest_quickcheck.generator import DATA_TYPE_OPTIONS, IS_PY3
if not _has_pytestmark(metafunc):
return
randomize = None
ann_data_option = {}
for i, mark in enumerate(metafunc.function.pytestmark):
if mark.name == "randomize":
randomize = mark
data_option = {}
for opt in DATA_TYPE_OPTIONS:
if opt in randomize.kwargs:
data_option[opt] = randomize.kwargs.pop(opt)
ann_data_option.update(data_option)
args = tuple(i for i in randomize.kwargs.items())
if args:
randomize = Mark(randomize.name, args, {})
metafunc.function.pytestmark[i] = randomize
_set_parameterize(metafunc, randomize, data_option)
if IS_PY3 and hasattr(metafunc.function, "__annotations__"):
anns = metafunc.function.__annotations__.items()
args = get_randomize_args(randomize, anns)
if args:
_randomize = Mark("randomize", args, {})
_set_parameterize(metafunc, _randomize, ann_data_option)
def test_pytest_mark_positional(self):
mark = Mark()
def f():
pass
mark.world("hello")(f)
assert f.world.args[0] == "hello"
mark.world("world")(f)
def __call__(self, *args, **kwargs):
""" if passed a single callable argument: decorate it with mark info.
otherwise add *args/**kwargs in-place to mark information. """
from _pytest.mark import Mark, MarkInfo
if args:
func = args[0]
if len(args) == 1 and hasattr(func, '__call__') or \
hasattr(func, '__bases__'):
if hasattr(func, '__bases__'):
if hasattr(func, 'pytestmark'):
markers = func.pytestmark
if not isinstance(markers, list):
func.pytestmark = [markers, self]
else:
markers.append(self)
else:
func.pytestmark = [self]
else:
for x in self.tickets_id:
name = '%s%s' % (self.PREFIX, x)
holder = getattr(func, name, None)
mark = Mark(name, self.args, self.kwargs)
if holder is None:
holder = MarkInfo(mark)
setattr(func, name, holder)
else:
holder.add_mark(mark)
return func
kw = self.kwargs.copy()
kw.update(kwargs)
args = self.args + args
return self.__class__(self.markname, args=args, kwargs=kw)
def _compat_modify_args(markinfo, *args, **kwargs):
if hasattr(markinfo, 'add_mark'): # guess pytest >= 3.1.0
from _pytest.mark import Mark
markinfo.add_mark(Mark(markinfo.name, args, kwargs))
else:
markinfo.args += args
markinfo.kwargs.update(kwargs)
def test_pytest_mark_bare(self):
mark = Mark()
def f():
pass
mark.hello(f)
assert f.hello
def options(request: FixtureRequest, session_options: dict) -> dict:
"""The final options used to initialize Chrome browser."""
options_mark: Mark = reduce(
lambda mark1, mark2: mark1.combined_with(mark2),
request.node.iter_markers("options"),
Mark("options", args=tuple(), kwargs=dict()),
)
return dict(session_options, **options_mark.kwargs)
def test_pytest_mark_keywords(self):
mark = Mark()
def f():
pass
mark.world(x=3, y=4)(f)
assert f.world
assert f.world.kwargs['x'] == 3
assert f.world.kwargs['y'] == 4
def config_parse(cls, mark):
if "->" in mark:
mark, ret_factory = mark.split("->", 1)
kwargs = {"ret_factory": ret_factory}
else:
mark, ret_val = mark.split("=", 1)
kwargs = {"ret_val": guess(ret_val)}
return Mark(cls.name, tuple([mark]), kwargs)
def prop_alias(mock_obj_prefix=None, mock_factory_prefix="factories"):
"""
prop mark装饰器别名，指定要mock对象及工厂对象名字的前缀，减少装饰器长度。
:param mock_obj_prefix:
:param mock_factory_prefix:
:return:
"""
return DecoratorProxy(mock_obj_prefix, mock_factory_prefix,
MarkDecorator(Mark("prop", (), {})))
def test_pytest_mark_positional_func_and_keyword(self):
mark = Mark()
def f():
raise Exception
m = mark.world(f, omega="hello")
def g():
pass
assert m(g) == g
assert g.world.args[0] is f
assert g.world.kwargs["omega"] == "hello"
def prop_alias(mock_obj_prefix=None, mock_factory_prefix="factories"):
"""
prop mark装饰器别名，指定要mock对象及工厂对象名字的前缀，减少装饰器长度。
:param mock_obj_prefix:
:param mock_factory_prefix:
:return:
"""
return Proxy(MarkDecorator(Mark("prop", (), {})),
before=[
AOP.Hook(wrapper(mock_obj_prefix, mock_factory_prefix),
["__call__"])
])
def test_apply_multiple_and_merge(self):
mark = Mark()
def f():
pass
mark.world
mark.world(x=3)(f)
assert f.world.kwargs['x'] == 3
mark.world(y=4)(f)
assert f.world.kwargs['x'] == 3
assert f.world.kwargs['y'] == 4
mark.world(y=1)(f)
assert f.world.kwargs['y'] == 1
assert len(f.world.args) == 0
def test_pytest_mark_reuse(self):
mark = Mark()
def f():
pass
w = mark.some
w("hello", reason="123")(f)
assert f.some.args[0] == "hello"
assert f.some.kwargs['reason'] == "123"
def g():
pass
w("world", reason2="456")(g)
assert g.some.args[0] == "world"
assert 'reason' not in g.some.kwargs
assert g.some.kwargs['reason2'] == "456"
import glob
import logging
import os
import pytest
from _pytest.mark import Mark
from maigret.sites import MaigretDatabase
from maigret.maigret import setup_arguments_parser
CUR_PATH = os.path.dirname(os.path.realpath(__file__))
JSON_FILE = os.path.join(CUR_PATH, '../maigret/resources/data.json')
TEST_JSON_FILE = os.path.join(CUR_PATH, 'db.json')
LOCAL_TEST_JSON_FILE = os.path.join(CUR_PATH, 'local.json')
empty_mark = Mark('', (), {})
def by_slow_marker(item):
return item.get_closest_marker('slow', default=empty_mark)
def pytest_collection_modifyitems(items):
items.sort(key=by_slow_marker, reverse=False)
def get_test_reports_filenames():
return glob.glob(os.path.join('report_*'), recursive=False)
def remove_test_reports():
reports_list = get_test_reports_filenames()
def test_pytest_mark_name_starts_with_underscore(self):
mark = Mark()
pytest.raises(AttributeError, getattr, mark, '_some_name')
def test_markinfo_repr(self):
from _pytest.mark import MarkInfo, Mark
m = MarkInfo.for_mark(Mark("hello", (1, 2), {}))
repr(m)
import shutil
import subprocess
import sys
import time
import pytest
from _pytest.mark import Mark
from jupyterhub_traefik_proxy import TraefikEtcdProxy
from jupyterhub_traefik_proxy import TraefikConsulProxy
from jupyterhub_traefik_proxy import TraefikTomlProxy
# Define a "slow" test marker so that we can run the slow tests at the end
# ref: https://docs.pytest.org/en/6.0.1/example/simple.html#control-skipping-of-tests-according-to-command-line-option
# ref: https://stackoverflow.com/questions/61533694/run-slow-pytest-commands-at-the-end-of-the-test-suite
empty_mark = Mark("", [], {})
def by_slow_marker(item):
return item.get_closest_marker("slow", default=empty_mark)
def pytest_addoption(parser):
parser.addoption("--slow-last", action="store_true", default=False)
def pytest_collection_modifyitems(items, config):
if config.getoption("--slow-last"):
items.sort(key=by_slow_marker)
def config_parse(cls, mark_str):
return Mark(cls.name, tuple([guess(mark_str)]), dict())
def config_parse(cls, mark_str):
key, val = mark_str.split("=", 1)
return Mark(cls.name, tuple(), {key: guess(val)})
def config_parse(cls, mark_str):
mth = cls.mark_config_regex.search(mark_str)
if mth:
prop_name, key, val = mth.groups()
return Mark(cls.name, tuple([prop_name]), {eval(key): guess(val)})
def test_pytest_mark_notcallable(self) -> None:
mark = Mark()
with pytest.raises(TypeError):
mark() # type: ignore[operator]
'test.gff3',
'test.gbff',
'test.embl',
'test.fna',
'test.faa'
]
SKIP_PARAMETERS = [
'--skip-tmrna',
'--skip-trna',
'--skip-rrna',
'--skip-ncrna',
'--skip-ncrna-region',
'--skip-crispr',
'--skip-cds',
'--skip-sorf',
'--skip-ori',
'--skip-gap'
]
empty_mark = Mark('', [], {})
def by_slow_marker(item):
return item.get_closest_marker('slow', default=empty_mark)
def pytest_collection_modifyitems(items):
items.sort(key=by_slow_marker, reverse=False)
def test_pytest_mark_notcallable(self):
mark = Mark()
with pytest.raises(TypeError):
mark()
def test_pytest_mark_notcallable(self):
mark = Mark()
pytest.raises((AttributeError, TypeError), mark)
def test_pytest_mark_name_starts_with_underscore(self):
mark = Mark()
with pytest.raises(AttributeError):
mark._some_name
# content of conftest.py
import pathlib
import pytest
import requests
from _pytest.mark import Mark
from . import DATA_DIR
EMPTY_MARK = Mark("", [], {})
RUNLAST_MARK = "runlast"
def pytest_addoption(parser):
parser.addoption("--runschism",
action="store_true",
default=False,
help="run schism tests")
parser.addoption("--rundelft",
action="store_true",
default=False,
help="run delft tests")
parser.addoption("--runslow",
action="store_true",
default=False,
help="run slow tests")
parser.addoption("--runviz",
action="store_true",
default=False,
def config_parse(cls, mark):
key, val = mark.split("=", 1)
return Mark(cls.name, tuple(), {key: val})
