ss-tools/backend/tests/test_maintenance_api.py

# #region test_maintenance_api [C:3] [TYPE TestModule] [SEMANTICS test, maintenance, api, fastapi, pytest]
# @BRIEF Contract tests for Maintenance Banner API endpoints — T016, T025.
#   Tests POST /start, POST /{id}/end, POST /end-all, GET /events, GET /dashboard-banners,
#   GET /settings, PUT /settings.
# @LAYER Test
# @RELATION BINDS_TO -> [MaintenanceRoutesModule]
# @TEST_CONTRACT: POST /api/maintenance/start -> 202 {task_id, maintenance_id, status}
# @TEST_CONTRACT: POST /api/maintenance/{id}/end -> 202 {task_id, status}
# @TEST_CONTRACT: POST /api/maintenance/end-all -> 202 {task_id, status}
# @TEST_EDGE: missing_tables -> 422 validation error
# @TEST_EDGE: missing_environment_id -> 422 validation error
# @TEST_EDGE: end_time_before_start_time -> 400 validation error
# @TEST_EDGE: non_existent_event_end -> 404 not found
from datetime import UTC, datetime, timedelta
import pytest

# ── Patch GitService at module level to prevent /app/storage/repositories error ──
# Only patch git_service (5-line shim), NOT git._base (233 lines — breaks other tests).
# See test_api_key_routes.py for identical pattern.
import sys
from unittest.mock import AsyncMock, MagicMock

_SAVED_GIT_SERVICE = sys.modules.get('src.services.git_service')

_mock_git_svc_cls = MagicMock()
_mock_git_svc_cls.return_value = MagicMock()
sys.modules['src.services.git_service'] = MagicMock(GitService=_mock_git_svc_cls)


@pytest.fixture(scope="module", autouse=True)
def _restore_git_modules():
    """Restore real git_service module after this module's tests finish."""
    yield
    if _SAVED_GIT_SERVICE is not None:
        sys.modules['src.services.git_service'] = _SAVED_GIT_SERVICE
    else:
        sys.modules.pop('src.services.git_service', None)


# ── Fixtures ──────────────────────────────────────────────────

@pytest.fixture
def client():
    """Create a TestClient with all dependencies mocked."""
    from fastapi.testclient import TestClient

    from src.app import app
    return TestClient(app)


@pytest.fixture(autouse=True)
def auth_mock(client, mock_db):
    """Create a valid API key with maintenance permissions and mock JWT user."""
    from src.app import app
    from src.core.auth.api_key import generate_api_key
    from src.dependencies import get_current_user
    from src.models.api_key import APIKey

    # Create API key for mutation endpoints
    raw, prefix, key_hash = generate_api_key()
    api_key = APIKey(
        key_hash=key_hash,
        prefix=prefix,
        name="Test API Key",
        permissions=["maintenance:start", "maintenance:end", "maintenance:end_all"],
        active=True,
    )
    mock_db.add(api_key)
    mock_db.commit()

    client.headers.update({"X-API-Key": raw})

    # Mock JWT user for read-only endpoints
    mock_role = MagicMock()
    mock_role.name = "Admin"
    mock_role.permissions = []

    mock_user = MagicMock()
    mock_user.username = "test-admin"
    mock_user.roles = [mock_role]

    async def _mock_get_current_user():
        return mock_user

    app.dependency_overrides[get_current_user] = _mock_get_current_user

    yield

    client.headers.pop("X-API-Key", None)
    app.dependency_overrides = {}


@pytest.fixture
def mock_db():
    """Patch get_db dependency to return a clean in-memory session.
    
    Uses StaticPool so all Session() instances share the same connection,
    preventing SQLite threading issues where each :memory: connection
    creates a separate database.
    Creates all tables on the shared Base.metadata.
    """
    from sqlalchemy import create_engine
    from sqlalchemy.orm import sessionmaker
    from sqlalchemy.pool import StaticPool

    from src.dependencies import get_db
    from src.models.maintenance import DashboardScope, MaintenanceSettings
    from src.models.mapping import Base

    # StaticPool ensures all sessions share the same in-memory connection
    engine = create_engine(
        "sqlite:///:memory:",
        poolclass=StaticPool,
        connect_args={"check_same_thread": False},
        echo=False,
    )
    Base.metadata.create_all(engine)
    Session = sessionmaker(bind=engine)
    session = Session()

    # Create default settings
    settings = MaintenanceSettings(
        id="default",
        target_environment_id="test-env",
        display_timezone="UTC",
        banner_template="Test: {message} ({start_time}-{end_time})",
        dashboard_scope=DashboardScope.PUBLISHED_ONLY,
        excluded_dashboard_ids=[],
        forced_dashboard_ids=[],
    )
    session.add(settings)
    session.commit()

    def _get_db_override():
        db = Session()
        try:
            yield db
        finally:
            db.close()

    from src.app import app
    app.dependency_overrides[get_db] = _get_db_override
    yield session
    app.dependency_overrides.pop(get_db, None)
    session.close()


