File size: 5,691 Bytes
fcf8749
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
"""
Tests for Phase 2 Driver-facing API endpoints.
"""

import pytest
from datetime import date, timedelta
from uuid import uuid4


class TestDriverApiSchemas:
    """Tests for driver API schema validation."""
    
    def test_delivery_log_request_valid_status(self):
        """Valid delivery status should be accepted."""
        from app.schemas.driver_api import DeliveryLogRequest
        
        request = DeliveryLogRequest(
            assignment_id=uuid4(),
            route_id=uuid4(),
            driver_id=uuid4(),
            stop_order=1,
            status="DELIVERED",
            issue_type="NONE",
        )
        assert request.status == "DELIVERED"
    
    def test_stop_issue_request_validation(self):
        """Stop issue request should require notes."""
        from app.schemas.driver_api import StopIssueRequest
        
        request = StopIssueRequest(
            assignment_id=uuid4(),
            route_id=uuid4(),
            driver_id=uuid4(),
            stop_order=5,
            issue_type="SAFETY",
            notes="Dark street, no lights",
        )
        assert request.issue_type == "SAFETY"
        assert len(request.notes) > 0
    
    def test_route_swap_request_creation(self):
        """Route swap request should allow optional fields."""
        from app.schemas.driver_api import RouteSwapRequestCreate
        
        request = RouteSwapRequestCreate(
            from_driver_id=uuid4(),
            assignment_id=uuid4(),
            reason="Had heavy routes for 3 days",
            to_driver_id=None,
            preferred_date=None,
        )
        assert request.to_driver_id is None
        assert request.preferred_date is None


class TestDriverStatsResponse:
    """Tests for driver stats response schemas."""
    
    def test_day_stats_model(self):
        """DayStats should handle optional fields."""
        from app.schemas.driver_api import DayStats
        
        stats = DayStats(
            date=date.today(),
            workload_score=65.5,
            fairness_score=0.82,
            reported_stress_level=None,
            reported_fairness_rating=None,
        )
        assert stats.workload_score == 65.5
        assert stats.reported_stress_level is None
    
    def test_stats_aggregates_model(self):
        """StatsAggregates should compute correctly."""
        from app.schemas.driver_api import StatsAggregates
        
        aggregates = StatsAggregates(
            avg_workload=63.2,
            avg_fairness_score=0.83,
            avg_stress_level=3.5,
        )
        assert aggregates.avg_workload == 63.2


class TestTodayAssignmentResponse:
    """Tests for today's assignment response schema."""
    
    def test_full_response_structure(self):
        """Response should include all required nested objects."""
        from app.schemas.driver_api import (
            TodayAssignmentResponse,
            DriverDetail,
            AssignmentDetail,
            RouteSummaryDetail,
            StopDetail,
            PackageDetail,
        )
        
        driver_id = uuid4()
        route_id = uuid4()
        pkg_id = uuid4()
        
        response = TodayAssignmentResponse(
            date=date.today(),
            driver=DriverDetail(
                id=driver_id,
                external_id="ext_001",
                name="Raju",
                preferred_language="en",
            ),
            assignment=AssignmentDetail(
                assignment_id=uuid4(),
                route_id=route_id,
                workload_score=65.3,
                fairness_score=0.82,
                explanation="Moderate route assigned",
                route_summary=RouteSummaryDetail(
                    num_packages=22,
                    total_weight_kg=48.5,
                    num_stops=14,
                    route_difficulty_score=2.1,
                    estimated_time_minutes=145,
                ),
                stops=[
                    StopDetail(
                        stop_order=1,
                        address="Some Street, Area, City",
                        latitude=12.97,
                        longitude=77.60,
                        packages=[
                            PackageDetail(
                                id=pkg_id,
                                external_id="pkg_001",
                                weight_kg=2.5,
                                fragility_level=3,
                                priority="NORMAL",
                            )
                        ],
                    )
                ],
            ),
        )
        
        assert response.driver.name == "Raju"
        assert len(response.assignment.stops) == 1
        assert response.assignment.stops[0].packages[0].weight_kg == 2.5


class TestExtendedFeedbackRequest:
    """Tests for extended feedback request."""
    
    def test_extended_fields(self):
        """Extended feedback should accept new Phase 2 fields."""
        from app.schemas.driver_api import ExtendedFeedbackRequest
        
        request = ExtendedFeedbackRequest(
            driver_id=uuid4(),
            assignment_id=uuid4(),
            fairness_rating=4,
            stress_level=5,
            tiredness_level=3,
            hardest_aspect="stairs",
            route_difficulty_self_report=4,
            would_take_similar_route_again=True,
            most_unfair_aspect="parking",
            comments="Too many apartments with no lift",
        )
        
        assert request.route_difficulty_self_report == 4
        assert request.would_take_similar_route_again is True
        assert request.most_unfair_aspect == "parking"