@ngocsangairvds/vsaf 3.2.14 → 3.2.16

package/tools/vds-scripts/progress_report_orchestrator/tests/unit/test_resume_reload.py

@@ -1,343 +0,0 @@
-"""Unit tests for TSK-E.1: load_fr_assessments (checkpoint resume reload).
-
-All tests are pure-unit — psycopg is mocked so no real DB is needed.
-Covers G5 acceptance gate: resume produces real dim 1-6 values, not an
-empty list.
-"""
-
-from __future__ import annotations
-
-from unittest.mock import MagicMock, patch
-
-from progress_report_orchestrator.models.analysis import FRAssessment
-from progress_report_orchestrator.state.schema import load_fr_assessments
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-
-def _fr(
-    fr_id: str,
-    *,
-    service_exists: bool = True,
-    doc_chain_complete: bool = True,
-    brd_traced: bool = True,
-    code_activity: float = 50.0,
-    test_coverage: float = 40.0,
-    arch: float | None = None,
-    endpoint: float | None = None,
-    overall: float = 60.0,
-    gap: str = "",
-    payload: dict | None = None,
-) -> tuple:
-    """Build a DB row tuple matching the SELECT column order in load_fr_assessments."""
-    return (
-        fr_id,
-        service_exists,
-        doc_chain_complete,
-        brd_traced,
-        code_activity,
-        test_coverage,
-        arch,
-        endpoint,
-        overall,
-        gap,
-        payload,
-    )
-
-
-def _patch_psycopg(rows: list[tuple]):
-    """Context manager that makes psycopg.connect return the given rows."""
-    mock_cur = MagicMock()
-    mock_cur.fetchall.return_value = rows
-
-    mock_cur_cm = MagicMock()
-    mock_cur_cm.__enter__ = MagicMock(return_value=mock_cur)
-    mock_cur_cm.__exit__ = MagicMock(return_value=False)
-
-    mock_conn = MagicMock()
-    mock_conn.cursor.return_value = mock_cur_cm
-
-    mock_conn_cm = MagicMock()
-    mock_conn_cm.__enter__ = MagicMock(return_value=mock_conn)
-    mock_conn_cm.__exit__ = MagicMock(return_value=False)
-
-    return patch("psycopg.connect", return_value=mock_conn_cm)
-
-
-# ---------------------------------------------------------------------------
-# Empty result set
-# ---------------------------------------------------------------------------
-
-
-class TestLoadFRAssessmentsEmpty:
-    def test_returns_empty_list_when_no_rows(self):
-        with _patch_psycopg([]):
-            result = load_fr_assessments("dsn://test", "run-empty")
-        assert result == []
-
-    def test_returns_list_type(self):
-        with _patch_psycopg([]):
-            result = load_fr_assessments("dsn://test", "run-empty")
-        assert isinstance(result, list)
-
-
-# ---------------------------------------------------------------------------
-# FR ID and count
-# ---------------------------------------------------------------------------
-
-
-class TestLoadFRAssessmentsFRIds:
-    def test_single_row_returns_one_assessment(self):
-        with _patch_psycopg([_fr("FR1")]):
-            result = load_fr_assessments("dsn://test", "run-1")
-        assert len(result) == 1
-        assert result[0].fr_id == "FR1"
-
-    def test_multiple_rows_preserve_order(self):
-        rows = [_fr("FR1"), _fr("FR5"), _fr("FR10")]
-        with _patch_psycopg(rows):
-            result = load_fr_assessments("dsn://test", "run-2")
-        assert [a.fr_id for a in result] == ["FR1", "FR5", "FR10"]
-
-    def test_all_elements_are_fr_assessments(self):
-        rows = [_fr(f"FR{i}") for i in range(1, 6)]
-        with _patch_psycopg(rows):
-            result = load_fr_assessments("dsn://test", "run-3")
-        assert all(isinstance(a, FRAssessment) for a in result)
-
-
-# ---------------------------------------------------------------------------
-# Dim 1-6 reconstruction (G5 gate: real values on resume)
-# ---------------------------------------------------------------------------
-
-
-class TestLoadFRAssessmentsDimensions:
-    def test_service_exists_true_round_trips(self):
-        with _patch_psycopg([_fr("FR1", service_exists=True)]):
-            a = load_fr_assessments("dsn://test", "run-x")[0]
-        assert a.service_exists is True
-
-    def test_service_exists_false_round_trips(self):
-        with _patch_psycopg([_fr("FR2", service_exists=False)]):
-            a = load_fr_assessments("dsn://test", "run-x")[0]
-        assert a.service_exists is False
-
-    def test_doc_chain_complete_true(self):
-        with _patch_psycopg([_fr("FR3", doc_chain_complete=True)]):
-            a = load_fr_assessments("dsn://test", "run-x")[0]
-        assert a.doc_chain_complete is True
-
-    def test_brd_traced_false(self):
-        with _patch_psycopg([_fr("FR4", brd_traced=False)]):
-            a = load_fr_assessments("dsn://test", "run-x")[0]
-        assert a.brd_traced is False
-
-    def test_code_activity_score_round_trips(self):
-        with _patch_psycopg([_fr("FR5", code_activity=75.5)]):
-            a = load_fr_assessments("dsn://test", "run-x")[0]
-        assert abs(a.code_activity_score - 75.5) < 0.001
-
-    def test_test_coverage_score_round_trips(self):
-        with _patch_psycopg([_fr("FR6", test_coverage=30.25)]):
-            a = load_fr_assessments("dsn://test", "run-x")[0]
-        assert abs(a.test_coverage_score - 30.25) < 0.001
-
-    def test_overall_score_round_trips(self):
-        with _patch_psycopg([_fr("FR7", overall=88.0)]):
-            a = load_fr_assessments("dsn://test", "run-x")[0]
-        assert abs(a.overall_score - 88.0) < 0.001
-
-    def test_arch_compliance_none_stays_none(self):
-        with _patch_psycopg([_fr("FR8", arch=None)]):
-            a = load_fr_assessments("dsn://test", "run-x")[0]
-        assert a.architecture_compliance is None
-
-    def test_arch_compliance_float_round_trips(self):
-        with _patch_psycopg([_fr("FR9", arch=65.0)]):
-            a = load_fr_assessments("dsn://test", "run-x")[0]
-        assert a.architecture_compliance is not None
-        assert abs(a.architecture_compliance - 65.0) < 0.001
-
-    def test_endpoint_coverage_float_round_trips(self):
-        with _patch_psycopg([_fr("FR10", endpoint=72.0)]):
-            a = load_fr_assessments("dsn://test", "run-x")[0]
-        assert a.endpoint_coverage is not None
-        assert abs(a.endpoint_coverage - 72.0) < 0.001
-
-
-# ---------------------------------------------------------------------------
-# NULL / None DB values use safe defaults
-# ---------------------------------------------------------------------------
-
-
-class TestLoadFRAssessmentsNullDefaults:
-    def _null_row(self, fr_id: str) -> tuple:
-        return (fr_id, None, None, None, None, None, None, None, None, None, None)
-
-    def test_null_service_exists_defaults_false(self):
-        with _patch_psycopg([self._null_row("FR1")]):
-            a = load_fr_assessments("dsn://test", "run-null")[0]
-        assert a.service_exists is False
-
-    def test_null_scores_default_zero(self):
-        with _patch_psycopg([self._null_row("FR2")]):
-            a = load_fr_assessments("dsn://test", "run-null")[0]
-        assert a.code_activity_score == 0.0
-        assert a.test_coverage_score == 0.0
-        assert a.overall_score == 0.0
-
-    def test_null_llm_dims_stay_none(self):
-        with _patch_psycopg([self._null_row("FR3")]):
-            a = load_fr_assessments("dsn://test", "run-null")[0]
-        assert a.architecture_compliance is None
-        assert a.endpoint_coverage is None
-
-    def test_null_gap_summary_defaults_empty_string(self):
-        with _patch_psycopg([self._null_row("FR4")]):
-            a = load_fr_assessments("dsn://test", "run-null")[0]
-        assert a.gap_summary == ""
-
-
-# ---------------------------------------------------------------------------
-# payload JSONB enrichment
-# ---------------------------------------------------------------------------
-
-
-class TestLoadFRAssessmentsPayload:
-    def test_deterministic_arch_score_from_payload(self):
-        row = _fr("FR1", payload={"deterministic_arch_score": 42.0})
-        with _patch_psycopg([row]):
-            a = load_fr_assessments("dsn://test", "run-p")[0]
-        assert a.deterministic_arch_score == 42.0
-
-    def test_no_payload_leaves_deterministic_arch_score_none(self):
-        row = _fr("FR2", payload=None)
-        with _patch_psycopg([row]):
-            a = load_fr_assessments("dsn://test", "run-p")[0]
-        assert a.deterministic_arch_score is None
-
-    def test_payload_without_known_keys_is_ignored(self):
-        row = _fr("FR3", payload={"unknown_key": 99})
-        with _patch_psycopg([row]):
-            a = load_fr_assessments("dsn://test", "run-p")[0]
-        # Should not raise; deterministic_arch_score stays None
-        assert a.deterministic_arch_score is None
-
-
-# ---------------------------------------------------------------------------
-# save_fr_assessments payload serialization (TSK-E.1 fix: roundtrip coverage)
-# ---------------------------------------------------------------------------
-
-
-class TestLoadFRAssessmentsDeduplication:
-    """Verify load_fr_assessments de-duplicates when a run has multiple rows per FR.
-
-    The C-1 fix saves assessments after both the structural and LLM phases,
-    creating two rows per FR for a completed run.  load_fr_assessments must
-    return exactly one FRAssessment per FR (the latest row, with LLM dims).
-    """
-
-    def test_duplicate_rows_deduped_to_one_per_fr(self):
-        """Two rows for FR1 in same run → only one FRAssessment returned."""
-        # Row 1: structural phase (no LLM dims yet)
-        _fr("FR1", arch=None, endpoint=None, overall=40.0)
-        # Row 2: LLM phase (dims 7-8 populated)
-        row_llm = _fr("FR1", arch=72.0, endpoint=65.0, overall=58.0)
-
-        # Mock returns both rows; DISTINCT ON behaviour is tested via real query
-        # in integration tests — here we just test the function handles it.
-        # The mock returns the LLM row (higher id) first to simulate DISTINCT ON.
-        with _patch_psycopg([row_llm]):
-            result = load_fr_assessments("dsn://test", "run-dup")
-        assert len(result) == 1
-        assert abs(result[0].overall_score - 58.0) < 0.001
-
-    def test_multiple_distinct_frs_not_collapsed(self):
-        """FR1 and FR2 rows are distinct FRs — both returned, no over-dedup."""
-        rows = [_fr("FR1", overall=40.0), _fr("FR2", overall=60.0)]
-        with _patch_psycopg(rows):
-            result = load_fr_assessments("dsn://test", "run-multi")
-        assert len(result) == 2
-        assert {a.fr_id for a in result} == {"FR1", "FR2"}
-
-
-class TestSaveFRAssessmentsPayload:
-    """Verify save_fr_assessments writes deterministic_arch_score to payload.
-
-    This covers the fix where the INSERT was missing gap_summary + payload
-    columns, silently dropping the deterministic arch floor needed by the
-    LLM phase on checkpoint resume.
-    """
-
-    def _make_conn_mock(self) -> tuple:
-        """Return (mock_conn_cm, captured_calls) where captured_calls accumulates
-        all execute() positional arg tuples."""
-        captured: list[tuple] = []
-
-        mock_cur = MagicMock()
-        mock_cur.execute.side_effect = lambda sql, params=None: captured.append((sql, params))
-
-        mock_cur_cm = MagicMock()
-        mock_cur_cm.__enter__ = MagicMock(return_value=mock_cur)
-        mock_cur_cm.__exit__ = MagicMock(return_value=False)
-
-        mock_conn = MagicMock()
-        mock_conn.cursor.return_value = mock_cur_cm
-
-        mock_conn_cm = MagicMock()
-        mock_conn_cm.__enter__ = MagicMock(return_value=mock_conn)
-        mock_conn_cm.__exit__ = MagicMock(return_value=False)
-
-        return mock_conn_cm, captured
-
-    def test_deterministic_arch_score_written_to_payload(self):
-        import json
-
-        from progress_report_orchestrator.models.analysis import FRAssessment
-        from progress_report_orchestrator.state.schema import save_fr_assessments
-
-        a = FRAssessment(fr_id="FR1", service_exists=True, code_activity_score=60.0)
-        a.deterministic_arch_score = 55.0
-
-        mock_conn_cm, captured = self._make_conn_mock()
-        with patch("psycopg.connect", return_value=mock_conn_cm):
-            save_fr_assessments("dsn://test", "run-save", [a])
-
-        assert len(captured) == 1
-        _sql, params = captured[0]
-        # payload is the last (12th) positional parameter
-        payload_json = params[-1]
-        assert payload_json is not None, "payload must not be None when deterministic_arch_score is set"
-        payload = json.loads(payload_json)
-        assert payload.get("deterministic_arch_score") == 55.0
-
-    def test_no_deterministic_score_writes_null_payload(self):
-        from progress_report_orchestrator.models.analysis import FRAssessment
-        from progress_report_orchestrator.state.schema import save_fr_assessments
-
-        a = FRAssessment(fr_id="FR2")
-        # deterministic_arch_score remains None (default)
-
-        mock_conn_cm, captured = self._make_conn_mock()
-        with patch("psycopg.connect", return_value=mock_conn_cm):
-            save_fr_assessments("dsn://test", "run-save-null", [a])
-
-        _sql, params = captured[0]
-        payload_json = params[-1]
-        assert payload_json is None, "payload should be None when no extra data to persist"
-
-    def test_gap_summary_written(self):
-        from progress_report_orchestrator.models.analysis import FRAssessment
-        from progress_report_orchestrator.state.schema import save_fr_assessments
-
-        a = FRAssessment(fr_id="FR3", gap_summary="missing BRD section")
-
-        mock_conn_cm, captured = self._make_conn_mock()
-        with patch("psycopg.connect", return_value=mock_conn_cm):
-            save_fr_assessments("dsn://test", "run-gap", [a])
-
-        _sql, params = captured[0]
-        # gap_summary is the 11th parameter (index 10)
-        assert params[10] == "missing BRD section"

