test(objectives): cover pinned work and breaks in prefer-early-tours

vrp-core unit tests for the new rule: a shift holding only unmovable work
still charges its delay for the first job that could have gone elsewhere, a
job which cannot change shift charges nothing, a shift already holding movable
work stays free, and fitness ignores shifts held open by unmovable work alone.
The paired regression test asserts an earlier empty shift beats one held open
by standing work - under the previous behaviour those score 432000 against
345600, so joining the late shift wins.

vrp-pragmatic behavioural tests over a plan where a relation pins an
appointment to a later shift, parked next to the jobs so cost prefers joining
it. Covered for an any relation and a strict one, since the two reach the
solver by different paths. A third test asserts the break on that shift is
still taken.

Each test was checked against the unfixed code: with nothing excluded all
three fail, and with pinned jobs excluded but breaks still counted, only the
break test fails.

minimize-tours is left out of the objective list in these tests on purpose -
ranked above, it consolidates onto the pinned shift whatever this objective
prefers.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: hutchinsp01

vrp-core/tests/unit/construction/features/early_tours_test.rs

@@ -28,20 +28,51 @@ fn create_fleet(days: usize) -> Fleet {
         .build()
 }
 
+/// A job here stands for work the solver cannot move off its shift: one pinned by a relation, or a
+/// service job the vehicle generates for that shift alone, such as a break.
+const PINNED_LOCATION: Location = 100;
+
 fn create_objective(fleet: &Fleet) -> Arc<dyn FeatureObjective> {
-    create_prefer_early_tours_feature("prefer_early_tours", get_earliest_shift_start(fleet)).unwrap().objective.unwrap()
+    create_objective_with(fleet, Arc::new(|_| true))
+}
+
+/// Builds an objective which treats jobs at [`PINNED_LOCATION`] as unmovable.
+fn create_pinning_objective(fleet: &Fleet) -> Arc<dyn FeatureObjective> {
+    create_objective_with(fleet, Arc::new(|job: &Job| job_location(job) != Some(PINNED_LOCATION)))
+}
+
+fn create_objective_with(fleet: &Fleet, is_discretionary_fn: DiscretionaryJobFn) -> Arc<dyn FeatureObjective> {
+    create_prefer_early_tours_feature("prefer_early_tours", get_earliest_shift_start(fleet), is_discretionary_fn)
+        .unwrap()
+        .objective
+        .unwrap()
+}
+
+fn job_location(job: &Job) -> Option<Location> {
+    job.as_single().and_then(|single| single.places.first()).and_then(|place| place.location)
 }
 
 /// Creates a route on the given day's shift with `job_count` jobs in its tour.
 fn create_route_ctx(fleet: &Fleet, day: usize, job_count: usize) -> RouteContext {
+    create_route_ctx_at(fleet, day, (0..job_count).map(|idx| idx + 1).collect())
+}
+
+/// Creates a route on the given day's shift with a job at each of the given locations.
+fn create_route_ctx_at(fleet: &Fleet, day: usize, locations: Vec<Location>) -> RouteContext {
     let route = RouteBuilder::default()
         .with_vehicle(fleet, format!("day_{day}").as_str())
-        .add_activities((0..job_count).map(|idx| ActivityBuilder::with_location(idx + 1).build()))
+        .add_activities(locations.into_iter().map(|location| ActivityBuilder::with_location(location).build()))
         .build();
 
     RouteContextBuilder::default().with_route(route).build()
 }
 
+fn get_fitness(objective: &Arc<dyn FeatureObjective>, fleet: &Fleet, days: Vec<(usize, Vec<Location>)>) -> Cost {
+    let routes = days.into_iter().map(|(day, locations)| create_route_ctx_at(fleet, day, locations)).collect();
+
+    objective.fitness(&TestInsertionContextBuilder::default().with_routes(routes).build())
+}
+
 parameterized_test! {can_estimate_delay_of_opening_a_shift, (day, expected), {
     can_estimate_delay_of_opening_a_shift_impl(day, expected);
 }}
@@ -150,3 +181,93 @@ fn can_use_first_job_arrival_floor_when_shift_start_is_relaxed() {
     assert_eq!(actor.detail.time.start, 0.);
     assert_eq!(get_shift_start(actor.as_ref()), 3. * DAY);
 }
