busya
31680a1bc9
- Auto-expiry: expired events auto-end on GET /events via task manager - Height: _estimate_markdown_height adapted to unit=8px scale with padding detection - CRITICAL-1: removed dead import remove_chart_from_position (QA finding) - CRITICAL-2: added chart alive check in ensure_banner_chart (QA finding) - CRITICAL-3: fixed test assertions update_markdown_chart → update_banner_on_dashboard - @POST contract: fixed return range [2,12] → [19,200] - Tests: 8 new tests (auto-expiry + layout height)
365 lines
16 KiB
Python
365 lines
16 KiB
Python
# #region TestStorageConfigMigration [C:3] [TYPE Module] [SEMANTICS test,storage,config,git]
|
|
# @BRIEF Verify StorageConfig root_path change from "backups" to "/app/storage",
|
|
# ConfigManager fallback without config.json, validate_path behaviour, and
|
|
# GitPlugin shared-config-manager integration.
|
|
# @RELATION BINDS_TO -> [StorageModels]
|
|
# @RELATION BINDS_TO -> [ConfigManager]
|
|
# @RELATION BINDS_TO -> [GitPluginModule]
|
|
# @TEST_EDGE: missing_config_json -> ConfigManager falls back to _default_config when config.json absent
|
|
# @TEST_EDGE: default_root_path -> StorageConfig().root_path == "/app/storage" (was "backups")
|
|
# @TEST_EDGE: invalid_path -> validate_path returns False for /nonexistent/path
|
|
# @TEST_EDGE: git_plugin_uses_shared_config -> GitPlugin.__init__ uses shared config_manager from src.dependencies
|
|
# @TEST_INVARIANT: INV_7 (<400 lines) -> VERIFIED_BY: module_length_within_limits
|
|
# @RATIONALE Orthogonal coverage across 4 projections:
|
|
# P1 (model contract), P4 (traceability from @POST),
|
|
# P2 (decision-memory — GitPlugin no longer reads config.json fallback),
|
|
# P5 (architecture realism — tests match real runtime paths).
|
|
import os
|
|
from pathlib import Path
|
|
import sys
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
|
|
|
|
import pytest
|
|
|
|
# #region TestStorageConfigDefaults [C:2] [TYPE Class]
|
|
# @BRIEF Verify StorageConfig default field values after the root_path change.
|
|
|
|
class TestStorageConfigDefaults:
|
|
"""Verify StorageConfig default field values."""
|
|
|
|
# #region test_root_path_default [C:2] [TYPE Function]
|
|
# @BRIEF StorageConfig().root_path must equal "/app/storage" (was "backups").
|
|
def test_root_path_default(self):
|
|
from src.models.storage import StorageConfig
|
|
|
|
config = StorageConfig()
|
|
assert config.root_path == "/app/storage"
|
|
# #endregion test_root_path_default
|
|
|
|
# #region test_root_path_is_string [C:2] [TYPE Function]
|
|
# @BRIEF root_path is always a str (type safety).
|
|
def test_root_path_is_string(self):
|
|
from src.models.storage import StorageConfig
|
|
|
|
config = StorageConfig()
|
|
assert isinstance(config.root_path, str)
|
|
# #endregion test_root_path_is_string
|
|
|
|
# #region test_other_defaults_unchanged [C:2] [TYPE Function]
|
|
# @BRIEF Other StorageConfig fields were not affected by the root_path change.
|
|
def test_other_defaults_unchanged(self):
|
|
from src.models.storage import StorageConfig
|
|
|
|
config = StorageConfig()
|
|
assert config.backup_path == "backups"
|
|
assert config.repo_path == "repositories"
|
|
assert config.filename_pattern == "{name}_{timestamp}"
|
|
assert config.backup_structure_pattern == "{category}/"
|
|
# #endregion test_other_defaults_unchanged
|
|
|
|
# #region test_global_settings_propagates_storage [C:2] [TYPE Function]
|
|
# @BRIEF GlobalSettings().storage.root_path inherits the StorageConfig default.
|
|
def test_global_settings_propagates_storage(self):
|
|
from src.core.config_models import GlobalSettings
|
|
from src.models.storage import StorageConfig
|
|
|
|
settings = GlobalSettings()
|
|
assert settings.storage.root_path == "/app/storage"
|
|
assert isinstance(settings.storage, StorageConfig)
|
|
# #endregion test_global_settings_propagates_storage
|
|
|
|
# #region test_override_root_path [C:2] [TYPE Function]
|
|
# @BRIEF Explicit root_path overrides the default.
|
|
def test_override_root_path(self):
|
|
from src.models.storage import StorageConfig
|
|
|
|
config = StorageConfig(root_path="/custom/path")
|
|
assert config.root_path == "/custom/path"
|
|
# Other fields should remain at their defaults
|
|
assert config.backup_path == "backups"
|
|
# #endregion test_override_root_path
|
|
|
|
|
|
# #endregion TestStorageConfigDefaults
|
|
|
|
|
|
# #region TestConfigManagerDefaults [C:2] [TYPE Class]
|
|
# @BRIEF Verify ConfigManager produces correct defaults when no config.json exists.
|
|
|
|
class TestConfigManagerDefaults:
|
|
"""Verify ConfigManager initialisation without config.json (DB + file fallback)."""
|
|
|
|
# #region test_init_falls_to_defaults [C:2] [TYPE Function]
|
|
# @BRIEF ConfigManager(…nonexistent…) loads defaults when both DB and config.json are absent.
|
|
# @TEST_FIXTURE: tmp_path + mocked SessionLocal returning no record.
|
|
# @RATIONALE Full path: _load_config → no DB record → _load_from_legacy_file (absent)
|
|
# → _default_config(). Ensures the entire chain works without config.json.
|
|
def test_init_falls_to_defaults(self, tmp_path: Path):
|
|
nonexistent = tmp_path / "no_config.json"
|
|
|
|
with patch("src.core.config_manager.SessionLocal") as mock_sl:
|
|
mock_session = MagicMock()
|
|
mock_sl.return_value = mock_session
|
|
mock_session.query.return_value.filter.return_value.first.return_value = None
|
|
|
|
from src.core.config_manager import ConfigManager
|
|
|
|
cm = ConfigManager(config_path=str(nonexistent))
|
|
config = cm.get_config()
|
|
|
|
# Core assertions
|
|
assert config.settings.storage.root_path == "/app/storage"
|
|
assert config.settings.logging.level == "INFO"
|
|
assert config.environments == []
|
|
# #endregion test_init_falls_to_defaults
|
|
|
|
# #region test_default_config_root_path [C:2] [TYPE Function]
|
|
# @BRIEF _default_config() hardcodes root_path == "/app/storage" via StorageConfig default.
|
|
def test_default_config_root_path(self):
|
|
from src.core.config_manager import ConfigManager
|
|
|
|
with patch("src.core.config_manager.SessionLocal") as mock_sl:
|
|
mock_session = MagicMock()
|
|
mock_sl.return_value = mock_session
|
|
mock_session.query.return_value.filter.return_value.first.return_value = None
|
|
|
|
cm = ConfigManager(config_path="/nonexistent-test-defaults.json")
|
|
config = cm.get_config()
|
|
|
|
assert config.settings.storage.root_path == "/app/storage"
|
|
# #endregion test_default_config_root_path
|
|
|
|
# #region test_features_from_env_still_applied [C:2] [TYPE Function]
|
|
# @BRIEF Even without config.json, _apply_features_from_env runs during default init.
|
|
def test_features_from_env_still_applied(self, tmp_path: Path):
|
|
nonexistent = tmp_path / "no_config.json"
|
|
|
|
with patch("src.core.config_manager.SessionLocal") as mock_sl:
|
|
mock_session = MagicMock()
|
|
mock_sl.return_value = mock_session
|
|
mock_session.query.return_value.filter.return_value.first.return_value = None
|
|
|
|
with patch.dict(os.environ, {"FEATURES__DATASET_REVIEW": "false"}, clear=False):
|
|
from src.core.config_manager import ConfigManager
|
|
|
|
cm = ConfigManager(config_path=str(nonexistent))
|
|
config = cm.get_config()
|
|
|
|
assert config.settings.features.dataset_review is False
|
|
assert config.settings.storage.root_path == "/app/storage"
|
|
# #endregion test_features_from_env_still_applied
|
|
|
|
|
|
# #endregion TestConfigManagerDefaults
|
|
|
|
|
|
# #region TestValidatePath [C:2] [TYPE Class]
|
|
# @BRIEF Verify ConfigManager.validate_path contract.
|
|
|
|
class TestValidatePath:
|
|
"""Verify validate_path creates writable directories and rejects invalid paths."""
|
|
|
|
# #region test_validate_path_creates_directory [C:2] [TYPE Function]
|
|
# @BRIEF validate_path creates the target directory and returns (True, "OK").
|
|
# @TEST_FIXTURE: tmp_path ensures no side effects on real storage.
|
|
def test_validate_path_creates_directory(self, tmp_path: Path):
|
|
target = tmp_path / "app" / "storage"
|
|
assert not target.exists()
|
|
|
|
with patch("src.core.config_manager.SessionLocal") as mock_sl:
|
|
mock_session = MagicMock()
|
|
mock_sl.return_value = mock_session
|
|
mock_session.query.return_value.filter.return_value.first.return_value = None
|
|
|
|
from src.core.config_manager import ConfigManager
|
|
|
|
cm = ConfigManager(config_path=str(tmp_path / "cfg.json"))
|
|
|
|
is_valid, message = cm.validate_path(str(target))
|
|
|
|
assert is_valid is True
|
|
assert message == "OK"
|
|
assert target.exists()
|
|
assert target.is_dir()
|
|
# #endregion test_validate_path_creates_directory
|
|
|
|
# #region test_validate_path_already_exists [C:2] [TYPE Function]
|
|
# @BRIEF validate_path succeeds when the directory already exists.
|
|
def test_validate_path_already_exists(self, tmp_path: Path):
|
|
existing = tmp_path / "existing" / "storage"
|
|
existing.mkdir(parents=True)
|
|
|
|
with patch("src.core.config_manager.SessionLocal") as mock_sl:
|
|
mock_session = MagicMock()
|
|
mock_sl.return_value = mock_session
|
|
mock_session.query.return_value.filter.return_value.first.return_value = None
|
|
|
|
from src.core.config_manager import ConfigManager
|
|
|
|
cm = ConfigManager(config_path=str(tmp_path / "cfg.json"))
|
|
|
|
is_valid, message = cm.validate_path(str(existing))
|
|
|
|
assert is_valid is True
|
|
assert message == "OK"
|
|
# #endregion test_validate_path_already_exists
|
|
|
|
# #region test_validate_path_nonexistent_root [C:2] [TYPE Function]
|
|
# @BRIEF validate_path returns False for a path under / (non-writable by non-root).
|
|
# @RATIONALE /nonexistent/path cannot be created by a non-root user.
|
|
# Skip when running as root because root can create directories anywhere.
|
|
@pytest.mark.skipif(
|
|
os.geteuid() == 0,
|
|
reason="Cannot test permission-denied path as root",
|
|
)
|
|
def test_validate_path_nonexistent_root(self):
|
|
with patch("src.core.config_manager.SessionLocal") as mock_sl:
|
|
mock_session = MagicMock()
|
|
mock_sl.return_value = mock_session
|
|
mock_session.query.return_value.filter.return_value.first.return_value = None
|
|
|
|
from src.core.config_manager import ConfigManager
|
|
|
|
cm = ConfigManager(config_path="/tmp/__nonexistent_test_cfg.json")
|
|
|
|
is_valid, message = cm.validate_path("/nonexistent/path")
|
|
|
|
assert is_valid is False
|
|
assert isinstance(message, str)
|
|
assert len(message) > 0
|
|
# #endregion test_validate_path_nonexistent_root
|
|
|
|
# #region test_validate_path_read_only_parent [C:2] [TYPE Function]
|
|
# @BRIEF validate_path returns False when the parent directory is not writable.
|
|
def test_validate_path_read_only_parent(self, tmp_path: Path):
|
|
import stat
|
|
|
|
read_only_parent = tmp_path / "readonly_parent"
|
|
read_only_parent.mkdir()
|
|
# Remove write permission from parent
|
|
read_only_parent.chmod(stat.S_IRUSR | stat.S_IXUSR)
|
|
|
|
child = read_only_parent / "subdir"
|
|
|
|
with patch("src.core.config_manager.SessionLocal") as mock_sl:
|
|
mock_session = MagicMock()
|
|
mock_sl.return_value = mock_session
|
|
mock_session.query.return_value.filter.return_value.first.return_value = None
|
|
|
|
from src.core.config_manager import ConfigManager
|
|
|
|
cm = ConfigManager(config_path=str(tmp_path / "cfg.json"))
|
|
|
|
is_valid, message = cm.validate_path(str(child))
|
|
|
|
assert is_valid is False
|
|
assert isinstance(message, str)
|
|
# #endregion test_validate_path_read_only_parent
|
|
|
|
|
|
# #endregion TestValidatePath
|
|
|
|
|
|
# #region TestGitPluginConfigIntegration [C:2] [TYPE Class]
|
|
# @BRIEF Verify GitPlugin uses shared config_manager from src.dependencies (no config.json fallback).
|
|
|
|
class TestGitPluginConfigIntegration:
|
|
"""Verify GitPlugin shares config_manager without re-reading config.json."""
|
|
|
|
# #region test_git_plugin_uses_shared_config_manager [C:2] [TYPE Function]
|
|
# @BRIEF GitPlugin.__init__ picks up the shared config_manager from src.dependencies.
|
|
# @TEST_FIXTURE: mock GitService to avoid real git initialisation.
|
|
def test_git_plugin_uses_shared_config_manager(self):
|
|
mock_config_manager = MagicMock()
|
|
mock_config_manager.get_environments.return_value = []
|
|
|
|
with (
|
|
patch("src.plugins.git_plugin.GitService") as mock_git_svc,
|
|
patch("src.dependencies.config_manager", mock_config_manager),
|
|
):
|
|
from src.plugins.git_plugin import GitPlugin
|
|
|
|
plugin = GitPlugin()
|
|
|
|
# Prove the shared instance is used, NOT a freshly-created ConfigManager
|
|
assert plugin.config_manager is mock_config_manager
|
|
assert plugin.config_manager.get_environments() == []
|
|
mock_git_svc.assert_called_once()
|
|
# #endregion test_git_plugin_uses_shared_config_manager
|
|
|
|
# #region test_git_plugin_fallback_creates_new [C:2] [TYPE Function]
|
|
# @BRIEF When from src.dependencies import config_manager fails,
|
|
# GitPlugin falls back to ConfigManager().
|
|
# @RATIONALE The try/except in GitPlugin.__init__ guards against import
|
|
# failure. This test forces the fallback by removing config_manager
|
|
# from dependencies module dict before the import executes.
|
|
def test_git_plugin_fallback_creates_new(self):
|
|
import src.dependencies
|
|
|
|
# Remove config_manager so 'from src.dependencies import config_manager' raises ImportError
|
|
saved = getattr(src.dependencies, "config_manager", None)
|
|
if "config_manager" in src.dependencies.__dict__:
|
|
del src.dependencies.__dict__["config_manager"]
|
|
|
|
with (
|
|
patch("src.plugins.git_plugin.GitService") as mock_git_svc,
|
|
patch("src.plugins.git_plugin.ConfigManager") as mock_cm_cls,
|
|
):
|
|
from src.plugins.git_plugin import GitPlugin
|
|
|
|
plugin = GitPlugin()
|
|
|
|
mock_cm_cls.assert_called_once()
|
|
assert plugin.config_manager is mock_cm_cls.return_value
|
|
mock_git_svc.assert_called_once()
|
|
# Restore to avoid side effects in other tests
|
|
src.dependencies.config_manager = saved
|
|
# #endregion test_git_plugin_fallback_creates_new
|
|
|
|
|
|
# #endregion TestGitPluginConfigIntegration
|
|
|
|
|
|
# #region TestRegressionGuard [C:2] [TYPE Class]
|
|
# @BRIEF Guard against regressions in existing test contracts and stale assertions.
|
|
|
|
class TestRegressionGuard:
|
|
"""Detect stale assertions in sibling test files."""
|
|
|
|
# #region test_existing_test_would_fail [C:2] [TYPE Function]
|
|
# @BRIEF Existing test_storage_audit_fixes.py still asserts root_path=="backups" (WRONG).
|
|
# @RATIONALE The sibling test at test_storage_audit_fixes.py:66 contains
|
|
# `assert config.root_path == "backups"` which is now a stale assertion.
|
|
# This test documents the intentional break and serves as a canary
|
|
# until that file is updated.
|
|
def test_existing_test_would_fail(self):
|
|
from src.models.storage import StorageConfig
|
|
|
|
config = StorageConfig()
|
|
# The OLD default was "backups"; the NEW default is "/app/storage".
|
|
# This assertion does NOT match the old test!
|
|
assert config.root_path == "/app/storage"
|
|
assert config.root_path != "backups", (
|
|
"Stale assertion in test_storage_audit_fixes.py:66 expects 'backups'. "
|
|
"Update that file after confirming this change is intentional."
|
|
)
|
|
# #endregion test_existing_test_would_fail
|
|
|
|
# #region test_storage_settings_endpoint_shape [C:2] [TYPE Function]
|
|
# @BRIEF The API response shape for storage settings is still StorageConfig.
|
|
def test_storage_settings_endpoint_shape(self):
|
|
from src.models.storage import StorageConfig
|
|
|
|
schema = StorageConfig.model_json_schema()
|
|
props = schema.get("properties", {})
|
|
assert "root_path" in props
|
|
assert props["root_path"]["default"] == "/app/storage"
|
|
assert props["backup_path"]["default"] == "backups"
|
|
# #endregion test_storage_settings_endpoint_shape
|
|
|
|
|
|
# #endregion TestRegressionGuard
|
|
# #endregion TestStorageConfigMigration
|