Merge pull request #5430 from HHS/OPS-5380/fix-agreement-reporting-mismatch

fix: use built in award type instead of custom one for reporting summary

Author: rajohnson90

backend/ops_api/ops/utils/reporting_summary.py

@@ -1,5 +1,4 @@
 from decimal import Decimal
-from typing import Optional
 
 from sqlalchemy import and_, func, select
 from sqlalchemy.orm import Session, joinedload
@@ -25,32 +24,6 @@
 ]
 
 
-def classify_agreement_for_fy(agreement: Agreement, fiscal_year: int) -> Optional[str]:
-    """
-    Classify agreement as NEW, CONTINUING, or None for a given fiscal year.
-
-    Replicates Agreement.award_type property logic but accepts explicit fiscal year.
-    """
-    has_non_draft_blis = any(
-        bli.status is not None and bli.status != BudgetLineItemStatus.DRAFT for bli in agreement.budget_line_items
-    )
-
-    if not has_non_draft_blis:
-        return None
-
-    if not agreement.is_awarded:
-        return AgreementClassification.NEW.name
-
-    award_fy = agreement.award_fiscal_year
-    if award_fy is None:
-        return AgreementClassification.NEW.name
-
-    if fiscal_year <= award_fy:
-        return AgreementClassification.NEW.name
-
-    return AgreementClassification.CONTINUING.name
-
-
 def _find_bucket_type(agreement_type):
     """Find the spending bucket type for a given agreement type."""
     for config in AGREEMENT_TYPE_CONFIG:
