Fix color inconsistency in verbose mode for passed tests with warnings

Fixed issue where test status showed green instead of yellow for passed
tests with warnings in verbose mode. Tests with warnings now correctly
display in yellow both during progress and in the final summary.

Changes:
- Added pytest_report_teststatus hook with tryfirst=True to provide yellow
  markup for passed tests that have warnings
- Set has_warnings attribute on TestReport for xdist compatibility
- Added color logic in _determine_main_color to keep progress green while
  running in verbose mode
- Moved TestReport and CallInfo imports out of TYPE_CHECKING block for
  100% coverage
- Removed unused _nodeids_with_warnings global state (memory leak fix)
- Updated test to verify has_warnings attribute directly

Fixes #13201

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: treyshaffer

AUTHORS

@@ -463,6 +463,7 @@ Tomer Keren
 Tony Narlock
 Tor Colvin
 Trevor Bekolay
+Trey Shaffer
 Tushar Sadhwani
 Tyler Goodlet
 Tyler Smart

changelog/13201.bugfix.rst

@@ -0,0 +1 @@
+Fixed color inconsistency in verbose mode where test status showed green instead of yellow for passed tests with warnings.

src/_pytest/terminal.py

@@ -1377,6 +1377,9 @@ def _determine_main_color(self, unknown_type_seen: bool) -> str:
         stats = self.stats
         if "failed" in stats or "error" in stats:
             main_color = "red"
+        elif self.showlongtestinfo and not self._is_last_item:
+            # In verbose mode, keep progress green while tests are running
+            main_color = "green"
         elif "warnings" in stats or "xpassed" in stats or unknown_type_seen:
             main_color = "yellow"
         elif "passed" in stats or not self._is_last_item:

src/_pytest/warnings.py

@@ -13,11 +13,18 @@
 from _pytest.config import parse_warning_filter
 from _pytest.main import Session
 from _pytest.nodes import Item
+from _pytest.reports import TestReport
+from _pytest.runner import CallInfo
+from _pytest.stash import StashKey
 from _pytest.terminal import TerminalReporter
 from _pytest.tracemalloc import tracemalloc_message
 import pytest
 
 
