| """ generic mechanism for marking and selecting python functions. """ |
| from __future__ import absolute_import, division, print_function |
| |
| import inspect |
| import warnings |
| import attr |
| from collections import namedtuple |
| from operator import attrgetter |
| from six.moves import map |
| from .deprecated import MARK_PARAMETERSET_UNPACKING |
| from .compat import NOTSET, getfslineno |
| |
| |
| def alias(name, warning=None): |
| getter = attrgetter(name) |
| |
| def warned(self): |
| warnings.warn(warning, stacklevel=2) |
| return getter(self) |
| |
| return property(getter if warning is None else warned, doc='alias for ' + name) |
| |
| |
| class ParameterSet(namedtuple('ParameterSet', 'values, marks, id')): |
| @classmethod |
| def param(cls, *values, **kw): |
| marks = kw.pop('marks', ()) |
| if isinstance(marks, MarkDecorator): |
| marks = marks, |
| else: |
| assert isinstance(marks, (tuple, list, set)) |
| |
| def param_extract_id(id=None): |
| return id |
| |
| id = param_extract_id(**kw) |
| return cls(values, marks, id) |
| |
| @classmethod |
| def extract_from(cls, parameterset, legacy_force_tuple=False): |
| """ |
| :param parameterset: |
| a legacy style parameterset that may or may not be a tuple, |
| and may or may not be wrapped into a mess of mark objects |
| |
| :param legacy_force_tuple: |
| enforce tuple wrapping so single argument tuple values |
| don't get decomposed and break tests |
| |
| """ |
| |
| if isinstance(parameterset, cls): |
| return parameterset |
| if not isinstance(parameterset, MarkDecorator) and legacy_force_tuple: |
| return cls.param(parameterset) |
| |
| newmarks = [] |
| argval = parameterset |
| while isinstance(argval, MarkDecorator): |
| newmarks.append(MarkDecorator(Mark( |
| argval.markname, argval.args[:-1], argval.kwargs))) |
| argval = argval.args[-1] |
| assert not isinstance(argval, ParameterSet) |
| if legacy_force_tuple: |
| argval = argval, |
| |
| if newmarks: |
| warnings.warn(MARK_PARAMETERSET_UNPACKING) |
| |
| return cls(argval, marks=newmarks, id=None) |
| |
| @classmethod |
| def _for_parameterize(cls, argnames, argvalues, function): |
| if not isinstance(argnames, (tuple, list)): |
| argnames = [x.strip() for x in argnames.split(",") if x.strip()] |
| force_tuple = len(argnames) == 1 |
| else: |
| force_tuple = False |
| parameters = [ |
| ParameterSet.extract_from(x, legacy_force_tuple=force_tuple) |
| for x in argvalues] |
| del argvalues |
| |
| if not parameters: |
| fs, lineno = getfslineno(function) |
| reason = "got empty parameter set %r, function %s at %s:%d" % ( |
| argnames, function.__name__, fs, lineno) |
| mark = MARK_GEN.skip(reason=reason) |
| parameters.append(ParameterSet( |
| values=(NOTSET,) * len(argnames), |
| marks=[mark], |
| id=None, |
| )) |
| return argnames, parameters |
| |
| |
| class MarkerError(Exception): |
| |
| """Error in use of a pytest marker/attribute.""" |
| |
| |
| def param(*values, **kw): |
| return ParameterSet.param(*values, **kw) |
| |
| |
| def pytest_addoption(parser): |
| group = parser.getgroup("general") |
| group._addoption( |
| '-k', |
| action="store", dest="keyword", default='', metavar="EXPRESSION", |
| help="only run tests which match the given substring expression. " |
| "An expression is a python evaluatable expression " |
| "where all names are substring-matched against test names " |
| "and their parent classes. Example: -k 'test_method or test_" |
| "other' matches all test functions and classes whose name " |
| "contains 'test_method' or 'test_other', while -k 'not test_method' " |
| "matches those that don't contain 'test_method' in their names. " |
| "Additionally keywords are matched to classes and functions " |
| "containing extra names in their 'extra_keyword_matches' set, " |
| "as well as functions which have names assigned directly to them." |
| ) |
| |
| group._addoption( |
| "-m", |
| action="store", dest="markexpr", default="", metavar="MARKEXPR", |
| help="only run tests matching given mark expression. " |
| "example: -m 'mark1 and not mark2'." |
| ) |
| |
| group.addoption( |
| "--markers", action="store_true", |
| help="show markers (builtin, plugin and per-project ones)." |
| ) |
| |
| parser.addini("markers", "markers for test functions", 'linelist') |
| |
| |
| def pytest_cmdline_main(config): |
| import _pytest.config |
| if config.option.markers: |
| config._do_configure() |
| tw = _pytest.config.create_terminal_writer(config) |
| for line in config.getini("markers"): |
| parts = line.split(":", 1) |
| name = parts[0] |
| rest = parts[1] if len(parts) == 2 else '' |
| tw.write("@pytest.mark.%s:" % name, bold=True) |
| tw.line(rest) |
| tw.line() |
| config._ensure_unconfigure() |
| return 0 |
| |
| |
| pytest_cmdline_main.tryfirst = True |
| |
| |
| def pytest_collection_modifyitems(items, config): |
| keywordexpr = config.option.keyword.lstrip() |
| matchexpr = config.option.markexpr |
| if not keywordexpr and not matchexpr: |
| return |
| # pytest used to allow "-" for negating |
| # but today we just allow "-" at the beginning, use "not" instead |
| # we probably remove "-" altogether soon |
| if keywordexpr.startswith("-"): |
| keywordexpr = "not " + keywordexpr[1:] |
| selectuntil = False |
| if keywordexpr[-1:] == ":": |
| selectuntil = True |
| keywordexpr = keywordexpr[:-1] |
| |
| remaining = [] |
| deselected = [] |
| for colitem in items: |
| if keywordexpr and not matchkeyword(colitem, keywordexpr): |
| deselected.append(colitem) |
| else: |
| if selectuntil: |
| keywordexpr = None |
| if matchexpr: |
| if not matchmark(colitem, matchexpr): |
| deselected.append(colitem) |
| continue |
| remaining.append(colitem) |
| |
| if deselected: |
| config.hook.pytest_deselected(items=deselected) |
| items[:] = remaining |
| |
| |
| @attr.s |
| class MarkMapping(object): |
| """Provides a local mapping for markers where item access |
| resolves to True if the marker is present. """ |
| |
| own_mark_names = attr.ib() |
| |
| @classmethod |
| def from_keywords(cls, keywords): |
| mark_names = set() |
| for key, value in keywords.items(): |
| if isinstance(value, MarkInfo) or isinstance(value, MarkDecorator): |
| mark_names.add(key) |
| return cls(mark_names) |
| |
| def __getitem__(self, name): |
| return name in self.own_mark_names |
| |
| |
| class KeywordMapping(object): |
| """Provides a local mapping for keywords. |
| Given a list of names, map any substring of one of these names to True. |
| """ |
| |
| def __init__(self, names): |
| self._names = names |
| |
| def __getitem__(self, subname): |
| for name in self._names: |
| if subname in name: |
| return True |
| return False |
| |
| |
| def matchmark(colitem, markexpr): |
| """Tries to match on any marker names, attached to the given colitem.""" |
| return eval(markexpr, {}, MarkMapping.from_keywords(colitem.keywords)) |
| |
| |
| def matchkeyword(colitem, keywordexpr): |
| """Tries to match given keyword expression to given collector item. |
| |
| Will match on the name of colitem, including the names of its parents. |
| Only matches names of items which are either a :class:`Class` or a |
| :class:`Function`. |
| Additionally, matches on names in the 'extra_keyword_matches' set of |
| any item, as well as names directly assigned to test functions. |
| """ |
| mapped_names = set() |
| |
| # Add the names of the current item and any parent items |
| import pytest |
| for item in colitem.listchain(): |
| if not isinstance(item, pytest.Instance): |
| mapped_names.add(item.name) |
| |
| # Add the names added as extra keywords to current or parent items |
| for name in colitem.listextrakeywords(): |
| mapped_names.add(name) |
| |
| # Add the names attached to the current function through direct assignment |
| if hasattr(colitem, 'function'): |
| for name in colitem.function.__dict__: |
| mapped_names.add(name) |
| |
| mapping = KeywordMapping(mapped_names) |
| if " " not in keywordexpr: |
| # special case to allow for simple "-k pass" and "-k 1.3" |
| return mapping[keywordexpr] |
| elif keywordexpr.startswith("not ") and " " not in keywordexpr[4:]: |
| return not mapping[keywordexpr[4:]] |
| return eval(keywordexpr, {}, mapping) |
| |
| |
| def pytest_configure(config): |
| config._old_mark_config = MARK_GEN._config |
| if config.option.strict: |
| MARK_GEN._config = config |
| |
| |
| def pytest_unconfigure(config): |
| MARK_GEN._config = getattr(config, '_old_mark_config', None) |
| |
| |
| class MarkGenerator: |
| """ Factory for :class:`MarkDecorator` objects - exposed as |
| a ``pytest.mark`` singleton instance. Example:: |
| |
| import pytest |
| @pytest.mark.slowtest |
| def test_function(): |
| pass |
| |
| will set a 'slowtest' :class:`MarkInfo` object |
| on the ``test_function`` object. """ |
| _config = None |
| |
| def __getattr__(self, name): |
| if name[0] == "_": |
| raise AttributeError("Marker name must NOT start with underscore") |
| if self._config is not None: |
| self._check(name) |
| return MarkDecorator(Mark(name, (), {})) |
| |
| def _check(self, name): |
| try: |
| if name in self._markers: |
| return |
| except AttributeError: |
| pass |
| self._markers = values = set() |
| for line in self._config.getini("markers"): |
| marker = line.split(":", 1)[0] |
| marker = marker.rstrip() |
| x = marker.split("(", 1)[0] |
| values.add(x) |
| if name not in self._markers: |
| raise AttributeError("%r not a registered marker" % (name,)) |
| |
| |
| def istestfunc(func): |
| return hasattr(func, "__call__") and \ |
| getattr(func, "__name__", "<lambda>") != "<lambda>" |
| |
| |
| @attr.s(frozen=True) |
| class Mark(object): |
| name = attr.ib() |
| args = attr.ib() |
| kwargs = attr.ib() |
| |
| def combined_with(self, other): |
| assert self.name == other.name |
| return Mark( |
| self.name, self.args + other.args, |
| dict(self.kwargs, **other.kwargs)) |
| |
| |
| @attr.s |
| class MarkDecorator(object): |
| """ A decorator for test functions and test classes. When applied |
| it will create :class:`MarkInfo` objects which may be |
| :ref:`retrieved by hooks as item keywords <excontrolskip>`. |
| MarkDecorator instances are often created like this:: |
| |
| mark1 = pytest.mark.NAME # simple MarkDecorator |
| mark2 = pytest.mark.NAME(name1=value) # parametrized MarkDecorator |
| |
| and can then be applied as decorators to test functions:: |
| |
| @mark2 |
| def test_function(): |
| pass |
| |
| When a MarkDecorator instance is called it does the following: |
| 1. If called with a single class as its only positional argument and no |
| additional keyword arguments, it attaches itself to the class so it |
| gets applied automatically to all test cases found in that class. |
| 2. If called with a single function as its only positional argument and |
| no additional keyword arguments, it attaches a MarkInfo object to the |
| function, containing all the arguments already stored internally in |
| the MarkDecorator. |
| 3. When called in any other case, it performs a 'fake construction' call, |
| i.e. it returns a new MarkDecorator instance with the original |
| MarkDecorator's content updated with the arguments passed to this |
| call. |
| |
| Note: The rules above prevent MarkDecorator objects from storing only a |
| single function or class reference as their positional argument with no |
| additional keyword or positional arguments. |
| |
| """ |
| |
| mark = attr.ib(validator=attr.validators.instance_of(Mark)) |
| |
| name = alias('mark.name') |
| args = alias('mark.args') |
| kwargs = alias('mark.kwargs') |
| |
| @property |
| def markname(self): |
| return self.name # for backward-compat (2.4.1 had this attr) |
| |
| def __eq__(self, other): |
| return self.mark == other.mark if isinstance(other, MarkDecorator) else False |
| |
| def __repr__(self): |
| return "<MarkDecorator %r>" % (self.mark,) |
| |
| def with_args(self, *args, **kwargs): |
| """ return a MarkDecorator with extra arguments added |
| |
| unlike call this can be used even if the sole argument is a callable/class |
| |
| :return: MarkDecorator |
| """ |
| |
| mark = Mark(self.name, args, kwargs) |
| return self.__class__(self.mark.combined_with(mark)) |
| |
| 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. """ |
| if args and not kwargs: |
| func = args[0] |
| is_class = inspect.isclass(func) |
| if len(args) == 1 and (istestfunc(func) or is_class): |
| if is_class: |
| store_mark(func, self.mark) |
| else: |
| store_legacy_markinfo(func, self.mark) |
| store_mark(func, self.mark) |
| return func |
| return self.with_args(*args, **kwargs) |
| |
| |
| def get_unpacked_marks(obj): |
| """ |
| obtain the unpacked marks that are stored on a object |
| """ |
| mark_list = getattr(obj, 'pytestmark', []) |
| |
| if not isinstance(mark_list, list): |
| mark_list = [mark_list] |
| return [ |
| getattr(mark, 'mark', mark) # unpack MarkDecorator |
| for mark in mark_list |
| ] |
| |
| |
| def store_mark(obj, mark): |
| """store a Mark on a object |
| this is used to implement the Mark declarations/decorators correctly |
| """ |
| assert isinstance(mark, Mark), mark |
| # always reassign name to avoid updating pytestmark |
| # in a reference that was only borrowed |
| obj.pytestmark = get_unpacked_marks(obj) + [mark] |
| |
| |
| def store_legacy_markinfo(func, mark): |
| """create the legacy MarkInfo objects and put them onto the function |
| """ |
| if not isinstance(mark, Mark): |
| raise TypeError("got {mark!r} instead of a Mark".format(mark=mark)) |
| holder = getattr(func, mark.name, None) |
| if holder is None: |
| holder = MarkInfo(mark) |
| setattr(func, mark.name, holder) |
| else: |
| holder.add_mark(mark) |
| |
| |
| class MarkInfo(object): |
| """ Marking object created by :class:`MarkDecorator` instances. """ |
| |
| def __init__(self, mark): |
| assert isinstance(mark, Mark), repr(mark) |
| self.combined = mark |
| self._marks = [mark] |
| |
| name = alias('combined.name') |
| args = alias('combined.args') |
| kwargs = alias('combined.kwargs') |
| |
| def __repr__(self): |
| return "<MarkInfo {0!r}>".format(self.combined) |
| |
| def add_mark(self, mark): |
| """ add a MarkInfo with the given args and kwargs. """ |
| self._marks.append(mark) |
| self.combined = self.combined.combined_with(mark) |
| |
| def __iter__(self): |
| """ yield MarkInfo objects each relating to a marking-call. """ |
| return map(MarkInfo, self._marks) |
| |
| |
| MARK_GEN = MarkGenerator() |
| |
| |
| def _marked(func, mark): |
| """ Returns True if :func: is already marked with :mark:, False otherwise. |
| This can happen if marker is applied to class and the test file is |
| invoked more than once. |
| """ |
| try: |
| func_mark = getattr(func, mark.name) |
| except AttributeError: |
| return False |
| return mark.args == func_mark.args and mark.kwargs == func_mark.kwargs |
| |
| |
| def transfer_markers(funcobj, cls, mod): |
| """ |
| this function transfers class level markers and module level markers |
| into function level markinfo objects |
| |
| this is the main reason why marks are so broken |
| the resolution will involve phasing out function level MarkInfo objects |
| |
| """ |
| for obj in (cls, mod): |
| for mark in get_unpacked_marks(obj): |
| if not _marked(funcobj, mark): |
| store_legacy_markinfo(funcobj, mark) |
