test_mcp_config.py

Go to the documentation of this file.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# tests/tests_mcp/test_mcp_config.py
 
"""
Purpose
-------
Regression tests for :mod:`oct.mcp.config` — ``McpConfig`` dataclass
and ``load_config()``.
 
Responsibilities
----------------
- Verify default values, JSON loading, and field clamping.
- Verify environment variable overrides.
- Verify file-size guard and malformed JSON fallback.
 
Diagnostics
-----------
Domain: MCP-TESTS
Levels:
    L2 — test lifecycle
    L3 — assertion details
    L4 — deep tracing
 
Contracts
---------
- Config files are written to ``tmp_path``; no real config is modified.
"""
 
from __future__ import annotations
 
import json
import os
from pathlib import Path
 
import pytest
 
from oct.mcp.config import (
    McpConfig,
    VALID_MCP_PROFILES,
    _CONFIG_MAX_BYTES,
    load_config,
    _apply_json,
)
 
 
# -------------------------------------------------------------------
# McpConfig defaults
# -------------------------------------------------------------------
 
class TestMcpConfigDefaults:
    def test_profile_default(self):
        cfg = McpConfig()
        assert cfg.profile == "default"
 
    def test_rate_limit_default(self):
        assert McpConfig().rate_limit_per_minute == 30
 
    def test_timeout_default(self):
        assert McpConfig().timeout_default_seconds == 60
 
    def test_timeout_test_default(self):
        assert McpConfig().timeout_test_seconds == 300
 
    def test_max_output_bytes_default(self):
        assert McpConfig().max_output_bytes == 1_048_576
 
    def test_max_jobs_default(self):
        assert McpConfig().max_jobs == 4
 
    def test_auto_approve_read_tools_default(self):
        assert McpConfig().auto_approve_read_tools is True
 
    def test_dry_run_default(self):
        assert McpConfig().dry_run_default_for_writes is True
 
    def test_redaction_always_on_default(self):
        assert McpConfig().redaction_always_on is False
 
    def test_trust_repo_config_default(self):
        assert McpConfig().trust_repo_config is False
 
    def test_safe_mode_default(self):
        assert McpConfig().safe_mode is False
 
    def test_audit_log_max_files_default(self):
        assert McpConfig().audit_log_max_files == 20
 
    def test_audit_log_max_size_mb_default(self):
        assert McpConfig().audit_log_max_size_mb == 5.0
 
 
# -------------------------------------------------------------------
# VALID_MCP_PROFILES
# -------------------------------------------------------------------
 
class TestValidMcpProfiles:
    def test_contains_default(self):
        assert "default" in VALID_MCP_PROFILES
 
    def test_contains_strict(self):
        assert "strict" in VALID_MCP_PROFILES
 
    def test_contains_airgapped(self):
        assert "airgapped" in VALID_MCP_PROFILES
 
    def test_does_not_contain_admin(self):
        assert "admin" not in VALID_MCP_PROFILES
 
 
# -------------------------------------------------------------------
# load_config — missing file
# -------------------------------------------------------------------
 
class TestLoadConfigMissingFile:
    def test_returns_defaults_when_no_file(self, tmp_path: Path):
        cfg = load_config(tmp_path / "nonexistent.json")
        assert cfg.profile == "default"
        assert cfg.safe_mode is False
 
    def test_returns_mcpconfig_instance(self, tmp_path: Path):
        cfg = load_config(tmp_path / "nonexistent.json")
        assert isinstance(cfg, McpConfig)
 
 
# -------------------------------------------------------------------
# load_config — valid JSON
# -------------------------------------------------------------------
 