@pytest.fixture
def mock_task_manager():
    """Patch get_task_manager to return a mock."""
    from src.dependencies import get_task_manager

    mock_tm = MagicMock()
    mock_task = MagicMock()
    mock_task.id = "test-task-id-123"
    mock_tm.create_task = AsyncMock(return_value=mock_task)

    from src.app import app
    app.dependency_overrides[get_task_manager] = lambda: mock_tm
    yield mock_tm
    app.dependency_overrides.pop(get_task_manager, None)


# ── T016: POST /api/maintenance/start ─────────────────────────

class TestStartEndpoint:
    """Contract tests for POST /api/maintenance/start."""

    # #region test_start_returns_202 [C:2] [TYPE Function]
    # @BRIEF Valid request returns 202 with task_id and maintenance_id.
    def test_start_returns_202(self, client, mock_db, mock_task_manager):
        response = client.post(
            "/api/maintenance/start",
            json={
                "tables": ["raw.sales"],
                "start_time": (datetime.now(UTC) + timedelta(hours=1)).isoformat(),
                "end_time": (datetime.now(UTC) + timedelta(hours=3)).isoformat(),
                "message": "Test maintenance",
                "environment_id": "test-env",
            },
        )
        assert response.status_code == 202
        data = response.json()
        assert "task_id" in data
        assert "maintenance_id" in data
        assert data["status"] == "pending"
    # #endregion test_start_returns_202

    # #region test_start_missing_tables [C:2] [TYPE Function]
    # @BRIEF Missing tables field returns 422.
    def test_start_missing_tables(self, client, mock_db, mock_task_manager):
        response = client.post(
            "/api/maintenance/start",
            json={
                "start_time": (datetime.now(UTC) + timedelta(hours=1)).isoformat(),
            },
        )
        assert response.status_code == 422
    # #endregion test_start_missing_tables

    # #region test_start_missing_environment_id [C:2] [TYPE Function]
    # @BRIEF Missing environment_id field returns 422.
    # @TEST_EDGE: missing_environment_id -> 422 validation error
    def test_start_missing_environment_id(self, client, mock_db, mock_task_manager):
        response = client.post(
            "/api/maintenance/start",
            json={
                "tables": ["raw.sales"],
                "start_time": (datetime.now(UTC) + timedelta(hours=1)).isoformat(),
                "end_time": (datetime.now(UTC) + timedelta(hours=3)).isoformat(),
                "message": "Test maintenance",
            },
        )
        assert response.status_code == 422
        data = response.json()
        assert any(
            "environment_id" in str(err.get("loc", []))
            for err in (data.get("detail", []) if isinstance(data.get("detail"), list) else [])
        )
    # #endregion test_start_missing_environment_id

    # #region test_start_end_time_before_start [C:2] [TYPE Function]
    # @BRIEF end_time before start_time returns 400.
    def test_start_end_time_before_start(self, client, mock_db, mock_task_manager):
        response = client.post(
            "/api/maintenance/start",
            json={
                "tables": ["raw.sales"],
                "start_time": (datetime.now(UTC) + timedelta(hours=3)).isoformat(),
                "end_time": (datetime.now(UTC) + timedelta(hours=1)).isoformat(),
                "environment_id": "test-env",
            },
        )
        assert response.status_code == 400
    # #endregion test_start_end_time_before_start

    # #region test_start_too_many_tables [C:2] [TYPE Function]
    # @BRIEF More than 100 tables returns 422 (Pydantic validation).
    def test_start_too_many_tables(self, client, mock_db, mock_task_manager):
        tables = [f"raw.table{i}" for i in range(101)]
        response = client.post(
            "/api/maintenance/start",
            json={
                "tables": tables,
                "start_time": (datetime.now(UTC) + timedelta(hours=1)).isoformat(),
                "environment_id": "test-env",
            },
        )
        assert response.status_code == 422
    # #endregion test_start_too_many_tables

    # #region test_start_idempotency [C:2] [TYPE Function]
    # @BRIEF Same (tables, start, end) returns already_active.
    def test_start_idempotency(self, client, mock_db, mock_task_manager):
        from src.models.maintenance import MaintenanceEvent, MaintenanceEventStatus

        payload = {
            "tables": ["raw.sales"],
            "start_time": (datetime.now(UTC) + timedelta(hours=1)).isoformat(),
            "end_time": (datetime.now(UTC) + timedelta(hours=3)).isoformat(),
            "environment_id": "test-env",
        }

        # First call creates event
        response1 = client.post("/api/maintenance/start", json=payload)
        assert response1.status_code == 202

        # Manually set event to ACTIVE so idempotency check finds it
        maintenance_id = response1.json()["maintenance_id"]
        event = mock_db.query(MaintenanceEvent).filter(
            MaintenanceEvent.id == maintenance_id
        ).first()
        if event:
            event.status = MaintenanceEventStatus.ACTIVE
            mock_db.commit()

        # Second call with same params — idempotent
        response2 = client.post("/api/maintenance/start", json=payload)
        assert response2.status_code == 202
        data = response2.json()
        # Should have maintenance_id and status
        assert data.get("maintenance_id") or data.get("status")
    # #endregion test_start_idempotency


