test_mcp_write_tools.py

Go to the documentation of this file.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# tests/tests_mcp/test_mcp_write_tools.py
 
"""
Purpose
-------
Regression tests for Phase 5B write-tool Pydantic models
(:mod:`oct.mcp.validator`) and argv builders (:mod:`oct.mcp.executor`).
 
Responsibilities
----------------
- Verify all 11 write-tool models (defaults, unknown field rejection,
  confirm field).
- Verify ``FormatArgs`` double guard and ``GitCommitArgs`` safety.
- Verify path traversal (T-02) and shell metacharacter rejection.
- Verify strict/airgapped profile blocks write tools.
- Verify argv builder spot-checks (format dry-run, format fix, git
  commit).
- Verify T-06 privilege escalation and T-06b strict-profile denial.
 
Diagnostics
-----------
Domain: MCP-TESTS
Levels:
    L2 — test lifecycle
    L3 — assertion details
    L4 — deep tracing
 
Contracts
---------
- Tests are in-memory validation and policy checks; no subprocess or
  filesystem writes.
"""
 
from __future__ import annotations
 
import sys
from pathlib import Path
 
import pytest
from pydantic import ValidationError
 
from oct.mcp.executor import (
    _build_argv_format,
    _build_argv_git_commit,
    _build_argv_git_changelog,
    _build_argv_git_init,
    _build_argv_new,
    _build_argv_scaffold,
    _build_argv_clean,
    _build_argv_docs,
)
from oct.mcp.policy import McpPolicy, TOOL_MANIFEST
from oct.mcp.validator import (
    FormatArgs,
    DocsArgs,
    ExportSourceArgs,
    NewArgs,
    ScaffoldArgs,
    CleanArgs,
    InstallHooksArgs,
    GitCommitArgs,
    GitHooksInstallArgs,
    GitInitArgs,
    GitChangelogArgs,
    validate_tool_args,
)
 
 
# -------------------------------------------------------------------
# FormatArgs
# -------------------------------------------------------------------
 
class TestFormatArgs:
    def test_defaults(self):
        m = FormatArgs.model_validate({})
        assert m.paths == []
        assert m.apply is False
        assert m.confirm is False
        assert m.changed is False
        assert m.verbose is False
        assert m.json_output is True
 
    def test_unknown_field_rejected(self):
        with pytest.raises(ValidationError):
            FormatArgs.model_validate({"evil_flag": True})
 
    def test_jobs_field_removed(self):
        # OI-502: ``jobs`` was removed from FormatArgs because the CLI
        # formatter does not accept ``--jobs``.
        with pytest.raises(ValidationError):
            FormatArgs.model_validate({"jobs": 1})
 
    def test_path_traversal_rejected(self, tmp_path: Path):
        with pytest.raises(ValidationError):
            FormatArgs.model_validate(
                {"paths": ["../../../etc/passwd"]},
                context={"project_root": tmp_path},
            )
 
    def test_shell_metachar_in_path_rejected(self, tmp_path: Path):
        with pytest.raises(ValidationError):
            FormatArgs.model_validate(
                {"paths": ["src; rm -rf /"]},
                context={"project_root": tmp_path},
            )
 
    def test_apply_and_confirm_accepted(self):
        m = FormatArgs.model_validate({"apply": True, "confirm": True})
        assert m.apply is True
        assert m.confirm is True
 
    def test_t06_apply_true_confirm_false_model_accepts(self):
        """T-06: validator accepts apply=True, confirm=False — HITL gate catches this."""
        m = FormatArgs.model_validate({"apply": True, "confirm": False})
        assert m.apply is True
        assert m.confirm is False  # safety gate will intercept
 
 
# -------------------------------------------------------------------
# DocsArgs
# -------------------------------------------------------------------
 