+
+parameterized_test! {can_estimate_delay_for_a_shift_holding_only_unmovable_work, (day, expected), {
+    can_estimate_delay_for_a_shift_holding_only_unmovable_work_impl(day, expected);
+}}
+
+can_estimate_delay_for_a_shift_holding_only_unmovable_work! {
+    case_01_earliest_shift_is_still_free: (0, 0.),
+    case_02_last_day: (4, 4. * DAY),
+}
+
+fn can_estimate_delay_for_a_shift_holding_only_unmovable_work_impl(day: usize, expected: Cost) {
+    // a standing appointment does not pay for the shift, so the first job which could have gone
+    // elsewhere still does - otherwise that day reads as already paid for and draws in new work
+    let fleet = create_fleet(5);
+    let objective = create_pinning_objective(&fleet);
+    let route_ctx = create_route_ctx_at(&fleet, day, vec![PINNED_LOCATION]);
+    let solution_ctx = TestInsertionContextBuilder::default().build().solution;
+    let job = TestSingleBuilder::default().location(Some(1)).build_as_job_ref();
+
+    let result = objective.estimate(&MoveContext::route(&solution_ctx, &route_ctx, &job));
+
+    assert_eq!(result, expected);
+}
+
+#[test]
+fn can_estimate_nothing_for_a_shift_already_holding_movable_work() {
+    // once some movable work is on the shift, the delay is already paid and the rest is free
+    let fleet = create_fleet(5);
+    let objective = create_pinning_objective(&fleet);
+    let route_ctx = create_route_ctx_at(&fleet, 4, vec![PINNED_LOCATION, 1]);
+    let solution_ctx = TestInsertionContextBuilder::default().build().solution;
+    let job = TestSingleBuilder::default().location(Some(2)).build_as_job_ref();
+
+    let result = objective.estimate(&MoveContext::route(&solution_ctx, &route_ctx, &job));
+
+    assert_eq!(result, 0.);
+}
+
+#[test]
+fn can_estimate_nothing_for_a_job_which_cannot_change_shift() {
+    // the job has nowhere else to go, so charging its shift would only add noise
+    let fleet = create_fleet(5);
+    let objective = create_pinning_objective(&fleet);
+    let route_ctx = create_route_ctx_at(&fleet, 4, vec![]);
+    let solution_ctx = TestInsertionContextBuilder::default().build().solution;
+    let job = TestSingleBuilder::default().location(Some(PINNED_LOCATION)).build_as_job_ref();
+
+    let result = objective.estimate(&MoveContext::route(&solution_ctx, &route_ctx, &job));
+
+    assert_eq!(result, 0.);
+}
+
+parameterized_test! {can_estimate_fitness_ignoring_unmovable_work, (days, expected), {
+    can_estimate_fitness_ignoring_unmovable_work_impl(days, expected);
+}}
+
+can_estimate_fitness_ignoring_unmovable_work! {
+    case_01_a_shift_of_standing_work_alone_is_free: (vec![(4, vec![PINNED_LOCATION])], 0.),
+    case_02_new_work_on_the_earliest_shift: (vec![(0, vec![1]), (4, vec![PINNED_LOCATION])], 0.),
+    case_03_new_work_joining_the_standing_shift: (vec![(4, vec![PINNED_LOCATION, 1])], 4. * DAY),
+    case_04_new_work_on_its_own_second_day: (vec![(1, vec![1]), (4, vec![PINNED_LOCATION])], DAY),
+    // standing work on a shift which is worked anyway changes nothing
+    case_05_mixed_shift_costs_its_delay_once: (vec![(1, vec![PINNED_LOCATION, 1, 2])], DAY),
+}
+
+fn can_estimate_fitness_ignoring_unmovable_work_impl(days: Vec<(usize, Vec<Location>)>, expected: Cost) {
+    let fleet = create_fleet(5);
+    let objective = create_pinning_objective(&fleet);
+
+    let result = get_fitness(&objective, &fleet, days);
+
+    assert_eq!(result, expected);
+}
+
+#[test]
+fn can_prefer_an_earlier_empty_shift_over_one_held_open_by_standing_work() {
+    // the regression this rule exists for: a recurring Thursday appointment must not make Thursday
+    // a free home for work which could have been done on Tuesday. Counting the pinned shift makes
+    // joining it score delay(Thu) against delay(Tue) + delay(Thu), so joining always wins.
+    let fleet = create_fleet(5);
+    let objective = create_pinning_objective(&fleet);
+
+    let join_standing_shift = get_fitness(&objective, &fleet, vec![(4, vec![PINNED_LOCATION, 1])]);
+    let open_earlier_shift = get_fitness(&objective, &fleet, vec![(1, vec![1]), (4, vec![PINNED_LOCATION])]);
+
+    assert!(
+        open_earlier_shift < join_standing_shift,
+        "expected opening the earlier shift ({open_earlier_shift}) to beat joining the standing one ({join_standing_shift})"
+    );
+}

vrp-pragmatic/tests/features/objectives/prefer_early_tours.rs

@@ -1,5 +1,6 @@
 use crate::format::problem::Objective::*;
 use crate::format::problem::*;
+use crate::format::solution::Solution;
 use crate::format_time;
 use crate::helpers::*;
 
