tenzir-test 0.11.0__tar.gz → 0.12.0__tar.gz

{tenzir_test-0.11.0 → tenzir_test-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tenzir-test
-Version: 0.11.0
+Version: 0.12.0
 Summary: Reusable test execution framework extracted from the Tenzir repository.
 Project-URL: Homepage, https://github.com/tenzir/test
 Project-URL: Repository, https://github.com/tenzir/test

{tenzir_test-0.11.0 → tenzir_test-0.12.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tenzir-test"
-version = "0.11.0"
+version = "0.12.0"
 description = "Reusable test execution framework extracted from the Tenzir repository."
 readme = "README.md"
 requires-python = ">=3.12"

{tenzir_test-0.11.0 → tenzir_test-0.12.0}/src/tenzir_test/cli.py

@@ -191,6 +191,8 @@ def main(argv: Sequence[str] | None = None) -> int:
     """Run the Click command and translate Click exits to integer codes."""
 
     command_main = getattr(cli, "main")
+    previous_color_mode = runtime.get_color_mode()
+    runtime.set_color_mode(runtime.ColorMode.AUTO)
     try:
         result = command_main(
             args=list(argv) if argv is not None else None,
@@ -206,6 +208,8 @@ def main(argv: Sequence[str] | None = None) -> int:
         return _normalize_exit_code(exc.code)
     else:
         return _normalize_exit_code(result)
+    finally:
+        runtime.set_color_mode(previous_color_mode)
 
 
 if __name__ == "__main__":

{tenzir_test-0.11.0 → tenzir_test-0.12.0}/src/tenzir_test/run.py

@@ -138,6 +138,14 @@ class HarnessMode(enum.Enum):
     PASSTHROUGH = "passthrough"
 
 
+class ColorMode(enum.Enum):
+    """Supported color output policies."""
+
+    AUTO = "auto"
+    ALWAYS = "always"
+    NEVER = "never"
+
+
 def detect_execution_mode(root: Path) -> tuple[ExecutionMode, Path | None]:
     """Return the execution mode and detected package root for `root`."""
 
@@ -159,19 +167,23 @@ INPUTS_DIR: Path = ROOT / "inputs"
 EXECUTION_MODE: ExecutionMode = ExecutionMode.PROJECT
 _DETECTED_PACKAGE_ROOT: Path | None = None
 HARNESS_MODE = HarnessMode.COMPARE
-CHECKMARK = "\033[92;1m✔\033[0m"
-CROSS = "\033[31m✘\033[0m"
-INFO = "\033[94;1mi\033[0m"
-SKIP = "\033[90;1m●\033[0m"
-DEBUG_PREFIX = "\033[95m◆\033[0m"
-BOLD = "\033[1m"
-CHECK_COLOR = "\033[92;1m"
-PASS_MAX_COLOR = "\033[92m"
-FAIL_COLOR = "\033[31m"
-SKIP_COLOR = "\033[90;1m"
-RESET_COLOR = "\033[0m"
-DETAIL_COLOR = "\033[2;37m"
-PASS_SPECTRUM = [
+_COLOR_MODE = ColorMode.NEVER
+COLORS_ENABLED = False
+CHECKMARK = ""
+CROSS = ""
+INFO = ""
+SKIP = ""
+DEBUG_PREFIX = ""
+BOLD = ""
+CHECK_COLOR = ""
+PASS_MAX_COLOR = ""
+FAIL_COLOR = ""
+SKIP_COLOR = ""
+RESET_COLOR = ""
+DETAIL_COLOR = ""
+DIFF_ADD_COLOR = ""
+PASS_SPECTRUM: list[str] = []
+_COLORED_PASS_SPECTRUM = [
     "\033[38;5;52m",  # 0-9%   deep red
     "\033[38;5;88m",  # 10-19% red
     "\033[38;5;124m",  # 20-29% dark orange
@@ -182,8 +194,107 @@ PASS_SPECTRUM = [
     "\033[38;5;148m",  # 70-79% spring green
     "\033[38;5;112m",  # 80-89% medium green
     "\033[38;5;28m",  # 90-99% deep forest green
-    PASS_MAX_COLOR,  # 100% bright green
+    "\033[92m",  # 100% bright green
 ]
+_INTERRUPTED_NOTICE = "└─▶ test interrupted by user"
+
+
+def _colors_available() -> bool:
+    if _COLOR_MODE is ColorMode.NEVER:
+        return False
+    if "NO_COLOR" in os.environ:
+        return False
+    if _COLOR_MODE is ColorMode.ALWAYS:
+        return True
+    return True
+
+
+def _apply_color_palette() -> None:
+    global COLORS_ENABLED
+    global CHECKMARK
+    global CROSS
+    global INFO
+    global SKIP
+    global DEBUG_PREFIX
+    global BOLD
+    global CHECK_COLOR
+    global PASS_MAX_COLOR
+    global FAIL_COLOR
+    global SKIP_COLOR
+    global RESET_COLOR
+    global DETAIL_COLOR
+    global DIFF_ADD_COLOR
+    global PASS_SPECTRUM
+    global _INTERRUPTED_NOTICE
+
+    COLORS_ENABLED = _colors_available()
+    RESET_COLOR = "\033[0m" if COLORS_ENABLED else ""
+
+    def _wrap(code: str, text: str) -> str:
+        if not code:
+            return text
+        return f"{code}{text}{RESET_COLOR}"
+
+    CHECK_COLOR = "\033[92;1m" if COLORS_ENABLED else ""
+    PASS_MAX_COLOR = "\033[92m" if COLORS_ENABLED else ""
+    FAIL_COLOR = "\033[31m" if COLORS_ENABLED else ""
+    SKIP_COLOR = "\033[90;1m" if COLORS_ENABLED else ""
+    DETAIL_COLOR = "\033[2;37m" if COLORS_ENABLED else ""
+    DIFF_ADD_COLOR = "\033[32m" if COLORS_ENABLED else ""
+    BOLD = "\033[1m" if COLORS_ENABLED else ""
+
+    CHECKMARK = _wrap(CHECK_COLOR, "✔")
+    CROSS = _wrap(FAIL_COLOR, "✘")
+    INFO = _wrap("\033[94;1m" if COLORS_ENABLED else "", "i")
+    SKIP = _wrap(SKIP_COLOR, "●")
+    DEBUG_PREFIX = _wrap("\033[95m" if COLORS_ENABLED else "", "◆")
+    PASS_SPECTRUM = (
+        list(_COLORED_PASS_SPECTRUM) if COLORS_ENABLED else ["" for _ in _COLORED_PASS_SPECTRUM]
+    )
+    _INTERRUPTED_NOTICE = (
+        f"└─▶ {_wrap('\033[33m' if COLORS_ENABLED else '', 'test interrupted by user')}"
+    )
+
+
+def refresh_color_palette() -> None:
+    """Re-evaluate ANSI color availability based on environment variables."""
+
+    _apply_color_palette()
+
+
+def colors_enabled() -> bool:
+    return COLORS_ENABLED
+
+
+def get_color_mode() -> ColorMode:
+    return _COLOR_MODE
+
+
+def set_color_mode(mode: ColorMode) -> None:
+    global _COLOR_MODE
+    if not isinstance(mode, ColorMode):
+        raise TypeError("mode must be an instance of ColorMode")
+    if _COLOR_MODE is mode:
+        return
+    _COLOR_MODE = mode
+    _apply_color_palette()
+
+
+def colorize(text: str, color: str) -> str:
+    """Wrap `text` with the given ANSI `color` code if colors are enabled."""
+
+    if not color:
+        return text
+    return f"{color}{text}{RESET_COLOR}"
+
+
+def format_failure_message(message: str) -> str:
+    """Render a standardized failure line with optional ANSI coloring."""
+
+    return f"└─▶ {colorize(message, FAIL_COLOR)}"
+
+
+_apply_color_palette()
 ANSI_ESCAPE = re.compile(r"\x1b\[[0-9;]*m")
 
 stdout_lock = threading.RLock()
@@ -244,8 +355,6 @@ def _is_interrupt_exit(returncode: int) -> bool:
     return returncode in {128 + sig for sig in _INTERRUPT_SIGNALS}
 
 
-_INTERRUPTED_NOTICE = "└─▶ \033[33mtest interrupted by user\033[0m"
-
 _CURRENT_RETRY_CONTEXT = threading.local()
 _CURRENT_SUITE_CONTEXT = threading.local()
 
@@ -332,7 +441,8 @@ def _format_attempt_suffix() -> str:
     attempt, max_attempts = progress
     if attempt <= 1 or max_attempts <= 1:
         return ""
-    return f"  \033[2;37mattempts={attempt}/{max_attempts}\033[0m"
+    detail = f"attempts={attempt}/{max_attempts}"
+    return f"  {colorize(detail, DETAIL_COLOR)}"
 
 
 def _format_suite_suffix() -> str:
@@ -342,7 +452,8 @@ def _format_suite_suffix() -> str:
     name, index, total = progress
     if not name or total <= 0:
         return ""
-    return f"  \033[2;37msuite={name} ({index}/{total})\033[0m"
+    detail = f"suite={name} ({index}/{total})"
+    return f"  {colorize(detail, DETAIL_COLOR)}"
 
 
 TEST_TMP_ENV_VAR = "TENZIR_TMP_DIR"
@@ -2175,8 +2286,8 @@ def _color_tree_glyphs(line: str, color: str) -> str:
     glyphs = {"│", "├", "└", "─"}
     parts = []
     for char in line:
-        if char in glyphs:
-            parts.append(f"{color}{char}\033[0m")
+        if char in glyphs and color:
+            parts.append(f"{color}{char}{RESET_COLOR}")
         else:
             parts.append(char)
     return "".join(parts)
@@ -2424,7 +2535,7 @@ def _print_detailed_summary(summary: Summary) -> None:
     if summary.failed_paths:
         print(f"{CROSS} Failed tests:")
         for line in _render_tree(_build_path_tree(summary.failed_paths)):
-            print(f"  {_color_tree_glyphs(line, '\033[31m')}")
+            print(f"  {_color_tree_glyphs(line, FAIL_COLOR)}")
 
 
 def get_version() -> str:
@@ -2489,16 +2600,16 @@ def _format_unary_symbols(count: int, symbols: dict[int, str]) -> str:
 def _format_diff_counter(added: int, removed: int) -> str:
     plus_segment = _format_unary_symbols(added, _PLUS_SYMBOLS)
     minus_segment = _format_unary_symbols(removed, _MINUS_SYMBOLS)
-    colored_plus = f"\033[32m{plus_segment}\033[0m" if plus_segment else ""
-    colored_minus = f"\033[31m{minus_segment}\033[0m" if minus_segment else ""
+    colored_plus = colorize(plus_segment, DIFF_ADD_COLOR) if plus_segment else ""
+    colored_minus = colorize(minus_segment, FAIL_COLOR) if minus_segment else ""
     return f"{colored_plus}{colored_minus}"
 
 
 def _format_stat_header(path: os.PathLike[str] | str, added: int, removed: int) -> str:
     path_str = os.fspath(path)
     counter = _format_diff_counter(added, removed)
-    plus_count = f"\033[32m{added}(+)\033[0m"
-    minus_count = f"\033[31m{removed}(-)\033[0m"
+    plus_count = colorize(f"{added}(+)", DIFF_ADD_COLOR)
+    minus_count = colorize(f"{removed}(-)", FAIL_COLOR)
     if counter:
         counter_segment = f" {counter}"
     else:
@@ -2543,9 +2654,9 @@ def print_diff(expected: bytes, actual: bytes, path: Path) -> None:
                 continue
             text = raw_line.decode("utf-8", "replace").rstrip("\r\n")
             if raw_line.startswith(b"+") and not raw_line.startswith(b"+++"):
-                text = f"\033[32m{text}\033[0m"
+                text = colorize(text, DIFF_ADD_COLOR)
             elif raw_line.startswith(b"-") and not raw_line.startswith(b"---"):
-                text = f"\033[31m{text}\033[0m"
+                text = colorize(text, FAIL_COLOR)
             diff_lines.append(text)
     rel_path = _relativize_path(path)
     rel_path_str = os.fspath(rel_path)
@@ -2589,7 +2700,7 @@ def run_simple_test(
         # Parse test configuration
         test_config = parse_test_config(test, coverage=coverage)
     except ValueError as e:
-        report_failure(test, f"└─▶ \033[31m{e}\033[0m")
+        report_failure(test, format_failure_message(str(e)))
         return False
 
     inputs_override = typing.cast(str | None, test_config.get("inputs"))
@@ -2675,13 +2786,16 @@ def run_simple_test(
             captured_stderr = completed.stderr or b""
             stderr_output = captured_stderr.replace(root_bytes, b"")
     except subprocess.TimeoutExpired:
-        report_failure(test, f"└─▶ \033[31msubprocess hit {timeout}s timeout\033[0m")
+        report_failure(
+            test,
+            format_failure_message(f"subprocess hit {timeout}s timeout"),
+        )
         return False
     except subprocess.CalledProcessError as e:
-        report_failure(test, f"└─▶ \033[31msubprocess error: {e}\033[0m")
+        report_failure(test, format_failure_message(f"subprocess error: {e}"))
         return False
     except Exception as e:
-        report_failure(test, f"└─▶ \033[31munexpected exception: {e}\033[0m")
+        report_failure(test, format_failure_message(f"unexpected exception: {e}"))
         return False
     finally:
         fixtures_impl.pop_context(context_token)
@@ -2696,7 +2810,7 @@ def run_simple_test(
         summary_line = (
             _INTERRUPTED_NOTICE
             if interrupted
-            else f"└─▶ \033[31mgot unexpected exit code {completed.returncode}\033[0m"
+            else format_failure_message(f"got unexpected exit code {completed.returncode}")
         )
         if passthrough_mode:
             report_failure(test, summary_line)
@@ -2729,7 +2843,7 @@ def run_simple_test(
             f.write(output)
     else:
         if not ref_path.exists():
-            report_failure(test, f'└─▶ \033[31mFailed to find ref file: "{ref_path}"\033[0m')
+            report_failure(test, format_failure_message(f'Failed to find ref file: "{ref_path}"'))
             return False
         log_comparison(test, ref_path, mode="comparing")
         expected = ref_path.read_bytes()
@@ -2758,7 +2872,9 @@ def handle_skip(reason: str, test: Path, update: bool, output_ext: str) -> bool
             if expected != b"":
                 report_failure(
                     test,
-                    f'└─▶ \033[31mReference file for skipped test must be empty: "{ref_path}"\033[0m',
+                    format_failure_message(
+                        f'Reference file for skipped test must be empty: "{ref_path}"'
+                    ),
                 )
                 return False
     return "skipped"
@@ -2935,7 +3051,7 @@ class Worker:
             if suite_fixtures is None:
                 configured_fixtures = config_fixtures
         if parse_error is not None:
-            message = f"└─▶ \033[31m{parse_error}\033[0m"
+            message = format_failure_message(parse_error)
             report_failure(test_path, message)
             summary.total += 1
             summary.record_runner_outcome(runner.name, False)
@@ -2981,7 +3097,7 @@ class Worker:
                     interrupted = True
                     outcome = False
                 except Exception as exc:
-                    error_message = f"└─▶ \033[31m{exc}\033[0m"
+                    error_message = format_failure_message(str(exc))
                     report_failure(test_path, error_message)
                     outcome = False
                     final_interrupted = False

{tenzir_test-0.11.0 → tenzir_test-0.12.0}/src/tenzir_test/runners/custom_python_fixture_runner.py

@@ -127,7 +127,9 @@ class CustomPythonFixture(ExtRunner):
                     if not ref_path.exists():
                         run_mod.report_failure(
                             test,
-                            f'└─▶ \033[31mFailed to find ref file: "{ref_path}"\033[0m',
+                            run_mod.format_failure_message(
+                                f'Failed to find ref file: "{ref_path}"'
+                            ),
                         )
                         return False
                     run_mod.log_comparison(test, ref_path, mode="comparing")
@@ -144,7 +146,8 @@ class CustomPythonFixture(ExtRunner):
                 run_mod.cleanup_test_tmp_dir(env.get(run_mod.TEST_TMP_ENV_VAR))
         except subprocess.TimeoutExpired:
             run_mod.report_failure(
-                test, f"└─▶ \033[31mpython fixture hit {timeout}s timeout\033[0m"
+                test,
+                run_mod.format_failure_message(f"python fixture hit {timeout}s timeout"),
             )
             return False
         except subprocess.CalledProcessError as e:

{tenzir_test-0.11.0 → tenzir_test-0.12.0}/src/tenzir_test/runners/shell_runner.py

@@ -79,7 +79,9 @@ class ShellRunner(ExtRunner):
         good = completed.returncode == 0
         if expect_error == good:
             suppressed = run_mod.should_suppress_failure_output()
-            summary_line = f"└─▶ \033[31mgot unexpected exit code {completed.returncode}\033[0m"
+            summary_line = run_mod.format_failure_message(
+                f"got unexpected exit code {completed.returncode}"
+            )
             if passthrough:
                 if not suppressed:
                     run_mod.report_failure(test, summary_line)
@@ -127,7 +129,7 @@ class ShellRunner(ExtRunner):
             if not stdout_path.exists():
                 run_mod.report_failure(
                     test,
-                    f'└─▶ \033[31mFailed to find ref file: "{stdout_path}"\033[0m',
+                    run_mod.format_failure_message(f'Failed to find ref file: "{stdout_path}"'),
                 )
                 return False
             run_mod.log_comparison(test, stdout_path, mode="comparing")

{tenzir_test-0.11.0 → tenzir_test-0.12.0}/tests/test_run.py

@@ -16,6 +16,7 @@ from tenzir_test.runners.runner import Runner
 
 def test_main_warns_when_outside_project_root(tmp_path, monkeypatch, capsys):
     original_settings = run._settings
+    original_root = run.ROOT
     monkeypatch.setenv("TENZIR_TEST_ROOT", str(tmp_path))
     monkeypatch.delenv("TENZIR_BINARY", raising=False)
     monkeypatch.delenv("TENZIR_NODE_BINARY", raising=False)
@@ -24,7 +25,13 @@ def test_main_warns_when_outside_project_root(tmp_path, monkeypatch, capsys):
         try:
             run.main([])
         finally:
-            run.apply_settings(original_settings)
+            if original_settings is not None:
+                run.apply_settings(original_settings)
+            else:
+                run._settings = None
+                run.TENZIR_BINARY = None
+                run.TENZIR_NODE_BINARY = None
+                run._set_project_root(original_root)
 
     assert exc.value.code == 1
     captured = capsys.readouterr()
@@ -35,6 +42,7 @@ def test_main_warns_when_outside_project_root(tmp_path, monkeypatch, capsys):
 
 def test_main_warns_outside_project_root_with_selection(tmp_path, monkeypatch, capsys):
     original_settings = run._settings
+    original_root = run.ROOT
     monkeypatch.setenv("TENZIR_TEST_ROOT", str(tmp_path))
     monkeypatch.delenv("TENZIR_BINARY", raising=False)
     monkeypatch.delenv("TENZIR_NODE_BINARY", raising=False)
@@ -43,7 +51,13 @@ def test_main_warns_outside_project_root_with_selection(tmp_path, monkeypatch, c
         try:
             run.main(["tests/sample.tql"])
         finally:
-            run.apply_settings(original_settings)
+            if original_settings is not None:
+                run.apply_settings(original_settings)
+            else:
+                run._settings = None
+                run.TENZIR_BINARY = None
+                run.TENZIR_NODE_BINARY = None
+                run._set_project_root(original_root)
 
     assert str(exc.value).startswith("error: test path `tests/sample.tql` does not exist")
     captured = capsys.readouterr()
@@ -52,6 +66,7 @@ def test_main_warns_outside_project_root_with_selection(tmp_path, monkeypatch, c
 
 def test_main_accepts_satellite_selection_without_project_root(tmp_path, monkeypatch, capsys):
     original_settings = run._settings
+    original_root = run.ROOT
     library_root = tmp_path / "library"
     library_root.mkdir()
     package_dir = library_root / "pkg"
@@ -67,7 +82,13 @@ def test_main_accepts_satellite_selection_without_project_root(tmp_path, monkeyp
     try:
         run.main(["pkg"])
     finally:
-        run.apply_settings(original_settings)
+        if original_settings is not None:
+            run.apply_settings(original_settings)
+        else:
+            run._settings = None
+            run.TENZIR_BINARY = None
+            run.TENZIR_NODE_BINARY = None
+            run._set_project_root(original_root)
 
     captured = capsys.readouterr()
     lines = [line for line in captured.out.splitlines() if line]
@@ -78,6 +99,7 @@ def test_main_accepts_current_directory_selection_without_project_root(
     tmp_path, monkeypatch, capsys
 ):
     original_settings = run._settings
+    original_root = run.ROOT
     library_root = tmp_path / "library"
     library_root.mkdir()
     package_dir = library_root / "pkg"
@@ -93,7 +115,13 @@ def test_main_accepts_current_directory_selection_without_project_root(
     try:
         run.main(["."])
     finally:
-        run.apply_settings(original_settings)
+        if original_settings is not None:
+            run.apply_settings(original_settings)
+        else:
+            run._settings = None
+            run.TENZIR_BINARY = None
+            run.TENZIR_NODE_BINARY = None
+            run._set_project_root(original_root)
 
     captured = capsys.readouterr()
     lines = [line for line in captured.out.splitlines() if line]
@@ -241,16 +269,29 @@ def test_print_detailed_summary_outputs_tree(capsys):
     )
     summary.runner_stats["tenzir"] = run.RunnerStats(total=2, failed=1, skipped=1)
 
-    run._print_detailed_summary(summary)
+    original_color_mode = run.get_color_mode()
+    fail_color = ""
+    reset_color = ""
+    skip_symbol = run.SKIP
+    cross_symbol = run.CROSS
+    try:
+        run.set_color_mode(run.ColorMode.ALWAYS)
+        run._print_detailed_summary(summary)
+        output = capsys.readouterr().out.splitlines()
+        fail_color = run.FAIL_COLOR
+        reset_color = run.RESET_COLOR
+        skip_symbol = run.SKIP
+        cross_symbol = run.CROSS
+    finally:
+        run.set_color_mode(original_color_mode)
 
-    output = capsys.readouterr().out.splitlines()
     assert output[0] == ""
-    assert output[1] == f"{run.SKIP} Skipped tests:"
+    assert output[1] == f"{skip_symbol} Skipped tests:"
     assert output[2] == "  └── pkg"
     assert output[3] == "      └── tests"
     assert output[4] == "          └── slow.tql"
     assert output[5] == ""
-    assert output[6] == f"{run.CROSS} Failed tests:"
+    assert output[6] == f"{cross_symbol} Failed tests:"
     failed_lines = output[7:10]
     for line, suffix in zip(
         failed_lines,
@@ -259,8 +300,10 @@ def test_print_detailed_summary_outputs_tree(capsys):
     ):
         assert line.startswith("  ")
         assert line.endswith(suffix)
-        assert line.count("\x1b[31m") >= 1
-        assert f"\x1b[31m{suffix.strip()}" not in line
+        assert fail_color in line
+        if fail_color and reset_color:
+            assert f"{fail_color}{suffix.strip()}" not in line
+            assert line.endswith(f"{suffix}")
 
 
 def test_handle_skip_uses_skip_glyph(tmp_path, capsys):
@@ -860,42 +903,55 @@ def test_detailed_summary_order(capsys):
 def test_print_diff_default_layout(capsys):
     original_show_diff = run.should_show_diff_output()
     original_show_stat = run.should_show_diff_stat()
+    original_color_mode = run.get_color_mode()
     try:
+        run.set_color_mode(run.ColorMode.ALWAYS)
         run.set_show_diff_output(True)
         run.set_show_diff_stat(True)
         run.print_diff(b"line\nbeta\n", b"line\ngamma\n", Path("tests/example.txt"))
+        output = capsys.readouterr().out.splitlines()
+        expected_counter = run._format_diff_counter(1, 1)
+        expected_counts = (
+            f"{run.colorize('1(+)', run.DIFF_ADD_COLOR)}/{run.colorize('1(-)', run.FAIL_COLOR)}"
+        )
+        colored_minus = run.colorize("-beta", run.FAIL_COLOR)
+        colored_plus = run.colorize("+gamma", run.DIFF_ADD_COLOR)
     finally:
+        run.set_color_mode(original_color_mode)
         run.set_show_diff_output(original_show_diff)
         run.set_show_diff_stat(original_show_stat)
 
-    output = capsys.readouterr().out.splitlines()
     assert output[0].startswith(f"{run._BLOCK_INDENT}┌ tests/example.txt")
-    expected_counter = run._format_diff_counter(1, 1)
-    assert "\033[32m1(+)\033[0m/\033[31m1(-)\033[0m" in output[0]
+    assert expected_counts in output[0]
     assert output[0].endswith(expected_counter)
     assert output[1] == f"{run._BLOCK_INDENT}│ @@ -1,2 +1,2 @@"
     assert output[2] == f"{run._BLOCK_INDENT}│  line"
-    assert output[3].startswith(f"{run._BLOCK_INDENT}│ \033[31m-beta")
-    assert output[4].startswith(f"{run._BLOCK_INDENT}│ \033[32m+gamma")
+    assert output[3].startswith(f"{run._BLOCK_INDENT}│ {colored_minus}")
+    assert output[4].startswith(f"{run._BLOCK_INDENT}│ {colored_plus}")
     assert output[5] == f"{run._BLOCK_INDENT}└ 2 lines changed"
 
 
 def test_print_diff_no_diff_outputs_stat_only(capsys):
     original_show_diff = run.should_show_diff_output()
     original_show_stat = run.should_show_diff_stat()
+    original_color_mode = run.get_color_mode()
     try:
+        run.set_color_mode(run.ColorMode.ALWAYS)
         run.set_show_diff_output(False)
         run.set_show_diff_stat(True)
         run.print_diff(b"line\nbeta\n", b"line\ngamma\n", Path("tests/example.txt"))
+        output = capsys.readouterr().out.splitlines()
+        expected_header = (
+            f"{run._BLOCK_INDENT}┌ tests/example.txt "
+            f"{run.colorize('1(+)', run.DIFF_ADD_COLOR)}"
+            f"/{run.colorize('1(-)', run.FAIL_COLOR)} "
+            f"{run._format_diff_counter(1, 1)}"
+        )
     finally:
+        run.set_color_mode(original_color_mode)
         run.set_show_diff_output(original_show_diff)
         run.set_show_diff_stat(original_show_stat)
 
-    output = capsys.readouterr().out.splitlines()
-    expected_header = (
-        f"{run._BLOCK_INDENT}┌ tests/example.txt "
-        f"\033[32m1(+)\033[0m/\033[31m1(-)\033[0m {run._format_diff_counter(1, 1)}"
-    )
     assert output == [
         expected_header,
         f"{run._BLOCK_INDENT}└ 2 lines changed",
@@ -933,6 +989,33 @@ def test_print_diff_disabled_outputs_nothing(capsys):
     assert capsys.readouterr().out.strip() == ""
 
 
+def test_no_color_env_disables_colors(monkeypatch, capsys):
+    original_show_diff = run.should_show_diff_output()
+    original_show_stat = run.should_show_diff_stat()
+    original_color_mode = run.get_color_mode()
+    capsys.readouterr()
+    try:
+        run.set_color_mode(run.ColorMode.ALWAYS)
+        monkeypatch.setenv("NO_COLOR", "1")
+        run.refresh_color_palette()
+        run.set_show_diff_output(True)
+        run.set_show_diff_stat(True)
+        run.print_diff(b"line\nbeta\n", b"line\ngamma\n", Path("tests/example.txt"))
+        captured = capsys.readouterr().out
+        palette_state = run.colors_enabled()
+        checkmark_symbol = run.CHECKMARK
+    finally:
+        monkeypatch.delenv("NO_COLOR", raising=False)
+        run.set_color_mode(original_color_mode)
+        run.refresh_color_palette()
+        run.set_show_diff_output(original_show_diff)
+        run.set_show_diff_stat(original_show_stat)
+
+    assert "\033[" not in captured
+    assert palette_state is False
+    assert checkmark_symbol == "✔"
+
+
 def test_describe_project_root_detects_standard_project(tmp_path: Path) -> None:
     project_root = tmp_path / "proj"
     tests_dir = project_root / "tests"