class TestDocsArgs:
    def test_defaults(self):
        m = DocsArgs.model_validate({})
        assert m.sphinx is False
        assert m.doxygen is False
        assert m.all_docs is False
        assert m.dry_run is True
        assert m.confirm is False
 
    def test_unknown_field_rejected(self):
        with pytest.raises(ValidationError):
            DocsArgs.model_validate({"unknown": True})
 
    def test_valid_args(self):
        m = DocsArgs.model_validate({"sphinx": True, "confirm": True, "dry_run": False})
        assert m.sphinx is True
        assert m.confirm is True
        assert m.dry_run is False
 
 
# -------------------------------------------------------------------
# ExportSourceArgs
# -------------------------------------------------------------------
 
class TestExportSourceArgs:
    def test_defaults(self):
        m = ExportSourceArgs.model_validate({})
        assert m.confirm is False
        assert m.verbose is False
        assert m.single_dir is False
        assert m.warn_secrets is True
        assert m.block_secrets is False
 
    def test_unknown_field_rejected(self):
        with pytest.raises(ValidationError):
            ExportSourceArgs.model_validate({"output_dir": "/tmp"})
 
 
# -------------------------------------------------------------------
# NewArgs
# -------------------------------------------------------------------
 
class TestNewArgs:
    def test_path_required(self):
        with pytest.raises(ValidationError):
            NewArgs.model_validate({})  # path is required
 
    def test_defaults_with_path(self, tmp_path: Path):
        (tmp_path / "src").mkdir()
        m = NewArgs.model_validate(
            {"path": "src/foo.py"},
            context={"project_root": tmp_path},
        )
        assert m.path == "src/foo.py"
        assert m.confirm is False
        assert m.dry_run is True
        assert m.force is False
        assert m.create_test is False
 
    def test_t02_path_traversal_rejected(self, tmp_path: Path):
        """T-02: path traversal in write tool."""
        with pytest.raises(ValidationError):
            NewArgs.model_validate(
                {"path": "../../../etc/cron.d/evil"},
                context={"project_root": tmp_path},
            )
 
    def test_shell_metachar_in_path_rejected(self):
        with pytest.raises(ValidationError):
            NewArgs.model_validate({"path": "src/foo; rm -rf /"})
 
    def test_unknown_field_rejected(self, tmp_path: Path):
        with pytest.raises(ValidationError):
            NewArgs.model_validate({"path": "src/foo.py", "evil": True})
 
 
# -------------------------------------------------------------------
# ScaffoldArgs
# -------------------------------------------------------------------
 
class TestScaffoldArgs:
    def test_name_required(self):
        with pytest.raises(ValidationError):
            ScaffoldArgs.model_validate({})
 
    def test_defaults_with_name(self):
        m = ScaffoldArgs.model_validate({"name": "myproject"})
        assert m.name == "myproject"
        assert m.confirm is False
        assert m.dry_run is True
 
    def test_shell_metachar_in_name_rejected(self):
        with pytest.raises(ValidationError):
            ScaffoldArgs.model_validate({"name": "proj; rm -rf /"})
 
    def test_unknown_field_rejected(self):
        with pytest.raises(ValidationError):
            ScaffoldArgs.model_validate({"name": "myproject", "evil": True})
 
 
# -------------------------------------------------------------------
# CleanArgs
# -------------------------------------------------------------------
 
class TestCleanArgs:
    def test_defaults(self):
        m = CleanArgs.model_validate({})
        assert m.path is None
        assert m.confirm is False
        assert m.dry_run is True
 
    def test_path_traversal_rejected(self, tmp_path: Path):
        with pytest.raises(ValidationError):
            CleanArgs.model_validate(
                {"path": "../../../etc"},
                context={"project_root": tmp_path},
            )
 
    def test_shell_metachar_in_path_rejected(self):
        with pytest.raises(ValidationError):
            CleanArgs.model_validate({"path": "/tmp; rm -rf /"})
 
    def test_none_path_accepted(self):
        m = CleanArgs.model_validate({"path": None})
        assert m.path is None
 
    def test_unknown_field_rejected(self):
        with pytest.raises(ValidationError):
            CleanArgs.model_validate({"evil": True})
 
 
