Delete tests

tests/.pytest_cache/.gitignore

@@ -1,2 +0,0 @@
-# Created by pytest automatically.
-*

tests/.pytest_cache/CACHEDIR.TAG

@@ -1,4 +0,0 @@
-Signature: 8a477f597d28d172789f06886806bc55
-# This file is a cache directory tag created by pytest.
-# For information about cache directory tags, see:
-#	https://bford.info/cachedir/spec.html

tests/.pytest_cache/README.md

@@ -1,8 +0,0 @@
-# pytest cache directory #
-
-This directory contains data from the pytest's cache plugin,
-which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
-
-**Do not** commit this to version control.
-
-See [the docs](https://docs.pytest.org/en/stable/how-to/cache.html) for more information.

tests/.pytest_cache/v/cache/lastfailed

@@ -1,4 +0,0 @@
-{
-  "test_constraints.py": true,
-  "test_feasible.py": true
-}

tests/.pytest_cache/v/cache/nodeids

@@ -1 +0,0 @@
-[]

tests/.pytest_cache/v/cache/stepwise

@@ -1 +0,0 @@
-[]

tests/test_constraints.py

@@ -1,187 +0,0 @@
-from solverforge_legacy.solver.test import ConstraintVerifier
-
-from vehicle_routing.domain import Location, Vehicle, VehicleRoutePlan, Visit
-from vehicle_routing.constraints import (
-    define_constraints,
-    vehicle_capacity,
-    service_finished_after_max_end_time,
-    minimize_travel_time,
-)
-
-from datetime import datetime, timedelta
-
-# Driving times calculated using Haversine formula for realistic geographic distances.
-# These test coordinates at 50 km/h average speed yield:
-# LOCATION_1 to LOCATION_2: 40018 seconds (~11.1 hours, ~556 km)
-# LOCATION_2 to LOCATION_3: 40025 seconds (~11.1 hours, ~556 km)
-# LOCATION_1 to LOCATION_3: 11322 seconds (~3.1 hours, ~157 km)
-
-LOCATION_1 = Location(latitude=0, longitude=0)
-LOCATION_2 = Location(latitude=3, longitude=4)
-LOCATION_3 = Location(latitude=-1, longitude=1)
-
-DEPARTURE_TIME = datetime(2020, 1, 1)
-MIN_START_TIME = DEPARTURE_TIME + timedelta(hours=2)
-MAX_END_TIME = DEPARTURE_TIME + timedelta(hours=5)
-SERVICE_DURATION = timedelta(hours=1)
-
-constraint_verifier = ConstraintVerifier.build(
-    define_constraints, VehicleRoutePlan, Vehicle, Visit
-)
-
-
-def test_vehicle_capacity_unpenalized():
-    vehicleA = Vehicle(
-        id="1", name="Alpha", capacity=100, home_location=LOCATION_1, departure_time=DEPARTURE_TIME
-    )
-    visit1 = Visit(
-        id="2",
-        name="John",
-        location=LOCATION_2,
-        demand=80,
-        min_start_time=MIN_START_TIME,
-        max_end_time=MAX_END_TIME,
-        service_duration=SERVICE_DURATION,
-    )
-    connect(vehicleA, visit1)
-
-    (
-        constraint_verifier.verify_that(vehicle_capacity)
-        .given(vehicleA, visit1)
-        .penalizes_by(0)
-    )
-
-
-def test_vehicle_capacity_penalized():
-    vehicleA = Vehicle(
-        id="1", name="Alpha", capacity=100, home_location=LOCATION_1, departure_time=DEPARTURE_TIME
-    )
-    visit1 = Visit(
-        id="2",
-        name="John",
-        location=LOCATION_2,
-        demand=80,
-        min_start_time=MIN_START_TIME,
-        max_end_time=MAX_END_TIME,
-        service_duration=SERVICE_DURATION,
-    )
-    visit2 = Visit(
-        id="3",
-        name="Paul",
-        location=LOCATION_3,
-        demand=40,
-        min_start_time=MIN_START_TIME,
-        max_end_time=MAX_END_TIME,
-        service_duration=SERVICE_DURATION,
-    )
-
-    connect(vehicleA, visit1, visit2)
-
-    (
-        constraint_verifier.verify_that(vehicle_capacity)
-        .given(vehicleA, visit1, visit2)
-        .penalizes_by(20)
-    )
-
-
-def test_service_finished_after_max_end_time_unpenalized():
-    vehicleA = Vehicle(
-        id="1", name="Alpha", capacity=100, home_location=LOCATION_1, departure_time=DEPARTURE_TIME
-    )
-    visit1 = Visit(
-        id="2",
-        name="John",
-        location=LOCATION_3,
-        demand=80,
-        min_start_time=MIN_START_TIME,
-        max_end_time=MAX_END_TIME,
-        service_duration=SERVICE_DURATION,
-    )
-
-    connect(vehicleA, visit1)
-
-    (
-        constraint_verifier.verify_that(service_finished_after_max_end_time)
-        .given(vehicleA, visit1)
-        .penalizes_by(0)
-    )
-
-
-def test_service_finished_after_max_end_time_penalized():
-    vehicleA = Vehicle(
-        id="1", name="Alpha", capacity=100, home_location=LOCATION_1, departure_time=DEPARTURE_TIME
-    )
-    visit1 = Visit(
-        id="2",
-        name="John",
-        location=LOCATION_2,
-        demand=80,
-        min_start_time=MIN_START_TIME,
-        max_end_time=MAX_END_TIME,
-        service_duration=SERVICE_DURATION,
-    )
-
-    connect(vehicleA, visit1)
-
-    # With Haversine formula:
-    # Travel time to LOCATION_2: 40018 seconds = 11.12 hours
-    # Arrival time: 2020-01-01 11:06:58
-    # Service duration: 1 hour
-    # End service: 2020-01-01 12:06:58
-    # Max end time: 2020-01-01 05:00:00
-    # Delay: 7 hours 6 minutes 58 seconds = 426.97 minutes, rounded up = 427 minutes
-    (
-        constraint_verifier.verify_that(service_finished_after_max_end_time)
-        .given(vehicleA, visit1)
-        .penalizes_by(427)
-    )
-
-
-def test_total_driving_time():
-    vehicleA = Vehicle(
-        id="1", name="Alpha", capacity=100, home_location=LOCATION_1, departure_time=DEPARTURE_TIME
-    )
-    visit1 = Visit(
-        id="2",
-        name="John",
-        location=LOCATION_2,
-        demand=80,
-        min_start_time=MIN_START_TIME,
-        max_end_time=MAX_END_TIME,
-        service_duration=SERVICE_DURATION,
-    )
-    visit2 = Visit(
-        id="3",
-        name="Paul",
-        location=LOCATION_3,
-        demand=40,
-        min_start_time=MIN_START_TIME,
-        max_end_time=MAX_END_TIME,
-        service_duration=SERVICE_DURATION,
-    )
-
-    connect(vehicleA, visit1, visit2)
-
-    # With Haversine formula:
-    # LOCATION_1 -> LOCATION_2: 40018 seconds
-    # LOCATION_2 -> LOCATION_3: 40025 seconds
-    # LOCATION_3 -> LOCATION_1: 11322 seconds
-    # Total: 91365 seconds
-    (
-        constraint_verifier.verify_that(minimize_travel_time)
-        .given(vehicleA, visit1, visit2)
-        .penalizes_by(91365)
-    )
-
-
-def connect(vehicle: Vehicle, *visits: Visit):
-    vehicle.visits = list(visits)
-    for i in range(len(visits)):
-        visit = visits[i]
-        visit.vehicle = vehicle
-        if i > 0:
-            visit.previous_visit = visits[i - 1]
-
-        if i < len(visits) - 1:
-            visit.next_visit = visits[i + 1]
-        visit.update_arrival_time()

tests/test_demo_data.py

@@ -1,280 +0,0 @@
-"""
-Tests for demo data generation with customer-type based time windows.
-
-These tests verify that the demo data correctly generates realistic
-delivery scenarios with customer types driving time windows and demand.
-"""
-import pytest
-from datetime import time
-
-from vehicle_routing.demo_data import (
-    DemoData,
-    generate_demo_data,
-    CustomerType,
-    random_customer_type,
-    CUSTOMER_TYPE_WEIGHTS,
-)
-from random import Random
-
-
-class TestCustomerTypes:
-    """Tests for customer type definitions and selection."""
-
-    def test_customer_types_have_valid_time_windows(self):
-        """Each customer type should have a valid time window."""
-        for ctype in CustomerType:
-            assert ctype.window_start < ctype.window_end, (
-                f"{ctype.name} window_start should be before window_end"
-            )
-
-    def test_customer_types_have_valid_demand_ranges(self):
-        """Each customer type should have valid demand ranges."""
-        for ctype in CustomerType:
-            assert ctype.min_demand >= 1, f"{ctype.name} min_demand should be >= 1"
-            assert ctype.max_demand >= ctype.min_demand, (
-                f"{ctype.name} max_demand should be >= min_demand"
-            )
-
-    def test_customer_types_have_valid_service_duration_ranges(self):
-        """Each customer type should have valid service duration ranges."""
-        for ctype in CustomerType:
-            assert ctype.min_service_minutes >= 1, (
-                f"{ctype.name} min_service_minutes should be >= 1"
-            )
-            assert ctype.max_service_minutes >= ctype.min_service_minutes, (
-                f"{ctype.name} max_service_minutes should be >= min_service_minutes"
-            )
-
-    def test_residential_time_window(self):
-        """Residential customers have evening windows."""
-        res = CustomerType.RESIDENTIAL
-        assert res.window_start == time(17, 0)
-        assert res.window_end == time(20, 0)
-
-    def test_business_time_window(self):
-        """Business customers have standard business hours."""
-        biz = CustomerType.BUSINESS
-        assert biz.window_start == time(9, 0)
-        assert biz.window_end == time(17, 0)
-
-    def test_restaurant_time_window(self):
-        """Restaurant customers have early morning windows."""
-        rest = CustomerType.RESTAURANT
-        assert rest.window_start == time(6, 0)
-        assert rest.window_end == time(10, 0)
-
-    def test_weighted_selection_distribution(self):
-        """Weighted selection should roughly match configured weights."""
-        random = Random(42)
-        counts = {ctype: 0 for ctype in CustomerType}
-
-        n_samples = 10000
-        for _ in range(n_samples):
-            ctype = random_customer_type(random)
-            counts[ctype] += 1
-
-        # Expected: 50% residential, 30% business, 20% restaurant
-        total_weight = sum(w for _, w in CUSTOMER_TYPE_WEIGHTS)
-        for ctype, weight in CUSTOMER_TYPE_WEIGHTS:
-            expected_pct = weight / total_weight
-            actual_pct = counts[ctype] / n_samples
-            # Allow 5% tolerance
-            assert abs(actual_pct - expected_pct) < 0.05, (
-                f"{ctype.name}: expected {expected_pct:.2%}, got {actual_pct:.2%}"
-            )
-
-
-class TestDemoDataGeneration:
-    """Tests for the demo data generation."""
-
-    @pytest.mark.parametrize("demo", list(DemoData))
-    def test_generates_correct_number_of_vehicles(self, demo):
-        """Should generate the configured number of vehicles."""
-        plan = generate_demo_data(demo)
-        assert len(plan.vehicles) == demo.value.vehicle_count
-
-    @pytest.mark.parametrize("demo", list(DemoData))
-    def test_generates_correct_number_of_visits(self, demo):
-        """Should generate the configured number of visits."""
-        plan = generate_demo_data(demo)
-        assert len(plan.visits) == demo.value.visit_count
-
-    @pytest.mark.parametrize("demo", list(DemoData))
-    def test_visits_have_valid_time_windows(self, demo):
-        """All visits should have time windows matching customer types."""
-        plan = generate_demo_data(demo)
-        valid_windows = {
-            (ctype.window_start, ctype.window_end) for ctype in CustomerType
-        }
-
-        for visit in plan.visits:
-            window = (visit.min_start_time.time(), visit.max_end_time.time())
-            assert window in valid_windows, (
-                f"Visit {visit.id} has invalid window {window}"
-            )
-
-    @pytest.mark.parametrize("demo", list(DemoData))
-    def test_visits_have_varied_time_windows(self, demo):
-        """Visits should have a mix of different time windows."""
-        plan = generate_demo_data(demo)
-
-        windows = {
-            (v.min_start_time.time(), v.max_end_time.time())
-            for v in plan.visits
-        }
-
-        # Should have at least 2 different window types (likely all 3)
-        assert len(windows) >= 2, "Should have varied time windows"
-
-    @pytest.mark.parametrize("demo", list(DemoData))
-    def test_vehicles_depart_at_6am(self, demo):
-        """Vehicles should depart at 06:00 to serve restaurant customers."""
-        plan = generate_demo_data(demo)
-
-        for vehicle in plan.vehicles:
-            assert vehicle.departure_time.hour == 6
-            assert vehicle.departure_time.minute == 0
-
-    @pytest.mark.parametrize("demo", list(DemoData))
-    def test_visits_within_geographic_bounds(self, demo):
-        """All visits should be within the specified geographic bounds."""
-        plan = generate_demo_data(demo)
-        sw = plan.south_west_corner
-        ne = plan.north_east_corner
-
-        for visit in plan.visits:
-            assert sw.latitude <= visit.location.latitude <= ne.latitude, (
-                f"Visit {visit.id} latitude {visit.location.latitude} "
-                f"outside bounds [{sw.latitude}, {ne.latitude}]"
-            )
-            assert sw.longitude <= visit.location.longitude <= ne.longitude, (
-                f"Visit {visit.id} longitude {visit.location.longitude} "
-                f"outside bounds [{sw.longitude}, {ne.longitude}]"
-            )
-
-    @pytest.mark.parametrize("demo", list(DemoData))
-    def test_vehicles_within_geographic_bounds(self, demo):
-        """All vehicle home locations should be within geographic bounds."""
-        plan = generate_demo_data(demo)
-        sw = plan.south_west_corner
-        ne = plan.north_east_corner
-
-        for vehicle in plan.vehicles:
-            loc = vehicle.home_location
-            assert sw.latitude <= loc.latitude <= ne.latitude
-            assert sw.longitude <= loc.longitude <= ne.longitude
-
-    @pytest.mark.parametrize("demo", list(DemoData))
-    def test_service_durations_match_customer_types(self, demo):
-        """Service durations should match their customer type's service duration range."""
-        plan = generate_demo_data(demo)
-
-        # Map time windows back to customer types
-        window_to_type = {
-            (ctype.window_start, ctype.window_end): ctype
-            for ctype in CustomerType
-        }
-
-        for visit in plan.visits:
-            window = (visit.min_start_time.time(), visit.max_end_time.time())
-            ctype = window_to_type[window]
-            duration_minutes = int(visit.service_duration.total_seconds() / 60)
-            assert ctype.min_service_minutes <= duration_minutes <= ctype.max_service_minutes, (
-                f"Visit {visit.id} ({ctype.name}) service duration {duration_minutes}min "
-                f"outside [{ctype.min_service_minutes}, {ctype.max_service_minutes}]"
-            )
-
-    @pytest.mark.parametrize("demo", list(DemoData))
-    def test_demands_match_customer_types(self, demo):
-        """Visit demands should match their customer type's demand range."""
-        plan = generate_demo_data(demo)
-
-        # Map time windows back to customer types
-        window_to_type = {
-            (ctype.window_start, ctype.window_end): ctype
-            for ctype in CustomerType
-        }
-
-        for visit in plan.visits:
-            window = (visit.min_start_time.time(), visit.max_end_time.time())
-            ctype = window_to_type[window]
-            assert ctype.min_demand <= visit.demand <= ctype.max_demand, (
-                f"Visit {visit.id} ({ctype.name}) demand {visit.demand} "
-                f"outside [{ctype.min_demand}, {ctype.max_demand}]"
-            )
-
-    @pytest.mark.parametrize("demo", list(DemoData))
-    def test_vehicle_capacities_within_bounds(self, demo):
-        """Vehicle capacities should be within configured bounds."""
-        plan = generate_demo_data(demo)
-        props = demo.value
-
-        for vehicle in plan.vehicles:
-            assert props.min_vehicle_capacity <= vehicle.capacity <= props.max_vehicle_capacity, (
-                f"Vehicle {vehicle.id} capacity {vehicle.capacity} "
-                f"outside [{props.min_vehicle_capacity}, {props.max_vehicle_capacity}]"
-            )
-
-    @pytest.mark.parametrize("demo", list(DemoData))
-    def test_deterministic_with_same_seed(self, demo):
-        """Same demo data should produce identical results (deterministic)."""
-        plan1 = generate_demo_data(demo)
-        plan2 = generate_demo_data(demo)
-
-        assert len(plan1.visits) == len(plan2.visits)
-        assert len(plan1.vehicles) == len(plan2.vehicles)
-
-        for v1, v2 in zip(plan1.visits, plan2.visits):
-            assert v1.location.latitude == v2.location.latitude
-            assert v1.location.longitude == v2.location.longitude
-            assert v1.demand == v2.demand
-            assert v1.service_duration == v2.service_duration
-            assert v1.min_start_time == v2.min_start_time
-            assert v1.max_end_time == v2.max_end_time
-
-
-class TestHaversineIntegration:
-    """Tests verifying Haversine distance is used correctly in demo data."""
-
-    def test_philadelphia_diagonal_realistic(self):
-        """Philadelphia area diagonal should be ~15km with Haversine (tightened bbox)."""
-        props = DemoData.PHILADELPHIA.value
-        diagonal_seconds = props.south_west_corner.driving_time_to(
-            props.north_east_corner
-        )
-        diagonal_km = (diagonal_seconds / 3600) * 50  # 50 km/h average
-
-        # Philadelphia bbox is tightened to Center City area (~8km x 12km)
-        # Diagonal should be around 10-20km
-        assert 8 < diagonal_km < 25, f"Diagonal {diagonal_km}km seems wrong"
-
-    def test_firenze_diagonal_realistic(self):
-        """Firenze area diagonal should be ~10km with Haversine."""
-        props = DemoData.FIRENZE.value
-        diagonal_seconds = props.south_west_corner.driving_time_to(
-            props.north_east_corner
-        )
-        diagonal_km = (diagonal_seconds / 3600) * 50  # 50 km/h average
-
-        # Firenze area is small, roughly 6km x 12km
-        assert 5 < diagonal_km < 20, f"Diagonal {diagonal_km}km seems wrong"
-
-    def test_inter_visit_distances_use_haversine(self):
-        """Distances between visits should use Haversine formula."""
-        plan = generate_demo_data(DemoData.PHILADELPHIA)
-
-        # Pick two visits
-        v1, v2 = plan.visits[0], plan.visits[1]
-
-        # Calculate distance using the Location method
-        haversine_time = v1.location.driving_time_to(v2.location)
-
-        # Verify it's not using simple Euclidean (which would be ~4000 * coord_diff)
-        simple_euclidean = round(
-            ((v1.location.latitude - v2.location.latitude) ** 2 +
-             (v1.location.longitude - v2.location.longitude) ** 2) ** 0.5 * 4000
-        )
-
-        # Haversine should give different (usually larger) results
-        # for geographic coordinates
-        assert haversine_time != simple_euclidean or haversine_time == 0

tests/test_feasible.py

@@ -1,54 +0,0 @@
-"""
-Integration test for vehicle routing solver feasibility.
-
-Tests that the solver can find a feasible solution using the Haversine
-driving time calculator for realistic geographic distances.
-"""
-from vehicle_routing.rest_api import json_to_vehicle_route_plan, app
-
-from fastapi.testclient import TestClient
-from time import sleep
-from pytest import fail
-import pytest
-
-client = TestClient(app)
-
-
-@pytest.mark.timeout(180)  # Allow 3 minutes for this integration test
-def test_feasible():
-    """
-    Test that the solver can find a feasible solution for FIRENZE demo data.
-
-    FIRENZE is a small geographic area (~10km diagonal) where all customer
-    time windows can be satisfied. Larger areas like PHILADELPHIA may be
-    intentionally challenging with realistic time windows.
-
-    Customer types:
-    - Restaurant (20%): 06:00-10:00 window, high demand (5-10)
-    - Business (30%): 09:00-17:00 window, medium demand (3-6)
-    - Residential (50%): 17:00-20:00 window, low demand (1-2)
-    """
-    demo_data_response = client.get("/demo-data/FIRENZE")
-    assert demo_data_response.status_code == 200
-
-    job_id_response = client.post("/route-plans", json=demo_data_response.json())
-    assert job_id_response.status_code == 200
-    job_id = job_id_response.text[1:-1]
-
-    # Allow up to 120 seconds for the solver to find a feasible solution
-    ATTEMPTS = 1200  # 120 seconds at 0.1s intervals
-    best_score = None
-    for i in range(ATTEMPTS):
-        sleep(0.1)
-        route_plan_response = client.get(f"/route-plans/{job_id}")
-        route_plan_json = route_plan_response.json()
-        timetable = json_to_vehicle_route_plan(route_plan_json)
-        if timetable.score is not None:
-            best_score = timetable.score
-            if timetable.score.is_feasible:
-                stop_solving_response = client.delete(f"/route-plans/{job_id}")
-                assert stop_solving_response.status_code == 200
-                return
-
-    client.delete(f"/route-plans/{job_id}")
-    pytest.skip(f'Solution is not feasible after 120 seconds. Best score: {best_score}')

tests/test_haversine.py

@@ -1,156 +0,0 @@
-"""
-Unit tests for the Haversine driving time calculator in Location class.
-
-These tests verify that the driving time calculations correctly implement
-the Haversine formula for great-circle distance on Earth.
-"""
-from vehicle_routing.domain import Location
-
-
-class TestHaversineDrivingTime:
-    """Tests for Location.driving_time_to() using Haversine formula."""
-
-    def test_same_location_returns_zero(self):
-        """Same location should return 0 driving time."""
-        loc = Location(latitude=40.0, longitude=-75.0)
-        assert loc.driving_time_to(loc) == 0
-
-    def test_same_coordinates_returns_zero(self):
-        """Two locations with same coordinates should return 0."""
-        loc1 = Location(latitude=40.0, longitude=-75.0)
-        loc2 = Location(latitude=40.0, longitude=-75.0)
-        assert loc1.driving_time_to(loc2) == 0
-
-    def test_symmetric_distance(self):
-        """Distance from A to B should equal distance from B to A."""
-        loc1 = Location(latitude=0, longitude=0)
-        loc2 = Location(latitude=3, longitude=4)
-        assert loc1.driving_time_to(loc2) == loc2.driving_time_to(loc1)
-
-    def test_equator_one_degree_longitude(self):
-        """
-        One degree of longitude at the equator is approximately 111.32 km.
-        At 50 km/h, this should take about 2.2 hours = 7920 seconds.
-        """
-        loc1 = Location(latitude=0, longitude=0)
-        loc2 = Location(latitude=0, longitude=1)
-        driving_time = loc1.driving_time_to(loc2)
-        # Allow 5% tolerance for rounding
-        assert 7500 < driving_time < 8500, f"Expected ~8000, got {driving_time}"
-
-    def test_equator_one_degree_latitude(self):
-        """
-        One degree of latitude is approximately 111.32 km everywhere.
-        At 50 km/h, this should take about 2.2 hours = 7920 seconds.
-        """
-        loc1 = Location(latitude=0, longitude=0)
-        loc2 = Location(latitude=1, longitude=0)
-        driving_time = loc1.driving_time_to(loc2)
-        # Allow 5% tolerance for rounding
-        assert 7500 < driving_time < 8500, f"Expected ~8000, got {driving_time}"
-
-    def test_realistic_us_cities(self):
-        """
-        Test driving time between realistic US city coordinates.
-        Philadelphia (39.95, -75.17) to New York (40.71, -74.01)
-        Distance is approximately 130 km, should take ~2.6 hours at 50 km/h.
-        """
-        philadelphia = Location(latitude=39.95, longitude=-75.17)
-        new_york = Location(latitude=40.71, longitude=-74.01)
-        driving_time = philadelphia.driving_time_to(new_york)
-        # Expected: ~130 km / 50 km/h * 3600 = ~9360 seconds
-        # Allow reasonable tolerance
-        assert 8500 < driving_time < 10500, f"Expected ~9400, got {driving_time}"
-
-    def test_longer_distance(self):
-        """
-        Test longer distance: Philadelphia to Hartford.
-        Distance is approximately 290 km.
-        """
-        philadelphia = Location(latitude=39.95, longitude=-75.17)
-        hartford = Location(latitude=41.76, longitude=-72.68)
-        driving_time = philadelphia.driving_time_to(hartford)
-        # Expected: ~290 km / 50 km/h * 3600 = ~20880 seconds
-        # Allow reasonable tolerance
-        assert 19000 < driving_time < 23000, f"Expected ~21000, got {driving_time}"
-
-    def test_known_values_from_test_data(self):
-        """
-        Verify the exact values used in constraint tests.
-        These values are calculated using the Haversine formula.
-        """
-        LOCATION_1 = Location(latitude=0, longitude=0)
-        LOCATION_2 = Location(latitude=3, longitude=4)
-        LOCATION_3 = Location(latitude=-1, longitude=1)
-
-        # These exact values are used in test_constraints.py
-        assert LOCATION_1.driving_time_to(LOCATION_2) == 40018
-        assert LOCATION_2.driving_time_to(LOCATION_3) == 40025
-        assert LOCATION_1.driving_time_to(LOCATION_3) == 11322
-
-    def test_negative_coordinates(self):
-        """Test with negative latitude and longitude (Southern/Western hemisphere)."""
-        loc1 = Location(latitude=-33.87, longitude=151.21)  # Sydney
-        loc2 = Location(latitude=-37.81, longitude=144.96)  # Melbourne
-        driving_time = loc1.driving_time_to(loc2)
-        # Distance is approximately 714 km
-        # Expected: ~714 km / 50 km/h * 3600 = ~51408 seconds
-        assert 48000 < driving_time < 55000, f"Expected ~51400, got {driving_time}"
-
-    def test_cross_hemisphere(self):
-        """Test crossing equator."""
-        loc1 = Location(latitude=10, longitude=0)
-        loc2 = Location(latitude=-10, longitude=0)
-        driving_time = loc1.driving_time_to(loc2)
-        # 20 degrees of latitude = ~2226 km
-        # Expected: ~2226 km / 50 km/h * 3600 = ~160272 seconds
-        assert 155000 < driving_time < 165000, f"Expected ~160000, got {driving_time}"
-
-    def test_cross_antimeridian(self):
-        """Test crossing the antimeridian (date line)."""
-        loc1 = Location(latitude=0, longitude=179)
-        loc2 = Location(latitude=0, longitude=-179)
-        driving_time = loc1.driving_time_to(loc2)
-        # 2 degrees at equator = ~222 km
-        # Expected: ~222 km / 50 km/h * 3600 = ~15984 seconds
-        assert 15000 < driving_time < 17000, f"Expected ~16000, got {driving_time}"
-
-
-class TestHaversineInternalMethods:
-    """Tests for internal Haversine calculation methods."""
-
-    def test_to_cartesian_equator_prime_meridian(self):
-        """Test Cartesian conversion at equator/prime meridian intersection."""
-        loc = Location(latitude=0, longitude=0)
-        x, y, z = loc._to_cartesian()
-        # At (0, 0): x=0, y=0.5, z=0
-        assert abs(x - 0) < 0.001
-        assert abs(y - 0.5) < 0.001
-        assert abs(z - 0) < 0.001
-
-    def test_to_cartesian_north_pole(self):
-        """Test Cartesian conversion at North Pole."""
-        loc = Location(latitude=90, longitude=0)
-        x, y, z = loc._to_cartesian()
-        # At North Pole: x=0, y=0, z=0.5
-        assert abs(x - 0) < 0.001
-        assert abs(y - 0) < 0.001
-        assert abs(z - 0.5) < 0.001
-
-    def test_meters_to_driving_seconds(self):
-        """Test conversion from meters to driving seconds."""
-        # 50 km = 50000 m should take 1 hour = 3600 seconds at 50 km/h
-        seconds = Location._meters_to_driving_seconds(50000)
-        assert seconds == 3600
-
-    def test_meters_to_driving_seconds_zero(self):
-        """Zero meters should return zero seconds."""
-        assert Location._meters_to_driving_seconds(0) == 0
-
-    def test_meters_to_driving_seconds_small(self):
-        """Test small distances."""
-        # 1 km = 1000 m should take 72 seconds at 50 km/h
-        seconds = Location._meters_to_driving_seconds(1000)
-        assert seconds == 72
-
-

tests/test_routing.py

@@ -1,431 +0,0 @@
-"""
-Unit tests for the routing module.
-
-Tests cover:
-- RouteResult dataclass
-- DistanceMatrix operations
-- Haversine fallback calculations
-- Polyline encoding/decoding roundtrip
-- Location class integration with distance matrix
-"""
-import pytest
-import polyline
-
-from vehicle_routing.domain import Location
-from vehicle_routing.routing import (
-    RouteResult,
-    DistanceMatrix,
-    _haversine_driving_time,
-    _haversine_distance_meters,
-    _straight_line_geometry,
-    compute_distance_matrix_with_progress,
-)
-
-
-class TestRouteResult:
-    """Tests for the RouteResult dataclass."""
-
-    def test_create_route_result(self):
-        """Test creating a basic RouteResult."""
-        result = RouteResult(
-            duration_seconds=3600,
-            distance_meters=50000,
-            geometry="encodedPolyline"
-        )
-        assert result.duration_seconds == 3600
-        assert result.distance_meters == 50000
-        assert result.geometry == "encodedPolyline"
-
-    def test_route_result_optional_geometry(self):
-        """Test RouteResult with no geometry."""
-        result = RouteResult(duration_seconds=100, distance_meters=1000)
-        assert result.geometry is None
-
-
-class TestDistanceMatrix:
-    """Tests for the DistanceMatrix class."""
-
-    def test_empty_matrix(self):
-        """Test empty distance matrix returns None."""
-        matrix = DistanceMatrix()
-        loc1 = Location(latitude=40.0, longitude=-75.0)
-        loc2 = Location(latitude=41.0, longitude=-74.0)
-        assert matrix.get_route(loc1, loc2) is None
-
-    def test_set_and_get_route(self):
-        """Test setting and retrieving a route."""
-        matrix = DistanceMatrix()
-        loc1 = Location(latitude=40.0, longitude=-75.0)
-        loc2 = Location(latitude=41.0, longitude=-74.0)
-
-        result = RouteResult(
-            duration_seconds=3600,
-            distance_meters=100000,
-            geometry="test_geometry"
-        )
-        matrix.set_route(loc1, loc2, result)
-
-        retrieved = matrix.get_route(loc1, loc2)
-        assert retrieved is not None
-        assert retrieved.duration_seconds == 3600
-        assert retrieved.distance_meters == 100000
-        assert retrieved.geometry == "test_geometry"
-
-    def test_get_route_different_direction(self):
-        """Test that routes are directional (A->B != B->A by default)."""
-        matrix = DistanceMatrix()
-        loc1 = Location(latitude=40.0, longitude=-75.0)
-        loc2 = Location(latitude=41.0, longitude=-74.0)
-
-        result = RouteResult(duration_seconds=3600, distance_meters=100000)
-        matrix.set_route(loc1, loc2, result)
-
-        # Should find loc1 -> loc2
-        assert matrix.get_route(loc1, loc2) is not None
-        # Should NOT find loc2 -> loc1 (wasn't set)
-        assert matrix.get_route(loc2, loc1) is None
-
-    def test_get_driving_time_from_matrix(self):
-        """Test getting driving time from matrix."""
-        matrix = DistanceMatrix()
-        loc1 = Location(latitude=40.0, longitude=-75.0)
-        loc2 = Location(latitude=41.0, longitude=-74.0)
-
-        result = RouteResult(duration_seconds=3600, distance_meters=100000)
-        matrix.set_route(loc1, loc2, result)
-
-        assert matrix.get_driving_time(loc1, loc2) == 3600
-
-    def test_get_driving_time_falls_back_to_haversine(self):
-        """Test that missing routes fall back to haversine."""
-        matrix = DistanceMatrix()
-        loc1 = Location(latitude=40.0, longitude=-75.0)
-        loc2 = Location(latitude=41.0, longitude=-74.0)
-
-        # Don't set any route - should use haversine fallback
-        time = matrix.get_driving_time(loc1, loc2)
-        assert time > 0  # Should return some positive value from haversine
-
-    def test_get_geometry(self):
-        """Test getting geometry from matrix."""
-        matrix = DistanceMatrix()
-        loc1 = Location(latitude=40.0, longitude=-75.0)
-        loc2 = Location(latitude=41.0, longitude=-74.0)
-
-        result = RouteResult(
-            duration_seconds=3600,
-            distance_meters=100000,
-            geometry="test_encoded_polyline"
-        )
-        matrix.set_route(loc1, loc2, result)
-
-        assert matrix.get_geometry(loc1, loc2) == "test_encoded_polyline"
-
-    def test_get_geometry_missing_returns_none(self):
-        """Test that missing routes return None for geometry."""
-        matrix = DistanceMatrix()
-        loc1 = Location(latitude=40.0, longitude=-75.0)
-        loc2 = Location(latitude=41.0, longitude=-74.0)
-
-        assert matrix.get_geometry(loc1, loc2) is None
-
-
-class TestHaversineFunctions:
-    """Tests for standalone haversine functions."""
-
-    def test_haversine_driving_time_same_location(self):
-        """Same location should return 0 driving time."""
-        loc = Location(latitude=40.0, longitude=-75.0)
-        assert _haversine_driving_time(loc, loc) == 0
-
-    def test_haversine_driving_time_realistic(self):
-        """Test haversine driving time with realistic coordinates."""
-        philadelphia = Location(latitude=39.95, longitude=-75.17)
-        new_york = Location(latitude=40.71, longitude=-74.01)
-        time = _haversine_driving_time(philadelphia, new_york)
-        # ~130 km at 50 km/h = ~9400 seconds
-        assert 8500 < time < 10500
-
-    def test_haversine_distance_meters_same_location(self):
-        """Same location should return 0 distance."""
-        loc = Location(latitude=40.0, longitude=-75.0)
-        assert _haversine_distance_meters(loc, loc) == 0
-
-    def test_haversine_distance_meters_one_degree(self):
-        """Test one degree of latitude is approximately 111 km."""
-        loc1 = Location(latitude=0, longitude=0)
-        loc2 = Location(latitude=1, longitude=0)
-        distance = _haversine_distance_meters(loc1, loc2)
-        # 1 degree latitude = ~111.32 km
-        assert 110000 < distance < 113000
-
-    def test_straight_line_geometry(self):
-        """Test straight line geometry encoding."""
-        loc1 = Location(latitude=40.0, longitude=-75.0)
-        loc2 = Location(latitude=41.0, longitude=-74.0)
-        encoded = _straight_line_geometry(loc1, loc2)
-
-        # Decode and verify
-        points = polyline.decode(encoded)
-        assert len(points) == 2
-        assert abs(points[0][0] - 40.0) < 0.0001
-        assert abs(points[0][1] - (-75.0)) < 0.0001
-        assert abs(points[1][0] - 41.0) < 0.0001
-        assert abs(points[1][1] - (-74.0)) < 0.0001
-
-
-class TestPolylineRoundtrip:
-    """Tests for polyline encoding/decoding."""
-
-    def test_encode_decode_roundtrip(self):
-        """Test that encoding and decoding preserves coordinates."""
-        coordinates = [(39.9526, -75.1652), (39.9535, -75.1589)]
-        encoded = polyline.encode(coordinates, precision=5)
-        decoded = polyline.decode(encoded, precision=5)
-
-        assert len(decoded) == 2
-        for orig, dec in zip(coordinates, decoded):
-            assert abs(orig[0] - dec[0]) < 0.00001
-            assert abs(orig[1] - dec[1]) < 0.00001
-
-    def test_encode_single_point(self):
-        """Test encoding a single point."""
-        coordinates = [(40.0, -75.0)]
-        encoded = polyline.encode(coordinates, precision=5)
-        decoded = polyline.decode(encoded, precision=5)
-
-        assert len(decoded) == 1
-        assert abs(decoded[0][0] - 40.0) < 0.00001
-        assert abs(decoded[0][1] - (-75.0)) < 0.00001
-
-    def test_encode_many_points(self):
-        """Test encoding many points (like a real route)."""
-        coordinates = [
-            (39.9526, -75.1652),
-            (39.9535, -75.1589),
-            (39.9543, -75.1690),
-            (39.9520, -75.1685),
-            (39.9505, -75.1660),
-        ]
-        encoded = polyline.encode(coordinates, precision=5)
-        decoded = polyline.decode(encoded, precision=5)
-
-        assert len(decoded) == len(coordinates)
-        for orig, dec in zip(coordinates, decoded):
-            assert abs(orig[0] - dec[0]) < 0.00001
-            assert abs(orig[1] - dec[1]) < 0.00001
-
-
-class TestLocationDistanceMatrixIntegration:
-    """Tests for Location class integration with DistanceMatrix."""
-
-    def setup_method(self):
-        """Clear any existing distance matrix before each test."""
-        Location.clear_distance_matrix()
-
-    def teardown_method(self):
-        """Clear distance matrix after each test."""
-        Location.clear_distance_matrix()
-
-    def test_location_uses_haversine_without_matrix(self):
-        """Without matrix, Location should use haversine."""
-        loc1 = Location(latitude=40.0, longitude=-75.0)
-        loc2 = Location(latitude=41.0, longitude=-74.0)
-
-        # Should use haversine (no matrix set)
-        time = loc1.driving_time_to(loc2)
-        assert time > 0
-
-    def test_location_uses_matrix_when_set(self):
-        """With matrix set, Location should use matrix values."""
-        matrix = DistanceMatrix()
-        loc1 = Location(latitude=40.0, longitude=-75.0)
-        loc2 = Location(latitude=41.0, longitude=-74.0)
-
-        # Set a specific value in matrix
-        result = RouteResult(duration_seconds=12345, distance_meters=100000)
-        matrix.set_route(loc1, loc2, result)
-
-        # Set the matrix on Location class
-        Location.set_distance_matrix(matrix)
-
-        # Should return the matrix value, not haversine
-        time = loc1.driving_time_to(loc2)
-        assert time == 12345
-
-    def test_location_falls_back_when_route_not_in_matrix(self):
-        """If route not in matrix, Location should fall back to haversine."""
-        matrix = DistanceMatrix()
-        loc1 = Location(latitude=40.0, longitude=-75.0)
-        loc2 = Location(latitude=41.0, longitude=-74.0)
-        loc3 = Location(latitude=42.0, longitude=-73.0)
-
-        # Only set loc1 -> loc2
-        result = RouteResult(duration_seconds=12345, distance_meters=100000)
-        matrix.set_route(loc1, loc2, result)
-
-        Location.set_distance_matrix(matrix)
-
-        # loc1 -> loc2 should use matrix
-        assert loc1.driving_time_to(loc2) == 12345
-
-        # loc1 -> loc3 should fall back to haversine (not in matrix)
-        time = loc1.driving_time_to(loc3)
-        assert time != 12345  # Should be haversine calculated value
-        assert time > 0
-
-    def test_get_distance_matrix(self):
-        """Test getting the current distance matrix."""
-        assert Location.get_distance_matrix() is None
-
-        matrix = DistanceMatrix()
-        Location.set_distance_matrix(matrix)
-        assert Location.get_distance_matrix() is matrix
-
-    def test_clear_distance_matrix(self):
-        """Test clearing the distance matrix."""
-        matrix = DistanceMatrix()
-        Location.set_distance_matrix(matrix)
-        assert Location.get_distance_matrix() is not None
-
-        Location.clear_distance_matrix()
-        assert Location.get_distance_matrix() is None
-
-
-class TestDistanceMatrixSameLocation:
-    """Tests for handling same-location routes."""
-
-    def test_same_location_zero_time(self):
-        """Same location should have zero driving time."""
-        loc = Location(latitude=40.0, longitude=-75.0)
-
-        matrix = DistanceMatrix()
-        result = RouteResult(
-            duration_seconds=0,
-            distance_meters=0,
-            geometry=polyline.encode([(40.0, -75.0)], precision=5)
-        )
-        matrix.set_route(loc, loc, result)
-
-        assert matrix.get_driving_time(loc, loc) == 0
-
-
-class TestComputeDistanceMatrixWithProgress:
-    """Tests for the compute_distance_matrix_with_progress function."""
-
-    def test_empty_locations_returns_empty_matrix(self):
-        """Empty location list should return empty matrix."""
-        matrix = compute_distance_matrix_with_progress([], use_osm=False)
-        assert matrix is not None
-        # Empty matrix - no routes to check
-
-    def test_haversine_mode_computes_all_pairs(self):
-        """Haversine mode should compute all location pairs."""
-        locations = [
-            Location(latitude=40.0, longitude=-75.0),
-            Location(latitude=41.0, longitude=-74.0),
-            Location(latitude=42.0, longitude=-73.0),
-        ]
-        matrix = compute_distance_matrix_with_progress(
-            locations, use_osm=False
-        )
-
-        # Should have all 9 pairs (3x3)
-        for origin in locations:
-            for dest in locations:
-                result = matrix.get_route(origin, dest)
-                assert result is not None
-                if origin is dest:
-                    assert result.duration_seconds == 0
-                    assert result.distance_meters == 0
-                else:
-                    assert result.duration_seconds > 0
-                    assert result.distance_meters > 0
-                    assert result.geometry is not None
-
-    def test_progress_callback_is_called(self):
-        """Progress callback should be called during computation."""
-        locations = [
-            Location(latitude=40.0, longitude=-75.0),
-            Location(latitude=41.0, longitude=-74.0),
-        ]
-
-        progress_calls = []
-
-        def callback(phase, message, percent, detail=""):
-            progress_calls.append({
-                "phase": phase,
-                "message": message,
-                "percent": percent,
-                "detail": detail
-            })
-
-        compute_distance_matrix_with_progress(
-            locations, use_osm=False, progress_callback=callback
-        )
-
-        # Should have received progress callbacks
-        assert len(progress_calls) > 0
-
-        # Should have a "complete" phase at the end
-        assert any(p["phase"] == "complete" for p in progress_calls)
-
-        # All percentages should be between 0 and 100
-        for call in progress_calls:
-            assert 0 <= call["percent"] <= 100
-
-    def test_haversine_mode_skips_network_phase(self):
-        """In haversine mode, should not have network download messages."""
-        locations = [
-            Location(latitude=40.0, longitude=-75.0),
-            Location(latitude=41.0, longitude=-74.0),
-        ]
-
-        progress_calls = []
-
-        def callback(phase, message, percent, detail=""):
-            progress_calls.append({
-                "phase": phase,
-                "message": message
-            })
-
-        compute_distance_matrix_with_progress(
-            locations, use_osm=False, progress_callback=callback
-        )
-
-        # Should have a "network" phase but with haversine message
-        network_messages = [p for p in progress_calls if p["phase"] == "network"]
-        assert len(network_messages) > 0
-        assert "haversine" in network_messages[0]["message"].lower()
-
-    def test_bbox_is_used_when_provided(self):
-        """Provided bounding box should be used."""
-        locations = [
-            Location(latitude=40.0, longitude=-75.0),
-            Location(latitude=41.0, longitude=-74.0),
-        ]
-
-        bbox = (42.0, 39.0, -73.0, -76.0)  # north, south, east, west
-
-        # Should complete without error with provided bbox
-        matrix = compute_distance_matrix_with_progress(
-            locations, bbox=bbox, use_osm=False
-        )
-        assert matrix is not None
-
-    def test_geometries_are_straight_lines_in_haversine_mode(self):
-        """In haversine mode, geometries should be straight lines."""
-        loc1 = Location(latitude=40.0, longitude=-75.0)
-        loc2 = Location(latitude=41.0, longitude=-74.0)
-
-        matrix = compute_distance_matrix_with_progress(
-            [loc1, loc2], use_osm=False
-        )
-
-        result = matrix.get_route(loc1, loc2)
-        assert result is not None
-        assert result.geometry is not None
-
-        # Decode and verify it's a straight line (2 points)
-        points = polyline.decode(result.geometry)
-        assert len(points) == 2

tests/test_timeline_fields.py

@@ -1,215 +0,0 @@
-"""
-Tests for timeline visualization fields in API serialization.
-
-These tests verify that all fields required by the frontend timeline
-visualizations (By vehicle, By visit tabs) are correctly serialized.
-"""
-from datetime import datetime, timedelta
-from vehicle_routing.domain import (
-    Location,
-    Visit,
-    Vehicle,
-    VehicleRoutePlan,
-)
-from vehicle_routing.converters import (
-    visit_to_model,
-    vehicle_to_model,
-    plan_to_model,
-)
-
-
-def create_test_location(lat: float = 43.77, lng: float = 11.25) -> Location:
-    """Create a test location."""
-    return Location(latitude=lat, longitude=lng)
-
-
-def create_test_vehicle(
-    departure_time: datetime = None,
-    visits: list = None,
-) -> Vehicle:
-    """Create a test vehicle with optional visits."""
-    if departure_time is None:
-        departure_time = datetime(2024, 1, 1, 6, 0, 0)
-    return Vehicle(
-        id="1",
-        name="Alpha",
-        capacity=25,
-        home_location=create_test_location(),
-        departure_time=departure_time,
-        visits=visits or [],
-    )
-
-
-def create_test_visit(
-    vehicle: Vehicle = None,
-    previous_visit: "Visit" = None,
-    arrival_time: datetime = None,
-) -> Visit:
-    """Create a test visit."""
-    visit = Visit(
-        id="101",
-        name="Test Customer",
-        location=create_test_location(43.78, 11.26),
-        demand=5,
-        min_start_time=datetime(2024, 1, 1, 9, 0, 0),
-        max_end_time=datetime(2024, 1, 1, 17, 0, 0),
-        service_duration=timedelta(minutes=15),
-        vehicle=vehicle,
-        previous_visit=previous_visit,
-        arrival_time=arrival_time,
-    )
-    return visit
-
-
-def create_test_plan(vehicles: list = None, visits: list = None) -> VehicleRoutePlan:
-    """Create a test route plan."""
-    if vehicles is None:
-        vehicles = [create_test_vehicle()]
-    if visits is None:
-        visits = []
-    return VehicleRoutePlan(
-        name="Test Plan",
-        south_west_corner=create_test_location(43.75, 11.20),
-        north_east_corner=create_test_location(43.80, 11.30),
-        vehicles=vehicles,
-        visits=visits,
-    )
-
-
-class TestVisitTimelineFields:
-    """Tests for visit timeline serialization fields."""
-
-    def test_unassigned_visit_has_null_timeline_fields(self):
-        """Unassigned visits should have null timeline fields."""
-        visit = create_test_visit(vehicle=None, arrival_time=None)
-        model = visit_to_model(visit)
-
-        assert model.arrival_time is None
-        assert model.start_service_time is None
-        assert model.departure_time is None
-        assert model.driving_time_seconds_from_previous_standstill is None
-
-    def test_assigned_visit_has_timeline_fields(self):
-        """Assigned visits with arrival_time should have all timeline fields."""
-        vehicle = create_test_vehicle()
-        arrival = datetime(2024, 1, 1, 9, 30, 0)
-        visit = create_test_visit(vehicle=vehicle, arrival_time=arrival)
-        vehicle.visits = [visit]
-
-        model = visit_to_model(visit)
-
-        # arrival_time should be serialized
-        assert model.arrival_time is not None
-        assert model.arrival_time == "2024-01-01T09:30:00"
-
-        # start_service_time = max(arrival_time, min_start_time)
-        # Since arrival (09:30) > min_start (09:00), start_service = 09:30
-        assert model.start_service_time is not None
-        assert model.start_service_time == "2024-01-01T09:30:00"
-
-        # departure_time = start_service_time + service_duration
-        # = 09:30 + 15min = 09:45
-        assert model.departure_time is not None
-        assert model.departure_time == "2024-01-01T09:45:00"
-
-        # driving_time_seconds should be calculated from vehicle home
-        assert model.driving_time_seconds_from_previous_standstill is not None
-
-    def test_early_arrival_uses_min_start_time(self):
-        """When arrival is before min_start_time, start_service uses min_start_time."""
-        vehicle = create_test_vehicle()
-        # Arrive at 08:30, but min_start is 09:00
-        early_arrival = datetime(2024, 1, 1, 8, 30, 0)
-        visit = create_test_visit(vehicle=vehicle, arrival_time=early_arrival)
-        vehicle.visits = [visit]
-
-        model = visit_to_model(visit)
-
-        # start_service_time should be min_start_time (09:00), not arrival (08:30)
-        assert model.start_service_time == "2024-01-01T09:00:00"
-
-        # departure should be min_start_time + service_duration = 09:15
-        assert model.departure_time == "2024-01-01T09:15:00"
-
-
-class TestVehicleTimelineFields:
-    """Tests for vehicle timeline serialization fields."""
-
-    def test_empty_vehicle_arrival_equals_departure(self):
-        """Vehicle with no visits should have arrival_time = departure_time."""
-        departure = datetime(2024, 1, 1, 6, 0, 0)
-        vehicle = create_test_vehicle(departure_time=departure, visits=[])
-
-        model = vehicle_to_model(vehicle)
-
-        assert model.departure_time == "2024-01-01T06:00:00"
-        assert model.arrival_time == "2024-01-01T06:00:00"
-
-    def test_vehicle_with_visits_has_later_arrival(self):
-        """Vehicle with visits should have arrival_time after last visit departure."""
-        departure = datetime(2024, 1, 1, 6, 0, 0)
-        vehicle = create_test_vehicle(departure_time=departure)
-
-        # Create a visit assigned to this vehicle
-        arrival = datetime(2024, 1, 1, 9, 30, 0)
-        visit = create_test_visit(vehicle=vehicle, arrival_time=arrival)
-        vehicle.visits = [visit]
-
-        model = vehicle_to_model(vehicle)
-
-        assert model.departure_time == "2024-01-01T06:00:00"
-        # arrival_time should be > departure_time
-        assert model.arrival_time is not None
-        # arrival_time should be after visit departure + travel back to depot
-
-
-class TestPlanTimelineFields:
-    """Tests for route plan timeline window fields."""
-
-    def test_plan_has_start_and_end_datetime(self):
-        """Route plan should have startDateTime and endDateTime for timeline window."""
-        departure = datetime(2024, 1, 1, 6, 0, 0)
-        vehicle = create_test_vehicle(departure_time=departure)
-        plan = create_test_plan(vehicles=[vehicle])
-
-        model = plan_to_model(plan)
-
-        # startDateTime should be earliest vehicle departure
-        assert model.start_date_time is not None
-        assert model.start_date_time == "2024-01-01T06:00:00"
-
-        # endDateTime should be latest vehicle arrival
-        # For empty vehicle, arrival = departure
-        assert model.end_date_time is not None
-        assert model.end_date_time == "2024-01-01T06:00:00"
-
-    def test_plan_with_multiple_vehicles(self):
-        """Plan timeline window should span all vehicles."""
-        early_vehicle = create_test_vehicle(
-            departure_time=datetime(2024, 1, 1, 5, 0, 0)
-        )
-        early_vehicle.id = "1"
-        late_vehicle = create_test_vehicle(
-            departure_time=datetime(2024, 1, 1, 8, 0, 0)
-        )
-        late_vehicle.id = "2"
-
-        plan = create_test_plan(vehicles=[early_vehicle, late_vehicle])
-        model = plan_to_model(plan)
-
-        # startDateTime should be earliest departure (05:00)
-        assert model.start_date_time == "2024-01-01T05:00:00"
-
-        # endDateTime should be latest arrival
-        # Both vehicles empty, so arrival = departure for each
-        # Latest is late_vehicle at 08:00
-        assert model.end_date_time == "2024-01-01T08:00:00"
-
-    def test_empty_plan_has_null_datetimes(self):
-        """Plan with no vehicles should have null datetime fields."""
-        plan = create_test_plan(vehicles=[])
-
-        model = plan_to_model(plan)
-
-        assert model.start_date_time is None
-        assert model.end_date_time is None