fix: validate marker names in -m expression with --strict-markers

Closes #2781

Co-authored-by: Cursor AI <ai@cursor.sh>
Co-authored-by: Anthropic Claude Opus 4.5 <claude@anthropic.com>

Author: 3 people

changelog/2781.feature.rst

@@ -0,0 +1 @@
+When :confval:`strict_markers` is enabled, marker names used in :option:`-m` expressions are now validated against registered markers.

src/_pytest/mark/__init__.py

@@ -258,6 +258,10 @@ def deselect_by_mark(items: list[Item], config: Config) -> None:
         return
 
     expr = _parse_expression(matchexpr, "Wrong expression passed to '-m'")
+
+    # Validate marker names in the expression if strict_markers is enabled.
+    _validate_marker_names(expr, config)
+
     remaining: list[Item] = []
     deselected: list[Item] = []
     for item in items:
@@ -270,6 +274,34 @@ def deselect_by_mark(items: list[Item], config: Config) -> None:
         items[:] = remaining
 
 
+def _validate_marker_names(expr: Expression, config: Config) -> None:
+    """Validate that all marker names in the expression are registered.
+
+    Only validates when strict_markers is enabled.
+    """
+    strict_markers = config.getini("strict_markers")
+    if strict_markers is None:
+        strict_markers = config.getini("strict")
+    if not strict_markers:
+        return
+
+    registered_markers: set[str] = set()
+    for line in 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()
+        registered_markers.add(marker)
+
+    unknown_markers = expr.idents() - registered_markers
+    if unknown_markers:
+        unknown_str = ", ".join(sorted(unknown_markers))
+        raise UsageError(
+            f"Unknown marker(s) in '-m' expression: {unknown_str}. "
+            "Use 'pytest --markers' to see available markers."
+        )
+
+
 def _parse_expression(expr: str, exc_message: str) -> Expression:
     try:
         return Expression.compile(expr)

src/_pytest/mark/expression.py

@@ -70,10 +70,11 @@ class Token:
 
 
 class Scanner:
-    __slots__ = ("current", "input", "tokens")
+    __slots__ = ("current", "idents", "input", "tokens")
 
     def __init__(self, input: str) -> None:
         self.input = input
+        self.idents: set[str] = set()
         self.tokens = self.lex(input)
         self.current = next(self.tokens)
 
@@ -163,13 +164,13 @@ def reject(self, expected: Sequence[TokenType]) -> NoReturn:
 IDENT_PREFIX = "$"
 
 
-def expression(s: Scanner) -> ast.Expression:
+def expression(s: Scanner) -> tuple[ast.Expression, frozenset[str]]:
     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))
+    return ast.fix_missing_locations(ast.Expression(ret)), frozenset(s.idents)
 
 
 def expr(s: Scanner) -> ast.expr:
@@ -197,6 +198,7 @@ def not_expr(s: Scanner) -> ast.expr:
         return ret
     ident = s.accept(TokenType.IDENT)
     if ident:
+        s.idents.add(ident.value)
         name = ast.Name(IDENT_PREFIX + ident.value, ast.Load())
         if s.accept(TokenType.LPAREN):
             ret = ast.Call(func=name, args=[], keywords=all_kwargs(s))
@@ -314,12 +316,16 @@ class Expression:
     The expression can be evaluated against different matchers.
     """
 
-    __slots__ = ("_code", "input")
+    __slots__ = ("_code", "_idents", "input")
 
-    def __init__(self, input: str, code: types.CodeType) -> None:
+    def __init__(
+        self, input: str, code: types.CodeType, idents: frozenset[str]
+    ) -> None:
         #: The original input line, as a string.
         self.input: Final = input
         self._code: Final = code
+        #: All identifiers which appear in the expression.
+        self._idents: Final = idents
 
     @classmethod
     def compile(cls, input: str) -> Expression:
@@ -329,13 +335,17 @@ def compile(cls, input: str) -> Expression:
 
         :raises SyntaxError: If the expression is malformed.
         """