# ── T025: POST /api/maintenance/{id}/end ──────────────────────

class TestEndEndpoint:
    """Contract tests for POST /api/maintenance/{id}/end."""

    # #region test_end_returns_202 [C:2] [TYPE Function]
    # @BRIEF Valid maintenance_id returns 202.
    def test_end_returns_202(self, client, mock_db, mock_task_manager):
        from src.models.maintenance import MaintenanceEvent, MaintenanceEventStatus

        event = MaintenanceEvent(
            tables=["raw.sales"],
            start_time=datetime.now(UTC),
            status=MaintenanceEventStatus.ACTIVE,
            environment_id="test-env",
        )
        mock_db.add(event)
        mock_db.commit()

        response = client.post(f"/api/maintenance/{event.id}/end")
        assert response.status_code == 202
        data = response.json()
        assert "task_id" in data
    # #endregion test_end_returns_202

    # #region test_end_not_found [C:2] [TYPE Function]
    # @BRIEF Non-existent maintenance_id returns 404.
    def test_end_not_found(self, client, mock_db, mock_task_manager):
        response = client.post("/api/maintenance/nonexistent-id/end")
        assert response.status_code == 404
    # #endregion test_end_not_found


# ── POST /api/maintenance/end-all ─────────────────────────────

class TestEndAllEndpoint:
    """Contract tests for POST /api/maintenance/end-all."""

    # #region test_end_all_returns_202 [C:2] [TYPE Function]
    # @BRIEF end-all returns 202.
    def test_end_all_returns_202(self, client, mock_db, mock_task_manager):
        response = client.post("/api/maintenance/end-all")
        assert response.status_code == 202
        data = response.json()
        assert "task_id" in data
        assert data["status"] == "pending"
    # #endregion test_end_all_returns_202


# ── GET /api/maintenance/events ───────────────────────────────

