test_mcp_redactor.py

Go to the documentation of this file.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# tests/tests_mcp/test_mcp_redactor.py
 
"""
Purpose
-------
Regression tests for :mod:`oct.mcp.redactor` — five-step output
sanitisation pipeline.
 
Responsibilities
----------------
- Verify secret-line filtering (T-03) and path anonymisation (T-07).
- Verify ANSI stripping, truncation, and git URL redaction.
- Verify custom redaction patterns.
 
Diagnostics
-----------
Domain: MCP-TESTS
Levels:
    L2 — test lifecycle
    L3 — assertion details
    L4 — deep tracing
 
Contracts
---------
- Tests operate on in-memory strings; no files are written.
"""
 
from __future__ import annotations
 
import os
from pathlib import Path
 
import pytest
 
from oct.mcp.redactor import Redactor, RedactorResult
 
 
def make_redactor(**kwargs) -> Redactor:
    return Redactor(**kwargs)
 
 
# -------------------------------------------------------------------
# RedactorResult
# -------------------------------------------------------------------
 
class TestRedactorResult:
    def test_fields_present(self):
        r = RedactorResult(text="hi", redactions_applied=0, truncated=False, original_size_bytes=2)
        assert r.text == "hi"
        assert r.redactions_applied == 0
        assert r.truncated is False
 
 
# -------------------------------------------------------------------
# Step 1: custom patterns from config
# -------------------------------------------------------------------
 
class TestStep1CustomPatterns:
    def test_custom_pattern_string_redacted(self, tmp_path: Path):
        r = Redactor(redaction_patterns=["MYSECRET"])
        result = r.apply_all("output MYSECRET value", tmp_path)
        assert "MYSECRET" not in result.text
        assert "[REDACTED]" in result.text
        assert result.redactions_applied >= 1
 
    def test_custom_pattern_dict_with_replacement(self, tmp_path: Path):
        r = Redactor(redaction_patterns=[{"pattern": r"\bJWT_\w+", "replacement": "[JWT]"}])
        result = r.apply_all("token JWT_xyz123 used", tmp_path)
        assert "[JWT]" in result.text
 
    def test_invalid_pattern_skipped(self, tmp_path: Path):
        # Should not raise — invalid patterns are silently skipped.
        r = Redactor(redaction_patterns=["[invalid(regex"])
        result = r.apply_all("some text", tmp_path)
        assert result.text == "some text"
 
    def test_no_patterns_no_change(self, tmp_path: Path):
        r = Redactor(redaction_patterns=[])
        result = r.apply_all("clean output", tmp_path)
        assert result.text == "clean output"
 
 
# -------------------------------------------------------------------
# Step 2: secret-name assignment line filtering  (T-03)
# -------------------------------------------------------------------
 
class TestStep2SecretLines:
    def test_api_key_assignment_redacted(self, tmp_path: Path):
        r = Redactor()
        result = r.apply_all("API_KEY=abc123secret", tmp_path)
        assert "abc123secret" not in result.text
        assert "[REDACTED]" in result.text
 
    def test_password_assignment_redacted(self, tmp_path: Path):
        r = Redactor()
        result = r.apply_all("password=hunter2", tmp_path)
        assert "hunter2" not in result.text
 
    def test_token_assignment_redacted(self, tmp_path: Path):
        r = Redactor()
        result = r.apply_all("token=ghp_xxxxxxxxxxxx", tmp_path)
        assert "ghp_xxxxxxxxxxxx" not in result.text
 
    def test_colon_separator_redacted(self, tmp_path: Path):
        r = Redactor()
        result = r.apply_all("secret: mysecretvalue", tmp_path)
        assert "mysecretvalue" not in result.text
 
    def test_non_secret_key_preserved(self, tmp_path: Path):
        r = Redactor()
        result = r.apply_all("filename=output.py", tmp_path)
        assert "output.py" in result.text
 
    def test_multiline_only_secret_line_redacted(self, tmp_path: Path):
        r = Redactor()
        text = "result=OK\napi_key=secret123\nstatus=pass"
        result = r.apply_all(text, tmp_path)
        assert "OK" in result.text
        assert "pass" in result.text
        assert "secret123" not in result.text
 
    def test_t03_secret_exfiltration_blocked(self, tmp_path: Path):
        """T-03: API_KEY in output must be redacted before reaching client."""
        r = Redactor()
        output = "Running lint...\nAPI_KEY=sk-abc123\nLint passed."
        result = r.apply_all(output, tmp_path)
        assert "sk-abc123" not in result.text
        assert result.redactions_applied >= 1
 
 
# -------------------------------------------------------------------
# Step 2b: git URL credential redaction
# -------------------------------------------------------------------
 