class TestLoadConfigValidJson:
    def test_loads_profile(self, tmp_path: Path):
        p = tmp_path / "config.json"
        p.write_text(json.dumps({"profile": "strict"}))
        cfg = load_config(p)
        assert cfg.profile == "strict"
 
    def test_loads_rate_limit(self, tmp_path: Path):
        p = tmp_path / "config.json"
        p.write_text(json.dumps({"rate_limit_per_minute": 10}))
        cfg = load_config(p)
        assert cfg.rate_limit_per_minute == 10
 
    def test_loads_timeout(self, tmp_path: Path):
        p = tmp_path / "config.json"
        p.write_text(json.dumps({"timeout_default_seconds": 90}))
        cfg = load_config(p)
        assert cfg.timeout_default_seconds == 90
 
    def test_loads_trust_repo_config(self, tmp_path: Path):
        p = tmp_path / "config.json"
        p.write_text(json.dumps({"trust_repo_config": True}))
        cfg = load_config(p)
        assert cfg.trust_repo_config is True
 
    def test_loads_audit_log_path(self, tmp_path: Path):
        p = tmp_path / "config.json"
        custom_path = "/custom/audit.log"
        p.write_text(json.dumps({"audit_log_path": custom_path}))
        cfg = load_config(p)
        assert cfg.audit_log_path == custom_path
 
    def test_loads_audit_log_max_files(self, tmp_path: Path):
        p = tmp_path / "config.json"
        p.write_text(json.dumps({"audit_log_max_files": 5}))
        cfg = load_config(p)
        assert cfg.audit_log_max_files == 5
 
    def test_loads_audit_log_max_size_mb(self, tmp_path: Path):
        p = tmp_path / "config.json"
        p.write_text(json.dumps({"audit_log_max_size_mb": 10.0}))
        cfg = load_config(p)
        assert cfg.audit_log_max_size_mb == 10.0
 
 
# -------------------------------------------------------------------
# load_config — field clamping
# -------------------------------------------------------------------
 
class TestLoadConfigClamping:
    def test_rate_limit_clamped_min(self, tmp_path: Path):
        p = tmp_path / "config.json"
        p.write_text(json.dumps({"rate_limit_per_minute": 0}))
        cfg = load_config(p)
        assert cfg.rate_limit_per_minute == 1  # clamped to min
 
    def test_rate_limit_clamped_max(self, tmp_path: Path):
        p = tmp_path / "config.json"
        p.write_text(json.dumps({"rate_limit_per_minute": 9999}))
        cfg = load_config(p)
        assert cfg.rate_limit_per_minute == 1000
 
    def test_timeout_clamped_min(self, tmp_path: Path):
        p = tmp_path / "config.json"
        p.write_text(json.dumps({"timeout_default_seconds": 1}))
        cfg = load_config(p)
        assert cfg.timeout_default_seconds == 5
 
    def test_timeout_clamped_max(self, tmp_path: Path):
        p = tmp_path / "config.json"
        p.write_text(json.dumps({"timeout_default_seconds": 9999}))
        cfg = load_config(p)
        assert cfg.timeout_default_seconds == 300
 
    def test_max_jobs_clamped_min(self, tmp_path: Path):
        p = tmp_path / "config.json"
        p.write_text(json.dumps({"max_jobs": 0}))
        cfg = load_config(p)
        assert cfg.max_jobs == 1
 
    def test_max_jobs_clamped_max(self, tmp_path: Path):
        p = tmp_path / "config.json"
        p.write_text(json.dumps({"max_jobs": 999}))
        cfg = load_config(p)
        assert cfg.max_jobs == 16
 
    def test_audit_log_max_files_clamped(self, tmp_path: Path):
        p = tmp_path / "config.json"
        p.write_text(json.dumps({"audit_log_max_files": 999}))
        cfg = load_config(p)
        assert cfg.audit_log_max_files == 100
 
    def test_audit_log_max_size_mb_clamped(self, tmp_path: Path):
        p = tmp_path / "config.json"
        p.write_text(json.dumps({"audit_log_max_size_mb": 500.0}))
        cfg = load_config(p)
        assert cfg.audit_log_max_size_mb == 100.0
 
 