# -------------------------------------------------------------------
# InstallHooksArgs
# -------------------------------------------------------------------
 
class TestInstallHooksArgs:
    def test_defaults(self):
        m = InstallHooksArgs.model_validate({})
        assert m.confirm is False
        assert m.force is False
 
    def test_unknown_field_rejected(self):
        with pytest.raises(ValidationError):
            InstallHooksArgs.model_validate({"no_verify": True})
 
 
# -------------------------------------------------------------------
# GitCommitArgs
# -------------------------------------------------------------------
 
class TestGitCommitArgs:
    def test_message_required(self):
        with pytest.raises(ValidationError):
            GitCommitArgs.model_validate({})
 
    def test_defaults_with_message(self):
        m = GitCommitArgs.model_validate({"message": "feat: add thing"})
        assert m.message == "feat: add thing"
        assert m.confirm is False
        assert m.force is False
 
    def test_t06_no_verify_field_rejected(self):
        """T-06: no_verify must not be accepted — bypassing hooks not permitted."""
        with pytest.raises(ValidationError):
            GitCommitArgs.model_validate({"message": "feat: test", "no_verify": True})
 
    def test_scoped_commit_accepted(self):
        """OI-502: scoped Conventional Commits used to be rejected by the
        shell-metachar validator because ``(`` / ``)`` are shell metas.
        The new validator delegates to :mod:`oct.git.conventional` so
        scoped types round-trip correctly.
        """
        m = GitCommitArgs.model_validate(
            {"message": "feat(core): add validator parity"}
        )
        assert m.message == "feat(core): add validator parity"
 
    def test_breaking_change_marker_accepted(self):
        """OI-502: ``feat!:`` is valid Conventional Commits."""
        m = GitCommitArgs.model_validate(
            {"message": "feat!: drop legacy config"}
        )
        assert m.message.startswith("feat!:")
 
    def test_invalid_conventional_format_rejected(self):
        """Messages that don't match ``type[(scope)]: subject`` are rejected."""
        with pytest.raises(ValidationError):
            GitCommitArgs.model_validate({"message": "just some random text"})
 
    def test_unknown_type_rejected(self):
        with pytest.raises(ValidationError):
            GitCommitArgs.model_validate({"message": "badtype: add x"})
 
    def test_uppercase_subject_rejected(self):
        with pytest.raises(ValidationError):
            GitCommitArgs.model_validate({"message": "feat: Add a thing"})
 
    def test_valid_conventional_commit(self):
        m = GitCommitArgs.model_validate({"message": "feat: add new feature"})
        assert m.message == "feat: add new feature"
 
    def test_unknown_field_rejected(self):
        with pytest.raises(ValidationError):
            GitCommitArgs.model_validate({"message": "feat: test", "evil_flag": True})
 
 
# -------------------------------------------------------------------
# GitHooksInstallArgs
# -------------------------------------------------------------------
 
class TestGitHooksInstallArgs:
    def test_defaults(self):
        m = GitHooksInstallArgs.model_validate({})
        assert m.confirm is False
        assert m.force is False
 
    def test_unknown_field_rejected(self):
        with pytest.raises(ValidationError):
            GitHooksInstallArgs.model_validate({"no_verify": True})
 
 
# -------------------------------------------------------------------
# GitInitArgs
# -------------------------------------------------------------------
 
class TestGitInitArgs:
    def test_defaults(self):
        m = GitInitArgs.model_validate({})
        assert m.confirm is False
        assert m.dry_run is True
        assert m.github is False
        assert m.no_hooks is False
 
    def test_unknown_field_rejected(self):
        with pytest.raises(ValidationError):
            GitInitArgs.model_validate({"evil": True})
 
 
# -------------------------------------------------------------------
# GitChangelogArgs
# -------------------------------------------------------------------
 