-        astexpr = expression(Scanner(input))
+        astexpr, idents = expression(Scanner(input))
         code = compile(
             astexpr,
             filename="<pytest match expression>",
             mode="eval",
         )
-        return Expression(input, code)
+        return Expression(input, code, idents)
+
+    def idents(self) -> frozenset[str]:
+        """Return the set of all identifiers which appear in the expression."""
+        return self._idents
 
     def evaluate(self, matcher: ExpressionMatcher) -> bool:
         """Evaluate the match expression.

testing/test_mark.py

@@ -3,10 +3,14 @@
 
 import os
 import sys
+from typing import cast
 from unittest import mock
 
 from _pytest.config import ExitCode
+from _pytest.config import UsageError
+from _pytest.mark import _validate_marker_names
 from _pytest.mark import MarkGenerator
+from _pytest.mark.expression import Expression
 from _pytest.mark.structures import EMPTY_PARAMETERSET_OPTION
 from _pytest.nodes import Collector
 from _pytest.nodes import Node
@@ -213,6 +217,62 @@ def test_hello():
     )
 
 
+class TestValidateMarkerNames:
+    """Tests for _validate_marker_names (issue #2781)."""
+
+    class FakeConfig:
+        def __init__(
+            self,
+            markers: list[str],
+            strict_markers: bool | None = None,
+            strict: bool = False,
+        ) -> None:
+            self._ini: dict[str, list[str] | bool | None] = {
+                "markers": markers,
+                "strict_markers": strict_markers,
+                "strict": strict,
+            }
+
+        def getini(self, name: str) -> list[str] | bool | None:
+            return self._ini[name]
+
+    def _make_config(
+        self,
+        strict_markers: bool | None = None,
+        strict: bool = False,
+    ) -> pytest.Config:
+        return cast(
+            pytest.Config,
+            self.FakeConfig(
+                markers=["registered: a registered marker"],
+                strict_markers=strict_markers,
+                strict=strict,
+            ),
+        )
+
+    def test_unknown_marker_with_strict_markers(self) -> None:
+        expr = Expression.compile("unknown_marker")
+
+        with pytest.raises(UsageError, match=r"Unknown marker.*unknown_marker"):
+            _validate_marker_names(expr, self._make_config(strict_markers=True))
+
+    def test_unknown_marker_with_strict(self) -> None:
+        expr = Expression.compile("unknown_marker")
+
+        with pytest.raises(UsageError, match=r"Unknown marker.*unknown_marker"):
+            _validate_marker_names(expr, self._make_config(strict=True))
+
+    def test_registered_marker_passes(self) -> None:
+        expr = Expression.compile("registered")
+
+        _validate_marker_names(expr, self._make_config(strict_markers=True))
+
+    def test_no_validation_without_strict(self) -> None:
+        expr = Expression.compile("any_marker")
+
+        _validate_marker_names(expr, self._make_config())
+
+
 @pytest.mark.parametrize(
     ("expr", "expected_passed"),
     [

testing/test_mark_expression.py

@@ -322,3 +322,21 @@ def test_str_keyword_expressions(
     expr: str, expected: bool, mark_matcher: MarkMatcher
 ) -> None:
     assert evaluate(expr, mark_matcher) is expected
+
+
+@pytest.mark.parametrize(
+    ("expr", "expected_idents"),
+    (
+        ("", frozenset()),
+        ("foo", frozenset(["foo"])),
+        ("foo and bar", frozenset(["foo", "bar"])),
+        ("foo or bar", frozenset(["foo", "bar"])),
+        ("not foo", frozenset(["foo"])),
+        ("(foo and bar) or baz", frozenset(["foo", "bar", "baz"])),
+        ("foo and foo", frozenset(["foo"])),  # Duplicates are deduplicated.
+        ("mark(a=1)", frozenset(["mark"])),  # Only marker name, not kwargs.
+    ),
+)
+def test_expression_idents(expr: str, expected_idents: frozenset[str]) -> None:
+    """Test that Expression.idents() returns the identifiers in the expression."""
+    assert Expression.compile(expr).idents() == expected_idents