# -------------------------------------------------------------------
# load_config — invalid/unknown fields are ignored
# -------------------------------------------------------------------
 
class TestLoadConfigRobustness:
    def test_unknown_field_ignored(self, tmp_path: Path):
        p = tmp_path / "config.json"
        p.write_text(json.dumps({"profile": "strict", "unknown_key": "value"}))
        cfg = load_config(p)
        assert cfg.profile == "strict"
 
    def test_invalid_profile_ignored(self, tmp_path: Path):
        p = tmp_path / "config.json"
        p.write_text(json.dumps({"profile": "admin"}))
        cfg = load_config(p)
        assert cfg.profile == "default"  # invalid profile not applied
 
    def test_malformed_json_returns_defaults(self, tmp_path: Path):
        p = tmp_path / "config.json"
        p.write_text("{not valid json}")
        cfg = load_config(p)
        assert cfg.profile == "default"
 
    def test_json_array_not_applied(self, tmp_path: Path):
        p = tmp_path / "config.json"
        p.write_text("[1, 2, 3]")
        cfg = load_config(p)
        assert cfg.profile == "default"
 
    def test_boolean_string_not_applied(self, tmp_path: Path):
        # Only actual JSON booleans should be accepted.
        p = tmp_path / "config.json"
        p.write_text(json.dumps({"auto_approve_read_tools": "true"}))
        cfg = load_config(p)
        assert cfg.auto_approve_read_tools is True  # default unchanged
 
    def test_file_too_large_returns_defaults(self, tmp_path: Path):
        p = tmp_path / "config.json"
        # Write a file larger than 64 KB.
        p.write_bytes(b'{"profile": "strict"}' + b" " * (_CONFIG_MAX_BYTES + 100))
        cfg = load_config(p)
        assert cfg.profile == "default"  # large file not applied
 
 
# -------------------------------------------------------------------
# load_config — environment variable overrides
# -------------------------------------------------------------------
 
class TestLoadConfigEnvOverrides:
    def test_safe_mode_env(self, tmp_path: Path, monkeypatch):
        monkeypatch.setenv("OCT_MCP_SAFE_MODE", "1")
        cfg = load_config(tmp_path / "nonexistent.json")
        assert cfg.safe_mode is True
 
    def test_safe_mode_env_zero_not_applied(self, tmp_path: Path, monkeypatch):
        monkeypatch.setenv("OCT_MCP_SAFE_MODE", "0")
        cfg = load_config(tmp_path / "nonexistent.json")
        assert cfg.safe_mode is False
 
    def test_trust_repo_config_env(self, tmp_path: Path, monkeypatch):
        monkeypatch.setenv("OCT_TRUST_REPO_CONFIG", "1")
        cfg = load_config(tmp_path / "nonexistent.json")
        assert cfg.trust_repo_config is True
 
    def test_profile_env_strict(self, tmp_path: Path, monkeypatch):
        monkeypatch.setenv("OCT_MCP_PROFILE", "strict")
        cfg = load_config(tmp_path / "nonexistent.json")
        assert cfg.profile == "strict"
 
    def test_profile_env_airgapped(self, tmp_path: Path, monkeypatch):
        monkeypatch.setenv("OCT_MCP_PROFILE", "airgapped")
        cfg = load_config(tmp_path / "nonexistent.json")
        assert cfg.profile == "airgapped"
 
    def test_profile_env_invalid_ignored(self, tmp_path: Path, monkeypatch):
        monkeypatch.setenv("OCT_MCP_PROFILE", "superadmin")
        cfg = load_config(tmp_path / "nonexistent.json")
        assert cfg.profile == "default"
 
    def test_env_overrides_file_value(self, tmp_path: Path, monkeypatch):
        p = tmp_path / "config.json"
        p.write_text(json.dumps({"profile": "strict"}))
        monkeypatch.setenv("OCT_MCP_PROFILE", "airgapped")
        cfg = load_config(p)
        assert cfg.profile == "airgapped"