class TestGitChangelogArgs:
    def test_defaults(self):
        m = GitChangelogArgs.model_validate({})
        assert m.confirm is False
        assert m.dry_run is True
        assert m.since is None
        assert m.version is None
 
    def test_since_accepted(self):
        m = GitChangelogArgs.model_validate({"since": "v0.14.0"})
        assert m.since == "v0.14.0"
 
    def test_shell_metachar_in_since_rejected(self):
        with pytest.raises(ValidationError):
            GitChangelogArgs.model_validate({"since": "v0.14.0; rm -rf /"})
 
    def test_shell_metachar_in_version_rejected(self):
        with pytest.raises(ValidationError):
            GitChangelogArgs.model_validate({"version": "v0.15.0 && evil"})
 
    def test_unknown_field_rejected(self):
        with pytest.raises(ValidationError):
            GitChangelogArgs.model_validate({"evil": True})
 
 
# -------------------------------------------------------------------
# validate_tool_args() — write tool integration
# -------------------------------------------------------------------
 
class TestValidateToolArgsWriteTools:
    def test_all_write_tools_accepted(self):
        write_tools = [
            ("oct_format", {}),
            ("oct_docs", {}),
            ("oct_export_source", {}),
            ("oct_new", {"path": "src/foo.py"}),
            ("oct_scaffold", {"name": "myproject"}),
            ("oct_clean", {}),
            ("oct_install_hooks", {}),
            ("oct_git_commit", {"message": "feat: add thing"}),
            ("oct_git_hooks_install", {}),
            ("oct_git_init", {}),
            ("oct_git_changelog", {}),
        ]
        for tool_name, args in write_tools:
            result = validate_tool_args(tool_name, args)
            assert result is not None, f"{tool_name} should validate"
 
    def test_write_tool_path_traversal_blocked(self, tmp_path: Path):
        with pytest.raises(ValidationError):
            validate_tool_args(
                "oct_new",
                {"path": "../../evil.py"},
                project_root=tmp_path,
            )
 
    def test_write_tool_unknown_field_blocked(self):
        with pytest.raises(ValidationError):
            validate_tool_args("oct_clean", {"evil_key": True})
 
 
# -------------------------------------------------------------------
# Policy: write tools blocked in strict / airgapped
# -------------------------------------------------------------------
 
class TestWriteToolsPolicy:
    def test_strict_profile_blocks_write_tools(self):
        """T-06b: strict profile must deny all destructive tools."""
        policy = McpPolicy(profile="strict")
        for tool_name in [
            "oct_format", "oct_docs", "oct_export_source", "oct_new",
            "oct_scaffold", "oct_clean", "oct_install_hooks",
            "oct_git_commit", "oct_git_hooks_install", "oct_git_init",
            "oct_git_changelog",
        ]:
            decision = policy.check(tool_name)
            assert not decision.allowed, f"{tool_name} should be denied in strict profile"
            assert decision.policy_rule == "strict_no_destructive"
 
    def test_airgapped_profile_blocks_all_tools(self):
        policy = McpPolicy(profile="airgapped")
        for tool_name in TOOL_MANIFEST:
            decision = policy.check(tool_name)
            assert not decision.allowed
            assert decision.policy_rule == "airgapped_profile"
 
    def test_default_profile_allows_write_tools(self):
        policy = McpPolicy(profile="default")
        for tool_name in [
            "oct_format", "oct_clean", "oct_git_commit",
        ]:
            decision = policy.check(tool_name)
            assert decision.allowed
 
 
# -------------------------------------------------------------------
# Argv builder spot-checks
# -------------------------------------------------------------------
 
