Merge remote-tracking branch 'origin/enterprise' into feat/TG-1090-mcp-monitors-l1

Author: testgen-ci-bot

testgen/api/runs.py

@@ -6,10 +6,10 @@
 from testgen.api.deps import db_session, resolve_job
 from testgen.api.schemas import (
     ErrorResponse,
-    IssueBreakdown,
+    IssueCounts,
     ProfilingRunResponse,
     ProfilingRunResult,
-    TestBreakdown,
+    ResultCounts,
     TestRunResponse,
     TestRunResult,
 )
@@ -42,14 +42,7 @@ def get_test_run(job: JobExecution = resolve_job("view", JobExecution.job_key ==
         counts = TestResult.count_by_status(test_run.id)
         result = TestRunResult(
             score=test_run.dq_score_test_run,
-            tests=TestBreakdown(
-                passed=counts.passed,
-                failed=counts.failed,
-                warning=counts.warning,
-                error=counts.error,
-                log=counts.log,
-                dismissed=counts.dismissed,
-            ),
+            result_counts=ResultCounts.model_validate(counts, from_attributes=True),
         )
 
     test_suite_id = test_run.test_suite_id if test_run else None
@@ -80,18 +73,13 @@ def get_profiling_run(job: JobExecution = resolve_job("view", JobExecution.job_k
 
     result = None
     if profiling_run:
-        counts = HygieneIssue.count_by_likelihood(profiling_run.id)
+        counts = HygieneIssue.count_for_run(profiling_run.id)
         result = ProfilingRunResult(
             score=profiling_run.dq_score_profiling,
             table_ct=profiling_run.table_ct,
             column_ct=profiling_run.column_ct,
             record_ct=profiling_run.record_ct,
-            issues=IssueBreakdown(
-                definite=counts.definite,
-                likely=counts.likely,
-                possible=counts.possible,
-                dismissed=counts.dismissed,
-            ),
+            issue_counts=IssueCounts.model_validate(counts, from_attributes=True),
         )
 
     return ProfilingRunResponse(

testgen/api/schemas.py

@@ -48,8 +48,8 @@ class JobListResponse(BaseModel):
 # --- Test Runs ---
 
 
-class TestBreakdown(BaseModel):
-    """Counts of test results by outcome status."""
+class ResultCounts(BaseModel):
+    """Counts of test results by outcome status, with dismissed results separated."""
 
     passed: int = 0
     failed: int = 0
@@ -63,7 +63,7 @@ class TestRunResult(BaseModel):
     """Run-specific data populated when execution completes."""
 
     score: float | None = None
-    tests: TestBreakdown
+    result_counts: ResultCounts
 
 
 class TestRunResponse(BaseModel):
@@ -81,12 +81,26 @@ class TestRunResponse(BaseModel):
 # --- Profiling Runs ---
 
 
-class IssueBreakdown(BaseModel):
-    """Counts of hygiene issues by likelihood category."""
+class HygieneIssueCounts(BaseModel):
+    """Counts of active data-quality hygiene issues by likelihood category."""
 
     definite: int = 0
     likely: int = 0
     possible: int = 0
+
+
+class PotentialPiiCounts(BaseModel):
+    """Counts of active Potential PII findings by risk level."""
+
+    high: int = 0
+    moderate: int = 0
+
+
+class IssueCounts(BaseModel):
+    """Profiling-finding breakdown: active counts by kind, plus a single dismissed total."""
+
+    hygiene_issues: HygieneIssueCounts
+    potential_pii: PotentialPiiCounts
     dismissed: int = 0
 
 
@@ -97,7 +111,7 @@ class ProfilingRunResult(BaseModel):
     table_ct: int | None = None
     column_ct: int | None = None
     record_ct: int | None = None
-    issues: IssueBreakdown
+    issue_counts: IssueCounts
 
 
 class ProfilingRunResponse(BaseModel):

testgen/common/models/hygiene_issue.py

@@ -11,7 +11,7 @@
 from sqlalchemy.orm import aliased, relationship
 from sqlalchemy.sql.functions import func
 
-from testgen.common.enums import Disposition
+from testgen.common.enums import Disposition, IssueLikelihood, PiiRisk
 from testgen.common.models import Base, get_current_session
 from testgen.common.models.entity import Entity
 from testgen.common.models.job_execution import JobExecution
@@ -23,12 +23,28 @@
 
 
 @dataclass
-class IssueLikelihoodCounts:
-    """Counts of hygiene issues by likelihood category, with dismissed/inactive separated."""
+class HygieneIssueCounts:
+    """Counts of active data-quality hygiene issues by likelihood category."""
 
     definite: int = 0
     likely: int = 0
     possible: int = 0
+
+
+@dataclass
+class PotentialPiiCounts:
+    """Counts of active Potential PII findings by risk level."""
+
+    high: int = 0
+    moderate: int = 0
+
+
+@dataclass
+class IssueCounts:
+    """Profiling-finding breakdown: active counts by kind, plus a single dismissed total."""
+
+    hygiene_issues: HygieneIssueCounts
+    potential_pii: PotentialPiiCounts
     dismissed: int = 0
 
 
@@ -202,27 +218,37 @@ def select_count_by_priority(cls, profiling_run_id: UUID) -> dict[str, IssueCoun
         return result
 
     @classmethod
-    def count_by_likelihood(cls, profile_run_id: UUID) -> IssueLikelihoodCounts:
-        """Count hygiene issues by likelihood category for a single profiling run."""
-        dismissed = func.coalesce(cls.disposition, "Confirmed").in_(("Dismissed", "Inactive"))
+    def count_for_run(cls, profile_run_id: UUID) -> IssueCounts:
+        """Count profiling findings for a single run: active hygiene issues by likelihood,
+        active Potential PII findings by risk level, and a single dismissed total."""
+        dismissed = func.coalesce(cls.disposition, Disposition.CONFIRMED).in_(
+            (Disposition.DISMISSED, Disposition.INACTIVE)
+        )
+        is_pii = HygieneIssueType.likelihood == IssueLikelihood.POTENTIAL_PII
 
-        def _count_active(likelihood_values: tuple[str, ...]):
-            return func.sum(case((~dismissed & HygieneIssueType.likelihood.in_(likelihood_values), 1), else_=0))
+        def _count(condition):
+            return func.coalesce(func.sum(case((condition, 1), else_=0)), 0)
 
         query = (
             select(
-                _count_active(("Definite",)).label("definite"),
-                _count_active(("Likely",)).label("likely"),
-                _count_active(("Possible", "Potential PII")).label("possible"),
-                func.sum(case((dismissed, 1), else_=0)).label("dismissed"),
+                _count(~dismissed & (HygieneIssueType.likelihood == IssueLikelihood.DEFINITE)).label("definite"),
+                _count(~dismissed & (HygieneIssueType.likelihood == IssueLikelihood.LIKELY)).label("likely"),
+                _count(~dismissed & (HygieneIssueType.likelihood == IssueLikelihood.POSSIBLE)).label("possible"),
+                _count(~dismissed & is_pii & (cls.priority == PiiRisk.HIGH)).label("high"),
+                _count(~dismissed & is_pii & (cls.priority == PiiRisk.MODERATE)).label("moderate"),
+                _count(dismissed).label("dismissed"),
             )
             .select_from(cls)
             .join(HygieneIssueType, HygieneIssueType.id == cls.type_id)
             .where(cls.profile_run_id == profile_run_id)
         )
 
         row = get_current_session().execute(query).first()
-        return IssueLikelihoodCounts(**{k: v for k, v in row._mapping.items() if v is not None})
+        return IssueCounts(
+            hygiene_issues=HygieneIssueCounts(definite=row.definite, likely=row.likely, possible=row.possible),
+            potential_pii=PotentialPiiCounts(high=row.high, moderate=row.moderate),
+            dismissed=row.dismissed,
+        )
 
     @classmethod
     def _priority_order(cls):

tests/unit/api/test_runs.py

@@ -7,7 +7,7 @@
 import pytest
 
 from testgen.api.runs import get_profiling_run, get_test_run
-from testgen.common.models.hygiene_issue import IssueLikelihoodCounts
+from testgen.common.models.hygiene_issue import HygieneIssueCounts, IssueCounts, PotentialPiiCounts
 from testgen.common.models.test_result import ResultStatusCounts
 
 pytestmark = pytest.mark.unit
@@ -84,9 +84,9 @@ def test_get_test_run_completed(mock_tr_cls, mock_result_cls, mock_session):
     assert result.table_group_id == TABLE_GROUP_ID
     assert result.result is not None
     assert result.result.score == 0.95
-    assert result.result.tests.passed == 90
-    assert result.result.tests.failed == 5
-    assert result.result.tests.dismissed == 12
+    assert result.result.result_counts.passed == 90
+    assert result.result.result_counts.failed == 5
+    assert result.result.result_counts.dismissed == 12
 
 
 @patch(f"{MODULE}.TestRun")
@@ -111,8 +111,10 @@ def test_get_test_run_pending_no_run(mock_tr_cls):
 def test_get_profiling_run_completed(mock_pr_cls, mock_issue_cls):
     job = _mock_job()
     mock_pr_cls.get.return_value = _mock_profiling_run()
-    mock_issue_cls.count_by_likelihood.return_value = IssueLikelihoodCounts(
-        definite=5, likely=3, possible=8, dismissed=2,
+    mock_issue_cls.count_for_run.return_value = IssueCounts(
+        hygiene_issues=HygieneIssueCounts(definite=5, likely=3, possible=8),
+        potential_pii=PotentialPiiCounts(high=4, moderate=6),
+        dismissed=2,
     )
 
     result = get_profiling_run(job)
@@ -123,9 +125,12 @@ def test_get_profiling_run_completed(mock_pr_cls, mock_issue_cls):
     assert result.result is not None
     assert result.result.score == 0.88
     assert result.result.table_ct == 10
-    assert result.result.issues.definite == 5
-    assert result.result.issues.likely == 3
-    assert result.result.issues.dismissed == 2
+    assert result.result.issue_counts.hygiene_issues.definite == 5
+    assert result.result.issue_counts.hygiene_issues.likely == 3
+    assert result.result.issue_counts.hygiene_issues.possible == 8
+    assert result.result.issue_counts.potential_pii.high == 4
+    assert result.result.issue_counts.potential_pii.moderate == 6
+    assert result.result.issue_counts.dismissed == 2
 
 
 @patch(f"{MODULE}.ProfilingRun")