class TestEventsEndpoint:
    """Contract tests for GET /api/maintenance/events."""

    # #region test_list_events [C:2] [TYPE Function]
    # @BRIEF Returns active and completed events.
    def test_list_events(self, client, mock_db, mock_task_manager):
        from src.models.maintenance import MaintenanceEvent, MaintenanceEventStatus

        active = MaintenanceEvent(
            tables=["raw.active"],
            start_time=datetime.now(UTC),
            status=MaintenanceEventStatus.ACTIVE,
            environment_id="test-env",
        )
        mock_db.add(active)

        completed = MaintenanceEvent(
            tables=["raw.done"],
            start_time=datetime.now(UTC),
            status=MaintenanceEventStatus.COMPLETED,
            environment_id="test-env",
        )
        mock_db.add(completed)
        mock_db.commit()

        response = client.get("/api/maintenance/events")
        assert response.status_code == 200
        data = response.json()
        assert "active" in data
        assert "completed" in data
    # #endregion test_list_events

    # #region test_expired_event_auto_ends [C:2] [TYPE Function]
    # @BRIEF Event past end_time with ACTIVE status → create_task called with auto-end params.
    def test_expired_event_auto_ends(self, client, mock_db, mock_task_manager):
        from datetime import timedelta

        from src.models.maintenance import MaintenanceEvent, MaintenanceEventStatus

        event = MaintenanceEvent(
            tables=["raw.sales"],
            start_time=datetime.now(UTC) - timedelta(hours=2),
            end_time=datetime.now(UTC) - timedelta(hours=1),
            message="Expired maintenance",
            status=MaintenanceEventStatus.ACTIVE,
            environment_id="test-env",
        )
        mock_db.add(event)
        mock_db.commit()

        response = client.get("/api/maintenance/events")
        assert response.status_code == 200

        mock_task_manager.create_task.assert_called_once_with(
            plugin_id="maintenance_banner_apply",
            params={
                "operation": "end",
                "event_id": event.id,
                "environment_id": "test-env",
                "user": "system",
            },
        )
    # #endregion test_expired_event_auto_ends

    # #region test_future_end_time_skipped [C:2] [TYPE Function]
    # @BRIEF Event with future end_time → no task created, skipped by < now filter.
    def test_future_end_time_skipped(self, client, mock_db, mock_task_manager):
        from datetime import timedelta

        from src.models.maintenance import MaintenanceEvent, MaintenanceEventStatus

        event = MaintenanceEvent(
            tables=["raw.sales"],
            start_time=datetime.now(UTC) + timedelta(hours=1),
            end_time=datetime.now(UTC) + timedelta(hours=3),
            message="Future maintenance",
            status=MaintenanceEventStatus.ACTIVE,
            environment_id="test-env",
        )
        mock_db.add(event)
        mock_db.commit()

        response = client.get("/api/maintenance/events")
        assert response.status_code == 200

        mock_task_manager.create_task.assert_not_called()
    # #endregion test_future_end_time_skipped

    # #region test_no_end_time_skipped [C:2] [TYPE Function]
    # @BRIEF Event with end_time=None → no task created, skipped by isnot(None) filter.
    def test_no_end_time_skipped(self, client, mock_db, mock_task_manager):
        from datetime import timedelta

        from src.models.maintenance import MaintenanceEvent, MaintenanceEventStatus

        event = MaintenanceEvent(
            tables=["raw.sales"],
            start_time=datetime.now(UTC) - timedelta(hours=2),
            end_time=None,
            message="No end time",
            status=MaintenanceEventStatus.ACTIVE,
            environment_id="test-env",
        )
        mock_db.add(event)
        mock_db.commit()

        response = client.get("/api/maintenance/events")
        assert response.status_code == 200

        mock_task_manager.create_task.assert_not_called()
    # #endregion test_no_end_time_skipped


# ── GET /api/maintenance/dashboard-banners ────────────────────

class TestDashboardBannersEndpoint:
    """Contract tests for GET /api/maintenance/dashboard-banners."""

    # #region test_list_banners [C:2] [TYPE Function]
    # @BRIEF Returns list of active banners.
    def test_list_banners(self, client, mock_db, mock_task_manager):
        from src.models.maintenance import (
            MaintenanceDashboardBanner,
            MaintenanceDashboardBannerStatus,
        )

        banner = MaintenanceDashboardBanner(
            environment_id="test-env",
            dashboard_id=101,
            chart_id=12345,
            banner_text="Test",
            status=MaintenanceDashboardBannerStatus.ACTIVE,
        )
        mock_db.add(banner)
        mock_db.commit()

        response = client.get("/api/maintenance/dashboard-banners")
        assert response.status_code == 200
        data = response.json()
        assert isinstance(data, list)
    # #endregion test_list_banners


# ── GET /api/maintenance/settings ─────────────────────────────

class TestSettingsEndpoint:
    """Contract tests for GET/PUT /api/maintenance/settings."""

    # #region test_get_settings [C:2] [TYPE Function]
    # @BRIEF GET returns settings.
    def test_get_settings(self, client, mock_db, mock_task_manager):
        response = client.get("/api/maintenance/settings")
        assert response.status_code == 200
        data = response.json()
        assert "target_environment_id" in data
        assert data["target_environment_id"] == "test-env"
    # #endregion test_get_settings

    # #region test_put_settings [C:2] [TYPE Function]
    # @BRIEF PUT updates settings.
    def test_put_settings(self, client, mock_db, mock_task_manager):
        response = client.put(
            "/api/maintenance/settings",
            json={"display_timezone": "Europe/Moscow"},
        )
        assert response.status_code == 200
        data = response.json()
        assert data["display_timezone"] == "Europe/Moscow"
    # #endregion test_put_settings
# #endregion test_maintenance_api