mirror of
https://github.com/mauriceboe/TREK.git
synced 2026-10-21 22:46:32 +00:00
Maurice
c2dd66986c
A GPX or KML import stores the track's first point as the place's position, so the day route treated it as a single stop there and routed from the track start to the next stop, a second road running alongside the track. Any assigned place with a usable track now gets the gap a Tour already had: the route runs up to the track start and continues from the track end, on the desktop map and day list, the mobile timeline, the trip overview and the PDF map, which now draws the track as a line. A place without a usable track stays a plain stop and never shows as an invalid Tour. Refs #2600
508 lines
28 KiB
TypeScript
508 lines
28 KiB
TypeScript
import { describe, it, expect } from 'vitest'
|
|
import { buildDayRouteRuns, hotelBookendOf } from './dayRoutePlan'
|
|
import { projectDayItinerary } from './dayTourProjection'
|
|
import { resolveLegMode } from '../Planner/legMode'
|
|
import { planTripRoute, assembleTripRoute, emptyAnswers, summariseTripRoute } from './tripRouteGeometry'
|
|
import { buildAssignment, buildDay, buildPlace, buildReservation } from '../../../tests/helpers/factories'
|
|
import type { Accommodation, AssignmentsMap, Day, Reservation } from '../../types'
|
|
|
|
const at = (lat: number, lng: number, order: number, extra: Record<string, unknown> = {}) =>
|
|
buildAssignment({ day_id: 1, order_index: order, place: buildPlace({ lat, lng }), ...extra })
|
|
|
|
const inputs = (over: Partial<{
|
|
days: Day[]; assignments: AssignmentsMap; reservations: Reservation[]
|
|
accommodations: Accommodation[]; optimizeFromAccommodation: boolean | undefined
|
|
}> = {}) => ({
|
|
days: [buildDay({ id: 1, day_number: 1 })],
|
|
assignments: {},
|
|
reservations: [],
|
|
accommodations: [],
|
|
optimizeFromAccommodation: false,
|
|
...over,
|
|
})
|
|
|
|
describe('buildDayRouteRuns', () => {
|
|
it('FE-MAP-DRP-001: orders a day\'s located stops into one run', () => {
|
|
const runs = buildDayRouteRuns(1, inputs({
|
|
assignments: { '1': [at(48.86, 2.35, 1), at(45.76, 4.83, 0)] },
|
|
}))
|
|
|
|
expect(runs).toHaveLength(1)
|
|
// order_index, not the order they happen to sit in the array.
|
|
expect(runs[0].map(p => p.lat)).toEqual([45.76, 48.86])
|
|
expect(runs[0].every(p => p.isPlace)).toBe(true)
|
|
})
|
|
|
|
it('FE-MAP-DRP-002: drops a stop with no coordinates', () => {
|
|
const runs = buildDayRouteRuns(1, inputs({
|
|
assignments: {
|
|
'1': [
|
|
at(48.86, 2.35, 0),
|
|
buildAssignment({ day_id: 1, order_index: 1, place: buildPlace({ lat: null, lng: null }) }),
|
|
at(45.76, 4.83, 2),
|
|
],
|
|
},
|
|
}))
|
|
|
|
expect(runs[0]).toHaveLength(2)
|
|
})
|
|
|
|
it('FE-MAP-DRP-003: a lone stop is no drive at all', () => {
|
|
expect(buildDayRouteRuns(1, inputs({ assignments: { '1': [at(48.86, 2.35, 0)] } }))).toEqual([])
|
|
})
|
|
|
|
it('FE-MAP-DRP-004: carries the per-leg travel modes the router resolves against', () => {
|
|
const runs = buildDayRouteRuns(1, inputs({
|
|
assignments: {
|
|
'1': [
|
|
at(48.86, 2.35, 0, { leg_transport_mode: 'walking' }),
|
|
at(48.88, 2.36, 1, { incoming_leg_transport_mode: 'cycling' }),
|
|
],
|
|
},
|
|
}))
|
|
|
|
expect(runs[0][0].leg_transport_mode).toBe('walking')
|
|
expect(runs[0][1].incoming_leg_transport_mode).toBe('cycling')
|
|
})
|
|
|
|
it('FE-MAP-DRP-005: two real places stay one run however far apart they are', () => {
|
|
// Paris → Tokyo is far past MAX_DRIVE_KM, but both are real places someone
|
|
// planned, so the run stands: the reachability guard only ever splits a leg
|
|
// that touches a booking endpoint (#2133).
|
|
const runs = buildDayRouteRuns(1, inputs({
|
|
assignments: { '1': [at(48.86, 2.35, 0), at(35.68, 139.69, 1)] },
|
|
}))
|
|
|
|
expect(runs).toHaveLength(1)
|
|
})
|
|
|
|
it('FE-MAP-DRP-006: bookends the day with its accommodation when the setting is on', () => {
|
|
const accommodation = {
|
|
id: 1, trip_id: 1, place_lat: 48.80, place_lng: 2.30,
|
|
start_day_id: 1, end_day_id: 1,
|
|
} as unknown as Accommodation
|
|
const runs = buildDayRouteRuns(1, inputs({
|
|
assignments: { '1': [at(48.86, 2.35, 0), at(48.88, 2.36, 1)] },
|
|
accommodations: [accommodation],
|
|
optimizeFromAccommodation: true,
|
|
}))
|
|
|
|
const flat = runs.flat()
|
|
expect(flat.some(p => p.lat === 48.80 && !p.isPlace)).toBe(true)
|
|
})
|
|
|
|
it('FE-MAP-DRP-007: leaves the hotel out when the setting is off', () => {
|
|
const accommodation = {
|
|
id: 1, trip_id: 1, place_lat: 48.80, place_lng: 2.30,
|
|
start_day_id: 1, end_day_id: 1,
|
|
} as unknown as Accommodation
|
|
const runs = buildDayRouteRuns(1, inputs({
|
|
assignments: { '1': [at(48.86, 2.35, 0), at(48.88, 2.36, 1)] },
|
|
accommodations: [accommodation],
|
|
optimizeFromAccommodation: false,
|
|
}))
|
|
|
|
expect(runs.flat().some(p => p.lat === 48.80)).toBe(false)
|
|
})
|
|
|
|
it('FE-MAP-DRP-009: the stop a booked night wrote is no waypoint; the hotel is the bookend, behind the flight (#2430)', () => {
|
|
// Check-in at four, a flight in the morning, nothing else: the day plan hides the
|
|
// hotel's own stop and shows the flight, then the hotel. The road used to start at
|
|
// the hotel and drive to the departure airport, because the untimed stop kept
|
|
// its stored place ahead of the timed booking.
|
|
const hotel = { id: 30, trip_id: 1, place_lat: 53.5465, place_lng: 9.9727, start_day_id: 1, end_day_id: 3, check_in: '16:00', check_out: '11:00' } as unknown as Accommodation
|
|
const flight = {
|
|
id: 7, trip_id: 1, type: 'flight', title: 'KL 1783', status: 'confirmed', day_id: 1, end_day_id: 1,
|
|
reservation_time: '2026-10-19T10:00', reservation_end_time: '2026-10-19T11:00',
|
|
endpoints: [
|
|
{ role: 'from', sequence: 0, name: 'AMS', lat: 52.3105, lng: 4.7683 },
|
|
{ role: 'to', sequence: 1, name: 'HAM', lat: 53.6304, lng: 9.9882 },
|
|
],
|
|
} as unknown as Reservation
|
|
const runs = buildDayRouteRuns(1, inputs({
|
|
days: [buildDay({ id: 1, day_number: 1 }), buildDay({ id: 2, day_number: 2 }), buildDay({ id: 3, day_number: 3 })],
|
|
assignments: { '1': [at(53.5465, 9.9727, 0, { accommodation_id: 30 })] },
|
|
reservations: [flight],
|
|
accommodations: [hotel],
|
|
optimizeFromAccommodation: true,
|
|
}))
|
|
// One road: from the arrival airport to the hotel. None out of the hotel.
|
|
expect(runs).toHaveLength(1)
|
|
expect(runs[0].map(p => [p.lat, p.lng])).toEqual([[53.6304, 9.9882], [53.5465, 9.9727]])
|
|
})
|
|
|
|
it('FE-MAP-DRP-010: a hotel the traveller placed as a stop of their own still ends the road (#2430)', () => {
|
|
// The same day, but the hotel stop is not the booking's: it stays a waypoint, and
|
|
// the bookend rule declines the zero-kilometre leg onto itself as before.
|
|
const hotel = { id: 30, trip_id: 1, place_lat: 53.5465, place_lng: 9.9727, start_day_id: 1, end_day_id: 3, check_in: '16:00', check_out: '11:00' } as unknown as Accommodation
|
|
const runs = buildDayRouteRuns(1, inputs({
|
|
days: [buildDay({ id: 1, day_number: 1 }), buildDay({ id: 3, day_number: 3 })],
|
|
assignments: { '1': [at(53.5503, 9.9937, 0), at(53.5465, 9.9727, 1)] },
|
|
accommodations: [hotel],
|
|
optimizeFromAccommodation: true,
|
|
}))
|
|
expect(runs).toHaveLength(1)
|
|
expect(runs[0].map(p => p.lat)).toEqual([53.5503, 53.5465])
|
|
})
|
|
|
|
it('FE-MAP-DRP-015: the hotel points say which end of the day they are, a stop on the same spot does not (#2501)', () => {
|
|
const hotel = { id: 1, trip_id: 1, place_lat: 48.80, place_lng: 2.30, start_day_id: 1, end_day_id: 3 } as unknown as Accommodation
|
|
const runs = buildDayRouteRuns(2, inputs({
|
|
days: [buildDay({ id: 1, day_number: 1 }), buildDay({ id: 2, day_number: 2 }), buildDay({ id: 3, day_number: 3 })],
|
|
assignments: { '2': [at(48.86, 2.35, 0), at(48.80, 2.30, 1), at(48.88, 2.36, 2)] },
|
|
accommodations: [hotel],
|
|
optimizeFromAccommodation: true,
|
|
}))
|
|
const legs = runs.flatMap(run => run.slice(1).map((p, i) => hotelBookendOf(run[i], p) ?? null))
|
|
// Out of the hotel, three stops (one of them on the hotel's own spot), back to it.
|
|
expect(legs).toEqual(['morning', null, null, 'evening'])
|
|
})
|
|
|
|
it('FE-MAP-DRP-016: the one drive of a moving day without stops is its morning leg (#2476)', () => {
|
|
const days = [1, 2, 3].map(n => buildDay({ id: n, day_number: n }))
|
|
const stays = [
|
|
{ id: 1, trip_id: 1, place_lat: 48.137, place_lng: 11.575, start_day_id: 1, end_day_id: 2 },
|
|
{ id: 2, trip_id: 1, place_lat: 53.551, place_lng: 9.993, start_day_id: 2, end_day_id: 3 },
|
|
] as unknown as Accommodation[]
|
|
const [run] = buildDayRouteRuns(2, inputs({ days, accommodations: stays, optimizeFromAccommodation: true }))
|
|
expect(run.map(p => p.hotel)).toEqual(['morning', 'evening'])
|
|
expect(hotelBookendOf(run[0], run[1])).toBe('morning')
|
|
})
|
|
|
|
it('FE-MAP-DRP-008: a day that is not in the trip has no route', () => {
|
|
expect(buildDayRouteRuns(99, inputs({ assignments: { '1': [at(48.86, 2.35, 0)] } }))).toEqual([])
|
|
})
|
|
|
|
describe('a moving day from one stay to the next (#2476)', () => {
|
|
// Day 3 checks out of a hotel in Munich and into one in Hamburg, with a flight
|
|
// in between. The booked Hamburg night wrote its own (hidden) stop onto day 3.
|
|
const HOTEL_A = { lat: 48.137, lng: 11.575 }
|
|
const HOTEL_B = { lat: 53.551, lng: 9.993 }
|
|
const MUC = { lat: 48.353, lng: 11.786 }
|
|
const HAM = { lat: 53.63, lng: 9.988 }
|
|
const days = [1, 2, 3, 4, 5].map(n => buildDay({ id: n, day_number: n }))
|
|
const stays = [
|
|
{ id: 1, trip_id: 1, place_lat: HOTEL_A.lat, place_lng: HOTEL_A.lng, start_day_id: 1, end_day_id: 3, check_in: '15:00', check_out: '11:00' },
|
|
{ id: 2, trip_id: 1, place_lat: HOTEL_B.lat, place_lng: HOTEL_B.lng, start_day_id: 3, end_day_id: 5, check_in: '15:00', check_out: '11:00' },
|
|
] as unknown as Accommodation[]
|
|
const bookedStop = buildAssignment({ day_id: 3, order_index: 0, accommodation_id: 2, place: buildPlace({ ...HOTEL_B }) })
|
|
const flight = (located: boolean) => ({
|
|
id: 7, trip_id: 1, type: 'flight', title: 'LH 2078', status: 'confirmed', day_id: 3, end_day_id: 3,
|
|
reservation_time: '2026-11-04T15:15', reservation_end_time: '2026-11-04T17:20',
|
|
endpoints: located
|
|
? [{ role: 'from', sequence: 0, name: 'MUC', ...MUC }, { role: 'to', sequence: 1, name: 'HAM', ...HAM }]
|
|
: [],
|
|
}) as unknown as Reservation
|
|
const movingDay = (reservations: Reservation[], dayStops = [bookedStop]) =>
|
|
buildDayRouteRuns(3, inputs({
|
|
days, assignments: { '3': dayStops }, reservations, accommodations: stays, optimizeFromAccommodation: true,
|
|
})).map(run => run.map(p => [p.lat, p.lng]))
|
|
|
|
it('FE-MAP-DRP-011: a flight saved without airports draws no drive from one hotel to the other', () => {
|
|
// Nothing located is left on the day, and the flight is still the move: a road
|
|
// from Munich to Hamburg is exactly the trip that did not happen.
|
|
expect(movingDay([flight(false)])).toEqual([])
|
|
})
|
|
|
|
it('FE-MAP-DRP-012: with its airports the flight splits the day at them, as reported', () => {
|
|
expect(movingDay([flight(true)])).toEqual([
|
|
[[HOTEL_A.lat, HOTEL_A.lng], [MUC.lat, MUC.lng]],
|
|
[[HAM.lat, HAM.lng], [HOTEL_B.lat, HOTEL_B.lng]],
|
|
])
|
|
})
|
|
|
|
it('FE-MAP-DRP-013: without any booking the move is still the drive between the two hotels (#1297)', () => {
|
|
expect(movingDay([])).toEqual([[[HOTEL_A.lat, HOTEL_A.lng], [HOTEL_B.lat, HOTEL_B.lng]]])
|
|
})
|
|
|
|
it('FE-MAP-DRP-014: a hotel stop planned by hand ahead of the flight is reached after landing', () => {
|
|
// The traveller put the Hamburg hotel on the day before booking it, so the stop
|
|
// stays visible and carries no time. The flight still seats itself in front of
|
|
// the place it lands next to, and no road runs from Munich to Hamburg.
|
|
const handPlaced = at(HOTEL_B.lat, HOTEL_B.lng, 0, { day_id: 3 })
|
|
expect(movingDay([flight(true)], [handPlaced])).toEqual([
|
|
[[HOTEL_A.lat, HOTEL_A.lng], [MUC.lat, MUC.lng]],
|
|
[[HAM.lat, HAM.lng], [HOTEL_B.lat, HOTEL_B.lng]],
|
|
])
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('Tour day itinerary segments', () => {
|
|
const points = {
|
|
A: [48.1, 11.1], B: [48.101, 11.101], C: [48.13, 11.13],
|
|
S: [48.103, 11.103], E: [48.12, 11.12],
|
|
S2: [48.121, 11.121], E2: [48.125, 11.125],
|
|
} as const
|
|
type Name = keyof typeof points
|
|
const tour = (name: Name, end: Name, order: number, geometry?: string) => {
|
|
const assignment = at(points[name][0], points[name][1], order)
|
|
return { ...assignment, tour_place_id: assignment.place.id,
|
|
tour_route_geometry: geometry ?? JSON.stringify([points[name], points[end]]) }
|
|
}
|
|
const ordinary = (name: Name, order: number) => at(points[name][0], points[name][1], order)
|
|
const inspect = (list: AssignmentsMap['1'], enabled = true, profile: 'walking' | 'driving' = 'walking') => {
|
|
const input = { ...inputs({ assignments: { '1': list } }), toursEnabled: enabled }
|
|
const runs = buildDayRouteRuns(1, input)
|
|
const plan = planTripRoute(input, profile)
|
|
const lines = assembleTripRoute(plan, emptyAnswers(plan))[0]?.lines ?? []
|
|
return { runs: runs.map(run => run.map(p => [p.lat, p.lng])),
|
|
chunks: plan.flatMap(day => day.runs.flatMap(run => run.map(chunk => chunk.mode))), lines }
|
|
}
|
|
|
|
it('keeps ordinary A-B-C unchanged with Tours on or off', () => {
|
|
const list = [ordinary('A', 0), ordinary('B', 1), ordinary('C', 2)]
|
|
expect(inspect(list).runs).toEqual(inspect(list, false).runs)
|
|
expect(inspect(list).runs).toEqual([[points.A, points.B, points.C]])
|
|
})
|
|
|
|
it('skips an excluded ordinary activity while preserving the upstream A-C run', () => {
|
|
const list = [ordinary('A', 0), { ...ordinary('B', 1), route_excluded: true }, ordinary('C', 2)]
|
|
expect(inspect(list).runs).toEqual([[points.A, points.C]])
|
|
expect(inspect(list, false).runs).toEqual([[points.A, points.C]])
|
|
})
|
|
|
|
it('retains an excluded Tour and its line but uses no Tour endpoint in routing', () => {
|
|
const excluded = { ...tour('S', 'E', 1), route_excluded: true }
|
|
const list = [ordinary('A', 0), excluded, ordinary('C', 2)]
|
|
expect(projectDayItinerary(list, true)[1]).toMatchObject({
|
|
kind: 'tour', assignment: excluded, geometry: [points.S, points.E], valid: true,
|
|
})
|
|
expect(inspect(list).runs).toEqual([[points.A, points.C]])
|
|
expect(inspect(list).lines).toEqual([[points.A, points.C]])
|
|
expect(inspect(list, false).runs).toEqual([[points.A, points.C]])
|
|
})
|
|
|
|
it('frames an excluded Tour-only day without generating any calculated route line', () => {
|
|
const excluded = { ...tour('S', 'E', 0), route_excluded: true }
|
|
const plan = planTripRoute({ ...inputs({ assignments: { '1': [excluded] } }), toursEnabled: true }, 'walking')
|
|
expect(plan).toHaveLength(1)
|
|
expect(plan[0].runs).toEqual([])
|
|
const overview = summariseTripRoute(assembleTripRoute(plan, emptyAnswers(plan)))
|
|
expect(overview.lines).toEqual([])
|
|
expect(overview.days[0].tourLines).toEqual([[points.S, points.E]])
|
|
expect(overview.focusPoints).toEqual([points.S, points.E])
|
|
})
|
|
|
|
it('omits excluded first, last, consecutive and invalid Tours from connector anchors', () => {
|
|
const excluded = (start: Name, end: Name, order: number, geometry?: string) => ({
|
|
...tour(start, end, order, geometry), route_excluded: true,
|
|
})
|
|
expect(inspect([excluded('S', 'E', 0), ordinary('A', 1), ordinary('C', 2)]).runs).toEqual([[points.A, points.C]])
|
|
expect(inspect([ordinary('A', 0), ordinary('C', 1), excluded('S', 'E', 2)]).runs).toEqual([[points.A, points.C]])
|
|
expect(inspect([ordinary('A', 0), excluded('S', 'E', 1), excluded('S2', 'E2', 2), ordinary('C', 3)]).runs).toEqual([[points.A, points.C]])
|
|
expect(inspect([ordinary('A', 0), excluded('S', 'E', 1, '{bad'), ordinary('C', 2)]).runs).toEqual([[points.A, points.C]])
|
|
})
|
|
|
|
it.each(['cycling', 'cable_car', 'plugin:custom/walk'])('preserves %s overrides on connectors outside Tours', mode => {
|
|
const list = [{ ...ordinary('A', 0), leg_transport_mode: mode }, tour('S', 'E', 1), ordinary('C', 2)]
|
|
expect(inspect(list).runs).toEqual([[points.A, points.S], [points.E, points.C]])
|
|
expect(inspect(list).chunks).toEqual([mode, 'walking'])
|
|
})
|
|
|
|
it.each(['walking', 'driving'] as const)('uses connectors and authoritative point-to-point geometry in %s', profile => {
|
|
const list = [ordinary('A', 0), tour('S', 'E', 1), ordinary('C', 2)]
|
|
const projection = projectDayItinerary(list, true)
|
|
expect(projection[1]).toMatchObject({ kind: 'tour', valid: true, start: { lat: 48.103, lng: 11.103 }, end: { lat: 48.12, lng: 11.12 }, geometry: [points.S, points.E] })
|
|
expect(inspect(list, true, profile).runs).toEqual([[points.A, points.S], [points.E, points.C]])
|
|
expect(inspect(list, true, profile).lines).toEqual([[points.A, points.S], [points.E, points.C]])
|
|
expect(inspect(list, true, profile).chunks).toEqual([profile, profile])
|
|
expect(inspect(list, false, profile).runs).toEqual([[points.A, points.S, points.C]])
|
|
})
|
|
|
|
it('joins a loop at its shared start/end without routing across the Tour', () => {
|
|
const list = [ordinary('A', 0), tour('S', 'S', 1, JSON.stringify([points.S, points.E, points.S])), ordinary('C', 2)]
|
|
expect(inspect(list).runs).toEqual([[points.A, points.S], [points.S, points.C]])
|
|
expect(projectDayItinerary(list, true)[1]).toMatchObject({ kind: 'tour', loop: true })
|
|
})
|
|
|
|
it('handles first, last, single, and consecutive Tours', () => {
|
|
expect(inspect([tour('S', 'E', 0), ordinary('C', 1)]).runs).toEqual([[points.E, points.C]])
|
|
expect(inspect([ordinary('A', 0), tour('S', 'E', 1)]).runs).toEqual([[points.A, points.S]])
|
|
expect(inspect([tour('S', 'E', 0)]).runs).toEqual([])
|
|
expect(inspect([ordinary('A', 0), tour('S', 'E', 1), tour('S2', 'E2', 2), ordinary('C', 3)]).runs)
|
|
.toEqual([[points.A, points.S], [points.E, points.S2], [points.E2, points.C]])
|
|
})
|
|
|
|
it('bookends a single Tour at start/end and ignores excluded edge Tours for hotel anchors', () => {
|
|
const hotel = [48, 11]
|
|
const days = [1, 2, 3].map(id => buildDay({ id, day_number: id }))
|
|
const accommodations = [{ id: 1, trip_id: 1, start_day_id: 1, end_day_id: 3,
|
|
place_lat: hotel[0], place_lng: hotel[1] }] as Accommodation[]
|
|
const withHotels = (list: AssignmentsMap['1']) => buildDayRouteRuns(2, {
|
|
...inputs({ days, assignments: { '2': list.map(assignment => ({ ...assignment, day_id: 2 })) },
|
|
accommodations, optimizeFromAccommodation: true }), toursEnabled: true,
|
|
}).map(run => run.map(point => [point.lat, point.lng]))
|
|
expect(withHotels([tour('S', 'E', 0)])).toEqual([[hotel, points.S], [points.E, hotel]])
|
|
expect(withHotels([
|
|
{ ...tour('S', 'E', 0), route_excluded: true }, ordinary('A', 1), ordinary('C', 2),
|
|
{ ...tour('S2', 'E2', 3), route_excluded: true },
|
|
])).toEqual([[hotel, points.A], [points.A, points.C], [points.C, hotel]])
|
|
expect(withHotels([tour('S', 'E', 0, '{bad')])).toEqual([[hotel, points.S]])
|
|
})
|
|
|
|
it('preserves incoming/outgoing Tour modes on hotel connectors and overview chunks', () => {
|
|
const hotel = { id: 1, trip_id: 1, start_day_id: 1, end_day_id: 3, place_lat: 48.09, place_lng: 11.09 } as Accommodation
|
|
const days = [
|
|
buildDay({ id: 1, day_number: 1 }),
|
|
buildDay({ id: 2, day_number: 2, default_transport_mode: 'driving' }),
|
|
buildDay({ id: 3, day_number: 3 }),
|
|
]
|
|
const assignedTour = {
|
|
...tour('S', 'E', 0),
|
|
incoming_leg_transport_mode: 'walking',
|
|
leg_transport_mode: 'cycling',
|
|
}
|
|
const input = {
|
|
...inputs({ days, assignments: { '2': [assignedTour] }, accommodations: [hotel], optimizeFromAccommodation: true }),
|
|
toursEnabled: true,
|
|
}
|
|
|
|
const runs = buildDayRouteRuns(2, input)
|
|
expect(runs.map(run => run.map(point => [point.lat, point.lng]))).toEqual([
|
|
[[hotel.place_lat, hotel.place_lng], points.S],
|
|
[points.E, [hotel.place_lat, hotel.place_lng]],
|
|
])
|
|
expect(resolveLegMode(runs[0][0], runs[0][1], 'driving')).toBe('walking')
|
|
expect(resolveLegMode(runs[1][0], runs[1][1], 'driving')).toBe('cycling')
|
|
expect(runs[0][1].incoming_leg_transport_mode).toBe('walking')
|
|
expect(runs[1][0].leg_transport_mode).toBe('cycling')
|
|
|
|
const overview = planTripRoute(input, 'driving').find(day => day.day.id === 2)!
|
|
expect(overview.runs.map(run => run.map(chunk => chunk.mode))).toEqual([['walking'], ['cycling']])
|
|
expect(overview.tourLines).toEqual([[points.S, points.E]])
|
|
|
|
const loopTour = { ...tour('S', 'S', 0, JSON.stringify([points.S, points.E, points.S])),
|
|
incoming_leg_transport_mode: 'walking', leg_transport_mode: 'cycling' }
|
|
const loopInput = { ...input, assignments: { '2': [loopTour] } }
|
|
const loopRuns = buildDayRouteRuns(2, loopInput)
|
|
expect(loopRuns.map(run => resolveLegMode(run[0], run[1], 'driving'))).toEqual(['walking', 'cycling'])
|
|
expect(planTripRoute(loopInput, 'driving')[0].tourLines).toEqual([[points.S, points.E, points.S]])
|
|
|
|
const nextTour = { ...tour('S2', 'E2', 1), incoming_leg_transport_mode: 'walking', leg_transport_mode: 'cycling' }
|
|
const consecutiveInput = { ...input, assignments: { '2': [assignedTour, nextTour] } }
|
|
const consecutiveRuns = buildDayRouteRuns(2, consecutiveInput)
|
|
expect(consecutiveRuns.map(run => resolveLegMode(run[0], run[1], 'driving'))).toEqual(['walking', 'cycling', 'cycling'])
|
|
expect(planTripRoute(consecutiveInput, 'driving')[0].tourLines).toEqual([[points.S, points.E], [points.S2, points.E2]])
|
|
})
|
|
|
|
it('does not let an unlocated transport after an invalid Tour create an evening hotel connector', () => {
|
|
const hotel = { id: 1, trip_id: 1, start_day_id: 1, end_day_id: 3, place_lat: 48.09, place_lng: 11.09 } as Accommodation
|
|
const days = [buildDay({ id: 1, day_number: 1 }), buildDay({ id: 2, day_number: 2 }), buildDay({ id: 3, day_number: 3 })]
|
|
const invalidTour = tour('S', 'E', 0, '{bad')
|
|
const unlocatedTrain = buildReservation({ id: 90, type: 'train', day_id: 2, day_plan_position: 1, endpoints: [] })
|
|
const runs = buildDayRouteRuns(2, {
|
|
...inputs({ days, assignments: { '2': [invalidTour] }, reservations: [unlocatedTrain], accommodations: [hotel], optimizeFromAccommodation: true }),
|
|
toursEnabled: true,
|
|
})
|
|
|
|
expect(runs.map(run => run.map(point => [point.lat, point.lng]))).toEqual([[[hotel.place_lat, hotel.place_lng], points.S]])
|
|
})
|
|
|
|
it('marks malformed Tour geometry invalid without inventing an outgoing end', () => {
|
|
const list = [ordinary('A', 0), tour('S', 'E', 1, '{bad'), ordinary('C', 2)]
|
|
expect(projectDayItinerary(list, true)[1]).toMatchObject({ kind: 'tour', valid: false, start: { lat: 48.103, lng: 11.103 }, end: null })
|
|
expect(inspect(list).runs).toEqual([[points.A, points.S]])
|
|
expect(inspect(list, false).runs).toEqual([[points.A, points.S, points.C]])
|
|
})
|
|
|
|
it('uses first and last usable coordinates when Tour geometry contains malformed points', () => {
|
|
const malformedPointToPoint = JSON.stringify([
|
|
[91, 200], points.S, [Number.NaN, points.E[1]], points.E, [48.2],
|
|
])
|
|
const list = [ordinary('A', 0), tour('S', 'E', 1, malformedPointToPoint), ordinary('C', 2)]
|
|
expect(projectDayItinerary(list, true)[1]).toMatchObject({
|
|
kind: 'tour', valid: true, start: { lat: points.S[0], lng: points.S[1] },
|
|
end: { lat: points.E[0], lng: points.E[1] }, geometry: [points.S, points.E],
|
|
})
|
|
expect(inspect(list).runs).toEqual([[points.A, points.S], [points.E, points.C]])
|
|
})
|
|
|
|
it('uses the current Place geometry when a saved Tour changes before assignments refresh', () => {
|
|
const assignment = tour('S', 'E', 1)
|
|
const updatedEnd: [number, number] = [48.127, 11.127]
|
|
const places = [buildPlace({ id: assignment.place.id, lat: points.S[0], lng: points.S[1],
|
|
route_geometry: JSON.stringify([points.S, updatedEnd]) })]
|
|
const list = [ordinary('A', 0), assignment, ordinary('C', 2)]
|
|
expect(projectDayItinerary(list, true, places)[1]).toMatchObject({ end: { lat: 48.127, lng: 11.127 } })
|
|
expect(buildDayRouteRuns(1, { ...inputs({ assignments: { '1': list } }), toursEnabled: true, places })
|
|
.map(run => run.map(point => [point.lat, point.lng])))
|
|
.toEqual([[points.A, points.S], [updatedEnd, points.C]])
|
|
})
|
|
|
|
it('preserves the outgoing Tour mode override for connectors only', () => {
|
|
const list = [ordinary('A', 0), { ...tour('S', 'E', 1), leg_transport_mode: 'plugin:custom/walk' }, ordinary('C', 2)]
|
|
expect(inspect(list).chunks).toEqual(['walking', 'plugin:custom/walk'])
|
|
expect(projectDayItinerary(list, true)[1]).toMatchObject({ geometry: [points.S, points.E] })
|
|
})
|
|
})
|
|
|
|
// #2600: an imported GPX/KML place sits at its track's first point, so routing it as a
|
|
// plain stop drew a second road from the track start to the next stop, alongside the
|
|
// track itself. Any assigned place with a track now leaves that stretch to the track.
|
|
describe('Imported track places', () => {
|
|
const points = {
|
|
A: [35.2015, 24.1395], S: [35.201, 24.118], M: [35.199, 24.1], E: [35.1965, 24.079], C: [35.19, 24.07],
|
|
} as const
|
|
type Name = keyof typeof points
|
|
const stop = (name: Name, order: number, placeId: number) =>
|
|
buildAssignment({ id: 900 + order, day_id: 1, order_index: order,
|
|
place: buildPlace({ id: placeId, lat: points[name][0], lng: points[name][1] }) })
|
|
const trackPlace = (id: number, geometry: string | null, at: readonly [number, number] = points.S) =>
|
|
buildPlace({ id, lat: at[0], lng: at[1], route_geometry: geometry })
|
|
const track = JSON.stringify([points.S, points.M, points.E])
|
|
const runsOf = (list: AssignmentsMap['1'], places: ReturnType<typeof buildPlace>[], toursEnabled = false) =>
|
|
buildDayRouteRuns(1, { ...inputs({ assignments: { '1': list } }), toursEnabled, places })
|
|
.map(run => run.map(point => [point.lat, point.lng]))
|
|
|
|
it('routes up to the track start and carries on from its end, without the Tours addon', () => {
|
|
const list = [stop('A', 0, 1), stop('S', 1, 2), stop('C', 2, 3)]
|
|
const places = [buildPlace({ id: 1 }), trackPlace(2, track), buildPlace({ id: 3 })]
|
|
expect(runsOf(list, places)).toEqual([[points.A, points.S], [points.E, points.C]])
|
|
expect(runsOf(list, places, true)).toEqual([[points.A, points.S], [points.E, points.C]])
|
|
expect(projectDayItinerary(list, false, places)[1]).toMatchObject({ kind: 'tour', valid: true, geometry: [points.S, points.M, points.E] })
|
|
})
|
|
|
|
it('routes to the track start even when the marker was moved off it', () => {
|
|
const list = [stop('A', 0, 1), stop('C', 1, 2), stop('C', 2, 3)]
|
|
const places = [buildPlace({ id: 1 }), trackPlace(2, track, points.C), buildPlace({ id: 3 })]
|
|
expect(runsOf(list, places)).toEqual([[points.A, points.S], [points.E, points.C]])
|
|
})
|
|
|
|
it('takes the track as recorded, so one walked the other way still starts at its first point', () => {
|
|
const list = [stop('A', 0, 1), stop('E', 1, 2), stop('C', 2, 3)]
|
|
const places = [buildPlace({ id: 1 }), trackPlace(2, track, points.E), buildPlace({ id: 3 })]
|
|
expect(runsOf(list, places)).toEqual([[points.A, points.S], [points.E, points.C]])
|
|
})
|
|
|
|
it('keeps a place without a usable track as a plain stop, never as an invalid tour', () => {
|
|
const list = [stop('A', 0, 1), stop('S', 1, 2), stop('C', 2, 3)]
|
|
for (const geometry of [null, '{bad', JSON.stringify([points.S])]) {
|
|
const places = [buildPlace({ id: 1 }), trackPlace(2, geometry), buildPlace({ id: 3 })]
|
|
expect(runsOf(list, places)).toEqual([[points.A, points.S, points.C]])
|
|
expect(projectDayItinerary(list, true, places)[1]).toMatchObject({ kind: 'stop' })
|
|
}
|
|
// Places not loaded yet: the assignment alone carries no track, so nothing is guessed.
|
|
expect(runsOf(list, [])).toEqual([[points.A, points.S, points.C]])
|
|
})
|
|
|
|
it('starts the evening drive back to the hotel at the end of the track', () => {
|
|
const hotel = [35.5, 24.0]
|
|
const days = [1, 2, 3].map(id => buildDay({ id, day_number: id }))
|
|
const accommodations = [{ id: 1, trip_id: 1, start_day_id: 1, end_day_id: 3,
|
|
place_lat: hotel[0], place_lng: hotel[1] }] as Accommodation[]
|
|
const list = [stop('A', 0, 1), stop('S', 1, 2)].map(assignment => ({ ...assignment, day_id: 2 }))
|
|
const places = [buildPlace({ id: 1 }), trackPlace(2, track)]
|
|
expect(buildDayRouteRuns(2, { ...inputs({ days, assignments: { '2': list }, accommodations,
|
|
optimizeFromAccommodation: true }), places }).map(run => run.map(point => [point.lat, point.lng])))
|
|
.toEqual([[hotel, points.A], [points.A, points.S], [points.E, hotel]])
|
|
})
|
|
|
|
it('draws the track as a line in the trip overview and the PDF map', () => {
|
|
const list = [stop('A', 0, 1), stop('S', 1, 2), stop('C', 2, 3)]
|
|
const places = [buildPlace({ id: 1 }), trackPlace(2, track), buildPlace({ id: 3 })]
|
|
const plan = planTripRoute({ ...inputs({ assignments: { '1': list } }), places }, 'driving')
|
|
expect(plan[0].tourLines).toEqual([[points.S, points.M, points.E]])
|
|
})
|
|
})
|