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})