@@ -88,3 +89,100 @@ fn can_prefer_earliest_shift_with_out_of_hours_depot_travel() {
 fn objectives() -> Option<Vec<Objective>> {
     Some(vec![MinimizeUnassigned { breaks: None }, MinimizeTours, PreferEarlyTours, MinimizeCost])
 }
+
+/// Builds a plan where a standing appointment pinned by a relation already holds the `late` shift
+/// open, plus one new job which either shift could serve. `late` is parked next to both jobs while
+/// `early` has to drive out to them, and the new job sits exactly where the appointment already is,
+/// so joining the standing shift is free and cost clearly prefers it. The new job therefore only
+/// lands on `early` if this objective says so.
+fn create_problem_with_standing_work(relation_type: RelationType, late_break: Option<VehicleBreak>) -> Problem {
+    let shift = |earliest: f64, latest: f64, location: (f64, f64), breaks: Option<Vec<VehicleBreak>>| VehicleShift {
+        start: ShiftStart { earliest: format_time(earliest), latest: None, location: location.to_loc() },
+        end: Some(ShiftEnd { earliest: None, latest: format_time(latest), location: location.to_loc() }),
+        breaks,
+        ..create_default_vehicle_shift()
+    };
+
+    Problem {
+        plan: Plan {
+            jobs: vec![create_delivery_job("standing", (100., 0.)), create_delivery_job("new", (100., 0.))],
+            relations: Some(vec![Relation {
+                type_field: relation_type,
+                jobs: to_strings(vec!["standing"]),
+                vehicle_id: "late_1".to_string(),
+                shift_index: None,
+            }]),
+            ..create_empty_plan()
+        },
+        fleet: Fleet {
+            vehicles: vec![
+                VehicleType { shifts: vec![shift(0., 1000., (0., 0.), None)], ..create_default_vehicle("early") },
+                VehicleType {
+                    shifts: vec![shift(10000., 11000., (95., 0.), late_break.map(|item| vec![item]))],
+                    ..create_default_vehicle("late")
+                },
+            ],
+            ..create_default_fleet()
+        },
+        // `minimize-tours` is left out on purpose: ranked above, it would consolidate the new job
+        // onto the standing shift to save a tour, whatever this objective prefers
+        objectives: Some(vec![MinimizeUnassigned { breaks: None }, PreferEarlyTours, MinimizeCost]),
+    }
+}
+
+fn solve_problem(problem: Problem) -> Solution {
+    let matrix = create_matrix_from_problem(&problem);
+
+    solve_with_metaheuristic(problem, Some(vec![matrix]))
+}
+
+/// Returns the id of the vehicle serving the given job.
+fn get_vehicle_serving(solution: &Solution, job_id: &str) -> String {
+    solution
+        .tours
+        .iter()
+        .find(|tour| get_ids_from_tour(tour).iter().flatten().any(|id| id == job_id))
+        .unwrap_or_else(|| panic!("'{job_id}' is not served in any tour"))
+        .vehicle_id
+        .clone()
+}
+
+#[test]
+fn can_ignore_a_shift_held_open_by_a_pinned_job() {
+    // a recurring appointment on a later day must not turn that day into a free home for new work:
+    // it sits there whatever this objective prefers, so it does not pay for the shift
+    let solution = solve_problem(create_problem_with_standing_work(RelationType::Any, None));
+
+    assert_eq!(get_vehicle_serving(&solution, "new"), "early_1");
+}
+
+#[test]
+fn can_ignore_a_shift_held_open_by_a_strictly_pinned_job() {
+    // `strict` and `sequence` relations reach the solver as locked jobs while `any` reaches it as
+    // reserved ones, so the objective reads the locks rather than the solution's locked set
+    let solution = solve_problem(create_problem_with_standing_work(RelationType::Strict, None));
+
+    assert_eq!(get_vehicle_serving(&solution, "new"), "early_1");
+}
+
+#[test]
+fn can_keep_a_break_on_a_shift_held_open_by_a_pinned_job() {
+    // a break belongs to one shift and can never be taken a day earlier, so it must not read as
+    // work the solver chose to put there. Counting it would price the break at its shift's delay,
+    // and since this objective outranks cost the solver would rather drop the break than pay it.
+    let vehicle_break = VehicleBreak::Optional {
+        time: VehicleOptionalBreakTime::TimeWindow(vec![format_time(10000.), format_time(10100.)]),
+        places: vec![VehicleOptionalBreakPlace { duration: 2.0, location: None, tag: None }],
+        policy: None,
+    };
+
+    let solution = solve_problem(create_problem_with_standing_work(RelationType::Any, Some(vehicle_break)));
+
+    let late_tour = solution.tours.iter().find(|tour| tour.vehicle_id == "late_1").expect("no tour for 'late_1'");
+    assert_eq!(
+        get_ids_from_tour(late_tour),
+        vec![vec!["departure"], vec!["standing", "break"], vec!["arrival"]],
+        "the break should still be taken on the standing shift"
+    );
+    assert_eq!(get_vehicle_serving(&solution, "new"), "early_1");
+}