@ngocsangairvds/vsaf 3.2.13 → 3.2.15

package/tools/vds-scripts/progress_report_orchestrator/tests/integration/test_checkpoint.py

@@ -1,276 +0,0 @@
-"""Integration tests for TSK-D.1 + TSK-D.3: Checkpoint and delta DB helpers.
-
-Requires testcontainers[postgres] and a running Docker daemon.
-Run with: pytest tests/integration/ -m integration
-
-These tests create a real Postgres schema via testcontainers — not SQLite —
-because schema.py uses JSONB, TIMESTAMPTZ, and SERIAL which SQLite cannot
-faithfully replicate (see Appendix C: Test Strategy).
-"""
-
-from __future__ import annotations
-
-import pytest
-
-# testcontainers is an optional dev dependency; skip gracefully if missing.
-pytest.importorskip("testcontainers", reason="testcontainers not installed")
-
-from testcontainers.postgres import PostgresContainer
-
-from progress_report_orchestrator.state.schema import (
-    check_schema_status,
-    complete_run,
-    create_run,
-    fail_run,
-    get_previous_run_scores,
-    get_run,
-    phase_already_done,
-    save_fr_assessments,
-    update_run_phase,
-)
-
-# ---------------------------------------------------------------------------
-# Schema bootstrap for tests — phase P4 replaces ``init_schema()`` with Alembic.
-#
-# We invoke ``alembic upgrade head`` programmatically against the testcontainer
-# DSN so the integration tests exercise the *real* migration code path. Search
-# path is set at the DB level so the existing schema.py runtime helpers (which
-# emit unqualified SQL like ``INSERT INTO progress_runs ...``) keep working.
-# ---------------------------------------------------------------------------
-
-
-def _alembic_upgrade(dsn: str) -> None:
-    import os
-    import pathlib
-
-    from alembic.config import Config
-
-    from alembic import command
-
-    repo_root = pathlib.Path(__file__).resolve().parents[2]  # progress_report_orchestrator/
-    cfg = Config(str(repo_root / "alembic.ini"))
-    cfg.set_main_option("script_location", str(repo_root / "alembic"))
-    cfg.attributes["configure_logger"] = False
-    # env.py reads DATABASE_URL from os.environ (resolve_database_url).
-    # -x db= CLI args are not consumed by the shared runtime, so set the env var.
-    os.environ["DATABASE_URL"] = dsn
-    command.upgrade(cfg, "head")
-
-
-# ---------------------------------------------------------------------------
-# Session-scoped Postgres container (one container per test session)
-# ---------------------------------------------------------------------------
-
-
-@pytest.fixture(scope="session")
-def pg_dsn():
-    """Start a Postgres container and yield its DSN.  Container is stopped at end."""
-    pytest.importorskip("alembic", reason="alembic not installed")
-    with PostgresContainer("postgres:16-alpine") as pg:
-        dsn = pg.get_connection_url().replace("postgresql+psycopg2://", "postgresql://")
-
-        # Set search_path at the DB level so unqualified runtime DML in
-        # state/schema.py resolves to the ``progress`` schema. This mirrors
-        # the production posture (ALTER DATABASE vds_platform SET search_path
-        # TO progress, public).
-        import psycopg
-
-        # Create the progress schema before Alembic runs — the first migration
-        # writes to progress.alembic_version which requires the schema to exist.
-        with psycopg.connect(dsn, autocommit=True) as conn, conn.cursor() as cur:
-            cur.execute("CREATE SCHEMA IF NOT EXISTS progress")
-
-        # Apply the Alembic migration (creates progress.* tables).
-        _alembic_upgrade(dsn)
-
-        with psycopg.connect(dsn, autocommit=True) as conn, conn.cursor() as cur:
-            cur.execute("ALTER DATABASE test SET search_path TO progress, public")
-        yield dsn
-
-
-@pytest.fixture(autouse=True)
-def fresh_schema(pg_dsn):
-    """Truncate tables between tests to isolate without re-creating containers."""
-    yield
-    import psycopg
-
-    tables = [
-        "progress.fr_assessments",
-        "progress.service_analyses",
-        "progress.document_hashes",
-        "progress.daily_scores",
-        "progress.progress_runs",
-    ]
-    with psycopg.connect(pg_dsn) as conn:
-        with conn.cursor() as cur:
-            cur.execute(f"TRUNCATE {', '.join(tables)} RESTART IDENTITY CASCADE")
-        conn.commit()
-
-
-# ---------------------------------------------------------------------------
-# Schema initialisation
-# ---------------------------------------------------------------------------
-
-
-@pytest.mark.integration
-class TestSchemaInit:
-    def test_all_tables_present_after_init(self, pg_dsn):
-        status = check_schema_status(pg_dsn)
-        assert all(status.values()), f"Missing tables: {[k for k, v in status.items() if not v]}"
-
-    def test_alembic_upgrade_is_idempotent(self, pg_dsn):
-        # alembic upgrade head must be a no-op on an already-upgraded DB.
-        _alembic_upgrade(pg_dsn)
-        status = check_schema_status(pg_dsn)
-        assert all(status.values())
-
-
-# ---------------------------------------------------------------------------
-# create_run / get_run / update_run_phase / complete_run / fail_run
-# ---------------------------------------------------------------------------
-
-
-@pytest.mark.integration
-class TestRunLifecycle:
-    def test_create_and_get_run(self, pg_dsn):
-        create_run(pg_dsn, "run-001", "INSURANCE-AI")
-        row = get_run(pg_dsn, "run-001")
-        assert row is not None
-        assert row["run_id"] == "run-001"
-        assert row["project_key"] == "INSURANCE-AI"
-        assert row["status"] == "running"
-        assert row["completed_phase"] is None
-
-    def test_get_run_returns_none_for_missing(self, pg_dsn):
-        assert get_run(pg_dsn, "does-not-exist") is None
-
-    def test_update_run_phase(self, pg_dsn):
-        create_run(pg_dsn, "run-002", "INSURANCE-AI")
-        update_run_phase(pg_dsn, "run-002", "sync")
-        row = get_run(pg_dsn, "run-002")
-        assert row["completed_phase"] == "sync"
-
-    def test_complete_run(self, pg_dsn):
-        create_run(pg_dsn, "run-003", "INSURANCE-AI")
-        complete_run(pg_dsn, "run-003", 75.5)
-        row = get_run(pg_dsn, "run-003")
-        assert row["status"] == "complete"
-        assert abs(row["overall_score"] - 75.5) < 0.001
-
-    def test_fail_run(self, pg_dsn):
-        create_run(pg_dsn, "run-004", "INSURANCE-AI")
-        fail_run(pg_dsn, "run-004", "Phase sync failed: timeout")
-        row = get_run(pg_dsn, "run-004")
-        assert row["status"] == "failed"
-        assert "timeout" in row["error"]
-
-    def test_create_run_on_conflict_does_nothing(self, pg_dsn):
-        """Duplicate run_id must not raise (ON CONFLICT DO NOTHING)."""
-        create_run(pg_dsn, "run-dup", "INSURANCE-AI")
-        create_run(pg_dsn, "run-dup", "INSURANCE-AI")  # must not raise
-        row = get_run(pg_dsn, "run-dup")
-        assert row is not None
-
-    def test_fail_run_truncates_long_error(self, pg_dsn):
-        """Error strings longer than 4000 chars must not cause DB errors."""
-        create_run(pg_dsn, "run-long", "INSURANCE-AI")
-        long_error = "x" * 10_000
-        fail_run(pg_dsn, "run-long", long_error)  # must not raise
-        row = get_run(pg_dsn, "run-long")
-        assert row["status"] == "failed"
-
-
-# ---------------------------------------------------------------------------
-# save_fr_assessments + get_previous_run_scores (delta query)
-# ---------------------------------------------------------------------------
-
-
-@pytest.mark.integration
-class TestDeltaQueries:
-    def _make_assessment(self, fr_id: str, score: float):
-        """Create a real FRAssessment with a controlled overall_score."""
-        from progress_report_orchestrator.models.analysis import FRAssessment
-
-        a = FRAssessment(
-            fr_id=fr_id,
-            service_exists=True,
-            doc_chain_complete=True,
-            brd_traced=True,
-            code_activity_score=50.0,
-            test_coverage_score=40.0,
-        )
-        a.overall_score = score
-        return a
-
-    def test_no_previous_run_returns_empty(self, pg_dsn):
-        prev_id, scores = get_previous_run_scores(pg_dsn, "INSURANCE-AI")
-        assert prev_id is None
-        assert scores == {}
-
-    def test_returns_scores_from_latest_completed_run(self, pg_dsn):
-        # Create a completed run with assessments
-        create_run(pg_dsn, "prev-run", "INSURANCE-AI")
-        assessments = [self._make_assessment("FR1", 60.0), self._make_assessment("FR2", 80.0)]
-        save_fr_assessments(pg_dsn, "prev-run", assessments)
-        complete_run(pg_dsn, "prev-run", 70.0)
-
-        prev_id, scores = get_previous_run_scores(pg_dsn, "INSURANCE-AI")
-        assert prev_id == "prev-run"
-        assert abs(scores["FR1"] - 60.0) < 0.001
-        assert abs(scores["FR2"] - 80.0) < 0.001
-
-    def test_excludes_current_run(self, pg_dsn):
-        create_run(pg_dsn, "old-run", "INSURANCE-AI")
-        save_fr_assessments(pg_dsn, "old-run", [self._make_assessment("FR1", 50.0)])
-        complete_run(pg_dsn, "old-run", 50.0)
-
-        create_run(pg_dsn, "cur-run", "INSURANCE-AI")
-        complete_run(pg_dsn, "cur-run", 70.0)
-
-        # Exclude the current run — should get old-run
-        prev_id, scores = get_previous_run_scores(pg_dsn, "INSURANCE-AI", exclude_run_id="cur-run")
-        assert prev_id == "old-run"
-        assert "FR1" in scores
-
-    def test_running_run_not_returned_as_previous(self, pg_dsn):
-        """A run with status='running' must not be used as previous baseline."""
-        create_run(pg_dsn, "unfinished", "INSURANCE-AI")
-        # do NOT call complete_run — status stays 'running'
-
-        prev_id, scores = get_previous_run_scores(pg_dsn, "INSURANCE-AI")
-        assert prev_id is None
-        assert scores == {}
-
-    def test_most_recent_completed_run_is_used(self, pg_dsn):
-        """When multiple completed runs exist, the most recent one is the baseline."""
-        for i, score in enumerate([40.0, 60.0, 55.0]):
-            run_id = f"run-{i}"
-            create_run(pg_dsn, run_id, "INSURANCE-AI")
-            save_fr_assessments(pg_dsn, run_id, [self._make_assessment("FR1", score)])
-            complete_run(pg_dsn, run_id, score)
-
-        prev_id, scores = get_previous_run_scores(pg_dsn, "INSURANCE-AI")
-        # run-2 was inserted last, so it's the most recent
-        assert prev_id == "run-2"
-        assert abs(scores["FR1"] - 55.0) < 0.001
-
-
-# ---------------------------------------------------------------------------
-# Checkpoint resume: phase_already_done with real DB state
-# ---------------------------------------------------------------------------
-
-
-@pytest.mark.integration
-class TestCheckpointResume:
-    def test_resume_skips_completed_phases(self, pg_dsn):
-        create_run(pg_dsn, "resume-run", "INSURANCE-AI")
-        update_run_phase(pg_dsn, "resume-run", "structural")
-
-        row = get_run(pg_dsn, "resume-run")
-        completed = row["completed_phase"]
-
-        assert phase_already_done(completed, "sync") is True
-        assert phase_already_done(completed, "parse_kg") is True
-        assert phase_already_done(completed, "structural") is True
-        assert phase_already_done(completed, "llm_eval") is False
-        assert phase_already_done(completed, "report") is False

