test_option_c_dir.py

Go to the documentation of this file.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# tests/tests_core/test_option_c_dir.py
 
"""
Purpose
-------
FS-539 regression tests — :mod:`oct.core.option_c_dir` resolves paths
to the canonical ``.option_c/`` project dotdir with a legacy fallback
so in-flight migrations keep working for one release.
 
Responsibilities
----------------
- ``option_c_dir(root)`` returns ``root/.option_c``.
- ``resolve_octrc`` prefers ``.option_c/octrc.json``, falling back to
  ``root/.octrc.json``.
- ``resolve_debug_config`` prefers ``.option_c/debug_config.json``,
  then ``oc_diagnostics/debug_config.json``, then legacy
  ``diagnostics/debug_config.json``.
- ``resolve_logs_dir`` prefers ``.option_c/logs``, falls back to
  ``root/logs``.
- ``load_oc_status`` returns ``None`` when the file is missing and an
  :class:`OcStatus` dataclass when present.
 
Diagnostics
-----------
Domain: CORE-TESTS
    Levels:
        L2 — test lifecycle
        L3 — assertion details
        L4 — deep tracing
 
Contracts
---------
- All path-resolution tests use ``tmp_path`` as the project root.
"""
 
from __future__ import annotations
 
import json
from pathlib import Path
 
import pytest
 
from oct.core.option_c_dir import (
    OPTION_C_DIRNAME,
    OC_STATUS_FILENAME,
    OcStatus,
    load_oc_status,
    option_c_dir,
    resolve_debug_config,
    resolve_logs_dir,
    resolve_octrc,
    write_oc_status,
)
 
 
# ---------------------------------------------------------------------
# Constants
# ---------------------------------------------------------------------
 
 
def test_option_c_dirname_is_lowercase_dotdir():
    assert OPTION_C_DIRNAME == ".option_c"
 
 
def test_oc_status_filename_is_json():
    assert OC_STATUS_FILENAME == "oc_status.json"
 
 
def test_option_c_dir_joins_root(tmp_path: Path):
    assert option_c_dir(tmp_path) == tmp_path / ".option_c"
 
 
# ---------------------------------------------------------------------
# resolve_octrc
# ---------------------------------------------------------------------
 
 
class TestResolveOctrc:
    def test_prefers_option_c_when_present(self, tmp_path: Path):
        (tmp_path / ".option_c").mkdir()
        modern = tmp_path / ".option_c" / "octrc.json"
        modern.write_text("{}", encoding="utf-8")
        legacy = tmp_path / ".octrc.json"
        legacy.write_text("{}", encoding="utf-8")
 
        assert resolve_octrc(tmp_path) == modern
 
    def test_falls_back_to_legacy_when_modern_absent(self, tmp_path: Path):
        legacy = tmp_path / ".octrc.json"
        legacy.write_text("{}", encoding="utf-8")
 
        assert resolve_octrc(tmp_path) == legacy
 
    def test_returns_legacy_path_when_nothing_exists(self, tmp_path: Path):
        # The resolver must not raise when neither path exists; the loader
        # handles the missing-file case. It returns the legacy path so the
        # "file not found" error points the user at the expected location
        # rather than a brand-new .option_c/ they haven't migrated to.
        result = resolve_octrc(tmp_path)
        assert result == tmp_path / ".octrc.json"
 
 
# ---------------------------------------------------------------------
# resolve_debug_config
# ---------------------------------------------------------------------
 
 
class TestResolveDebugConfig:
    def test_prefers_option_c_dir(self, tmp_path: Path):
        (tmp_path / ".option_c").mkdir()
        modern = tmp_path / ".option_c" / "debug_config.json"
        modern.write_text("{}", encoding="utf-8")
        (tmp_path / "oc_diagnostics").mkdir()
        (tmp_path / "oc_diagnostics" / "debug_config.json").write_text(
            "{}", encoding="utf-8",
        )
 
        assert resolve_debug_config(tmp_path) == modern
 
    def test_falls_back_to_oc_diagnostics(self, tmp_path: Path):
        (tmp_path / "oc_diagnostics").mkdir()
        legacy = tmp_path / "oc_diagnostics" / "debug_config.json"
        legacy.write_text("{}", encoding="utf-8")
 
        assert resolve_debug_config(tmp_path) == legacy
 
    def test_falls_back_to_very_old_diagnostics(self, tmp_path: Path):
        (tmp_path / "diagnostics").mkdir()
        very_legacy = tmp_path / "diagnostics" / "debug_config.json"
        very_legacy.write_text("{}", encoding="utf-8")
 
        assert resolve_debug_config(tmp_path) == very_legacy
 
 