+# StashKey for storing warning log on items
+warning_captured_log_key = StashKey[list[warnings.WarningMessage]]()
+
+
 @contextmanager
 def catch_warnings_for_item(
     config: Config,
@@ -46,28 +53,17 @@ def catch_warnings_for_item(
         apply_warning_filters(config_filters, cmdline_filters)
 
         # apply filters from "filterwarnings" marks
-        nodeid = "" if item is None else item.nodeid
         if item is not None:
             for mark in item.iter_markers(name="filterwarnings"):
                 for arg in mark.args:
                     warnings.filterwarnings(*parse_warning_filter(arg, escape=False))
+            # Store the warning log on the item so it can be accessed during reporting
+            if record and log is not None:
+                item.stash[warning_captured_log_key] = log
 
-        try:
-            yield
-        finally:
-            if record:
-                # mypy can't infer that record=True means log is not None; help it.
-                assert log is not None
-
-                for warning_message in log:
-                    ihook.pytest_warning_recorded.call_historic(
-                        kwargs=dict(
-                            warning_message=warning_message,
-                            nodeid=nodeid,
-                            when=when,
-                            location=None,
-                        )
-                    )
+        yield
+        # Note: pytest_warning_recorded hooks are now dispatched from
+        # pytest_runtest_makereport for better timing and integration
 
 
 def warning_record_to_str(warning_message: warnings.WarningMessage) -> str:
@@ -89,6 +85,40 @@ def pytest_runtest_protocol(item: Item) -> Generator[None, object, object]:
         return (yield)
 
 
+@pytest.hookimpl(hookwrapper=True)
+def pytest_runtest_makereport(
+    item: Item, call: CallInfo[None]
+) -> Generator[None, TestReport, None]:
+    """Process warnings from stash and dispatch pytest_warning_recorded hooks."""
+    outcome = yield
+    report: TestReport = outcome.get_result()
+
+    if report.when == "call":
+        warning_log = item.stash.get(warning_captured_log_key, None)
+        if warning_log:
+            # Set attribute on report for xdist compatibility
+            report.has_warnings = True  # type: ignore[attr-defined]
+
+            for warning_message in warning_log:
+                item.ihook.pytest_warning_recorded.call_historic(
+                    kwargs=dict(
+                        warning_message=warning_message,
+                        nodeid=item.nodeid,
+                        when="runtest",
+                        location=None,
+                    )
+                )
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_report_teststatus(report: TestReport, config: Config):
+    """Provide yellow markup for passed tests that have warnings."""
+    if report.passed and report.when == "call":
+        if hasattr(report, "has_warnings") and report.has_warnings:
+            # Return (category, shortletter, verbose_word) with yellow markup
+            return "passed", ".", ("PASSED", {"yellow": True})
+
+
 @pytest.hookimpl(wrapper=True, tryfirst=True)
 def pytest_collection(session: Session) -> Generator[None, object, object]:
     config = session.config

testing/test_terminal.py

@@ -2191,7 +2191,7 @@ def test_foobar(i): raise ValueError()
                 [
                     r"test_axfail.py {yellow}x{reset}{green} \s+ \[  4%\]{reset}",
                     r"test_bar.py ({green}\.{reset}){{10}}{green} \s+ \[ 52%\]{reset}",
-                    r"test_foo.py ({green}\.{reset}){{5}}{yellow} \s+ \[ 76%\]{reset}",
+                    r"test_foo.py ({yellow}\.{reset}){{5}}{yellow} \s+ \[ 76%\]{reset}",
                     r"test_foobar.py ({red}F{reset}){{5}}{red} \s+ \[100%\]{reset}",
                 ]
             )
@@ -2208,6 +2208,179 @@ def test_foobar(i): raise ValueError()
             )
         )
 