package/tools/vds-scripts/progress_report_orchestrator/tests/test_alembic_migrations.py

@@ -1,265 +0,0 @@
-"""Structural tests for the progress_report_orchestrator Alembic stack.
-
-These tests are MOCKED — no real Postgres connection. They verify that the
-phase P4 Alembic scaffolding is wired correctly:
-
-- alembic.ini parses and points at the right script_location.
-- env.py imports the canonical ``include_name`` filter from
-  ``progress_report_orchestrator.db.alembic_filters``.
-- The ``include_name`` callback gates schemas correctly (only ``progress``).
-- The 0001 revision is discoverable, has the expected ID, and base revision.
-- target_metadata is None (intentionally — no SQLAlchemy ORM Base).
-
-Per project rule: tests MUST NOT hit real external services. Real Postgres
-exercise lives in ``tests/integration/test_checkpoint.py`` behind a
-``pytest.mark.integration`` gate + testcontainers fixture.
-"""
-
-from __future__ import annotations
-
-import pathlib
-
-import pytest
-
-REPO_ROOT = pathlib.Path(__file__).resolve().parents[1]
-ALEMBIC_INI = REPO_ROOT / "alembic.ini"
-ALEMBIC_DIR = REPO_ROOT / "alembic"
-VERSIONS_DIR = ALEMBIC_DIR / "versions"
-
-
-# ---------------------------------------------------------------------------
-# Filter module — pure-Python, no Alembic context required
-# ---------------------------------------------------------------------------
-
-
-class TestIncludeNameFilter:
-    """Verify the include_name callback gates schemas per ADR-INF-11."""
-
-    def test_filter_imports_cleanly(self) -> None:
-        # Imports without side effects (no Alembic context needed).
-        from progress_report_orchestrator.db.alembic_filters import (
-            MANAGED_SCHEMAS,
-            include_name,
-        )
-
-        assert callable(include_name)
-        assert isinstance(MANAGED_SCHEMAS, frozenset)
-
-    def test_managed_schemas_is_progress_only(self) -> None:
-        from progress_report_orchestrator.db.alembic_filters import MANAGED_SCHEMAS
-
-        assert frozenset({"progress"}) == MANAGED_SCHEMAS
-
-    @pytest.mark.parametrize(
-        "schema_name,expected",
-        [
-            ("progress", True),
-            ("audit_state", False),
-            ("memory", False),
-            ("sched", False),
-            ("dbos", False),
-            ("public", False),
-            (None, False),
-        ],
-    )
-    def test_include_name_for_schemas(self, schema_name, expected) -> None:
-        from progress_report_orchestrator.db.alembic_filters import include_name
-
-        assert include_name(schema_name, "schema", {}) is expected
-
-    def test_include_name_passes_non_schema_objects(self) -> None:
-        """Non-schema object types (table, column, index) are not filtered here."""
-        from progress_report_orchestrator.db.alembic_filters import include_name
-
-        # Schema-gating handles correctness for nested objects; we always
-        # return True for these so Alembic can still see them inside an
-        # already-included schema.
-        assert include_name("progress_runs", "table", {"schema_name": "progress"}) is True
-        assert include_name("run_id", "column", {"schema_name": "progress"}) is True
-        assert include_name("idx_anything", "index", {"schema_name": "progress"}) is True
-
-
-# ---------------------------------------------------------------------------
-# Alembic config + script directory layout
-# ---------------------------------------------------------------------------
-
-
-class TestAlembicConfig:
-    """Verify alembic.ini is parsable and points at the right script_location."""
-
-    def test_alembic_ini_exists(self) -> None:
-        assert ALEMBIC_INI.is_file(), f"alembic.ini missing at {ALEMBIC_INI}"
-
-    def test_script_py_mako_exists(self) -> None:
-        assert (ALEMBIC_DIR / "script.py.mako").is_file()
-
-    def test_env_py_exists(self) -> None:
-        assert (ALEMBIC_DIR / "env.py").is_file()
-
-    def test_versions_dir_exists(self) -> None:
-        assert VERSIONS_DIR.is_dir()
-
-    def test_config_loads(self) -> None:
-        from alembic.config import Config
-
-        cfg = Config(str(ALEMBIC_INI))
-        # script_location should resolve to the alembic/ dir via %(here)s.
-        script_loc = cfg.get_main_option("script_location")
-        assert script_loc is not None
-        assert pathlib.Path(script_loc).resolve() == ALEMBIC_DIR.resolve()
-
-
-# ---------------------------------------------------------------------------
-# 0001 revision — initial squash of the legacy 5-table schema
-# ---------------------------------------------------------------------------
-
-
-class TestInitialRevision:
-    """Verify 0001_initial_progress_schema.py has the right shape."""
-
-    def test_initial_revision_file_exists(self) -> None:
-        path = VERSIONS_DIR / "0001_initial_progress_schema.py"
-        assert path.is_file(), f"missing {path}"
-
-    def test_revision_id_and_down_revision(self) -> None:
-        # Import the module directly to read its top-level revision constants.
-        # We must NOT rely on alembic's ScriptDirectory here because that
-        # tries to instantiate context machinery.
-        import importlib.util
-
-        spec = importlib.util.spec_from_file_location(
-            "progress_initial_migration",
-            VERSIONS_DIR / "0001_initial_progress_schema.py",
-        )
-        assert spec is not None and spec.loader is not None
-        mod = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(mod)
-
-        assert mod.revision == "0001"
-        assert mod.down_revision is None
-
-    def test_upgrade_and_downgrade_callable(self) -> None:
-        import importlib.util
-
-        spec = importlib.util.spec_from_file_location(
-            "progress_initial_migration",
-            VERSIONS_DIR / "0001_initial_progress_schema.py",
-        )
-        assert spec is not None and spec.loader is not None
-        mod = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(mod)
-
-        assert callable(mod.upgrade)
-        assert callable(mod.downgrade)
-
-    def test_upgrade_creates_progress_schema_and_five_tables(self) -> None:
-        """Read the file as text and assert the 5 known tables are present."""
-        text = (VERSIONS_DIR / "0001_initial_progress_schema.py").read_text()
-
-        assert "CREATE SCHEMA IF NOT EXISTS progress" in text
-        for table in (
-            "progress.progress_runs",
-            "progress.fr_assessments",
-            "progress.document_hashes",
-            "progress.service_analyses",
-            "progress.daily_scores",
-        ):
-            assert table in text, f"missing CREATE for {table}"
-
-    def test_downgrade_does_not_drop_progress_schema(self) -> None:
-        """Per ADR-INF-11 the schema must NOT be dropped CASCADE in downgrade.
-
-        We strip the module docstring (which legitimately *mentions* the
-        forbidden statement as a warning) before scanning, so we only check
-        the executable code.
-        """
-        import ast
-
-        path = VERSIONS_DIR / "0001_initial_progress_schema.py"
-        tree = ast.parse(path.read_text())
-
-        # Drop the module docstring node so its text is excluded.
-        if (
-            tree.body
-            and isinstance(tree.body[0], ast.Expr)
-            and isinstance(tree.body[0].value, ast.Constant)
-            and isinstance(tree.body[0].value.value, str)
-        ):
-            tree.body = tree.body[1:]
-        code_text = ast.unparse(tree)
-
-        assert "DROP SCHEMA progress CASCADE" not in code_text
-        assert "DROP SCHEMA IF EXISTS progress CASCADE" not in code_text
-
-
-# ---------------------------------------------------------------------------
-# env.py wiring — imports include_name, target_metadata is None
-# ---------------------------------------------------------------------------
-
-
-class TestEnvPy:
-    """Verify env.py imports the right pieces and configures target_metadata."""
-
-    def test_env_py_imports_include_name_from_db_module(self) -> None:
-        text = (ALEMBIC_DIR / "env.py").read_text()
-
-        # The canonical pattern is to import include_name from the package's
-        # db/ module so it can be unit-tested in isolation (per ADR-INF-11).
-        assert "from progress_report_orchestrator.db.alembic_filters import include_name" in text
-
-    def test_env_py_target_metadata_is_none(self) -> None:
-        text = (ALEMBIC_DIR / "env.py").read_text()
-
-        # progress_report_orchestrator does not use SQLAlchemy ORM — DDL is
-        # raw SQL — so target_metadata must be None (autogenerate is disabled).
-        assert "target_metadata = None" in text
-
-    def test_env_py_uses_progress_version_table_schema(self) -> None:
-        text = (ALEMBIC_DIR / "env.py").read_text()
-
-        # alembic_version stays inside the progress schema (in-schema).
-        # env.py may use inline kwarg form (version_table_schema="progress") or
-        # dict-unpack form ("version_table_schema": "progress") — both are valid.
-        assert '"version_table_schema": "progress"' in text or 'version_table_schema="progress"' in text
-
-    def test_env_py_does_not_set_search_path_explicitly(self) -> None:
-        """Per ADR-INF-11 §SA2.0 Implicit-TX Gotcha — must not SET search_path
-        outside a transaction inside online()."""
-        text = (ALEMBIC_DIR / "env.py").read_text()
-
-        # The phrase appears only inside comments warning against it; ensure
-        # there is no executed connection.execute("SET search_path ...").
-        # We look for an actual call shape rather than the words.
-        assert 'connection.execute("SET search_path' not in text
-        assert "connection.execute('SET search_path" not in text
-
-
-# ---------------------------------------------------------------------------
-# state/schema.py — init_schema removed, helpers preserved
-# ---------------------------------------------------------------------------
-
-
-class TestSchemaModuleAfterRetirement:
-    """Verify state/schema.py no longer defines init_schema or _TABLES."""
-
-    def test_init_schema_not_importable(self) -> None:
-        from progress_report_orchestrator.state import schema as schema_mod
-
-        assert not hasattr(schema_mod, "init_schema")
-        assert not hasattr(schema_mod, "_TABLES")
-
-    def test_runtime_helpers_still_present(self) -> None:
-        # check_schema_status, EXPECTED_TABLES, and all DML helpers are
-        # preserved — they don't perform DDL.
-        from progress_report_orchestrator.state import schema as schema_mod
-
-        assert hasattr(schema_mod, "check_schema_status")
-        assert hasattr(schema_mod, "EXPECTED_TABLES")
-        assert hasattr(schema_mod, "create_run")
-        assert hasattr(schema_mod, "complete_run")
-        assert hasattr(schema_mod, "fail_run")
-        assert hasattr(schema_mod, "save_fr_assessments")
-        assert hasattr(schema_mod, "load_fr_assessments")
-        assert hasattr(schema_mod, "save_document_hashes")
-        assert hasattr(schema_mod, "save_service_analyses")
-        assert hasattr(schema_mod, "save_daily_scores")