updates
This commit is contained in:
Iliyan Angelov
@@ -0,0 +1,301 @@
|
||||
"""Generic mechanism for marking and selecting python functions."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import collections
|
||||
from collections.abc import Collection
|
||||
from collections.abc import Iterable
|
||||
from collections.abc import Set as AbstractSet
|
||||
import dataclasses
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from .expression import Expression
|
||||
from .structures import _HiddenParam
|
||||
from .structures import EMPTY_PARAMETERSET_OPTION
|
||||
from .structures import get_empty_parameterset_mark
|
||||
from .structures import HIDDEN_PARAM
|
||||
from .structures import Mark
|
||||
from .structures import MARK_GEN
|
||||
from .structures import MarkDecorator
|
||||
from .structures import MarkGenerator
|
||||
from .structures import ParameterSet
|
||||
from _pytest.config import Config
|
||||
from _pytest.config import ExitCode
|
||||
from _pytest.config import hookimpl
|
||||
from _pytest.config import UsageError
|
||||
from _pytest.config.argparsing import NOT_SET
|
||||
from _pytest.config.argparsing import Parser
|
||||
from _pytest.stash import StashKey
|
||||
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from _pytest.nodes import Item
|
||||
|
||||
|
||||
__all__ = [
|
||||
"HIDDEN_PARAM",
|
||||
"MARK_GEN",
|
||||
"Mark",
|
||||
"MarkDecorator",
|
||||
"MarkGenerator",
|
||||
"ParameterSet",
|
||||
"get_empty_parameterset_mark",
|
||||
]
|
||||
|
||||
|
||||
old_mark_config_key = StashKey[Config | None]()
|
||||
|
||||
|
||||
def param(
|
||||
*values: object,
|
||||
marks: MarkDecorator | Collection[MarkDecorator | Mark] = (),
|
||||
id: str | _HiddenParam | None = None,
|
||||
) -> ParameterSet:
|
||||
"""Specify a parameter in `pytest.mark.parametrize`_ calls or
|
||||
:ref:`parametrized fixtures <fixture-parametrize-marks>`.
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"test_input,expected",
|
||||
[
|
||||
("3+5", 8),
|
||||
pytest.param("6*9", 42, marks=pytest.mark.xfail),
|
||||
],
|
||||
)
|
||||
def test_eval(test_input, expected):
|
||||
assert eval(test_input) == expected
|
||||
|
||||
:param values: Variable args of the values of the parameter set, in order.
|
||||
|
||||
:param marks:
|
||||
A single mark or a list of marks to be applied to this parameter set.
|
||||
|
||||
:ref:`pytest.mark.usefixtures <pytest.mark.usefixtures ref>` cannot be added via this parameter.
|
||||
|
||||
:type id: str | Literal[pytest.HIDDEN_PARAM] | None
|
||||
:param id:
|
||||
The id to attribute to this parameter set.
|
||||
|
||||
.. versionadded:: 8.4
|
||||
:ref:`hidden-param` means to hide the parameter set
|
||||
from the test name. Can only be used at most 1 time, as
|
||||
test names need to be unique.
|
||||
"""
|
||||
return ParameterSet.param(*values, marks=marks, id=id)
|
||||
|
||||
|
||||
def pytest_addoption(parser: Parser) -> None:
|
||||
group = parser.getgroup("general")
|
||||
group._addoption( # private to use reserved lower-case short option
|
||||
"-k",
|
||||
action="store",
|
||||
dest="keyword",
|
||||
default="",
|
||||
metavar="EXPRESSION",
|
||||
help="Only run tests which match the given substring expression. "
|
||||
"An expression is a Python evaluable 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. "
|
||||
"-k 'not test_method and not test_other' will eliminate the matches. "
|
||||
"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. "
|
||||
"The matching is case-insensitive.",
|
||||
)
|
||||
|
||||
group._addoption( # private to use reserved lower-case short option
|
||||
"-m",
|
||||
action="store",
|
||||
dest="markexpr",
|
||||
default="",
|
||||
metavar="MARKEXPR",
|
||||
help="Only run tests matching given mark expression. "
|
||||
"For example: -m 'mark1 and not mark2'.",
|
||||
)
|
||||
|
||||
group.addoption(
|
||||
"--markers",
|
||||
action="store_true",
|
||||
help="show markers (builtin, plugin and per-project ones).",
|
||||
)
|
||||
|
||||
parser.addini("markers", "Register new markers for test functions", "linelist")
|
||||
parser.addini(EMPTY_PARAMETERSET_OPTION, "Default marker for empty parametersets")
|
||||
|
||||
|
||||
@hookimpl(tryfirst=True)
|
||||
def pytest_cmdline_main(config: Config) -> int | ExitCode | None:
|
||||
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(f"@pytest.mark.{name}:", bold=True)
|
||||
tw.line(rest)
|
||||
tw.line()
|
||||
config._ensure_unconfigure()
|
||||
return 0
|
||||
|
||||
return None
|
||||
|
||||
|
||||
@dataclasses.dataclass
|
||||
class KeywordMatcher:
|
||||
"""A matcher for keywords.
|
||||
|
||||
Given a list of names, matches any substring of one of these names. The
|
||||
string inclusion check is case-insensitive.
|
||||
|
||||
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.
|
||||
"""
|
||||
|
||||
__slots__ = ("_names",)
|
||||
|
||||
_names: AbstractSet[str]
|
||||
|
||||
@classmethod
|
||||
def from_item(cls, item: Item) -> KeywordMatcher:
|
||||
mapped_names = set()
|
||||
|
||||
# Add the names of the current item and any parent items,
|
||||
# except the Session and root Directory's which are not
|
||||
# interesting for matching.
|
||||
import pytest
|
||||
|
||||
for node in item.listchain():
|
||||
if isinstance(node, pytest.Session):
|
||||
continue
|
||||
if isinstance(node, pytest.Directory) and isinstance(
|
||||
node.parent, pytest.Session
|
||||
):
|
||||
continue
|
||||
mapped_names.add(node.name)
|
||||
|
||||
# Add the names added as extra keywords to current or parent items.
|
||||
mapped_names.update(item.listextrakeywords())
|
||||
|
||||
# Add the names attached to the current function through direct assignment.
|
||||
function_obj = getattr(item, "function", None)
|
||||
if function_obj:
|
||||
mapped_names.update(function_obj.__dict__)
|
||||
|
||||
# Add the markers to the keywords as we no longer handle them correctly.
|
||||
mapped_names.update(mark.name for mark in item.iter_markers())
|
||||
|
||||
return cls(mapped_names)
|
||||
|
||||
def __call__(self, subname: str, /, **kwargs: str | int | bool | None) -> bool:
|
||||
if kwargs:
|
||||
raise UsageError("Keyword expressions do not support call parameters.")
|
||||
subname = subname.lower()
|
||||
return any(subname in name.lower() for name in self._names)
|
||||
|
||||
|
||||
def deselect_by_keyword(items: list[Item], config: Config) -> None:
|
||||
keywordexpr = config.option.keyword.lstrip()
|
||||
if not keywordexpr:
|
||||
return
|
||||
|
||||
expr = _parse_expression(keywordexpr, "Wrong expression passed to '-k'")
|
||||
|
||||
remaining = []
|
||||
deselected = []
|
||||
for colitem in items:
|
||||
if not expr.evaluate(KeywordMatcher.from_item(colitem)):
|
||||
deselected.append(colitem)
|
||||
else:
|
||||
remaining.append(colitem)
|
||||
|
||||
if deselected:
|
||||
config.hook.pytest_deselected(items=deselected)
|
||||
items[:] = remaining
|
||||
|
||||
|
||||
@dataclasses.dataclass
|
||||
class MarkMatcher:
|
||||
"""A matcher for markers which are present.
|
||||
|
||||
Tries to match on any marker names, attached to the given colitem.
|
||||
"""
|
||||
|
||||
__slots__ = ("own_mark_name_mapping",)
|
||||
|
||||
own_mark_name_mapping: dict[str, list[Mark]]
|
||||
|
||||
@classmethod
|
||||
def from_markers(cls, markers: Iterable[Mark]) -> MarkMatcher:
|
||||
mark_name_mapping = collections.defaultdict(list)
|
||||
for mark in markers:
|
||||
mark_name_mapping[mark.name].append(mark)
|
||||
return cls(mark_name_mapping)
|
||||
|
||||
def __call__(self, name: str, /, **kwargs: str | int | bool | None) -> bool:
|
||||
if not (matches := self.own_mark_name_mapping.get(name, [])):
|
||||
return False
|
||||
|
||||
for mark in matches: # pylint: disable=consider-using-any-or-all
|
||||
if all(mark.kwargs.get(k, NOT_SET) == v for k, v in kwargs.items()):
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def deselect_by_mark(items: list[Item], config: Config) -> None:
|
||||
matchexpr = config.option.markexpr
|
||||
if not matchexpr:
|
||||
return
|
||||
|
||||
expr = _parse_expression(matchexpr, "Wrong expression passed to '-m'")
|
||||
remaining: list[Item] = []
|
||||
deselected: list[Item] = []
|
||||
for item in items:
|
||||
if expr.evaluate(MarkMatcher.from_markers(item.iter_markers())):
|
||||
remaining.append(item)
|
||||
else:
|
||||
deselected.append(item)
|
||||
if deselected:
|
||||
config.hook.pytest_deselected(items=deselected)
|
||||
items[:] = remaining
|
||||
|
||||
|
||||
def _parse_expression(expr: str, exc_message: str) -> Expression:
|
||||
try:
|
||||
return Expression.compile(expr)
|
||||
except SyntaxError as e:
|
||||
raise UsageError(
|
||||
f"{exc_message}: {e.text}: at column {e.offset}: {e.msg}"
|
||||
) from None
|
||||
|
||||
|
||||
def pytest_collection_modifyitems(items: list[Item], config: Config) -> None:
|
||||
deselect_by_keyword(items, config)
|
||||
deselect_by_mark(items, config)
|
||||
|
||||
|
||||
def pytest_configure(config: Config) -> None:
|
||||
config.stash[old_mark_config_key] = MARK_GEN._config
|
||||
MARK_GEN._config = config
|
||||
|
||||
empty_parameterset = config.getini(EMPTY_PARAMETERSET_OPTION)
|
||||
|
||||
if empty_parameterset not in ("skip", "xfail", "fail_at_collect", None, ""):
|
||||
raise UsageError(
|
||||
f"{EMPTY_PARAMETERSET_OPTION!s} must be one of skip, xfail or fail_at_collect"
|
||||
f" but it is {empty_parameterset!r}"
|
||||
)
|
||||
|
||||
|
||||
def pytest_unconfigure(config: Config) -> None:
|
||||
MARK_GEN._config = config.stash.get(old_mark_config_key, None)
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,353 @@
|
||||
r"""Evaluate match expressions, as used by `-k` and `-m`.
|
||||
|
||||
The grammar is:
|
||||
|
||||
expression: expr? EOF
|
||||
expr: and_expr ('or' and_expr)*
|
||||
and_expr: not_expr ('and' not_expr)*
|
||||
not_expr: 'not' not_expr | '(' expr ')' | ident kwargs?
|
||||
|
||||
ident: (\w|:|\+|-|\.|\[|\]|\\|/)+
|
||||
kwargs: ('(' name '=' value ( ', ' name '=' value )* ')')
|
||||
name: a valid ident, but not a reserved keyword
|
||||
value: (unescaped) string literal | (-)?[0-9]+ | 'False' | 'True' | 'None'
|
||||
|
||||
The semantics are:
|
||||
|
||||
- Empty expression evaluates to False.
|
||||
- ident evaluates to True or False according to a provided matcher function.
|
||||
- ident with parentheses and keyword arguments evaluates to True or False according to a provided matcher function.
|
||||
- or/and/not evaluate according to the usual boolean semantics.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import ast
|
||||
from collections.abc import Iterator
|
||||
from collections.abc import Mapping
|
||||
from collections.abc import Sequence
|
||||
import dataclasses
|
||||
import enum
|
||||
import keyword
|
||||
import re
|
||||
import types
|
||||
from typing import Final
|
||||
from typing import final
|
||||
from typing import Literal
|
||||
from typing import NoReturn
|
||||
from typing import overload
|
||||
from typing import Protocol
|
||||
|
||||
|
||||
__all__ = [
|
||||
"Expression",
|
||||
"ExpressionMatcher",
|
||||
]
|
||||
|
||||
|
||||
FILE_NAME: Final = "<pytest match expression>"
|
||||
|
||||
|
||||
class TokenType(enum.Enum):
|
||||
LPAREN = "left parenthesis"
|
||||
RPAREN = "right parenthesis"
|
||||
OR = "or"
|
||||
AND = "and"
|
||||
NOT = "not"
|
||||
IDENT = "identifier"
|
||||
EOF = "end of input"
|
||||
EQUAL = "="
|
||||
STRING = "string literal"
|
||||
COMMA = ","
|
||||
|
||||
|
||||
@dataclasses.dataclass(frozen=True)
|
||||
class Token:
|
||||
__slots__ = ("pos", "type", "value")
|
||||
type: TokenType
|
||||
value: str
|
||||
pos: int
|
||||
|
||||
|
||||
class Scanner:
|
||||
__slots__ = ("current", "input", "tokens")
|
||||
|
||||
def __init__(self, input: str) -> None:
|
||||
self.input = input
|
||||
self.tokens = self.lex(input)
|
||||
self.current = next(self.tokens)
|
||||
|
||||
def lex(self, input: str) -> Iterator[Token]:
|
||||
pos = 0
|
||||
while pos < len(input):
|
||||
if input[pos] in (" ", "\t"):
|
||||
pos += 1
|
||||
elif input[pos] == "(":
|
||||
yield Token(TokenType.LPAREN, "(", pos)
|
||||
pos += 1
|
||||
elif input[pos] == ")":
|
||||
yield Token(TokenType.RPAREN, ")", pos)
|
||||
pos += 1
|
||||
elif input[pos] == "=":
|
||||
yield Token(TokenType.EQUAL, "=", pos)
|
||||
pos += 1
|
||||
elif input[pos] == ",":
|
||||
yield Token(TokenType.COMMA, ",", pos)
|
||||
pos += 1
|
||||
elif (quote_char := input[pos]) in ("'", '"'):
|
||||
end_quote_pos = input.find(quote_char, pos + 1)
|
||||
if end_quote_pos == -1:
|
||||
raise SyntaxError(
|
||||
f'closing quote "{quote_char}" is missing',
|
||||
(FILE_NAME, 1, pos + 1, input),
|
||||
)
|
||||
value = input[pos : end_quote_pos + 1]
|
||||
if (backslash_pos := input.find("\\")) != -1:
|
||||
raise SyntaxError(
|
||||
r'escaping with "\" not supported in marker expression',
|
||||
(FILE_NAME, 1, backslash_pos + 1, input),
|
||||
)
|
||||
yield Token(TokenType.STRING, value, pos)
|
||||
pos += len(value)
|
||||
else:
|
||||
match = re.match(r"(:?\w|:|\+|-|\.|\[|\]|\\|/)+", input[pos:])
|
||||
if match:
|
||||
value = match.group(0)
|
||||
if value == "or":
|
||||
yield Token(TokenType.OR, value, pos)
|
||||
elif value == "and":
|
||||
yield Token(TokenType.AND, value, pos)
|
||||
elif value == "not":
|
||||
yield Token(TokenType.NOT, value, pos)
|
||||
else:
|
||||
yield Token(TokenType.IDENT, value, pos)
|
||||
pos += len(value)
|
||||
else:
|
||||
raise SyntaxError(
|
||||
f'unexpected character "{input[pos]}"',
|
||||
(FILE_NAME, 1, pos + 1, input),
|
||||
)
|
||||
yield Token(TokenType.EOF, "", pos)
|
||||
|
||||
@overload
|
||||
def accept(self, type: TokenType, *, reject: Literal[True]) -> Token: ...
|
||||
|
||||
@overload
|
||||
def accept(
|
||||
self, type: TokenType, *, reject: Literal[False] = False
|
||||
) -> Token | None: ...
|
||||
|
||||
def accept(self, type: TokenType, *, reject: bool = False) -> Token | None:
|
||||
if self.current.type is type:
|
||||
token = self.current
|
||||
if token.type is not TokenType.EOF:
|
||||
self.current = next(self.tokens)
|
||||
return token
|
||||
if reject:
|
||||
self.reject((type,))
|
||||
return None
|
||||
|
||||
def reject(self, expected: Sequence[TokenType]) -> NoReturn:
|
||||
raise SyntaxError(
|
||||
"expected {}; got {}".format(
|
||||
" OR ".join(type.value for type in expected),
|
||||
self.current.type.value,
|
||||
),
|
||||
(FILE_NAME, 1, self.current.pos + 1, self.input),
|
||||
)
|
||||
|
||||
|
||||
# True, False and None are legal match expression identifiers,
|
||||
# but illegal as Python identifiers. To fix this, this prefix
|
||||
# is added to identifiers in the conversion to Python AST.
|
||||
IDENT_PREFIX = "$"
|
||||
|
||||
|
||||
def expression(s: Scanner) -> ast.Expression:
|
||||
if s.accept(TokenType.EOF):
|
||||
ret: ast.expr = ast.Constant(False)
|
||||
else:
|
||||
ret = expr(s)
|
||||
s.accept(TokenType.EOF, reject=True)
|
||||
return ast.fix_missing_locations(ast.Expression(ret))
|
||||
|
||||
|
||||
def expr(s: Scanner) -> ast.expr:
|
||||
ret = and_expr(s)
|
||||
while s.accept(TokenType.OR):
|
||||
rhs = and_expr(s)
|
||||
ret = ast.BoolOp(ast.Or(), [ret, rhs])
|
||||
return ret
|
||||
|
||||
|
||||
def and_expr(s: Scanner) -> ast.expr:
|
||||
ret = not_expr(s)
|
||||
while s.accept(TokenType.AND):
|
||||
rhs = not_expr(s)
|
||||
ret = ast.BoolOp(ast.And(), [ret, rhs])
|
||||
return ret
|
||||
|
||||
|
||||
def not_expr(s: Scanner) -> ast.expr:
|
||||
if s.accept(TokenType.NOT):
|
||||
return ast.UnaryOp(ast.Not(), not_expr(s))
|
||||
if s.accept(TokenType.LPAREN):
|
||||
ret = expr(s)
|
||||
s.accept(TokenType.RPAREN, reject=True)
|
||||
return ret
|
||||
ident = s.accept(TokenType.IDENT)
|
||||
if ident:
|
||||
name = ast.Name(IDENT_PREFIX + ident.value, ast.Load())
|
||||
if s.accept(TokenType.LPAREN):
|
||||
ret = ast.Call(func=name, args=[], keywords=all_kwargs(s))
|
||||
s.accept(TokenType.RPAREN, reject=True)
|
||||
else:
|
||||
ret = name
|
||||
return ret
|
||||
|
||||
s.reject((TokenType.NOT, TokenType.LPAREN, TokenType.IDENT))
|
||||
|
||||
|
||||
BUILTIN_MATCHERS = {"True": True, "False": False, "None": None}
|
||||
|
||||
|
||||
def single_kwarg(s: Scanner) -> ast.keyword:
|
||||
keyword_name = s.accept(TokenType.IDENT, reject=True)
|
||||
if not keyword_name.value.isidentifier():
|
||||
raise SyntaxError(
|
||||
f"not a valid python identifier {keyword_name.value}",
|
||||
(FILE_NAME, 1, keyword_name.pos + 1, s.input),
|
||||
)
|
||||
if keyword.iskeyword(keyword_name.value):
|
||||
raise SyntaxError(
|
||||
f"unexpected reserved python keyword `{keyword_name.value}`",
|
||||
(FILE_NAME, 1, keyword_name.pos + 1, s.input),
|
||||
)
|
||||
s.accept(TokenType.EQUAL, reject=True)
|
||||
|
||||
if value_token := s.accept(TokenType.STRING):
|
||||
value: str | int | bool | None = value_token.value[1:-1] # strip quotes
|
||||
else:
|
||||
value_token = s.accept(TokenType.IDENT, reject=True)
|
||||
if (number := value_token.value).isdigit() or (
|
||||
number.startswith("-") and number[1:].isdigit()
|
||||
):
|
||||
value = int(number)
|
||||
elif value_token.value in BUILTIN_MATCHERS:
|
||||
value = BUILTIN_MATCHERS[value_token.value]
|
||||
else:
|
||||
raise SyntaxError(
|
||||
f'unexpected character/s "{value_token.value}"',
|
||||
(FILE_NAME, 1, value_token.pos + 1, s.input),
|
||||
)
|
||||
|
||||
ret = ast.keyword(keyword_name.value, ast.Constant(value))
|
||||
return ret
|
||||
|
||||
|
||||
def all_kwargs(s: Scanner) -> list[ast.keyword]:
|
||||
ret = [single_kwarg(s)]
|
||||
while s.accept(TokenType.COMMA):
|
||||
ret.append(single_kwarg(s))
|
||||
return ret
|
||||
|
||||
|
||||
class ExpressionMatcher(Protocol):
|
||||
"""A callable which, given an identifier and optional kwargs, should return
|
||||
whether it matches in an :class:`Expression` evaluation.
|
||||
|
||||
Should be prepared to handle arbitrary strings as input.
|
||||
|
||||
If no kwargs are provided, the expression of the form `foo`.
|
||||
If kwargs are provided, the expression is of the form `foo(1, b=True, "s")`.
|
||||
|
||||
If the expression is not supported (e.g. don't want to accept the kwargs
|
||||
syntax variant), should raise :class:`~pytest.UsageError`.
|
||||
|
||||
Example::
|
||||
|
||||
def matcher(name: str, /, **kwargs: str | int | bool | None) -> bool:
|
||||
# Match `cat`.
|
||||
if name == "cat" and not kwargs:
|
||||
return True
|
||||
# Match `dog(barks=True)`.
|
||||
if name == "dog" and kwargs == {"barks": False}:
|
||||
return True
|
||||
return False
|
||||
"""
|
||||
|
||||
def __call__(self, name: str, /, **kwargs: str | int | bool | None) -> bool: ...
|
||||
|
||||
|
||||
@dataclasses.dataclass
|
||||
class MatcherNameAdapter:
|
||||
matcher: ExpressionMatcher
|
||||
name: str
|
||||
|
||||
def __bool__(self) -> bool:
|
||||
return self.matcher(self.name)
|
||||
|
||||
def __call__(self, **kwargs: str | int | bool | None) -> bool:
|
||||
return self.matcher(self.name, **kwargs)
|
||||
|
||||
|
||||
class MatcherAdapter(Mapping[str, MatcherNameAdapter]):
|
||||
"""Adapts a matcher function to a locals mapping as required by eval()."""
|
||||
|
||||
def __init__(self, matcher: ExpressionMatcher) -> None:
|
||||
self.matcher = matcher
|
||||
|
||||
def __getitem__(self, key: str) -> MatcherNameAdapter:
|
||||
return MatcherNameAdapter(matcher=self.matcher, name=key[len(IDENT_PREFIX) :])
|
||||
|
||||
def __iter__(self) -> Iterator[str]:
|
||||
raise NotImplementedError()
|
||||
|
||||
def __len__(self) -> int:
|
||||
raise NotImplementedError()
|
||||
|
||||
|
||||
@final
|
||||
class Expression:
|
||||
"""A compiled match expression as used by -k and -m.
|
||||
|
||||
The expression can be evaluated against different matchers.
|
||||
"""
|
||||
|
||||
__slots__ = ("_code", "input")
|
||||
|
||||
def __init__(self, input: str, code: types.CodeType) -> None:
|
||||
#: The original input line, as a string.
|
||||
self.input: Final = input
|
||||
self._code: Final = code
|
||||
|
||||
@classmethod
|
||||
def compile(cls, input: str) -> Expression:
|
||||
"""Compile a match expression.
|
||||
|
||||
:param input: The input expression - one line.
|
||||
|
||||
:raises SyntaxError: If the expression is malformed.
|
||||
"""
|
||||
astexpr = expression(Scanner(input))
|
||||
code = compile(
|
||||
astexpr,
|
||||
filename="<pytest match expression>",
|
||||
mode="eval",
|
||||
)
|
||||
return Expression(input, code)
|
||||
|
||||
def evaluate(self, matcher: ExpressionMatcher) -> bool:
|
||||
"""Evaluate the match expression.
|
||||
|
||||
:param matcher:
|
||||
A callback which determines whether an identifier matches or not.
|
||||
See the :class:`ExpressionMatcher` protocol for details and example.
|
||||
|
||||
:returns: Whether the expression matches or not.
|
||||
|
||||
:raises UsageError:
|
||||
If the matcher doesn't support the expression. Cannot happen if the
|
||||
matcher supports all expressions.
|
||||
"""
|
||||
return bool(eval(self._code, {"__builtins__": {}}, MatcherAdapter(matcher)))
|
||||
@@ -0,0 +1,664 @@
|
||||
# mypy: allow-untyped-defs
|
||||
from __future__ import annotations
|
||||
|
||||
import collections.abc
|
||||
from collections.abc import Callable
|
||||
from collections.abc import Collection
|
||||
from collections.abc import Iterable
|
||||
from collections.abc import Iterator
|
||||
from collections.abc import Mapping
|
||||
from collections.abc import MutableMapping
|
||||
from collections.abc import Sequence
|
||||
import dataclasses
|
||||
import enum
|
||||
import inspect
|
||||
from typing import Any
|
||||
from typing import final
|
||||
from typing import NamedTuple
|
||||
from typing import overload
|
||||
from typing import TYPE_CHECKING
|
||||
from typing import TypeVar
|
||||
import warnings
|
||||
|
||||
from .._code import getfslineno
|
||||
from ..compat import NOTSET
|
||||
from ..compat import NotSetType
|
||||
from _pytest.config import Config
|
||||
from _pytest.deprecated import check_ispytest
|
||||
from _pytest.deprecated import MARKED_FIXTURE
|
||||
from _pytest.outcomes import fail
|
||||
from _pytest.raises import AbstractRaises
|
||||
from _pytest.scope import _ScopeName
|
||||
from _pytest.warning_types import PytestUnknownMarkWarning
|
||||
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from ..nodes import Node
|
||||
|
||||
|
||||
EMPTY_PARAMETERSET_OPTION = "empty_parameter_set_mark"
|
||||
|
||||
|
||||
# Singleton type for HIDDEN_PARAM, as described in:
|
||||
# https://www.python.org/dev/peps/pep-0484/#support-for-singleton-types-in-unions
|
||||
class _HiddenParam(enum.Enum):
|
||||
token = 0
|
||||
|
||||
|
||||
#: Can be used as a parameter set id to hide it from the test name.
|
||||
HIDDEN_PARAM = _HiddenParam.token
|
||||
|
||||
|
||||
def istestfunc(func) -> bool:
|
||||
return callable(func) and getattr(func, "__name__", "<lambda>") != "<lambda>"
|
||||
|
||||
|
||||
def get_empty_parameterset_mark(
|
||||
config: Config, argnames: Sequence[str], func
|
||||
) -> MarkDecorator:
|
||||
from ..nodes import Collector
|
||||
|
||||
argslisting = ", ".join(argnames)
|
||||
|
||||
_fs, lineno = getfslineno(func)
|
||||
reason = f"got empty parameter set for ({argslisting})"
|
||||
requested_mark = config.getini(EMPTY_PARAMETERSET_OPTION)
|
||||
if requested_mark in ("", None, "skip"):
|
||||
mark = MARK_GEN.skip(reason=reason)
|
||||
elif requested_mark == "xfail":
|
||||
mark = MARK_GEN.xfail(reason=reason, run=False)
|
||||
elif requested_mark == "fail_at_collect":
|
||||
raise Collector.CollectError(
|
||||
f"Empty parameter set in '{func.__name__}' at line {lineno + 1}"
|
||||
)
|
||||
else:
|
||||
raise LookupError(requested_mark)
|
||||
return mark
|
||||
|
||||
|
||||
class ParameterSet(NamedTuple):
|
||||
"""A set of values for a set of parameters along with associated marks and
|
||||
an optional ID for the set.
|
||||
|
||||
Examples::
|
||||
|
||||
pytest.param(1, 2, 3)
|
||||
# ParameterSet(values=(1, 2, 3), marks=(), id=None)
|
||||
|
||||
pytest.param("hello", id="greeting")
|
||||
# ParameterSet(values=("hello",), marks=(), id="greeting")
|
||||
|
||||
# Parameter set with marks
|
||||
pytest.param(42, marks=pytest.mark.xfail)
|
||||
# ParameterSet(values=(42,), marks=(MarkDecorator(...),), id=None)
|
||||
|
||||
# From parametrize mark (parameter names + list of parameter sets)
|
||||
pytest.mark.parametrize(
|
||||
("a", "b", "expected"),
|
||||
[
|
||||
(1, 2, 3),
|
||||
pytest.param(40, 2, 42, id="everything"),
|
||||
],
|
||||
)
|
||||
# ParameterSet(values=(1, 2, 3), marks=(), id=None)
|
||||
# ParameterSet(values=(40, 2, 42), marks=(), id="everything")
|
||||
"""
|
||||
|
||||
values: Sequence[object | NotSetType]
|
||||
marks: Collection[MarkDecorator | Mark]
|
||||
id: str | _HiddenParam | None
|
||||
|
||||
@classmethod
|
||||
def param(
|
||||
cls,
|
||||
*values: object,
|
||||
marks: MarkDecorator | Collection[MarkDecorator | Mark] = (),
|
||||
id: str | _HiddenParam | None = None,
|
||||
) -> ParameterSet:
|
||||
if isinstance(marks, MarkDecorator):
|
||||
marks = (marks,)
|
||||
else:
|
||||
assert isinstance(marks, collections.abc.Collection)
|
||||
if any(i.name == "usefixtures" for i in marks):
|
||||
raise ValueError(
|
||||
"pytest.param cannot add pytest.mark.usefixtures; see "
|
||||
"https://docs.pytest.org/en/stable/reference/reference.html#pytest-param"
|
||||
)
|
||||
|
||||
if id is not None:
|
||||
if not isinstance(id, str) and id is not HIDDEN_PARAM:
|
||||
raise TypeError(
|
||||
"Expected id to be a string or a `pytest.HIDDEN_PARAM` sentinel, "
|
||||
f"got {type(id)}: {id!r}",
|
||||
)
|
||||
return cls(values, marks, id)
|
||||
|
||||
@classmethod
|
||||
def extract_from(
|
||||
cls,
|
||||
parameterset: ParameterSet | Sequence[object] | object,
|
||||
force_tuple: bool = False,
|
||||
) -> ParameterSet:
|
||||
"""Extract from an object or objects.
|
||||
|
||||
: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 force_tuple:
|
||||
Enforce tuple wrapping so single argument tuple values
|
||||
don't get decomposed and break tests.
|
||||
"""
|
||||
if isinstance(parameterset, cls):
|
||||
return parameterset
|
||||
if force_tuple:
|
||||
return cls.param(parameterset)
|
||||
else:
|
||||
# TODO: Refactor to fix this type-ignore. Currently the following
|
||||
# passes type-checking but crashes:
|
||||
#
|
||||
# @pytest.mark.parametrize(('x', 'y'), [1, 2])
|
||||
# def test_foo(x, y): pass
|
||||
return cls(parameterset, marks=[], id=None) # type: ignore[arg-type]
|
||||
|
||||
@staticmethod
|
||||
def _parse_parametrize_args(
|
||||
argnames: str | Sequence[str],
|
||||
argvalues: Iterable[ParameterSet | Sequence[object] | object],
|
||||
*args,
|
||||
**kwargs,
|
||||
) -> tuple[Sequence[str], bool]:
|
||||
if isinstance(argnames, str):
|
||||
argnames = [x.strip() for x in argnames.split(",") if x.strip()]
|
||||
force_tuple = len(argnames) == 1
|
||||
else:
|
||||
force_tuple = False
|
||||
return argnames, force_tuple
|
||||
|
||||
@staticmethod
|
||||
def _parse_parametrize_parameters(
|
||||
argvalues: Iterable[ParameterSet | Sequence[object] | object],
|
||||
force_tuple: bool,
|
||||
) -> list[ParameterSet]:
|
||||
return [
|
||||
ParameterSet.extract_from(x, force_tuple=force_tuple) for x in argvalues
|
||||
]
|
||||
|
||||
@classmethod
|
||||
def _for_parametrize(
|
||||
cls,
|
||||
argnames: str | Sequence[str],
|
||||
argvalues: Iterable[ParameterSet | Sequence[object] | object],
|
||||
func,
|
||||
config: Config,
|
||||
nodeid: str,
|
||||
) -> tuple[Sequence[str], list[ParameterSet]]:
|
||||
argnames, force_tuple = cls._parse_parametrize_args(argnames, argvalues)
|
||||
parameters = cls._parse_parametrize_parameters(argvalues, force_tuple)
|
||||
del argvalues
|
||||
|
||||
if parameters:
|
||||
# Check all parameter sets have the correct number of values.
|
||||
for param in parameters:
|
||||
if len(param.values) != len(argnames):
|
||||
msg = (
|
||||
'{nodeid}: in "parametrize" the number of names ({names_len}):\n'
|
||||
" {names}\n"
|
||||
"must be equal to the number of values ({values_len}):\n"
|
||||
" {values}"
|
||||
)
|
||||
fail(
|
||||
msg.format(
|
||||
nodeid=nodeid,
|
||||
values=param.values,
|
||||
names=argnames,
|
||||
names_len=len(argnames),
|
||||
values_len=len(param.values),
|
||||
),
|
||||
pytrace=False,
|
||||
)
|
||||
else:
|
||||
# Empty parameter set (likely computed at runtime): create a single
|
||||
# parameter set with NOTSET values, with the "empty parameter set" mark applied to it.
|
||||
mark = get_empty_parameterset_mark(config, argnames, func)
|
||||
parameters.append(
|
||||
ParameterSet(
|
||||
values=(NOTSET,) * len(argnames), marks=[mark], id="NOTSET"
|
||||
)
|
||||
)
|
||||
return argnames, parameters
|
||||
|
||||
|
||||
@final
|
||||
@dataclasses.dataclass(frozen=True)
|
||||
class Mark:
|
||||
"""A pytest mark."""
|
||||
|
||||
#: Name of the mark.
|
||||
name: str
|
||||
#: Positional arguments of the mark decorator.
|
||||
args: tuple[Any, ...]
|
||||
#: Keyword arguments of the mark decorator.
|
||||
kwargs: Mapping[str, Any]
|
||||
|
||||
#: Source Mark for ids with parametrize Marks.
|
||||
_param_ids_from: Mark | None = dataclasses.field(default=None, repr=False)
|
||||
#: Resolved/generated ids with parametrize Marks.
|
||||
_param_ids_generated: Sequence[str] | None = dataclasses.field(
|
||||
default=None, repr=False
|
||||
)
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
name: str,
|
||||
args: tuple[Any, ...],
|
||||
kwargs: Mapping[str, Any],
|
||||
param_ids_from: Mark | None = None,
|
||||
param_ids_generated: Sequence[str] | None = None,
|
||||
*,
|
||||
_ispytest: bool = False,
|
||||
) -> None:
|
||||
""":meta private:"""
|
||||
check_ispytest(_ispytest)
|
||||
# Weirdness to bypass frozen=True.
|
||||
object.__setattr__(self, "name", name)
|
||||
object.__setattr__(self, "args", args)
|
||||
object.__setattr__(self, "kwargs", kwargs)
|
||||
object.__setattr__(self, "_param_ids_from", param_ids_from)
|
||||
object.__setattr__(self, "_param_ids_generated", param_ids_generated)
|
||||
|
||||
def _has_param_ids(self) -> bool:
|
||||
return "ids" in self.kwargs or len(self.args) >= 4
|
||||
|
||||
def combined_with(self, other: Mark) -> Mark:
|
||||
"""Return a new Mark which is a combination of this
|
||||
Mark and another Mark.
|
||||
|
||||
Combines by appending args and merging kwargs.
|
||||
|
||||
:param Mark other: The mark to combine with.
|
||||
:rtype: Mark
|
||||
"""
|
||||
assert self.name == other.name
|
||||
|
||||
# Remember source of ids with parametrize Marks.
|
||||
param_ids_from: Mark | None = None
|
||||
if self.name == "parametrize":
|
||||
if other._has_param_ids():
|
||||
param_ids_from = other
|
||||
elif self._has_param_ids():
|
||||
param_ids_from = self
|
||||
|
||||
return Mark(
|
||||
self.name,
|
||||
self.args + other.args,
|
||||
dict(self.kwargs, **other.kwargs),
|
||||
param_ids_from=param_ids_from,
|
||||
_ispytest=True,
|
||||
)
|
||||
|
||||
|
||||
# A generic parameter designating an object to which a Mark may
|
||||
# be applied -- a test function (callable) or class.
|
||||
# Note: a lambda is not allowed, but this can't be represented.
|
||||
Markable = TypeVar("Markable", bound=Callable[..., object] | type)
|
||||
|
||||
|
||||
@dataclasses.dataclass
|
||||
class MarkDecorator:
|
||||
"""A decorator for applying a mark on test functions and classes.
|
||||
|
||||
``MarkDecorators`` are created with ``pytest.mark``::
|
||||
|
||||
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`` 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 the mark 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 the mark to the function,
|
||||
containing all the arguments already stored internally in the
|
||||
``MarkDecorator``.
|
||||
|
||||
3. When called in any other case, 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 a ``MarkDecorator`` from storing only a
|
||||
single function or class reference as its positional argument with no
|
||||
additional keyword or positional arguments. You can work around this by
|
||||
using `with_args()`.
|
||||
"""
|
||||
|
||||
mark: Mark
|
||||
|
||||
def __init__(self, mark: Mark, *, _ispytest: bool = False) -> None:
|
||||
""":meta private:"""
|
||||
check_ispytest(_ispytest)
|
||||
self.mark = mark
|
||||
|
||||
@property
|
||||
def name(self) -> str:
|
||||
"""Alias for mark.name."""
|
||||
return self.mark.name
|
||||
|
||||
@property
|
||||
def args(self) -> tuple[Any, ...]:
|
||||
"""Alias for mark.args."""
|
||||
return self.mark.args
|
||||
|
||||
@property
|
||||
def kwargs(self) -> Mapping[str, Any]:
|
||||
"""Alias for mark.kwargs."""
|
||||
return self.mark.kwargs
|
||||
|
||||
@property
|
||||
def markname(self) -> str:
|
||||
""":meta private:"""
|
||||
return self.name # for backward-compat (2.4.1 had this attr)
|
||||
|
||||
def with_args(self, *args: object, **kwargs: object) -> MarkDecorator:
|
||||
"""Return a MarkDecorator with extra arguments added.
|
||||
|
||||
Unlike calling the MarkDecorator, with_args() can be used even
|
||||
if the sole argument is a callable/class.
|
||||
"""
|
||||
mark = Mark(self.name, args, kwargs, _ispytest=True)
|
||||
return MarkDecorator(self.mark.combined_with(mark), _ispytest=True)
|
||||
|
||||
# Type ignored because the overloads overlap with an incompatible
|
||||
# return type. Not much we can do about that. Thankfully mypy picks
|
||||
# the first match so it works out even if we break the rules.
|
||||
@overload
|
||||
def __call__(self, arg: Markable) -> Markable: # type: ignore[overload-overlap]
|
||||
pass
|
||||
|
||||
@overload
|
||||
def __call__(self, *args: object, **kwargs: object) -> MarkDecorator:
|
||||
pass
|
||||
|
||||
def __call__(self, *args: object, **kwargs: object):
|
||||
"""Call the MarkDecorator."""
|
||||
if args and not kwargs:
|
||||
func = args[0]
|
||||
is_class = inspect.isclass(func)
|
||||
# For staticmethods/classmethods, the marks are eventually fetched from the
|
||||
# function object, not the descriptor, so unwrap.
|
||||
unwrapped_func = func
|
||||
if isinstance(func, staticmethod | classmethod):
|
||||
unwrapped_func = func.__func__
|
||||
if len(args) == 1 and (istestfunc(unwrapped_func) or is_class):
|
||||
store_mark(unwrapped_func, self.mark, stacklevel=3)
|
||||
return func
|
||||
return self.with_args(*args, **kwargs)
|
||||
|
||||
|
||||
def get_unpacked_marks(
|
||||
obj: object | type,
|
||||
*,
|
||||
consider_mro: bool = True,
|
||||
) -> list[Mark]:
|
||||
"""Obtain the unpacked marks that are stored on an object.
|
||||
|
||||
If obj is a class and consider_mro is true, return marks applied to
|
||||
this class and all of its super-classes in MRO order. If consider_mro
|
||||
is false, only return marks applied directly to this class.
|
||||
"""
|
||||
if isinstance(obj, type):
|
||||
if not consider_mro:
|
||||
mark_lists = [obj.__dict__.get("pytestmark", [])]
|
||||
else:
|
||||
mark_lists = [
|
||||
x.__dict__.get("pytestmark", []) for x in reversed(obj.__mro__)
|
||||
]
|
||||
mark_list = []
|
||||
for item in mark_lists:
|
||||
if isinstance(item, list):
|
||||
mark_list.extend(item)
|
||||
else:
|
||||
mark_list.append(item)
|
||||
else:
|
||||
mark_attribute = getattr(obj, "pytestmark", [])
|
||||
if isinstance(mark_attribute, list):
|
||||
mark_list = mark_attribute
|
||||
else:
|
||||
mark_list = [mark_attribute]
|
||||
return list(normalize_mark_list(mark_list))
|
||||
|
||||
|
||||
def normalize_mark_list(
|
||||
mark_list: Iterable[Mark | MarkDecorator],
|
||||
) -> Iterable[Mark]:
|
||||
"""
|
||||
Normalize an iterable of Mark or MarkDecorator objects into a list of marks
|
||||
by retrieving the `mark` attribute on MarkDecorator instances.
|
||||
|
||||
:param mark_list: marks to normalize
|
||||
:returns: A new list of the extracted Mark objects
|
||||
"""
|
||||
for mark in mark_list:
|
||||
mark_obj = getattr(mark, "mark", mark)
|
||||
if not isinstance(mark_obj, Mark):
|
||||
raise TypeError(f"got {mark_obj!r} instead of Mark")
|
||||
yield mark_obj
|
||||
|
||||
|
||||
def store_mark(obj, mark: Mark, *, stacklevel: int = 2) -> None:
|
||||
"""Store a Mark on an object.
|
||||
|
||||
This is used to implement the Mark declarations/decorators correctly.
|
||||
"""
|
||||
assert isinstance(mark, Mark), mark
|
||||
|
||||
from ..fixtures import getfixturemarker
|
||||
|
||||
if getfixturemarker(obj) is not None:
|
||||
warnings.warn(MARKED_FIXTURE, stacklevel=stacklevel)
|
||||
|
||||
# Always reassign name to avoid updating pytestmark in a reference that
|
||||
# was only borrowed.
|
||||
obj.pytestmark = [*get_unpacked_marks(obj, consider_mro=False), mark]
|
||||
|
||||
|
||||
# Typing for builtin pytest marks. This is cheating; it gives builtin marks
|
||||
# special privilege, and breaks modularity. But practicality beats purity...
|
||||
if TYPE_CHECKING:
|
||||
|
||||
class _SkipMarkDecorator(MarkDecorator):
|
||||
@overload # type: ignore[override,no-overload-impl]
|
||||
def __call__(self, arg: Markable) -> Markable: ...
|
||||
|
||||
@overload
|
||||
def __call__(self, reason: str = ...) -> MarkDecorator: ...
|
||||
|
||||
class _SkipifMarkDecorator(MarkDecorator):
|
||||
def __call__( # type: ignore[override]
|
||||
self,
|
||||
condition: str | bool = ...,
|
||||
*conditions: str | bool,
|
||||
reason: str = ...,
|
||||
) -> MarkDecorator: ...
|
||||
|
||||
class _XfailMarkDecorator(MarkDecorator):
|
||||
@overload # type: ignore[override,no-overload-impl]
|
||||
def __call__(self, arg: Markable) -> Markable: ...
|
||||
|
||||
@overload
|
||||
def __call__(
|
||||
self,
|
||||
condition: str | bool = False,
|
||||
*conditions: str | bool,
|
||||
reason: str = ...,
|
||||
run: bool = ...,
|
||||
raises: None
|
||||
| type[BaseException]
|
||||
| tuple[type[BaseException], ...]
|
||||
| AbstractRaises[BaseException] = ...,
|
||||
strict: bool = ...,
|
||||
) -> MarkDecorator: ...
|
||||
|
||||
class _ParametrizeMarkDecorator(MarkDecorator):
|
||||
def __call__( # type: ignore[override]
|
||||
self,
|
||||
argnames: str | Sequence[str],
|
||||
argvalues: Iterable[ParameterSet | Sequence[object] | object],
|
||||
*,
|
||||
indirect: bool | Sequence[str] = ...,
|
||||
ids: Iterable[None | str | float | int | bool]
|
||||
| Callable[[Any], object | None]
|
||||
| None = ...,
|
||||
scope: _ScopeName | None = ...,
|
||||
) -> MarkDecorator: ...
|
||||
|
||||
class _UsefixturesMarkDecorator(MarkDecorator):
|
||||
def __call__(self, *fixtures: str) -> MarkDecorator: # type: ignore[override]
|
||||
...
|
||||
|
||||
class _FilterwarningsMarkDecorator(MarkDecorator):
|
||||
def __call__(self, *filters: str) -> MarkDecorator: # type: ignore[override]
|
||||
...
|
||||
|
||||
|
||||
@final
|
||||
class MarkGenerator:
|
||||
"""Factory for :class:`MarkDecorator` objects - exposed as
|
||||
a ``pytest.mark`` singleton instance.
|
||||
|
||||
Example::
|
||||
|
||||
import pytest
|
||||
|
||||
|
||||
@pytest.mark.slowtest
|
||||
def test_function():
|
||||
pass
|
||||
|
||||
applies a 'slowtest' :class:`Mark` on ``test_function``.
|
||||
"""
|
||||
|
||||
# See TYPE_CHECKING above.
|
||||
if TYPE_CHECKING:
|
||||
skip: _SkipMarkDecorator
|
||||
skipif: _SkipifMarkDecorator
|
||||
xfail: _XfailMarkDecorator
|
||||
parametrize: _ParametrizeMarkDecorator
|
||||
usefixtures: _UsefixturesMarkDecorator
|
||||
filterwarnings: _FilterwarningsMarkDecorator
|
||||
|
||||
def __init__(self, *, _ispytest: bool = False) -> None:
|
||||
check_ispytest(_ispytest)
|
||||
self._config: Config | None = None
|
||||
self._markers: set[str] = set()
|
||||
|
||||
def __getattr__(self, name: str) -> MarkDecorator:
|
||||
"""Generate a new :class:`MarkDecorator` with the given name."""
|
||||
if name[0] == "_":
|
||||
raise AttributeError("Marker name must NOT start with underscore")
|
||||
|
||||
if self._config is not None:
|
||||
# We store a set of markers as a performance optimisation - if a mark
|
||||
# name is in the set we definitely know it, but a mark may be known and
|
||||
# not in the set. We therefore start by updating the set!
|
||||
if name not in self._markers:
|
||||
for line in self._config.getini("markers"):
|
||||
# example lines: "skipif(condition): skip the given test if..."
|
||||
# or "hypothesis: tests which use Hypothesis", so to get the
|
||||
# marker name we split on both `:` and `(`.
|
||||
marker = line.split(":")[0].split("(")[0].strip()
|
||||
self._markers.add(marker)
|
||||
|
||||
# If the name is not in the set of known marks after updating,
|
||||
# then it really is time to issue a warning or an error.
|
||||
if name not in self._markers:
|
||||
# Raise a specific error for common misspellings of "parametrize".
|
||||
if name in ["parameterize", "parametrise", "parameterise"]:
|
||||
__tracebackhide__ = True
|
||||
fail(f"Unknown '{name}' mark, did you mean 'parametrize'?")
|
||||
|
||||
strict_markers = self._config.getini("strict_markers")
|
||||
if strict_markers is None:
|
||||
strict_markers = self._config.getini("strict")
|
||||
if strict_markers:
|
||||
fail(
|
||||
f"{name!r} not found in `markers` configuration option",
|
||||
pytrace=False,
|
||||
)
|
||||
|
||||
warnings.warn(
|
||||
f"Unknown pytest.mark.{name} - is this a typo? You can register "
|
||||
"custom marks to avoid this warning - for details, see "
|
||||
"https://docs.pytest.org/en/stable/how-to/mark.html",
|
||||
PytestUnknownMarkWarning,
|
||||
2,
|
||||
)
|
||||
|
||||
return MarkDecorator(Mark(name, (), {}, _ispytest=True), _ispytest=True)
|
||||
|
||||
|
||||
MARK_GEN = MarkGenerator(_ispytest=True)
|
||||
|
||||
|
||||
@final
|
||||
class NodeKeywords(MutableMapping[str, Any]):
|
||||
__slots__ = ("_markers", "node", "parent")
|
||||
|
||||
def __init__(self, node: Node) -> None:
|
||||
self.node = node
|
||||
self.parent = node.parent
|
||||
self._markers = {node.name: True}
|
||||
|
||||
def __getitem__(self, key: str) -> Any:
|
||||
try:
|
||||
return self._markers[key]
|
||||
except KeyError:
|
||||
if self.parent is None:
|
||||
raise
|
||||
return self.parent.keywords[key]
|
||||
|
||||
def __setitem__(self, key: str, value: Any) -> None:
|
||||
self._markers[key] = value
|
||||
|
||||
# Note: we could've avoided explicitly implementing some of the methods
|
||||
# below and use the collections.abc fallback, but that would be slow.
|
||||
|
||||
def __contains__(self, key: object) -> bool:
|
||||
return key in self._markers or (
|
||||
self.parent is not None and key in self.parent.keywords
|
||||
)
|
||||
|
||||
def update( # type: ignore[override]
|
||||
self,
|
||||
other: Mapping[str, Any] | Iterable[tuple[str, Any]] = (),
|
||||
**kwds: Any,
|
||||
) -> None:
|
||||
self._markers.update(other)
|
||||
self._markers.update(kwds)
|
||||
|
||||
def __delitem__(self, key: str) -> None:
|
||||
raise ValueError("cannot delete key in keywords dict")
|
||||
|
||||
def __iter__(self) -> Iterator[str]:
|
||||
# Doesn't need to be fast.
|
||||
yield from self._markers
|
||||
if self.parent is not None:
|
||||
for keyword in self.parent.keywords:
|
||||
# self._marks and self.parent.keywords can have duplicates.
|
||||
if keyword not in self._markers:
|
||||
yield keyword
|
||||
|
||||
def __len__(self) -> int:
|
||||
# Doesn't need to be fast.
|
||||
return sum(1 for keyword in self)
|
||||
|
||||
def __repr__(self) -> str:
|
||||
return f"<NodeKeywords for node {self.node}>"
|
||||
Reference in New Issue
Block a user