class TestArgvBuilders:
    def test_format_dry_run_when_apply_false(self):
        args = {"apply": False, "confirm": True, "paths": [], "jobs": 1}
        cmd = _build_argv_format(args, Path("/project"))
        assert "--dry-run" in cmd
        assert "--fix" not in cmd
 
    def test_format_fix_when_apply_true_confirm_true(self):
        args = {"apply": True, "confirm": True, "paths": [], "jobs": 1}
        cmd = _build_argv_format(args, Path("/project"))
        assert "--fix" in cmd
        assert "--dry-run" not in cmd
 
    def test_format_dry_run_override(self):
        """_dry_run_override=True forces --dry-run even when apply=True."""
        args = {"apply": True, "confirm": True, "_dry_run_override": True, "paths": [], "jobs": 1}
        cmd = _build_argv_format(args, Path("/project"))
        assert "--dry-run" in cmd
        assert "--fix" not in cmd
 
    def test_format_json_output(self):
        args = {"apply": False, "json_output": True, "paths": [], "jobs": 1}
        cmd = _build_argv_format(args, Path("/project"))
        assert "--json" in cmd
 
    def test_git_commit_no_no_verify(self):
        args = {"message": "feat: add thing", "confirm": True, "json_output": True}
        cmd = _build_argv_git_commit(args, Path("/project"))
        assert "--no-verify" not in cmd
        assert "-m" in cmd
        assert "feat: add thing" in cmd
 
    def test_git_commit_force_flag(self):
        args = {"message": "feat: test", "force": True, "json_output": True}
        cmd = _build_argv_git_commit(args, Path("/project"))
        assert "--force" in cmd
 
    def test_git_changelog_dry_run(self):
        args = {"dry_run": True, "json_output": True, "confirm": True}
        cmd = _build_argv_git_changelog(args, Path("/project"))
        assert "--dry-run" in cmd
 
    def test_git_changelog_no_dry_run(self):
        args = {"dry_run": False, "json_output": True, "confirm": True}
        cmd = _build_argv_git_changelog(args, Path("/project"))
        assert "--dry-run" not in cmd
 
    def test_git_init_dry_run(self):
        args = {"dry_run": True, "github": False, "no_hooks": False}
        cmd = _build_argv_git_init(args, Path("/project"))
        assert "--dry-run" in cmd
 
    def test_git_init_no_dry_run(self):
        args = {"dry_run": False, "github": False, "no_hooks": False}
        cmd = _build_argv_git_init(args, Path("/project"))
        assert "--dry-run" not in cmd
 
    def test_new_dry_run(self):
        args = {"path": "src/foo.py", "dry_run": True, "force": False, "create_test": False}
        cmd = _build_argv_new(args, Path("/project"))
        assert "--dry-run" in cmd
        assert "src/foo.py" in cmd
 
    def test_scaffold_dry_run(self):
        args = {"name": "myproject", "dry_run": True}
        cmd = _build_argv_scaffold(args, Path("/project"))
        assert "--dry-run" in cmd
        assert "myproject" in cmd
 
    def test_clean_dry_run(self):
        args = {"path": None, "dry_run": True}
        cmd = _build_argv_clean(args, Path("/project"))
        assert "--dry-run" in cmd
 
    def test_clean_no_dry_run(self):
        args = {"path": None, "dry_run": False}
        cmd = _build_argv_clean(args, Path("/project"))
        assert "--dry-run" not in cmd
 
    def test_docs_all_mode(self):
        args = {"all_docs": True, "dry_run": False, "sphinx": False, "doxygen": False, "clean": False}
        cmd = _build_argv_docs(args, Path("/project"))
        assert "--all" in cmd
 
    def test_docs_dry_run(self):
        args = {"all_docs": False, "dry_run": True, "sphinx": True, "doxygen": False, "clean": False}
        cmd = _build_argv_docs(args, Path("/project"))
        assert "--dry-run" in cmd
        assert "--sphinx" in cmd
 
    def test_argv_starts_with_python_m_oct(self):
        """All builders must use subprocess isolation (sys.executable -m oct)."""
        args = {"apply": False, "paths": [], "jobs": 1}
        cmd = _build_argv_format(args, Path("/project"))
        assert cmd[0] == sys.executable
        assert cmd[1] == "-m"
        assert cmd[2] == "oct"