planar 0.5.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

planar/rules/test_rules.py

@@ -1,7 +1,9 @@
 import json
 from datetime import datetime, timezone
 from enum import Enum
-from typing import Any, Dict
+from operator import itemgetter
+from pathlib import Path
+from typing import Any, Dict, cast
 from unittest.mock import patch
 from uuid import UUID
 
@@ -704,11 +706,9 @@ async def test_create_jdm_graph():
         col for col in output_columns if col.field == "discount_reason"
     )
 
-    assert getattr(rule_values, final_price_col.id) == "0"  # number default
-    assert getattr(rule_values, discount_applied_col.id) == "0"  # number default
-    assert (
-        getattr(rule_values, discount_reason_col.id) == '"default value"'
-    )  # string default
+    assert rule_values[final_price_col.id] == "0"  # number default
+    assert rule_values[discount_applied_col.id] == "0"  # number default
+    assert rule_values[discount_reason_col.id] == '"default value"'  # string default
 
     # Verify input and output nodes have proper schemas
     input_node = next(node for node in jdm_graph.nodes if node.type == "inputNode")
@@ -748,3 +748,747 @@ async def test_jdm_graph_evaluation():
     assert result.result["final_price"] == 0.0
     assert result.result["discount_applied"] == 0.0
     assert "default value" in result.result["discount_reason"]