+    def test_verbose_colored_warnings(
+        self, pytester: Pytester, monkeypatch, color_mapping
+    ) -> None:
+        """Test that verbose mode shows yellow PASSED for tests with warnings."""
+        monkeypatch.setenv("PY_COLORS", "1")
+        pytester.makepyfile(
+            test_warning="""
+                import warnings
+                def test_with_warning():
+                    warnings.warn("test warning", DeprecationWarning)
+
+                def test_without_warning():
+                    pass
+            """
+        )
+        result = pytester.runpytest("-v")
+        result.stdout.re_match_lines(
+            color_mapping.format_for_rematch(
+                [
+                    r"test_warning.py::test_with_warning {yellow}PASSED{reset}{green} \s+ \[ 50%\]{reset}",
+                    r"test_warning.py::test_without_warning {green}PASSED{reset}{yellow} \s+ \[100%\]{reset}",
+                ]
+            )
+        )
+
+    def test_verbose_colored_warnings_xdist(
+        self, pytester: Pytester, monkeypatch, color_mapping
+    ) -> None:
+        """Test that warning coloring works correctly with pytest-xdist parallel execution."""
+        pytest.importorskip("xdist")
+        monkeypatch.delenv("PYTEST_DISABLE_PLUGIN_AUTOLOAD", raising=False)
+        monkeypatch.setenv("PY_COLORS", "1")
+        pytester.makepyfile(
+            test_warning_xdist="""
+                import warnings
+                def test_with_warning_1():
+                    warnings.warn("warning in test 1", DeprecationWarning)
+                    pass
+
+                def test_with_warning_2():
+                    warnings.warn("warning in test 2", DeprecationWarning)
+                    pass
+
+                def test_without_warning():
+                    pass
+            """
+        )
+
+        output = pytester.runpytest("-v", "-n2")
+        # xdist outputs in random order, and uses format:
+        # [gw#][cyan] [%] [reset][color]STATUS[reset] test_name
+        # Note: \x1b[36m is cyan, which isn't in color_mapping
+        output.stdout.re_match_lines_random(
+            color_mapping.format_for_rematch(
+                [
+                    r"\[gw\d\]\x1b\[36m \[\s*\d+%\] {reset}{yellow}PASSED{reset} "
+                    r"test_warning_xdist.py::test_with_warning_1",
+                    r"\[gw\d\]\x1b\[36m \[\s*\d+%\] {reset}{yellow}PASSED{reset} "
+                    r"test_warning_xdist.py::test_with_warning_2",
+                    r"\[gw\d\]\x1b\[36m \[\s*\d+%\] {reset}{green}PASSED{reset} "
+                    r"test_warning_xdist.py::test_without_warning",
+                ]
+            )
+        )
+
+    def test_failed_test_with_warnings_shows_red(
+        self, pytester: Pytester, monkeypatch, color_mapping
+    ) -> None:
+        """Test that failed tests with warnings show RED, not yellow."""
+        monkeypatch.setenv("PY_COLORS", "1")
+        pytester.makepyfile(
+            test_failed_warning="""
+                import warnings
+                def test_fails_with_warning():
+                    warnings.warn("This will fail", DeprecationWarning)
+                    assert False, "Expected failure"
+
+                def test_passes_with_warning():
+                    warnings.warn("This passes", DeprecationWarning)
+                    assert True
+            """
+        )
+        result = pytester.runpytest("-v")
+        # Failed test should be RED even though it has warnings
+        result.stdout.re_match_lines(
+            color_mapping.format_for_rematch(
+                [
+                    r"test_failed_warning.py::test_fails_with_warning {red}FAILED{reset}",
+                    r"test_failed_warning.py::test_passes_with_warning {yellow}PASSED{reset}",
+                ]
+            )
+        )
+
+    def test_non_verbose_mode_with_warnings(
+        self, pytester: Pytester, monkeypatch, color_mapping
+    ) -> None:
+        """Test that non-verbose mode (dot output) works correctly with warnings."""
+        monkeypatch.setenv("PY_COLORS", "1")
+        pytester.makepyfile(
+            test_dots="""
+                import warnings
+                def test_with_warning():
+                    warnings.warn("warning", DeprecationWarning)
+                    pass
+
+                def test_without_warning():
+                    pass
+            """
+        )
+        result = pytester.runpytest()  # No -v flag
+        # Should show dots, yellow for warning, green for clean pass
+        result.stdout.re_match_lines(
+            color_mapping.format_for_rematch(
+                [
+                    r"test_dots.py {yellow}\.{reset}{green}\.{reset}",
+                ]
+            )
+        )
+
+    def test_multiple_warnings_single_test(
+        self, pytester: Pytester, monkeypatch, color_mapping
+    ) -> None:
+        """Test that tests with multiple warnings still show yellow."""
+        monkeypatch.setenv("PY_COLORS", "1")
+        pytester.makepyfile(
+            test_multi="""
+                import warnings
+                def test_multiple_warnings():
+                    warnings.warn("warning 1", DeprecationWarning)
+                    warnings.warn("warning 2", DeprecationWarning)
+                    warnings.warn("warning 3", DeprecationWarning)
+                    pass
+            """
+        )
+        result = pytester.runpytest("-v")
+        result.stdout.re_match_lines(
+            color_mapping.format_for_rematch(
+                [
+                    r"test_multi.py::test_multiple_warnings {yellow}PASSED{reset}",
+                ]
+            )
+        )
+
+    def test_warning_with_filterwarnings_mark(
+        self, pytester: Pytester, monkeypatch, color_mapping
+    ) -> None:
+        """Test that warnings with filterwarnings mark still show yellow."""
+        monkeypatch.setenv("PY_COLORS", "1")
+        pytester.makepyfile(
+            test_marked="""
+                import warnings
+                import pytest
+
+                @pytest.mark.filterwarnings("ignore::DeprecationWarning")
+                def test_with_ignored_warning():
+                    warnings.warn("ignored warning", DeprecationWarning)
+                    pass
+
+                def test_with_visible_warning():
+                    warnings.warn("visible warning", DeprecationWarning)
+                    pass
+            """
+        )
+        result = pytester.runpytest("-v")
+        result.stdout.re_match_lines(
+            color_mapping.format_for_rematch(
+                [
+                    r"test_marked.py::test_with_ignored_warning {green}PASSED{reset}",
+                    r"test_marked.py::test_with_visible_warning {yellow}PASSED{reset}",
+                ]
+            )
+        )
+
     def test_count(self, many_tests_files, pytester: Pytester) -> None:
         pytester.makeini(
             """

testing/test_warnings.py

@@ -888,3 +888,86 @@ def test_resource_warning(tmp_path):
         else []
     )
     result.stdout.fnmatch_lines([*expected_extra, "*1 passed*"])
+
+
+def test_warning_tracking_for_yellow_coloring(pytester: Pytester) -> None:
+    """Test that warnings set has_warnings attribute on reports for yellow markup."""
+    pytester.makepyfile(
+        """
+        import warnings
+        def test_with_warning():
+            warnings.warn("test warning", DeprecationWarning)
+            assert True
+
+        def test_without_warning():
+            assert True
+    """
+    )
+
+    # Use inline_run to verify the has_warnings attribute is set correctly
+    reprec = pytester.inline_run()
+
+    # Get all call phase reports
+    reports = reprec.getreports("pytest_runtest_logreport")
+    call_reports = [r for r in reports if r.when == "call"]
+
+    # Find the reports for each test
+    test_with_warning_report = None
+    test_without_warning_report = None
+    for report in call_reports:
+        if "test_with_warning" in report.nodeid:
+            test_with_warning_report = report
+        elif "test_without_warning" in report.nodeid:
+            test_without_warning_report = report
+
+    # Verify test_with_warning has the has_warnings attribute set
+    assert test_with_warning_report is not None, (
+        "Expected to find test_with_warning report"
+    )
+    assert hasattr(test_with_warning_report, "has_warnings"), (
+        "Expected test_with_warning report to have has_warnings attribute"
+    )
+    assert test_with_warning_report.has_warnings is True, (
+        "Expected has_warnings to be True for test with warnings"
+    )
+
+    # Verify test_without_warning does NOT have the has_warnings attribute
+    assert test_without_warning_report is not None, (
+        "Expected to find test_without_warning report"
+    )
+    assert not hasattr(test_without_warning_report, "has_warnings"), (
+        "Did not expect test_without_warning report to have has_warnings attribute"
+    )
+
+
+def test_warning_stash_storage(pytester: Pytester) -> None:
+    """Test that warning log is stored in item.stash during test execution."""
+    pytester.makepyfile(
+        """
+        import warnings
+
+        def test_with_warning():
+            warnings.warn("test warning", DeprecationWarning)
+            pass
+    """
+    )
+
+    # Use a plugin to capture the item and check the stash
+    captured_item = []
+
+    class StashChecker:
+        def pytest_runtest_call(self, item):
+            captured_item.append(item)
+
+    pytester.inline_run(plugins=[StashChecker()])
+
+    assert len(captured_item) == 1
+    item = captured_item[0]
+
+    # Check that the warning log was stored in the stash
+    from _pytest.warnings import warning_captured_log_key
+
+    warning_log = item.stash.get(warning_captured_log_key, None)
+    assert warning_log is not None, "Expected warning log to be stored in item.stash"
+    assert len(warning_log) > 0, "Expected at least one warning in the log"
+    assert "test warning" in str(warning_log[0].message)