class TestStep2bGitUrlRedaction:
    def test_http_credentials_redacted(self, tmp_path: Path):
        r = Redactor()
        result = r.apply_all("remote: https://user:token@github.com/repo", tmp_path)
        assert "user:token" not in result.text
        assert "***@" in result.text
 
 
# -------------------------------------------------------------------
# Step 3: path anonymisation  (T-07)
# -------------------------------------------------------------------
 
class TestStep3PathAnonymisation:
    def test_home_path_replaced(self, tmp_path: Path):
        r = Redactor()
        home = str(Path.home())
        result = r.apply_all(f"config at {home}/something", tmp_path)
        assert "[HOME]" in result.text
        assert home not in result.text
 
    def test_project_root_replaced(self, tmp_path: Path):
        r = Redactor()
        result = r.apply_all(f"file: {tmp_path}/src/main.py", tmp_path)
        assert "[PROJECT]" in result.text
        assert str(tmp_path) not in result.text
 
    def test_t07_info_disclosure_project_root(self, tmp_path: Path):
        """T-07: Absolute project path must not reach the client."""
        r = Redactor()
        output = f"Error in {tmp_path}/oct/mcp/config.py at line 42"
        result = r.apply_all(output, tmp_path)
        assert str(tmp_path) not in result.text
        assert "[PROJECT]" in result.text
 
    def test_t07_home_path_not_disclosed(self, tmp_path: Path):
        """T-07: Home directory path must be anonymised."""
        r = Redactor()
        home = str(Path.home())
        output = f"Audit log at {home}/.oct-mcp/audit.log"
        result = r.apply_all(output, tmp_path)
        assert home not in result.text
 
 
# -------------------------------------------------------------------
# Step 4: ANSI stripping
# -------------------------------------------------------------------
 
class TestStep4AnsiStripping:
    def test_colour_codes_removed(self, tmp_path: Path):
        r = Redactor()
        result = r.apply_all("\x1b[32mOK\x1b[0m", tmp_path)
        assert "\x1b" not in result.text
        assert "OK" in result.text
 
    def test_bold_codes_removed(self, tmp_path: Path):
        r = Redactor()
        result = r.apply_all("\x1b[1mBold\x1b[22m", tmp_path)
        assert "\x1b" not in result.text
        assert "Bold" in result.text
 
    def test_cursor_movement_removed(self, tmp_path: Path):
        r = Redactor()
        result = r.apply_all("line\x1b[Aclear", tmp_path)
        assert "\x1b" not in result.text
 
    def test_clean_text_unchanged(self, tmp_path: Path):
        r = Redactor()
        result = r.apply_all("No ANSI codes here", tmp_path)
        assert result.text == "No ANSI codes here"
        assert result.redactions_applied == 0
 
 
# -------------------------------------------------------------------
# Step 5: truncation
# -------------------------------------------------------------------
 
class TestStep5Truncation:
    def test_output_under_limit_not_truncated(self, tmp_path: Path):
        r = Redactor(max_output_bytes=1024)
        result = r.apply_all("short output", tmp_path)
        assert result.truncated is False
 
    def test_output_over_limit_truncated(self, tmp_path: Path):
        r = Redactor(max_output_bytes=100)
        big = "x" * 200
        result = r.apply_all(big, tmp_path)
        assert result.truncated is True
        assert "TRUNCATED" in result.text
 
    def test_truncation_marker_present(self, tmp_path: Path):
        r = Redactor(max_output_bytes=50)
        result = r.apply_all("a" * 200, tmp_path)
        assert "[OUTPUT TRUNCATED AT 50 BYTES]" in result.text
 
    def test_exactly_at_limit_not_truncated(self, tmp_path: Path):
        r = Redactor(max_output_bytes=100)
        text = "a" * 100  # exactly 100 bytes in UTF-8
        result = r.apply_all(text, tmp_path)
        assert result.truncated is False
 
    def test_original_size_bytes_recorded(self, tmp_path: Path):
        r = Redactor()
        text = "hello world"
        result = r.apply_all(text, tmp_path)
        assert result.original_size_bytes == len(text.encode("utf-8"))
 
 
# -------------------------------------------------------------------
# apply_all — combined / never raises
# -------------------------------------------------------------------
 
class TestApplyAll:
    def test_never_raises_on_empty_text(self, tmp_path: Path):
        r = Redactor()
        result = r.apply_all("", tmp_path)
        assert result.text == ""
 
    def test_returns_redactor_result(self, tmp_path: Path):
        r = Redactor()
        result = r.apply_all("output", tmp_path)
        assert isinstance(result, RedactorResult)
 
    def test_redaction_count_accumulates(self, tmp_path: Path):
        r = Redactor(redaction_patterns=["SECRET"])
        text = "API_KEY=abc\nSECRET\nSECRET"
        result = r.apply_all(text, tmp_path)
        # api_key line + 2 pattern matches
        assert result.redactions_applied >= 3