# ---------------------------------------------------------------------
# resolve_logs_dir
# ---------------------------------------------------------------------
 
 
class TestResolveLogsDir:
    def test_prefers_option_c_logs(self, tmp_path: Path):
        modern = tmp_path / ".option_c" / "logs"
        modern.mkdir(parents=True)
        (tmp_path / "logs").mkdir()
 
        assert resolve_logs_dir(tmp_path) == modern
 
    def test_falls_back_to_root_logs(self, tmp_path: Path):
        legacy = tmp_path / "logs"
        legacy.mkdir()
 
        assert resolve_logs_dir(tmp_path) == legacy
 
    def test_returns_legacy_on_unmigrated_project(self, tmp_path: Path):
        # No .option_c/ and no logs/ — an unmigrated working tree should
        # get the legacy path so legacy callers don't see surprise
        # .option_c/ creation. Fresh scaffolds materialise .option_c/
        # up-front, so the resolver then switches to the modern path.
        result = resolve_logs_dir(tmp_path)
        assert result == tmp_path / "logs"
 
    def test_returns_option_c_path_when_dotdir_exists(self, tmp_path: Path):
        # .option_c/ present (scaffold / migrate created it), logs subdir
        # not yet created — the resolver returns the modern path so the
        # first write lands under .option_c/logs/.
        (tmp_path / ".option_c").mkdir()
        result = resolve_logs_dir(tmp_path)
        assert result == tmp_path / ".option_c" / "logs"
 
 
# ---------------------------------------------------------------------
# OcStatus + read/write
# ---------------------------------------------------------------------
 
 
class TestOcStatus:
    def test_load_returns_none_when_missing(self, tmp_path: Path):
        assert load_oc_status(tmp_path) is None
 
    def test_load_returns_none_when_invalid_json(self, tmp_path: Path):
        (tmp_path / ".option_c").mkdir()
        (tmp_path / ".option_c" / "oc_status.json").write_text(
            "{ not json", encoding="utf-8",
        )
        assert load_oc_status(tmp_path) is None
 
    def test_write_and_round_trip(self, tmp_path: Path):
        status = OcStatus(
            stage="compliant",
            pillars={
                "linter": {"enabled": True, "since": "2026-04-16"},
                "diagnostics": {"enabled": True, "since": "2026-04-16"},
                "git": {"enabled": False, "since": None},
                "docs": {"enabled": True, "since": "2026-04-16"},
                "tests": {"enabled": True, "since": "2026-04-16"},
                "scaffold": {"enabled": True, "since": "2026-04-16"},
            },
            migrated_from={},
            oct_version_at_migration="0.19.0",
        )
        write_oc_status(tmp_path, status)
 
        path = tmp_path / ".option_c" / "oc_status.json"
        assert path.is_file()
 
        loaded = load_oc_status(tmp_path)
        assert loaded is not None
        assert loaded.stage == "compliant"
        assert loaded.pillars["git"]["enabled"] is False
        assert loaded.oct_version_at_migration == "0.19.0"
 
    def test_write_creates_option_c_dir_if_missing(self, tmp_path: Path):
        status = OcStatus(
            stage="bootstrap",
            pillars={},
            migrated_from={},
            oct_version_at_migration="0.19.0",
        )
        write_oc_status(tmp_path, status)
 
        assert (tmp_path / ".option_c").is_dir()
        assert (tmp_path / ".option_c" / "oc_status.json").is_file()
 
    def test_write_emits_schema_version(self, tmp_path: Path):
        status = OcStatus(
            stage="compliant",
            pillars={},
            migrated_from={},
            oct_version_at_migration="0.19.0",
        )
        write_oc_status(tmp_path, status)
 
        raw = json.loads(
            (tmp_path / ".option_c" / "oc_status.json").read_text(
                encoding="utf-8",
            )
        )
        assert raw["_schema_version"] == "1.0"
 
    def test_invalid_stage_rejected(self):
        with pytest.raises(ValueError):
            OcStatus(
                stage="banana",  # type: ignore[arg-type]
                pillars={},
                migrated_from={},
                oct_version_at_migration="0.19.0",
            )