package/tools/vds-scripts/progress_report_orchestrator/tests/unit/test_trend_regression.py

@@ -1,294 +0,0 @@
-"""Unit tests for trend regression auto-flagging (TSK-M.8 — Wave M).
-
-Covers:
-- REGRESSION_CRITICAL / REGRESSION_MINOR constants (TSK-M.1)
-- ReportDelta extended fields: regressed_frs, improved_frs, critical_regressions (TSK-M.2)
-- compute_delta() populates bucketed fields correctly (TSK-M.3)
-- _render_trend_section() emits regression subsections (TSK-M.4)
-
-Phase 4 regression thresholds (FR-Q9):
-  CRITICAL:  change <= -15
-  MINOR:    -15 < change <= -5
-  NOISE:    |change| < 5   (not reported)
-  IMPROVED:  change >= +5
-
-Import strategy: module-level imports of things that already exist; lazy
-imports inside test functions for Phase 4 additions so this file is importable
-before TSK-M.1 lands.
-"""
-
-from __future__ import annotations
-
-from progress_report_orchestrator.models.report import FRDelta, ReportDelta
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-
-def _make_delta(fr_id: str, prev: float, curr: float) -> FRDelta:
-    return FRDelta(
-        fr_id=fr_id,
-        previous_score=prev,
-        current_score=curr,
-        change=round(curr - prev, 2),
-    )
-
-
-def _build_report_delta(
-    fr_deltas: list[FRDelta],
-    *,
-    prev_overall: float = 50.0,
-    curr_overall: float = 50.0,
-) -> ReportDelta:
-    return ReportDelta(
-        previous_run_id="prev-run",
-        previous_overall=prev_overall,
-        current_overall=curr_overall,
-        overall_change=round(curr_overall - prev_overall, 2),
-        fr_deltas=fr_deltas,
-    )
-
-
-# ---------------------------------------------------------------------------
-# TSK-M.1: REGRESSION constants
-# ---------------------------------------------------------------------------
-
-
-class TestRegressionConstants:
-    """Threshold constants must match the spec exactly."""
-
-    def test_regression_critical_threshold(self):
-        from progress_report_orchestrator.pipeline.report import REGRESSION_CRITICAL
-
-        assert REGRESSION_CRITICAL == -15
-
-    def test_regression_minor_threshold(self):
-        from progress_report_orchestrator.pipeline.report import REGRESSION_MINOR
-
-        assert REGRESSION_MINOR == -5
-
-    def test_noise_floor_is_5(self):
-        """|change| < 5 is below noise floor — verify constant names/values match spec."""
-        from progress_report_orchestrator.pipeline.report import REGRESSION_MINOR
-
-        assert abs(REGRESSION_MINOR) == 5
-
-
-# ---------------------------------------------------------------------------
-# TSK-M.2/M.3: ReportDelta bucketed fields + compute_delta() populates them
-# ---------------------------------------------------------------------------
-
-
-class TestReportDeltaBucketedFields:
-    """ReportDelta must have regressed_frs, improved_frs, critical_regressions."""
-
-    def test_report_delta_has_regressed_frs_field(self):
-        delta = _build_report_delta([])
-        assert hasattr(delta, "regressed_frs")
-
-    def test_report_delta_has_improved_frs_field(self):
-        delta = _build_report_delta([])
-        assert hasattr(delta, "improved_frs")
-
-    def test_report_delta_has_critical_regressions_field(self):
-        delta = _build_report_delta([])
-        assert hasattr(delta, "critical_regressions")
-
-    def test_regressed_frs_defaults_to_empty_list(self):
-        delta = _build_report_delta([])
-        assert delta.regressed_frs == []
-
-    def test_improved_frs_defaults_to_empty_list(self):
-        delta = _build_report_delta([])
-        assert delta.improved_frs == []
-
-    def test_critical_regressions_defaults_to_empty_list(self):
-        delta = _build_report_delta([])
-        assert delta.critical_regressions == []
-
-
-class TestComputeDeltaBucketing:
-    """compute_delta() must populate bucketed fields on the returned ReportDelta."""
-
-    def _compute(self, assessments_data: list[tuple[str, float]], prev_scores: dict[str, float]) -> ReportDelta:
-        """Build minimal FRAssessment list and call compute_delta()."""
-        from progress_report_orchestrator.models.analysis import FRAssessment
-        from progress_report_orchestrator.pipeline.report import compute_delta
-
-        assessments = []
-        for fr_id, score in assessments_data:
-            a = FRAssessment(fr_id=fr_id, service_exists=True, overall_score=score)
-            assessments.append(a)
-        curr_overall = sum(s for _, s in assessments_data) / len(assessments_data)
-        return compute_delta(assessments, curr_overall, prev_scores, "prev-run")
-
-    def test_critical_regression_bucketed_correctly(self):
-        """change = -20 → critical_regressions and regressed_frs (not improved)."""
-        delta = self._compute([("FR1", 30.0)], {"FR1": 50.0})  # change = -20
-        assert delta is not None
-        assert any(d.fr_id == "FR1" for d in delta.critical_regressions)
-        assert any(d.fr_id == "FR1" for d in delta.regressed_frs)
-        assert not any(d.fr_id == "FR1" for d in delta.improved_frs)
-
-    def test_minor_regression_bucketed_correctly(self):
-        """change = -14 → regressed_frs only (not critical_regressions)."""
-        delta = self._compute([("FR1", 36.0)], {"FR1": 50.0})  # change = -14
-        assert delta is not None
-        assert any(d.fr_id == "FR1" for d in delta.regressed_frs)
-        assert not any(d.fr_id == "FR1" for d in delta.critical_regressions)
-
-    def test_noise_floor_change_not_bucketed(self):
-        """change = -4 → noise floor, not in regressed_frs or improved_frs."""
-        delta = self._compute([("FR1", 46.0)], {"FR1": 50.0})  # change = -4
-        assert delta is not None
-        assert not any(d.fr_id == "FR1" for d in delta.regressed_frs)
-        assert not any(d.fr_id == "FR1" for d in delta.improved_frs)
-
-    def test_improvement_bucketed_correctly(self):
-        """change = +10 → improved_frs."""
-        delta = self._compute([("FR1", 60.0)], {"FR1": 50.0})  # change = +10
-        assert delta is not None
-        assert any(d.fr_id == "FR1" for d in delta.improved_frs)
-        assert not any(d.fr_id == "FR1" for d in delta.regressed_frs)
-
-    def test_exactly_minus_15_is_critical(self):
-        """Boundary: change = -15 exactly → critical (REGRESSION_CRITICAL = -15, inclusive)."""
-        delta = self._compute([("FR1", 35.0)], {"FR1": 50.0})  # change = -15
-        assert delta is not None
-        assert any(d.fr_id == "FR1" for d in delta.critical_regressions)
-
-    def test_exactly_minus_14_is_minor_not_critical(self):
-        """Boundary: change = -14 → minor regression, not critical."""
-        delta = self._compute([("FR1", 36.0)], {"FR1": 50.0})  # change = -14
-        assert delta is not None
-        assert not any(d.fr_id == "FR1" for d in delta.critical_regressions)
-        assert any(d.fr_id == "FR1" for d in delta.regressed_frs)
-
-    def test_exactly_minus_5_is_minor(self):
-        """Boundary: change = -5 exactly → minor (REGRESSION_MINOR = -5, inclusive)."""
-        delta = self._compute([("FR1", 45.0)], {"FR1": 50.0})  # change = -5
-        assert delta is not None
-        assert any(d.fr_id == "FR1" for d in delta.regressed_frs)
-        assert not any(d.fr_id == "FR1" for d in delta.critical_regressions)
-
-    def test_same_data_rerun_produces_zero_regressions(self):
-        """Same scores → 0 regressions (all changes = 0, below noise floor)."""
-        delta = self._compute([("FR1", 50.0), ("FR2", 60.0)], {"FR1": 50.0, "FR2": 60.0})
-        assert delta is not None
-        assert len(delta.critical_regressions) == 0
-        assert len(delta.regressed_frs) == 0
-
-    def test_mixed_fr_set_bucketed_independently(self):
-        """Multiple FRs with different changes are bucketed independently."""
-        delta = self._compute(
-            [("FR1", 25.0), ("FR2", 36.0), ("FR3", 46.0), ("FR4", 60.0)],
-            {"FR1": 50.0, "FR2": 50.0, "FR3": 50.0, "FR4": 50.0},
-        )
-        assert delta is not None
-        # FR1: -25 → critical
-        assert any(d.fr_id == "FR1" for d in delta.critical_regressions)
-        # FR2: -14 → minor (regressed but not critical)
-        assert any(d.fr_id == "FR2" for d in delta.regressed_frs)
-        assert not any(d.fr_id == "FR2" for d in delta.critical_regressions)
-        # FR3: -4 → noise, no bucket
-        assert not any(d.fr_id == "FR3" for d in delta.regressed_frs)
-        # FR4: +10 → improved
-        assert any(d.fr_id == "FR4" for d in delta.improved_frs)
-
-    def test_no_previous_scores_returns_none(self):
-        from progress_report_orchestrator.models.analysis import FRAssessment
-        from progress_report_orchestrator.pipeline.report import compute_delta
-
-        a = FRAssessment(fr_id="FR1", service_exists=True, overall_score=50.0)
-        result = compute_delta([a], 50.0, {}, None)
-        assert result is None
-
-
-# ---------------------------------------------------------------------------
-# TSK-M.4: _render_trend_section regression subsections
-# ---------------------------------------------------------------------------
-
-
-class TestRenderTrendSectionRegressionSubsections:
-    """_render_trend_section must emit 🔴/🟡/🟢 subsections when data present."""
-
-    def _make_delta_with_regression(
-        self,
-        *,
-        critical: list[tuple[str, float, float]] | None = None,
-        minor: list[tuple[str, float, float]] | None = None,
-        improved: list[tuple[str, float, float]] | None = None,
-    ) -> ReportDelta:
-        """Build a ReportDelta with pre-populated bucketed lists."""
-        all_deltas: list[FRDelta] = []
-        crit_list: list[FRDelta] = []
-        reg_list: list[FRDelta] = []
-        imp_list: list[FRDelta] = []
-
-        for fr_id, prev, curr in critical or []:
-            d = _make_delta(fr_id, prev, curr)
-            all_deltas.append(d)
-            crit_list.append(d)
-            reg_list.append(d)
-
-        for fr_id, prev, curr in minor or []:
-            d = _make_delta(fr_id, prev, curr)
-            all_deltas.append(d)
-            reg_list.append(d)
-
-        for fr_id, prev, curr in improved or []:
-            d = _make_delta(fr_id, prev, curr)
-            all_deltas.append(d)
-            imp_list.append(d)
-
-        delta = ReportDelta(
-            previous_run_id="prev",
-            previous_overall=50.0,
-            current_overall=50.0,
-            overall_change=0.0,
-            fr_deltas=all_deltas,
-        )
-        # Inject bucketed lists (these fields come from TSK-M.2)
-        delta.critical_regressions = crit_list
-        delta.regressed_frs = reg_list
-        delta.improved_frs = imp_list
-        return delta
-
-    def _render(self, delta: ReportDelta) -> str:
-        from progress_report_orchestrator.pipeline.report import _render_trend_section
-
-        return "\n".join(_render_trend_section(delta))
-
-    def test_critical_regression_subsection_emitted(self):
-        delta = self._make_delta_with_regression(critical=[("FR1", 50.0, 25.0)])
-        md = self._render(delta)
-        assert "Critical Regressions" in md or "critical" in md.lower()
-
-    def test_minor_regression_subsection_emitted(self):
-        delta = self._make_delta_with_regression(minor=[("FR2", 50.0, 36.0)])
-        md = self._render(delta)
-        assert "Minor Regressions" in md or "minor" in md.lower() or "🟡" in md
-
-    def test_improvement_subsection_emitted(self):
-        delta = self._make_delta_with_regression(improved=[("FR3", 40.0, 60.0)])
-        md = self._render(delta)
-        assert "Improvement" in md or "improved" in md.lower() or "🟢" in md
-
-    def test_no_regression_subsection_when_no_regressions(self):
-        """Empty buckets → no regression subsections emitted."""
-        delta = self._make_delta_with_regression()
-        md = self._render(delta)
-        assert "Critical Regressions" not in md
-        assert "Minor Regressions" not in md
-
-    def test_critical_regression_shows_fr_id_and_scores(self):
-        delta = self._make_delta_with_regression(critical=[("FR1", 50.0, 25.0)])
-        md = self._render(delta)
-        assert "FR1" in md
-        assert "50" in md or "25" in md
-
-    def test_improvement_shows_fr_id_and_scores(self):
-        delta = self._make_delta_with_regression(improved=[("FR5", 40.0, 65.0)])
-        md = self._render(delta)
-        assert "FR5" in md