+
+
+def test_evalute_rule_with_airline_loyalty_points_calculator_rule():
+    airline_loyalty_points_calculator_path = (
+        Path(__file__).parent / "test_data" / "airline_loyalty_points_calculator.json"
+    )
+    with open(airline_loyalty_points_calculator_path, "r", encoding="utf-8") as f:
+        jdm_dict = json.load(f)
+
+    input_data = {
+        "booking": {
+            "fareClass": "Business",
+            "routeType": "International",
+            "distance": 3500,
+            "isSeasonalPromotion": True,
+        },
+        "member": {
+            "status": "Gold",
+            "id": "MEM12345",
+            "name": "John Smith",
+            "enrollmentDate": "2020-05-15",
+        },
+    }
+
+    result = evaluate_rule(JDMGraph.model_validate(jdm_dict), input_data)
+
+    assert result.success
+    assert cast(EvaluateResponse, result).result == {
+        "calculatedPoints": 9000,
+        "seasonalPromotion": 1.5,
+        "totalPoints": 9000,
+    }
+
+
+def test_evalute_rule_with_account_dormancy_management_rule():
+    account_dormancy_management_path = (
+        Path(__file__).parent / "test_data" / "account_dormancy_management.json"
+    )
+    with open(account_dormancy_management_path, "r", encoding="utf-8") as f:
+        jdm_dict = json.load(f)
+
+    input_data = {
+        "accountId": "ACC98765432",
+        "accountType": "savings",
+        "customerTier": "premium",
+        "lastActivityDate": "2024-11-15",
+        "dormancyThreshold": 180,
+        "accountBalance": 25750.45,
+        "currency": "USD",
+        "region": "NORTH_AMERICA",
+        "contactPreference": "email",
+        "customerEmail": "customer@example.com",
+        "customerPhone": "+15551234567",
+        "regulatoryJurisdiction": "US-NY",
+    }
+
+    result = evaluate_rule(JDMGraph.model_validate(jdm_dict), input_data)
+
+    assert result.success
+    assert cast(EvaluateResponse, result).result == {
+        "actionPriority": "high",
+        "recommendedAction": "fee_waiver",
+    }
+
+
+def test_evalute_rule_with_clinical_trial_eligibility_screener_rule():
+    clinical_trial_eligibility_screener_path = (
+        Path(__file__).parent / "test_data" / "clinical_trial_eligibility_screener.json"
+    )
+    with open(clinical_trial_eligibility_screener_path, "r", encoding="utf-8") as f:
+        jdm_dict = json.load(f)
+
+    input_data = {
+        "patient": {
+            "id": "P67890",
+            "name": "John Smith",
+            "age": 68,
+            "diagnosis": "lung_cancer",
+            "diseaseStage": "IV",
+            "currentMedications": ["immunosuppressants", "albuterol", "omeprazole"],
+            "priorTreatments": 3,
+            "comorbidities": ["autoimmune_disease", "COPD"],
+            "lastLabResults": {"wbc": 3.8, "hgb": 10.9, "plt": 150, "creatinine": 1.2},
+        }
+    }
+
+    result = evaluate_rule(JDMGraph.model_validate(jdm_dict), input_data)
+
+    expected_result = {
+        "decisionSummary": "Patient is not eligible for clinical trial",
+        "eligibilityReasons": [
+            {
+                "flag": False,
+                "reason": "Stage IV patients excluded from trial",
+            },
+            {
+                "flag": True,
+                "reason": "Diagnosis matches trial criteria",
+            },
+            {
+                "flag": True,
+                "reason": "Age within eligible range",
+            },
+            {
+                "flag": False,
+                "reason": "Excluded comorbidity present",
+            },
+            {
+                "flag": False,
+                "reason": "Patient taking excluded medications",
+            },
+            {
+                "flag": False,
+                "reason": "Too many prior treatments",
+            },
+        ],
+        "failedCriteria": [
+            "stage",
+            "comorbidity",
+            "medication",
+            "priorTreatment",
+        ],
+        "isEligible": False,
+    }
+
+    result = cast(EvaluateResponse, result)
+
+    def sort_reasons(reasons: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        return sorted(reasons, key=itemgetter("reason"))
+
+    assert result.success
+    assert result.result["decisionSummary"] == expected_result["decisionSummary"]
+    assert sort_reasons(result.result["eligibilityReasons"]) == sort_reasons(
+        expected_result["eligibilityReasons"]
+    )
+    assert sorted(result.result["failedCriteria"]) == sorted(
+        expected_result["failedCriteria"]
+    )
+    assert result.result["isEligible"] == expected_result["isEligible"]
+
+
+def test_evalute_rule_with_customer_lifetime_value_rule():
+    customer_lifetime_value_path = (
+        Path(__file__).parent / "test_data" / "customer_lifetime_value.json"
+    )
+    with open(customer_lifetime_value_path, "r", encoding="utf-8") as f:
+        jdm_dict = json.load(f)
+
+    input_data = {
+        "customer": {
+            "id": "CUST-12345",
+            "name": "John Doe",
+            "segment": "retail",
+            "acquisitionCost": 150,
+            "acquisitionChannel": "paid_search",
+        },
+        "purchaseHistory": {
+            "orderValues": [120, 89, 245, 78, 310],
+            "customerDurationMonths": 18,
+            "averageGrossMarginPercent": 35,
+            "retentionRate": 85,
+        },
+    }
+
+    result = evaluate_rule(JDMGraph.model_validate(jdm_dict), input_data)
+
+    assert result.success
+    assert cast(EvaluateResponse, result).result == {
+        "acquisitionCostRatio": 0.009543603664743808,
+        "adjustedLTV": 15567.333333333334,
+        "averageOrderValue": 168.4,
+        "basicLTV": 15717.333333333334,
+        "customer": {
+            "acquisitionChannel": "paid_search",
+            "acquisitionCost": 150,
+            "id": "CUST-12345",
+            "name": "John Doe",
+            "segment": "retail",
+        },
+        "customerInsights": {
+            "recommendedStrategy": "High-touch service, premium offers, exclusive events",
+            "tier": "platinum",
+        },
+        "customerLifetimeMonths": 80,
+        "grossMargin": 0.35,
+        "purchaseFrequency": 3.3333333333333335,
+        "purchaseHistory": {
+            "averageGrossMarginPercent": 35,
+            "customerDurationMonths": 18,
+            "orderValues": [120, 89, 245, 78, 310],
+            "retentionRate": 85,
+        },
+    }
+
+
+def test_evaluate_rule_with_supply_chain_risk_assessment_rule():
+    supply_chain_risk_assessment_path = (
+        Path(__file__).parent / "test_data" / "supply_chain_risk.json"
+    )
+    with open(supply_chain_risk_assessment_path, "r", encoding="utf-8") as f:
+        jdm_dict = json.load(f)
+
+    input_data = {
+        "supplier": {
+            "name": "GlobalTech Supplies Inc.",
+            "location": "medium_risk_region",
+            "performanceScore": 82,
+            "alternateSourcesCount": 2,
+            "products": [
+                {"id": "P123", "name": "Semiconductor Chip", "criticalComponent": True}
+            ],
+            "relationshipDurationMonths": 36,
+        },
+        "geopoliticalTensions": True,
+        "marketVolatility": "medium",
+        "supplyCategory": "electronics",
+        "leadTimeData": {"averageDays": 45, "historicalVariance": 8},
+    }
+
+    result = evaluate_rule(JDMGraph.model_validate(jdm_dict), input_data)
+
+    assert result.success
+    assert cast(EvaluateResponse, result).result == {
+        "adjustedRiskScore": 57,
+        "assessment": {
+            "baseRiskCategory": "medium",
+            "baseRiskScore": 40,
+            "recommendedAction": "Monitor supplier performance and conduct quarterly reviews",
+        },
+        "finalAssessment": {
+            "leadTimeImpact": "minor",
+            "priorityLevel": "medium",
+            "riskCategory": "medium",
+        },
+        "geopoliticalFactor": 1.3,
+        "geopoliticalTensions": True,
+        "leadTimeData": {"averageDays": 45, "historicalVariance": 8},
+        "marketVolatility": "medium",
+        "marketVolatilityFactor": 1.1,
+        "supplier": {
+            "alternateSourcesCount": 2,
+            "location": "medium_risk_region",
+            "name": "GlobalTech Supplies Inc.",
+            "performanceScore": 82,
+            "products": [
+                {"criticalComponent": True, "id": "P123", "name": "Semiconductor Chip"}
+            ],
+            "relationshipDurationMonths": 36,
+        },
+        "supplyCategory": "electronics",
+    }
+
+
+def test_evaluate_rule_with_import_duties_calculator_rule():
+    import_duties_calculator_path = (
+        Path(__file__).parent / "test_data" / "import_duties_calculator.json"
+    )
+    with open(import_duties_calculator_path, "r", encoding="utf-8") as f:
+        jdm_dict = json.load(f)
+
+    input_data = {
+        "product": {
+            "category": "electronics",
+            "value": 1200,
+            "weight": 0.8,
+            "hsCode": "851712",
+        },
+        "origin": {"country": "CN", "hasFTA": False, "preferentialTreatment": False},
+        "destination": {"country": "US"},
+    }
+
+    result = evaluate_rule(JDMGraph.model_validate(jdm_dict), input_data)
+
+    assert result.success
+    assert cast(EvaluateResponse, result).result == {
+        "additionalFees": 0,
+        "baseDuty": 180,
+        "countryAdjustment": 225,
+        "dutyRate": 0.1875,
+        "minDuty": 225,
+        "preferentialDiscount": 225,
+        "totalDuty": 225,
+    }
+
+
+def test_evaluate_rule_with_cellular_data_rollover_system_rule():
+    cellular_data_rollover_system_path = (
+        Path(__file__).parent / "test_data" / "cellular_data_rollover_system.json"
+    )
+    with open(cellular_data_rollover_system_path, "r", encoding="utf-8") as f:
+        jdm_dict = json.load(f)
+
+    input_data = {
+        "plan": {
+            "type": "premium",
+            "monthlyDataAllowance": 50,
+            "rolloverEligible": True,
+        },
+        "currentBillingCycle": {
+            "dataUsed": 35,
+            "consecutiveRollovers": 1,
+            "rolloverData": 5,
+        },
+    }
+
+    result = evaluate_rule(JDMGraph.model_validate(jdm_dict), input_data)
+
+    assert result.success
+    assert cast(EvaluateResponse, result).result == {
+        "nextBillingCycle": {"consecutiveRollovers": 2, "status": "approved"},
+        "responseMessage": "Rollover successful. You have 20 GB of rollover data available for your next billing cycle.",
+    }
+
+
+def test_evaluate_rule_with_online_check_in_eligibility_system_rule():
+    online_check_in_eligibility_system_path = (
+        Path(__file__).parent / "test_data" / "online_check_in_eligibility_system.json"
+    )
+    with open(online_check_in_eligibility_system_path, "r", encoding="utf-8") as f:
+        jdm_dict = json.load(f)
+
+    input_data = {
+        "passenger": {
+            "id": "P12345678",
+            "name": "John Smith",
+            "hasValidPassport": True,
+            "hasValidVisa": True,
+            "requiresSpecialAssistance": False,
+            "frequentFlyerStatus": "gold",
+        },
+        "flight": {
+            "flightNumber": "BA123",
+            "departureTime": "2025-03-20T10:30:00Z",
+            "origin": "LHR",
+            "destination": "JFK",
+            "requiresVisa": True,
+            "hasSeatSelection": True,
+            "allowsExtraBaggage": True,
+            "hasSpecialMealOptions": True,
+        },
+    }
+
+    result = evaluate_rule(JDMGraph.model_validate(jdm_dict), input_data)
+
+    assert result.success
+    assert cast(EvaluateResponse, result).result == {
+        "canAddBaggage": True,
+        "canSelectSeat": True,
+        "isEligible": False,
+        "message": "You are eligible for online check-in.",
+        "statusCode": "eligible",
+    }
+
+
+def test_evaluate_rule_with_warehouse_cross_docking_rule():
+    warehouse_cross_docking_path = (
+        Path(__file__).parent / "test_data" / "warehouse_cross_docking.json"
+    )
+    with open(warehouse_cross_docking_path, "r", encoding="utf-8") as f:
+        jdm_dict = json.load(f)
+
+    input_data = {
+        "inboundShipmentId": "IN-12345",
+        "inboundShipmentTime": "2025-03-19T10:00:00Z",
+        "outboundShipmentTime": "2025-03-20T09:00:00Z",
+        "matchingOutboundOrders": [
+            {
+                "orderId": "ORD-789",
+                "customerPriority": "standard",
+                "destinationZone": "East",
+            },
+            {
+                "orderId": "ORD-790",
+                "customerPriority": "premium",
+                "destinationZone": "East",
+            },
+        ],
+        "inboundShipmentItems": [
+            {"sku": "ITEM-001", "quantity": 50, "category": "Electronics"},
+            {"sku": "ITEM-002", "quantity": 30, "category": "Home Goods"},
+        ],
+        "currentStorageUsed": 7500,
+        "totalStorageCapacity": 10000,
+        "crossDockingBayAssignment": "Bay-E4",
+    }
+
+    result = evaluate_rule(JDMGraph.model_validate(jdm_dict), input_data)
+
+    assert result.success
+    assert cast(EvaluateResponse, result).result == {
+        "crossDockDecision": "cross-dock",
+        "crossDockingBayAssignment": "Bay-E4",
+        "currentStorageUsed": 7500,
+        "decisionReason": "Matching orders available within 48 hours",
+        "dockingBay": "Bay-E4",
+        "estimatedProcessingTime": 30,
+        "hasMatchingOutboundOrders": True,
+        "inboundShipmentId": "IN-12345",
+        "inboundShipmentItems": [
+            {"category": "Electronics", "quantity": 50, "sku": "ITEM-001"},
+            {"category": "Home Goods", "quantity": 30, "sku": "ITEM-002"},
+        ],
+        "inboundShipmentTime": "2025-03-19T10:00:00Z",
+        "matchingOutboundOrders": [
+            {
+                "customerPriority": "standard",
+                "destinationZone": "East",
+                "orderId": "ORD-789",
+            },
+            {
+                "customerPriority": "premium",
+                "destinationZone": "East",
+                "orderId": "ORD-790",
+            },
+        ],
+        "outboundShipmentTime": "2025-03-20T09:00:00Z",
+        "priority": "normal",
+        "timeDifferenceHours": 23,
+        "totalStorageCapacity": 10000,
+        "warehouseCapacityPercentage": 75,
+    }
+
+
+def test_evaluate_rule_with_booking_fraud_detection_rule():
+    booking_fraud_detection_path = (
+        Path(__file__).parent / "test_data" / "booking_fraud_detection.json"
+    )
+    with open(booking_fraud_detection_path, "r", encoding="utf-8") as f:
+        jdm_dict = json.load(f)
+
+    input_data = {
+        "booking": {
+            "payment_method": "prepaid_card",
+            "amount": 2500,
+            "ip_country": "US",
+        },
+        "account": {"country": "US", "bookings_last_24h": 6},
+    }
+
+    result = evaluate_rule(JDMGraph.model_validate(jdm_dict), input_data)
+
+    assert result.success
+    assert cast(EvaluateResponse, result).result == {
+        "flags": {"manual_review": True, "requires_verification": True},
+    }
+
+
+def test_evaluate_rule_with_applicant_risk_assessment_rule():
+    applicant_risk_assessment_path = (
+        Path(__file__).parent / "test_data" / "applicant_risk_assessment.json"
+    )
+    with open(applicant_risk_assessment_path, "r", encoding="utf-8") as f:
+        jdm_dict = json.load(f)
+
+    input_data = {
+        "applicant": {
+            "creditScore": 710,
+            "latePayments": 1,
+            "creditHistoryMonths": 48,
+            "employmentMonths": 36,
+            "incomeVerification": "complete",
+            "bankAccountStanding": "good",
+            "debtToIncomeRatio": 0.35,
+            "outstandingLoans": 2,
+        }
+    }
+
+    result = evaluate_rule(JDMGraph.model_validate(jdm_dict), input_data)
+
+    assert result.success
+    assert cast(EvaluateResponse, result).result == {
+        "applicant": {
+            "bankAccountStanding": "good",
+            "creditHistoryMonths": 48,
+            "creditScore": 710,
+            "debtToIncomeRatio": 0.35,
+            "employmentMonths": 36,
+            "incomeVerification": "complete",
+            "latePayments": 1,
+            "outstandingLoans": 2,
+        },
+        "approvalStatus": "manual-review",
+        "interestRateModifier": 0,
+        "negativeFactors": [],
+        "negativeFactorsCount": 0,
+        "riskCategory": "medium",
+        "scores": {"creditHistory": 20, "debtToIncome": 15, "incomeStability": 20},
+        "totalRiskScore": 55,
+    }
+
+
+def test_evaluate_rule_with_insurance_prior_authorization_rule():
+    insurance_prior_authorization_path = (
+        Path(__file__).parent / "test_data" / "insurance_prior_authorization.json"
+    )
+    with open(insurance_prior_authorization_path, "r", encoding="utf-8") as f:
+        jdm_dict = json.load(f)
+
+    input_data = {
+        "patientInfo": {"insuranceType": "Commercial"},
+        "diagnosisCodes": ["M54.5", "M51.26"],
+        "serviceType": "Imaging",
+        "serviceDetails": {
+            "code": "70551",
+            "cost": 1200,
+            "isEmergency": False,
+        },
+    }
+
+    result = evaluate_rule(JDMGraph.model_validate(jdm_dict), input_data)
+
+    assert result.success
+    assert cast(EvaluateResponse, result).result["requiresAuthorization"]
+    assert (
+        cast(EvaluateResponse, result).result["reason"]
+        == "Advanced imaging requires prior authorization"
+    )
+
+
+def test_evaluate_rule_with_portfolio_risk_monitor_rule():
+    portfolio_risk_monitor_path = (
+        Path(__file__).parent / "test_data" / "portfolio_risk_monitor.json"
+    )
+    with open(portfolio_risk_monitor_path, "r", encoding="utf-8") as f:
+        jdm_dict = json.load(f)
+
+    input_data = {
+        "customer": {
+            "id": "cust-78945",
+            "name": "John Smith",
+            "riskTolerance": "moderate",
+            "investmentHorizon": "long-term",
+            "preferences": {
+                "allowAutomaticAdjustments": True,
+                "alertThreshold": "moderate",
+                "communicationPreference": "email",
+            },
+        },
+        "portfolio": {
+            "id": "port-12345",
+            "name": "Retirement Portfolio",
+            "totalValue": 750000,
+            "creationDate": "2019-05-12",
+            "lastRebalance": 95,
+            "volatility": 22.5,
+            "highRiskPercentage": 35,
+            "currentAllocation": {"equity": 65, "bonds": 25, "cash": 10},
+            "targetAllocation": {"equity": 60, "bonds": 35, "cash": 5},
+            "holdings": [
+                {
+                    "symbol": "VTI",
+                    "category": "equity",
+                    "percentage": 30,
+                    "value": 225000,
+                },
+                {
+                    "symbol": "VXUS",
+                    "category": "equity",
+                    "percentage": 20,
+                    "value": 150000,
+                },
+                {
+                    "symbol": "VGT",
+                    "category": "equity",
+                    "percentage": 15,
+                    "value": 112500,
+                },
+                {
+                    "symbol": "BND",
+                    "category": "bonds",
+                    "percentage": 25,
+                    "value": 187500,
+                },
+                {
+                    "symbol": "CASH",
+                    "category": "cash",
+                    "percentage": 10,
+                    "value": 75000,
+                },
+            ],
+        },
+        "market": {
+            "volatilityIndex": 28.5,
+            "trendPercentage": -12.5,
+            "interestRate": 3.75,
+            "sectorPerformance": {
+                "technology": -15.2,
+                "healthcare": -5.1,
+                "financials": -18.4,
+                "consumerStaples": -3.2,
+                "utilities": 1.5,
+            },
+            "economicIndicators": {
+                "gdpGrowth": 0.8,
+                "inflation": 4.2,
+                "unemploymentRate": 4.1,
+            },
+        },
+    }
+
+    result = evaluate_rule(JDMGraph.model_validate(jdm_dict), input_data)
+
+    assert result.success
+
+    assert cast(EvaluateResponse, result).result["action"] == "rebalance"
+    assert cast(EvaluateResponse, result).result["outcome"] == {
+        "riskScore": 0.53,
+        "status": "rebalance_suggested",
+        "timestamp": cast(EvaluateResponse, result).result["outcome"]["timestamp"],
+    }
+
+    assert cast(EvaluateResponse, result).result["rebalanceDetails"] == {
+        "currentAllocation": {"bonds": 25, "cash": 10, "equity": 65},
+        "customerId": "cust-78945",
+        "date": cast(EvaluateResponse, result).result["rebalanceDetails"]["date"],
+        "driftPercentage": "5.0",
+        "message": "Rebalancing recommended: Portfolio has drifted 5.0% from target allocation.",
+        "portfolioId": "port-12345",
+        "riskCategory": "high",
+        "riskScore": 0.53,
+        "suggestedChanges": {"bonds": 10, "cash": -5, "equity": -5},
+        "targetAllocation": {"bonds": 35, "cash": 5, "equity": 60},
+    }
+
+
+def test_evaluate_rule_with_order_consolidation_system_rule():
+    order_consolidation_system_path = (
+        Path(__file__).parent / "test_data" / "order_consolidation_system.json"
+    )
+    with open(order_consolidation_system_path, "r", encoding="utf-8") as f:
+        jdm_dict = json.load(f)
+
+    input_data = {
+        "orders": [
+            {
+                "orderId": "ORD-12345",
+                "customerName": "John Smith",
+                "deliveryAddress": {
+                    "street": "123 Main St",
+                    "city": "Springfield",
+                    "state": "IL",
+                    "zipCode": "62704",
+                    "coordinates": {"latitude": 39.7817, "longitude": -89.6501},
+                },
+                "requestedDeliveryDate": "2025-03-25T14:00:00Z",
+                "orderWeight": 12.5,
+                "orderItems": 3,
+            },
+            {
+                "orderId": "ORD-12346",
+                "customerName": "Jane Doe",
+                "deliveryAddress": {
+                    "street": "456 Oak Ave",
+                    "city": "Springfield",
+                    "state": "IL",
+                    "zipCode": "62702",
+                    "coordinates": {"latitude": 39.8021, "longitude": -89.6443},
+                },
+                "requestedDeliveryDate": "2025-03-25T16:00:00Z",
+                "orderWeight": 8.2,
+                "orderItems": 2,
+            },
+        ],
+        "distanceKm": 35,
+        "deliveryWindowDifferenceHours": 24,
+        "availableCarrierCapacity": 4,
+        "orderWeight1": 12.5,
+        "orderWeight2": 8.2,
+        "carrierDetails": {
+            "carrierId": "CAR-789",
+            "maxCapacity": 500,
+            "currentLoad": 320,
+        },
+    }
+
+    result = evaluate_rule(JDMGraph.model_validate(jdm_dict), input_data)
+
+    assert result.success
+
+    assert cast(EvaluateResponse, result).result["canConsolidate"]
+    assert cast(EvaluateResponse, result).result["schedulingPriority"] == "high"
+    assert cast(EvaluateResponse, result).result["availableCarrierCapacity"] == 4
+    assert cast(EvaluateResponse, result).result["carrierDetails"] == {
+        "carrierId": "CAR-789",
+        "currentLoad": 320,
+        "maxCapacity": 500,
+    }
+    assert (
+        cast(EvaluateResponse, result).result["consolidationAction"]
+        == "immediate_consolidation"
+    )
+    assert cast(EvaluateResponse, result).result["consolidationPriority"] == "high"
+    assert cast(EvaluateResponse, result).result["consolidationWeight"] == 20.7
+    assert cast(EvaluateResponse, result).result["costSavingEstimate"] == 23.75
+    assert cast(EvaluateResponse, result).result["costSavingsReport"] == {
+        "fuelSavings": 5.25,
+        "laborSavings": 23.75,
+        "totalSavings": 29,
+    }
+
+    assert cast(EvaluateResponse, result).result["deliverySchedule"] == {
+        "estimatedDeliveryTime": None,
+        "notificationRequired": False,
+        "type": "consolidated",
+    }
+    assert cast(EvaluateResponse, result).result["deliveryWindowDifferenceHours"] == 24
+    assert cast(EvaluateResponse, result).result["distanceKm"] == 35
+    assert cast(EvaluateResponse, result).result["expectedFuelSavings"] == 5.25
+    assert (
+        cast(EvaluateResponse, result).result["explanation"]
+        == "Orders are nearby, delivery window compatible, and carrier has capacity"
+    )
+    assert cast(EvaluateResponse, result).result["orderWeight1"] == 12.5
+    assert cast(EvaluateResponse, result).result["orderWeight2"] == 8.2
+    assert cast(EvaluateResponse, result).result["orders"] == [
+        {
+            "customerName": "John Smith",
+            "deliveryAddress": {
+                "city": "Springfield",
+                "coordinates": {"latitude": 39.7817, "longitude": -89.6501},
+                "state": "IL",
+                "street": "123 Main St",
+                "zipCode": "62704",
+            },
+            "orderId": "ORD-12345",
+            "orderItems": 3,
+            "orderWeight": 12.5,
+            "requestedDeliveryDate": "2025-03-25T14:00:00Z",
+        },
+        {
+            "customerName": "Jane Doe",
+            "deliveryAddress": {
+                "city": "Springfield",
+                "coordinates": {"latitude": 39.8021, "longitude": -89.6443},
+                "state": "IL",
+                "street": "456 Oak Ave",
+                "zipCode": "62702",
+            },
+            "orderId": "ORD-12346",
+            "orderItems": 2,
+            "orderWeight": 8.2,
+            "requestedDeliveryDate": "2025-03-25T16:00:00Z",
+        },
+    ]