@ngocsangairvds/vsaf 3.2.14 → 3.2.16

package/tools/vds-scripts/audit_orchestrator/tests/unit/test_corpus_project_id_migration.py

@@ -1,318 +0,0 @@
-"""Tests for TSK-940.38 (FR-265): Corpus query migration to strict project_id joins.
-
-Verifies that corpus_purge_plan(), corpus_status_diagnostics(), and
-corpus_backfill_metadata() use strict project_id FK joins with no orphan
-fallback and no legacy key-only path.
-
-User rule: "do not add fallback, we need properly preparation."
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-from vds_audit_orchestrator.state.store import PostgresStateStore
-
-# ---------------------------------------------------------------------------
-# Unit tests for helper methods (no DB required — pure logic)
-# ---------------------------------------------------------------------------
-
-
-class TestCorpusDocProjectFilter:
-    """Tests for _corpus_doc_project_filter static method (strict mode)."""
-
-    def test_strict_project_id_only(self) -> None:
-        """Filter uses strict cd.project_id = %s — no orphan fallback."""
-        sql, params = PostgresStateStore._corpus_doc_project_filter(
-            project_id=42,
-            project_key="my-project",
-        )
-        assert sql == "cd.project_id = %s"
-        assert params == (42,)
-        # No orphan fallback — these must NOT appear
-        assert "IS NULL" not in sql
-        assert "rs.project_key" not in sql
-        assert " OR " not in sql
-
-    def test_project_id_zero_treated_as_valid(self) -> None:
-        """project_id=0 is a valid integer FK."""
-        sql, params = PostgresStateStore._corpus_doc_project_filter(
-            project_id=0,
-            project_key="p",
-        )
-        assert sql == "cd.project_id = %s"
-        assert params == (0,)
-
-    def test_single_param_only(self) -> None:
-        """Strict filter produces exactly 1 param (project_id only)."""
-        _, params = PostgresStateStore._corpus_doc_project_filter(
-            project_id=1,
-            project_key="k",
-        )
-        assert len(params) == 1
-
-
-class TestSnapshotProjectFilter:
-    """Tests for _snapshot_project_filter static method (strict mode)."""
-
-    def test_widens_scope_with_fk_subquery(self) -> None:
-        """Filter includes project_key match + FK subquery for linked snapshots."""
-        sql, params = PostgresStateStore._snapshot_project_filter(
-            project_id=99,
-            project_key="test-key",
-        )
-        assert "project_key = %s" in sql
-        assert "corpus_documents WHERE project_id = %s" in sql
-        assert params == ("test-key", 99)
-
-    def test_is_parenthesized(self) -> None:
-        """The OR condition must be parenthesized."""
-        sql, _ = PostgresStateStore._snapshot_project_filter(
-            project_id=1,
-            project_key="k",
-        )
-        assert sql.startswith("(")
-        assert sql.endswith(")")
-
-    def test_two_params(self) -> None:
-        """Snapshot filter produces exactly 2 params."""
-        _, params = PostgresStateStore._snapshot_project_filter(
-            project_id=1,
-            project_key="k",
-        )
-        assert len(params) == 2
-
-
-# ---------------------------------------------------------------------------
-# Signature compatibility tests (no DB required — verify project_id required)
-# ---------------------------------------------------------------------------
-
-
-class TestCorpusMethodSignatures:
-    """Verify that all migrated methods require project_id: int (no default)."""
-
-    def test_corpus_purge_plan_requires_project_id(self) -> None:
-        """corpus_purge_plan requires project_id: int (no default)."""
-        import inspect
-
-        sig = inspect.signature(PostgresStateStore.corpus_purge_plan)
-        assert "project_id" in sig.parameters
-        param = sig.parameters["project_id"]
-        assert param.default is inspect.Parameter.empty
-
-    def test_corpus_purge_execute_requires_project_id(self) -> None:
-        """corpus_purge_execute requires project_id: int (no default)."""
-        import inspect
-
-        sig = inspect.signature(PostgresStateStore.corpus_purge_execute)
-        assert "project_id" in sig.parameters
-        param = sig.parameters["project_id"]
-        assert param.default is inspect.Parameter.empty
-
-    def test_corpus_status_diagnostics_requires_project_id(self) -> None:
-        """corpus_status_diagnostics requires project_id: int (no default)."""
-        import inspect
-
-        sig = inspect.signature(PostgresStateStore.corpus_status_diagnostics)
-        assert "project_id" in sig.parameters
-        param = sig.parameters["project_id"]
-        assert param.default is inspect.Parameter.empty
-
-    def test_corpus_backfill_metadata_requires_project_id(self) -> None:
-        """corpus_backfill_metadata requires project_id: int (no default)."""
-        import inspect
-
-        sig = inspect.signature(PostgresStateStore.corpus_backfill_metadata)
-        assert "project_id" in sig.parameters
-        param = sig.parameters["project_id"]
-        assert param.default is inspect.Parameter.empty
-
-    def test_resolve_purge_snapshot_ids_requires_project_id(self) -> None:
-        """_resolve_purge_snapshot_ids requires project_id: int (no default)."""
-        import inspect
-
-        sig = inspect.signature(PostgresStateStore._resolve_purge_snapshot_ids)
-        assert "project_id" in sig.parameters
-        param = sig.parameters["project_id"]
-        assert param.default is inspect.Parameter.empty
-
-    def test_purge_artifacts_only_requires_project_id(self) -> None:
-        """_purge_artifacts_only requires project_id: int (no default)."""
-        import inspect
-
-        sig = inspect.signature(PostgresStateStore._purge_artifacts_only)
-        assert "project_id" in sig.parameters
-        param = sig.parameters["project_id"]
-        assert param.default is inspect.Parameter.empty
-
-
-# ---------------------------------------------------------------------------
-# Strict mode tests — no legacy fallback path
-# ---------------------------------------------------------------------------
-
-
-class TestNoLegacyFallback:
-    """Verify that legacy key-only paths are removed."""
-
-    def test_corpus_doc_filter_no_legacy_key_path(self) -> None:
-        """_corpus_doc_project_filter does not accept project_id=None."""
-        import inspect
-
-        sig = inspect.signature(PostgresStateStore._corpus_doc_project_filter)
-        param = sig.parameters["project_id"]
-        # Annotation should be int, not int | None
-        assert param.annotation is int or "int" in str(param.annotation)
-
-    def test_snapshot_filter_no_legacy_key_path(self) -> None:
-        """_snapshot_project_filter does not accept project_id=None."""
-        import inspect
-
-        sig = inspect.signature(PostgresStateStore._snapshot_project_filter)
-        param = sig.parameters["project_id"]
-        assert param.annotation is int or "int" in str(param.annotation)
-
-    def test_no_orphan_or_condition_in_corpus_filter(self) -> None:
-        """Corpus doc filter must not contain orphan fallback OR condition."""
-        sql, _ = PostgresStateStore._corpus_doc_project_filter(
-            project_id=42,
-            project_key="proj",
-        )
-        assert "IS NULL" not in sql
-        assert " OR " not in sql
-
-    def test_strict_project_id_params_count(self) -> None:
-        """Strict filter produces exactly 1 param (project_id only)."""
-        _, doc_params = PostgresStateStore._corpus_doc_project_filter(
-            project_id=1,
-            project_key="k",
-        )
-        assert len(doc_params) == 1
-        assert doc_params[0] == 1
-
-
-# ---------------------------------------------------------------------------
-# CLI mock tests (verify callers can pass project_id through)
-# ---------------------------------------------------------------------------
-
-
-class TestCorpusPurgePlanMock:
-    """Mock-based tests verifying corpus_purge_plan with project_id forwarding."""
-
-    def test_corpus_purge_plan_kwargs_accepted_with_project_id(self) -> None:
-        """corpus_purge_plan can be called with project_id kwarg (no TypeError)."""
-        kwargs: dict[str, Any] = {
-            "project_key": "test",
-            "project_id": 42,
-            "keep_latest": False,
-            "artifacts_only": False,
-        }
-        import inspect
-
-        sig = inspect.signature(PostgresStateStore.corpus_purge_plan)
-        for k in kwargs:
-            assert k in sig.parameters, f"{k} not in corpus_purge_plan params"
-
-    def test_corpus_purge_execute_kwargs_accepted_with_project_id(self) -> None:
-        """corpus_purge_execute can be called with project_id kwarg."""
-        kwargs: dict[str, Any] = {
-            "project_key": "test",
-            "project_id": 42,
-            "keep_latest": False,
-            "artifacts_only": False,
-            "lock_timeout_ms": 30000,
-        }
-        import inspect
-
-        sig = inspect.signature(PostgresStateStore.corpus_purge_execute)
-        for k in kwargs:
-            assert k in sig.parameters, f"{k} not in corpus_purge_execute params"
-
-
-class TestCorpusStatusDiagnosticsMock:
-    """Mock-based tests verifying corpus_status_diagnostics with project_id."""
-
-    def test_status_diagnostics_kwargs_accepted_with_project_id(self) -> None:
-        """corpus_status_diagnostics can be called with project_id kwarg."""
-        kwargs: dict[str, Any] = {
-            "project_key": "test",
-            "project_id": 99,
-        }
-        import inspect
-
-        sig = inspect.signature(PostgresStateStore.corpus_status_diagnostics)
-        for k in kwargs:
-            assert k in sig.parameters
-
-
-class TestCorpusBackfillMetadataMock:
-    """Mock-based tests verifying corpus_backfill_metadata with project_id."""
-
-    def test_backfill_metadata_kwargs_accepted_with_project_id(self) -> None:
-        """corpus_backfill_metadata can be called with project_id kwarg."""
-        kwargs: dict[str, Any] = {
-            "project_key": "test",
-            "project_id": 7,
-        }
-        import inspect
-
-        sig = inspect.signature(PostgresStateStore.corpus_backfill_metadata)
-        for k in kwargs:
-            assert k in sig.parameters
-
-
-# ---------------------------------------------------------------------------
-# SQL predicate correctness (verify f-string formatting is safe)
-# ---------------------------------------------------------------------------
-
-
-class TestSqlPredicateCorrectness:
-    """Verify that the SQL predicates are well-formed and parameterized."""
-
-    def test_corpus_doc_filter_is_simple(self) -> None:
-        """Strict filter is a simple equality — no parenthesization needed."""
-        sql, _ = PostgresStateStore._corpus_doc_project_filter(
-            project_id=1,
-            project_key="k",
-        )
-        assert sql == "cd.project_id = %s"
-
-    def test_snapshot_filter_is_parenthesized(self) -> None:
-        """Snapshot filter with OR condition must be parenthesized."""
-        sql, _ = PostgresStateStore._snapshot_project_filter(
-            project_id=1,
-            project_key="k",
-        )
-        assert sql.startswith("(")
-        assert sql.endswith(")")
-
-    def test_no_sql_injection_vectors(self) -> None:
-        """Params are positional — no string interpolation of user values."""
-        sql, params = PostgresStateStore._corpus_doc_project_filter(
-            project_id=42,
-            project_key="'; DROP TABLE --",
-        )
-        # The dangerous string must NOT be in SQL text (project_key not used in strict mode)
-        assert "DROP TABLE" not in sql
-        # project_key is unused in strict mode — only project_id in params
-        assert params == (42,)
-
-
-# ---------------------------------------------------------------------------
-# resolve_project_id tests
-# ---------------------------------------------------------------------------
-
-
-class TestResolveProjectId:
-    """Verify resolve_project_id method exists and has correct signature."""
-
-    def test_method_exists(self) -> None:
-        """PostgresStateStore has resolve_project_id method."""
-        assert hasattr(PostgresStateStore, "resolve_project_id")
-        assert callable(PostgresStateStore.resolve_project_id)
-
-    def test_signature_accepts_project_key(self) -> None:
-        """resolve_project_id accepts project_key: str."""
-        import inspect
-
-        sig = inspect.signature(PostgresStateStore.resolve_project_id)
-        assert "project_key" in sig.parameters

package/tools/vds-scripts/audit_orchestrator/tests/unit/test_corpus_status_diagnostics.py

@@ -1,239 +0,0 @@
-"""Tests for FR-300 / DD-190: Enhanced corpus-status diagnostics (TSK-940.88)."""
-
-from __future__ import annotations
-
-from unittest.mock import MagicMock, patch
-
-
-class TestCorpusStatusDiagnosticsNewMetrics:
-    """Verify new orphan_document_rate, duplicate_uri_count, and health degradation."""
-
-    def _make_store(self):
-        """Build a PostgresStateStore with a mocked connection."""
-        with patch("vds_audit_orchestrator.state.store.psycopg.connect") as mock_connect:
-            mock_conn = MagicMock()
-            mock_connect.return_value = mock_conn
-            from vds_audit_orchestrator.state.store import PostgresStateStore
-
-            store = PostgresStateStore.__new__(PostgresStateStore)
-            store._conn = mock_conn
-            store._dsn = "postgresql://test"
-            return store, mock_conn
-
-    def _setup_cursor_results(
-        self,
-        mock_conn,
-        *,
-        snapshot_rows,
-        totals,
-        by_source,
-        by_doc_class,
-        metadata,
-        orphan,
-        duplicate,
-        duplicate_latest,
-        truncated,
-        unscoped,
-    ):
-        """Configure cursor mock to return results in order of queries."""
-        mock_cursor = MagicMock()
-        mock_conn.cursor.return_value.__enter__ = MagicMock(return_value=mock_cursor)
-        mock_conn.cursor.return_value.__exit__ = MagicMock(return_value=False)
-
-        # fetchall/fetchone calls in order:
-        # 1. snapshot_rows (fetchall)
-        # 2. totals (fetchone)
-        # 3. by_source (fetchall)
-        # 4. by_doc_class (fetchall)
-        # 5. metadata (fetchone)
-        # 6. orphan (fetchone)
-        # 7. duplicate (fetchone)
-        # 8. duplicate_latest (fetchone)
-        # 9. truncated (fetchone)
-        # 10. unscoped (fetchone)
-        mock_cursor.fetchall.side_effect = [snapshot_rows, by_source, by_doc_class]
-        mock_cursor.fetchone.side_effect = [totals, metadata, orphan, duplicate, duplicate_latest, truncated, unscoped]
-        return mock_cursor
-
-    def test_clean_health_no_orphans_no_contamination(self):
-        store, mock_conn = self._make_store()
-        snap_filter_patch = patch.object(
-            type(store),
-            "_snapshot_project_filter",
-            return_value=("rs.id = ANY(%s)", ([1],)),
-        )
-
-        with snap_filter_patch:
-            self._setup_cursor_results(
-                mock_conn,
-                snapshot_rows=[
-                    {
-                        "id": 1,
-                        "snapshot_key": "test:project_corpus",
-                        "created_at": "2026-03-01",
-                        "chunk_count": 100,
-                        "priority": 3,
-                    }
-                ],
-                totals={"total_documents": 50, "total_chunks": 100},
-                by_source=[
-                    {"source_type": "confluence_page", "chunk_count": 80},
-                    {"source_type": "code_file", "chunk_count": 20},
-                ],
-                by_doc_class=[{"doc_class": "canonical_doc", "chunk_count": 100}],
-                metadata={"total_docs": 50, "docs_with_title": 50},
-                orphan={"total_code_docs": 20, "orphan_code_docs": 0},
-                duplicate={"duplicate_uri_count": 0},
-                duplicate_latest={"duplicate_uri_count_latest_snapshot": 0},
-                truncated={"truncated_chunk_count": 0},
-                unscoped={"unscoped_document_count": 0},
-            )
-            result = store.corpus_status_diagnostics(project_key="test", project_id=1)
-
-        assert result["health_status"] == "clean"
-        assert result["orphan_document_rate"] == 0.0
-        assert result["duplicate_uri_count"] == 0
-        assert result["duplicate_uri_count_latest_snapshot"] == 0
-        assert result["duplicate_uri_count_cross_snapshot"] == 0
-        assert result["orphan_code_docs"] == 0
-        assert result["unscoped_document_count"] == 0
-        assert result["truncated_chunk_count"] == 0
-
-    def test_warning_health_high_orphan_rate(self):
-        store, mock_conn = self._make_store()
-        snap_filter_patch = patch.object(
-            type(store),
-            "_snapshot_project_filter",
-            return_value=("rs.id = ANY(%s)", ([1],)),
-        )
-
-        with snap_filter_patch:
-            self._setup_cursor_results(
-                mock_conn,
-                snapshot_rows=[
-                    {
-                        "id": 1,
-                        "snapshot_key": "test:project_corpus",
-                        "created_at": "2026-03-01",
-                        "chunk_count": 100,
-                        "priority": 3,
-                    }
-                ],
-                totals={"total_documents": 50, "total_chunks": 100},
-                by_source=[{"source_type": "code_file", "chunk_count": 100}],
-                by_doc_class=[{"doc_class": "canonical_doc", "chunk_count": 100}],
-                metadata={"total_docs": 50, "docs_with_title": 50},
-                orphan={"total_code_docs": 20, "orphan_code_docs": 5},  # 25% orphan rate
-                duplicate={"duplicate_uri_count": 3},
-                duplicate_latest={"duplicate_uri_count_latest_snapshot": 1},
-                truncated={"truncated_chunk_count": 1},
-                unscoped={"unscoped_document_count": 2},
-            )
-            result = store.corpus_status_diagnostics(project_key="test", project_id=1)
-
-        assert result["health_status"] == "warning"
-        assert result["orphan_document_rate"] == 0.25
-        assert result["orphan_code_docs"] == 5
-        assert result["duplicate_uri_count"] == 3
-        assert result["duplicate_uri_count_latest_snapshot"] == 1
-        assert result["duplicate_uri_count_cross_snapshot"] == 2
-        assert result["unscoped_document_count"] == 2
-        assert result["truncated_chunk_count"] == 1
-
-    def test_empty_snapshots_returns_zero_metrics(self):
-        store, mock_conn = self._make_store()
-        snap_filter_patch = patch.object(
-            type(store),
-            "_snapshot_project_filter",
-            return_value=("rs.id = ANY(%s)", ([],)),
-        )
-
-        mock_cursor = MagicMock()
-        mock_conn.cursor.return_value.__enter__ = MagicMock(return_value=mock_cursor)
-        mock_conn.cursor.return_value.__exit__ = MagicMock(return_value=False)
-        mock_cursor.fetchall.return_value = []  # no snapshots
-
-        with snap_filter_patch:
-            result = store.corpus_status_diagnostics(project_key="test", project_id=1)
-
-        assert result["health_status"] == "clean"
-        assert result["total_chunks"] == 0
-        # New metrics should have defaults in the empty-snapshot branch
-        assert "orphan_document_rate" not in result or result.get("orphan_document_rate", 0.0) == 0.0
-
-    def test_return_includes_new_fields(self):
-        """Verify the return dict schema includes all FR-300 fields."""
-        store, mock_conn = self._make_store()
-        snap_filter_patch = patch.object(
-            type(store),
-            "_snapshot_project_filter",
-            return_value=("rs.id = ANY(%s)", ([1],)),
-        )
-
-        with snap_filter_patch:
-            self._setup_cursor_results(
-                mock_conn,
-                snapshot_rows=[{"id": 1, "snapshot_key": "k", "created_at": "t", "chunk_count": 10, "priority": 2}],
-                totals={"total_documents": 5, "total_chunks": 10},
-                by_source=[],
-                by_doc_class=[],
-                metadata={"total_docs": 5, "docs_with_title": 5},
-                orphan={"total_code_docs": 0, "orphan_code_docs": 0},
-                duplicate={"duplicate_uri_count": 0},
-                duplicate_latest={"duplicate_uri_count_latest_snapshot": 0},
-                truncated={"truncated_chunk_count": 0},
-                unscoped={"unscoped_document_count": 0},
-            )
-            result = store.corpus_status_diagnostics(project_key="test", project_id=1)
-
-        required_keys = {
-            "orphan_document_rate",
-            "orphan_code_docs",
-            "total_code_docs",
-            "duplicate_uri_count",
-            "duplicate_uri_count_latest_snapshot",
-            "duplicate_uri_count_cross_snapshot",
-            "truncated_chunk_count",
-            "unscoped_document_count",
-            "contamination_ratio",
-            "health_status",
-        }
-        assert required_keys.issubset(set(result.keys()))
-
-    def test_metadata_completeness_prefers_confluence_scope(self):
-        """Confluence metadata completeness should not be diluted by code_file rows."""
-        store, mock_conn = self._make_store()
-        snap_filter_patch = patch.object(
-            type(store),
-            "_snapshot_project_filter",
-            return_value=("rs.id = ANY(%s)", ([1],)),
-        )
-
-        with snap_filter_patch:
-            self._setup_cursor_results(
-                mock_conn,
-                snapshot_rows=[{"id": 1, "snapshot_key": "k", "created_at": "t", "chunk_count": 10, "priority": 2}],
-                totals={"total_documents": 100, "total_chunks": 10},
-                by_source=[
-                    {"source_type": "code_file", "chunk_count": 8},
-                    {"source_type": "confluence_page", "chunk_count": 2},
-                ],
-                by_doc_class=[{"doc_class": "canonical_doc", "chunk_count": 10}],
-                metadata={
-                    "total_docs": 100,
-                    "docs_with_title": 10,
-                    "confluence_total_docs": 5,
-                    "confluence_docs_with_title": 4,
-                },
-                orphan={"total_code_docs": 10, "orphan_code_docs": 0},
-                duplicate={"duplicate_uri_count": 0},
-                duplicate_latest={"duplicate_uri_count_latest_snapshot": 0},
-                truncated={"truncated_chunk_count": 0},
-                unscoped={"unscoped_document_count": 0},
-            )
-            result = store.corpus_status_diagnostics(project_key="test", project_id=1)
-
-        assert result["metadata_completeness_scope"] == "confluence"
-        assert result["metadata_total_docs_evaluated"] == 5
-        assert result["metadata_docs_with_title"] == 4
-        assert result["metadata_completeness_ratio"] == 0.8

package/tools/vds-scripts/audit_orchestrator/tests/unit/test_department_priority_ordering.py

@@ -1,131 +0,0 @@
-"""Tests for TSK-131.4a: Department-first priority ordering.
-
-Verifies that ``_sort_projects_by_department_priority`` produces the canonical
-department ordering (P.NTTT > P.App > P.CNL > P.NT tài chính > TT TTS) and
-falls back gracefully for unknown/missing departments.
-"""
-
-from __future__ import annotations
-
-from vds_audit_orchestrator.workflow_cmds import (
-    _DEPARTMENT_PRIORITY_ORDER,
-    _sort_projects_by_department_priority,
-)
-
-
-def _proj(dept: str | None, key: str = "proj") -> dict:
-    """Create a minimal project payload with department and project_storage_key.
-
-    Uses ``project_storage_key`` so that ``_manifest_project_key`` resolves via
-    the legacy slug path rather than requiring a real numeric ``page_id``.
-    """
-    d: dict = {"project_storage_key": key}
-    if dept is not None:
-        d["department"] = dept
-    return d
-
-
-class TestDepartmentPriorityOrder:
-    """Constant validation."""
-
-    def test_constant_has_five_entries(self) -> None:
-        assert len(_DEPARTMENT_PRIORITY_ORDER) == 5
-
-    def test_constant_starts_with_nttt(self) -> None:
-        assert _DEPARTMENT_PRIORITY_ORDER[0] == "P.NTTT"
-
-    def test_constant_ends_with_tts(self) -> None:
-        assert _DEPARTMENT_PRIORITY_ORDER[-1] == "TT TTS"
-
-
-class TestSortProjectsByDepartmentPriority:
-    """Sort function behaviour."""
-
-    def test_empty_list(self) -> None:
-        assert _sort_projects_by_department_priority([]) == []
-
-    def test_single_project_unchanged(self) -> None:
-        projects = [_proj("P.NTTT", "a")]
-        result = _sort_projects_by_department_priority(projects)
-        assert len(result) == 1
-        assert result[0]["department"] == "P.NTTT"
-
-    def test_canonical_order_is_respected(self) -> None:
-        projects = [
-            _proj("TT TTS", "z"),
-            _proj("P.CNL", "c"),
-            _proj("P.NTTT", "a"),
-            _proj("P.App", "b"),
-            _proj("P.NT tài chính", "d"),
-        ]
-        result = _sort_projects_by_department_priority(projects)
-        departments = [p["department"] for p in result]
-        assert departments == list(_DEPARTMENT_PRIORITY_ORDER)
-
-    def test_unknown_department_sorts_after_known(self) -> None:
-        projects = [
-            _proj("Unknown Dept", "x"),
-            _proj("P.NTTT", "a"),
-        ]
-        result = _sort_projects_by_department_priority(projects)
-        assert result[0]["department"] == "P.NTTT"
-        assert result[1]["department"] == "Unknown Dept"
-
-    def test_missing_department_sorts_last(self) -> None:
-        projects = [
-            _proj(None, "x"),
-            _proj("P.App", "a"),
-            _proj("Unknown Dept", "u"),
-        ]
-        result = _sort_projects_by_department_priority(projects)
-        assert result[0]["department"] == "P.App"
-        assert result[1]["department"] == "Unknown Dept"
-        assert "department" not in result[2]
-
-    def test_empty_string_department_sorts_last(self) -> None:
-        projects = [
-            _proj("", "x"),
-            _proj("P.CNL", "c"),
-        ]
-        result = _sort_projects_by_department_priority(projects)
-        assert result[0]["department"] == "P.CNL"
-        assert result[1]["department"] == ""
-
-    def test_tiebreaker_is_manifest_key(self) -> None:
-        projects = [
-            _proj("P.App", "z-proj"),
-            _proj("P.App", "a-proj"),
-        ]
-        result = _sort_projects_by_department_priority(projects)
-        assert result[0]["project_storage_key"] == "a-proj"
-        assert result[1]["project_storage_key"] == "z-proj"
-
-    def test_preserves_all_fields(self) -> None:
-        projects = [
-            {"project_storage_key": "a", "department": "P.NTTT", "page_id": "123", "extra": True},
-        ]
-        result = _sort_projects_by_department_priority(projects)
-        assert result[0]["page_id"] == "123"
-        assert result[0]["extra"] is True
-
-    def test_mixed_known_unknown_missing(self) -> None:
-        projects = [
-            _proj(None, "no-dept"),
-            _proj("TT TTS", "tts"),
-            _proj("Exotic", "exotic"),
-            _proj("P.NTTT", "nttt"),
-        ]
-        result = _sort_projects_by_department_priority(projects)
-        keys = [p["project_storage_key"] for p in result]
-        assert keys == ["nttt", "tts", "exotic", "no-dept"]
-
-    def test_stable_sort_within_same_priority(self) -> None:
-        """Projects with same department and same key length should maintain relative ordering via key tiebreaker."""
-        projects = [
-            _proj("P.CNL", "proj-b"),
-            _proj("P.CNL", "proj-a"),
-            _proj("P.CNL", "proj-c"),
-        ]
-        result = _sort_projects_by_department_priority(projects)
-        keys = [p["project_storage_key"] for p in result]
-        assert keys == ["proj-a", "proj-b", "proj-c"]