@@ -65,7 +38,7 @@ def _accumulate_agreement_spending(agreement, fiscal_year, totals, portfolio_ids
     if bucket_type is None:
         return
 
-    classification = classify_agreement_for_fy(agreement, fiscal_year)
+    classification = agreement.award_type  # Use award_type property for consistency with Agreements list
     if classification is None:
         return
 
@@ -205,7 +178,7 @@ def get_reporting_counts(session: Session, fiscal_year: int, portfolio_ids=None)
             continue
         agreement_counts[bucket_type] += 1
 
-        classification = classify_agreement_for_fy(agreement, fiscal_year)
+        classification = agreement.award_type
         if classification == AgreementClassification.NEW.name:
             new_counts[bucket_type] += 1
         elif classification == AgreementClassification.CONTINUING.name:

backend/ops_api/tests/ops/funding_summary/test_agreement_spending_summary.py

@@ -5,92 +5,20 @@
 import pytest
 
 from models import (
-    Agreement,
+    AgreementClassification,
     AgreementType,
     BudgetLineItemStatus,
     ContractAgreement,
     ContractBudgetLineItem,
     GrantAgreement,
     GrantBudgetLineItem,
 )
-from models.agreements import AgreementClassification
 from ops_api.ops.utils.reporting_summary import (
     _accumulate_agreement_spending,
-    classify_agreement_for_fy,
     get_agreement_spending_by_type,
 )
 
 
-class TestClassifyAgreementForFy:
-    def test_no_non_draft_blis_returns_none(self):
-        agreement = MagicMock(spec=Agreement)
-        draft_bli = MagicMock()
-        draft_bli.status = BudgetLineItemStatus.DRAFT
-        agreement.budget_line_items = [draft_bli]
-
-        result = classify_agreement_for_fy(agreement, 2025)
-        assert result is None
-
-    def test_empty_blis_returns_none(self):
-        agreement = MagicMock(spec=Agreement)
-        agreement.budget_line_items = []
-
-        result = classify_agreement_for_fy(agreement, 2025)
-        assert result is None
-
-    def test_not_awarded_returns_new(self):
-        agreement = MagicMock(spec=Agreement)
-        planned_bli = MagicMock()
-        planned_bli.status = BudgetLineItemStatus.PLANNED
-        agreement.budget_line_items = [planned_bli]
-        agreement.is_awarded = False
-
-        result = classify_agreement_for_fy(agreement, 2025)
-        assert result == AgreementClassification.NEW.name
-
-    def test_awarded_no_award_date_returns_new(self):
-        agreement = MagicMock(spec=Agreement)
-        planned_bli = MagicMock()
-        planned_bli.status = BudgetLineItemStatus.PLANNED
-        agreement.budget_line_items = [planned_bli]
-        agreement.is_awarded = True
-        agreement.award_fiscal_year = None
-
-        result = classify_agreement_for_fy(agreement, 2025)
-        assert result == AgreementClassification.NEW.name
-
-    def test_awarded_current_fy_lte_award_fy_returns_new(self):
-        agreement = MagicMock(spec=Agreement)
-        planned_bli = MagicMock()
-        planned_bli.status = BudgetLineItemStatus.PLANNED
-        agreement.budget_line_items = [planned_bli]
-        agreement.is_awarded = True
-        agreement.award_fiscal_year = 2025
-
-        result = classify_agreement_for_fy(agreement, 2025)
-        assert result == AgreementClassification.NEW.name
-
-    def test_awarded_current_fy_gt_award_fy_returns_continuing(self):
-        agreement = MagicMock(spec=Agreement)
-        planned_bli = MagicMock()
-        planned_bli.status = BudgetLineItemStatus.PLANNED
-        agreement.budget_line_items = [planned_bli]
-        agreement.is_awarded = True
-        agreement.award_fiscal_year = 2024
-
-        result = classify_agreement_for_fy(agreement, 2025)
-        assert result == AgreementClassification.CONTINUING.name
-
-    def test_bli_with_none_status_ignored(self):
-        agreement = MagicMock(spec=Agreement)
-        none_bli = MagicMock()
-        none_bli.status = None
-        agreement.budget_line_items = [none_bli]
-
-        result = classify_agreement_for_fy(agreement, 2025)
-        assert result is None
-
-
 @pytest.fixture()
 def db_with_agreement_spending_data(app, loaded_db, app_ctx):
     from models import CAN, CANFundingBudget, CANFundingDetails, Portfolio, ResearchProject
@@ -410,7 +338,7 @@ def test_processes_mix_of_blis_with_and_without_can(self):
         """Only BLIs with a CAN should contribute to totals."""
         agreement = MagicMock()
         agreement.agreement_type = AgreementType.CONTRACT
-        agreement.is_awarded = False
+        agreement.award_type = AgreementClassification.NEW.name
 
         bli_no_can = MagicMock()
         bli_no_can.fiscal_year = 2025

backend/ops_api/tests/ops/utils/test_reporting_counts.py

@@ -1,15 +1,21 @@
 from datetime import date
 from decimal import Decimal
+from unittest.mock import patch
 
 import pytest
 
 from models import (
+    CAN,
     AgreementType,
     BudgetLineItemStatus,
+    CANFundingBudget,
+    CANFundingDetails,
     ContractAgreement,
     ContractBudgetLineItem,
     GrantAgreement,
     GrantBudgetLineItem,
+    Portfolio,
+    ResearchProject,
 )
 from ops_api.ops.utils.reporting_summary import get_reporting_counts
 
@@ -202,3 +208,132 @@ def test_get_reporting_counts_empty_fy(app, loaded_db, app_ctx):
     assert result["new_agreements"]["total"] == 0
     assert result["continuing_agreements"]["total"] == 0
     assert result["budget_lines"]["total"] == 0
+
+
+@pytest.fixture()
+def db_with_2024_data(app, loaded_db, app_ctx):
+    """Fixture with FY 2024 data for testing with mocked get_current_fiscal_year."""
+
+    portfolio = Portfolio(name="FY2024 TEST PORTFOLIO", division_id=1)
+    can = CAN(number="FY2024_TEST_CAN")
+    portfolio.cans.append(can)
+    loaded_db.add(portfolio)
+    loaded_db.commit()
+
+    can_funding_details = CANFundingDetails(fiscal_year=2024, fund_code="FY2024TEST")
+    can.funding_details = can_funding_details
+    loaded_db.add(can_funding_details)
+    loaded_db.commit()
+
+    can_funding_budget = CANFundingBudget(can_id=can.id, fiscal_year=2024, budget=Decimal(30000000))
+    loaded_db.add(can_funding_budget)
+    loaded_db.commit()
+
+    # Research project
+    project = ResearchProject(title="FY2024 Test Project", short_title="FY24TP", description="Test project for FY 2024")
+    loaded_db.add(project)
+    loaded_db.commit()
+
+    # Contract agreement with PLANNED BLI in FY 2024
+    contract = ContractAgreement(name="FY2024 Contract", agreement_type=AgreementType.CONTRACT, project_id=project.id)
+    loaded_db.add(contract)
+    loaded_db.commit()
+
+    bli_planned = ContractBudgetLineItem(
+        line_description="FY2024 Planned BLI",
+        amount=Decimal("8000000"),
+        status=BudgetLineItemStatus.PLANNED,
+        can_id=can.id,
+        date_needed=date(2024, 3, 15),
+        agreement_id=contract.id,
+    )
+    loaded_db.add(bli_planned)
+    loaded_db.commit()
+
+    # Grant agreement with OBLIGATED BLI in FY 2024
+    grant = GrantAgreement(name="FY2024 Grant", agreement_type=AgreementType.GRANT, project_id=project.id)
+    loaded_db.add(grant)
+    loaded_db.commit()
+
+    bli_obligated = GrantBudgetLineItem(
+        line_description="FY2024 Obligated BLI",
+        amount=Decimal("3000000"),
+        status=BudgetLineItemStatus.OBLIGATED,
+        can_id=can.id,
+        date_needed=date(2024, 8, 1),
+        agreement_id=grant.id,
+    )
+    loaded_db.add(bli_obligated)
+    loaded_db.commit()
+
+    # Contract with IN_EXECUTION BLI in FY 2024
+    contract_exec = ContractAgreement(
+        name="FY2024 Executing Contract", agreement_type=AgreementType.CONTRACT, project_id=project.id
+    )
+    loaded_db.add(contract_exec)
+    loaded_db.commit()
+
+    bli_in_execution = ContractBudgetLineItem(
+        line_description="FY2024 In Execution BLI",
+        amount=Decimal("2000000"),
+        status=BudgetLineItemStatus.IN_EXECUTION,
+        can_id=can.id,
+        date_needed=date(2024, 5, 1),
+        agreement_id=contract_exec.id,
+    )
+    loaded_db.add(bli_in_execution)
+    loaded_db.commit()
+
+    yield loaded_db
+
+    loaded_db.rollback()
+    for obj in [
+        bli_in_execution,
+        contract_exec,
+        bli_obligated,
+        grant,
+        bli_planned,
+        contract,
+        project,
+        can_funding_budget,
+        can_funding_details,
+        can,
+        portfolio,
+    ]:
+        loaded_db.delete(obj)
+    loaded_db.commit()
+
+
+@patch("models.utils.fiscal_year.get_current_fiscal_year", return_value=2024)
+def test_get_reporting_counts_with_mocked_fy_2024(mock_fy, app, db_with_2024_data, app_ctx):
+    """Test get_reporting_counts with mocked get_current_fiscal_year returning 2024."""
+    # Verify the mock is working
+    # assert get_current_fiscal_year() == 2024
+
+    # Get reporting counts for FY 2024
+    result = get_reporting_counts(app.db_session, 2024)
+
+    # Verify structure
+    assert "projects" in result
+    assert "agreements" in result
+    assert "new_agreements" in result
+    assert "continuing_agreements" in result
+    assert "budget_lines" in result
+
+    # Verify project counts - we created 1 research project
+    assert result["projects"]["total"] >= 1
+    project_types = {t["type"]: t["count"] for t in result["projects"]["types"]}
+    assert project_types.get("RESEARCH", 0) >= 1
+
+    # Verify agreement counts - we created 2 contracts and 1 grant with non-DRAFT BLIs
+    assert result["agreements"]["total"] >= 3
+    agreement_types = {t["type"]: t["count"] for t in result["agreements"]["types"]}
+    assert agreement_types.get("CONTRACT", 0) >= 2  # 2 contracts
+    assert agreement_types.get("GRANT", 0) >= 1  # 1 grant
+
+    # Verify budget line counts - we created 3 BLIs: PLANNED, OBLIGATED, IN_EXECUTION
+    assert result["budget_lines"]["total"] >= 3
+    bli_types = {t["type"]: t["count"] for t in result["budget_lines"]["types"]}
+    assert bli_types.get("PLANNED", 0) >= 1
+    assert bli_types.get("OBLIGATED", 0) >= 1
+    assert bli_types.get("IN_EXECUTION", 0) >= 1