mirror of
https://github.com/mauriceboe/TREK.git
synced 2026-11-20 11:06:06 +00:00
ce69ae99a1
The bringers list moves next to the other bringer helpers so the card file exports components only, three tests read without non-null assertions or any, and three files take the formatting their checks expect.
845 lines
44 KiB
TypeScript
845 lines
44 KiB
TypeScript
import { describe, it, expect } from 'vitest'
|
|
import { parseTimeToMinutes, getSpanPhase, hidesOnMiddleDay, getTransportRouteEndpoints, getDisplayTimeForDay, getTransportForDay, getAssignmentReservations, pinnedAway, stopDayIds, getPlaceBookings, getMergedItems, chronoKeyOf, nightRowsOf, rideSeatKey, seatTimedDrop, yieldTimedBookings, stayStartingOn, storedRideSlot, timedSlot, type MergedItem } from './dayMerge'
|
|
import { planMergedOrder, withTransportPositions } from './mergedOrder'
|
|
|
|
describe('parseTimeToMinutes', () => {
|
|
it('parses HH:MM string', () => {
|
|
expect(parseTimeToMinutes('09:30')).toBe(570)
|
|
})
|
|
|
|
it('parses ISO datetime string', () => {
|
|
expect(parseTimeToMinutes('2025-03-30T14:00:00')).toBe(840)
|
|
})
|
|
|
|
it('returns null for null/empty', () => {
|
|
expect(parseTimeToMinutes(null)).toBeNull()
|
|
expect(parseTimeToMinutes(undefined)).toBeNull()
|
|
})
|
|
})
|
|
|
|
describe('getSpanPhase', () => {
|
|
it('returns single when start === end', () => {
|
|
expect(getSpanPhase({ day_id: 1, end_day_id: 1 }, 1)).toBe('single')
|
|
})
|
|
|
|
it('returns start for the departure day', () => {
|
|
expect(getSpanPhase({ day_id: 1, end_day_id: 3 }, 1)).toBe('start')
|
|
})
|
|
|
|
it('returns end for the arrival day', () => {
|
|
expect(getSpanPhase({ day_id: 1, end_day_id: 3 }, 3)).toBe('end')
|
|
})
|
|
|
|
it('returns middle for days in between', () => {
|
|
expect(getSpanPhase({ day_id: 1, end_day_id: 3 }, 2)).toBe('middle')
|
|
})
|
|
})
|
|
|
|
describe('hidesOnMiddleDay', () => {
|
|
it('keeps a one-day parking on its only day', () => {
|
|
expect(hidesOnMiddleDay({ type: 'parking', day_id: 1, end_day_id: 1 }, 1)).toBe(false)
|
|
})
|
|
|
|
it('keeps a two-day parking on both days (no day in between exists)', () => {
|
|
const parking = { type: 'parking', day_id: 1, end_day_id: 2 }
|
|
expect(hidesOnMiddleDay(parking, 1)).toBe(false)
|
|
expect(hidesOnMiddleDay(parking, 2)).toBe(false)
|
|
})
|
|
|
|
it('hides a three-day parking only on the day in between', () => {
|
|
const parking = { type: 'parking', day_id: 1, end_day_id: 3 }
|
|
expect(hidesOnMiddleDay(parking, 1)).toBe(false)
|
|
expect(hidesOnMiddleDay(parking, 2)).toBe(true)
|
|
expect(hidesOnMiddleDay(parking, 3)).toBe(false)
|
|
})
|
|
|
|
it('hides every day in between of a longer parking span (#1937)', () => {
|
|
const parking = { type: 'parking', day_id: 1, end_day_id: 5 }
|
|
expect([1, 2, 3, 4, 5].map(d => hidesOnMiddleDay(parking, d)))
|
|
.toEqual([false, true, true, true, false])
|
|
})
|
|
|
|
it('leaves a car rental visible, since its middle days move to the day header', () => {
|
|
expect(hidesOnMiddleDay({ type: 'car', day_id: 1, end_day_id: 3 }, 2)).toBe(false)
|
|
})
|
|
|
|
it('leaves every other booking type alone', () => {
|
|
for (const type of ['train', 'cruise', 'event', 'hotel', 'other']) {
|
|
expect(hidesOnMiddleDay({ type, day_id: 1, end_day_id: 3 }, 2)).toBe(false)
|
|
}
|
|
})
|
|
|
|
it('keeps a parking whose end day is not part of the trip', () => {
|
|
expect(hidesOnMiddleDay({ type: 'parking', day_id: 1, end_day_id: 999 }, 1)).toBe(false)
|
|
})
|
|
|
|
it('keeps an unscheduled parking', () => {
|
|
expect(hidesOnMiddleDay({ type: 'parking', day_id: null, end_day_id: null }, 2)).toBe(false)
|
|
})
|
|
})
|
|
|
|
describe('getTransportRouteEndpoints', () => {
|
|
const pickup = { role: 'from', lat: 48.1, lng: 11.5 }
|
|
const dropoff = { role: 'to', lat: 52.5, lng: 13.4 }
|
|
// A car rental spanning day 1 (pickup) through day 3 (drop-off).
|
|
const rental = { day_id: 1, end_day_id: 3, endpoints: [pickup, dropoff] }
|
|
|
|
it('routes to the pickup only on the start day of a multi-day rental', () => {
|
|
expect(getTransportRouteEndpoints(rental, 1)).toEqual({ from: { lat: 48.1, lng: 11.5 }, to: null })
|
|
})
|
|
|
|
it('routes from the drop-off only on the end day', () => {
|
|
expect(getTransportRouteEndpoints(rental, 3)).toEqual({ from: null, to: { lat: 52.5, lng: 13.4 } })
|
|
})
|
|
|
|
it('adds no waypoints on the days in between (regression for #1210)', () => {
|
|
expect(getTransportRouteEndpoints(rental, 2)).toEqual({ from: null, to: null })
|
|
})
|
|
|
|
it('uses both endpoints for a single-day transport', () => {
|
|
const sameDay = { day_id: 1, end_day_id: 1, endpoints: [pickup, dropoff] }
|
|
expect(getTransportRouteEndpoints(sameDay, 1)).toEqual({
|
|
from: { lat: 48.1, lng: 11.5 },
|
|
to: { lat: 52.5, lng: 13.4 },
|
|
})
|
|
})
|
|
|
|
it('returns nulls when the endpoints carry no coordinates', () => {
|
|
const noCoords = { day_id: 1, end_day_id: 1, endpoints: [{ role: 'from' }, { role: 'to' }] }
|
|
expect(getTransportRouteEndpoints(noCoords, 1)).toEqual({ from: null, to: null })
|
|
})
|
|
})
|
|
|
|
describe('getDisplayTimeForDay', () => {
|
|
const r = { day_id: 1, end_day_id: 3, reservation_time: '2025-01-01T09:00:00', reservation_end_time: '2025-01-03T14:00:00' }
|
|
|
|
it('returns reservation_time on start day', () => {
|
|
expect(getDisplayTimeForDay(r, 1)).toBe(r.reservation_time)
|
|
})
|
|
|
|
it('returns reservation_end_time on end day', () => {
|
|
expect(getDisplayTimeForDay(r, 3)).toBe(r.reservation_end_time)
|
|
})
|
|
|
|
it('returns null for middle day', () => {
|
|
expect(getDisplayTimeForDay(r, 2)).toBeNull()
|
|
})
|
|
})
|
|
|
|
describe('getTransportForDay', () => {
|
|
const days = [
|
|
{ id: 1, day_number: 1 },
|
|
{ id: 2, day_number: 2 },
|
|
{ id: 3, day_number: 3 },
|
|
]
|
|
|
|
it('excludes hotel (rendered via accommodation path)', () => {
|
|
const reservations = [{ id: 10, type: 'hotel', day_id: 1 }]
|
|
expect(getTransportForDay({ reservations, dayId: 1, dayAssignmentIds: [], days })).toHaveLength(0)
|
|
})
|
|
|
|
it('includes tour booking on the correct day', () => {
|
|
const reservations = [{ id: 20, type: 'tour', day_id: 1 }]
|
|
expect(getTransportForDay({ reservations, dayId: 1, dayAssignmentIds: [], days })).toHaveLength(1)
|
|
expect(getTransportForDay({ reservations, dayId: 2, dayAssignmentIds: [], days })).toHaveLength(0)
|
|
})
|
|
|
|
it('includes restaurant, event, and other bookings by day_id', () => {
|
|
const reservations = [
|
|
{ id: 30, type: 'restaurant', day_id: 2 },
|
|
{ id: 31, type: 'event', day_id: 2 },
|
|
{ id: 32, type: 'other', day_id: 2 },
|
|
]
|
|
expect(getTransportForDay({ reservations, dayId: 2, dayAssignmentIds: [], days })).toHaveLength(3)
|
|
expect(getTransportForDay({ reservations, dayId: 1, dayAssignmentIds: [], days })).toHaveLength(0)
|
|
})
|
|
|
|
it('includes single-day transport on the correct day', () => {
|
|
const reservations = [{ id: 10, type: 'flight', day_id: 1, end_day_id: 1 }]
|
|
expect(getTransportForDay({ reservations, dayId: 1, dayAssignmentIds: [], days })).toHaveLength(1)
|
|
expect(getTransportForDay({ reservations, dayId: 2, dayAssignmentIds: [], days })).toHaveLength(0)
|
|
})
|
|
|
|
it('includes multi-day transport on all spanned days', () => {
|
|
const reservations = [{ id: 10, type: 'train', day_id: 1, end_day_id: 3 }]
|
|
expect(getTransportForDay({ reservations, dayId: 1, dayAssignmentIds: [], days })).toHaveLength(1)
|
|
expect(getTransportForDay({ reservations, dayId: 2, dayAssignmentIds: [], days })).toHaveLength(1)
|
|
expect(getTransportForDay({ reservations, dayId: 3, dayAssignmentIds: [], days })).toHaveLength(1)
|
|
})
|
|
|
|
it('excludes transport linked to an assignment on that day', () => {
|
|
const reservations = [{ id: 10, type: 'bus', day_id: 1, end_day_id: 1, assignment_id: 42 }]
|
|
expect(getTransportForDay({ reservations, dayId: 1, dayAssignmentIds: [42], days })).toHaveLength(0)
|
|
expect(getTransportForDay({ reservations, dayId: 1, dayAssignmentIds: [99], days })).toHaveLength(1)
|
|
})
|
|
|
|
it('expands a multi-leg TRAIN into one row per leg with train detail on __leg (#1150)', () => {
|
|
const reservations = [{
|
|
id: 40, type: 'train', day_id: 1, end_day_id: 2,
|
|
metadata: JSON.stringify({
|
|
train_number: 'ICE 100',
|
|
legs: [
|
|
{ from: 'Berlin', to: 'Frankfurt', train_number: 'ICE 100', platform: '5', dep_day_id: 1, dep_time: '08:00', arr_day_id: 1, arr_time: '12:00' },
|
|
{ from: 'Frankfurt', to: 'München', train_number: 'ICE 500', platform: '9', dep_day_id: 2, dep_time: '09:00', arr_day_id: 2, arr_time: '12:00' },
|
|
],
|
|
}),
|
|
}]
|
|
const day1 = getTransportForDay({ reservations, dayId: 1, dayAssignmentIds: [], days })
|
|
expect(day1).toHaveLength(1)
|
|
expect(day1[0].__leg).toMatchObject({ index: 0, total: 2, from: 'Berlin', to: 'Frankfurt', train_number: 'ICE 100', platform: '5' })
|
|
const day2 = getTransportForDay({ reservations, dayId: 2, dayAssignmentIds: [], days })
|
|
expect(day2).toHaveLength(1)
|
|
expect(day2[0].__leg).toMatchObject({ index: 1, from: 'Frankfurt', to: 'München', train_number: 'ICE 500', platform: '9' })
|
|
})
|
|
|
|
it('leaves a single-leg train untouched (no __leg)', () => {
|
|
const reservations = [{ id: 41, type: 'train', day_id: 1, end_day_id: 1, metadata: JSON.stringify({ train_number: 'RE 1' }) }]
|
|
const rows = getTransportForDay({ reservations, dayId: 1, dayAssignmentIds: [], days })
|
|
expect(rows).toHaveLength(1)
|
|
expect(rows[0].__leg).toBeUndefined()
|
|
})
|
|
})
|
|
|
|
describe('a booking pinned to a stop on another day (#2604)', () => {
|
|
const days = [
|
|
{ id: 1, day_number: 1 },
|
|
{ id: 2, day_number: 2 },
|
|
{ id: 3, day_number: 3 },
|
|
{ id: 4, day_number: 4 },
|
|
]
|
|
const order = (id: number) => days.find(d => d.id === id)?.day_number ?? null
|
|
const stopDays = stopDayIds({ '1': [{ id: 41 }], '3': [{ id: 43 }, { id: 44 }], '4': undefined })
|
|
|
|
it('maps every stop to its day', () => {
|
|
expect([...stopDays.entries()]).toEqual([[41, 1], [43, 3], [44, 3]])
|
|
})
|
|
|
|
it("a stop outside the booking's own days wins, a stop on one of them or a gone stop does not", () => {
|
|
expect(pinnedAway({ assignment_id: 43, day_id: 1 }, stopDays, order)).toBe(true)
|
|
expect(pinnedAway({ assignment_id: 41, day_id: 1 }, stopDays, order)).toBe(false)
|
|
// A rental picked up at a stop still runs across the rest of its days.
|
|
expect(pinnedAway({ assignment_id: 43, day_id: 2, end_day_id: 4 }, stopDays, order)).toBe(false)
|
|
expect(pinnedAway({ assignment_id: 99, day_id: 1 }, stopDays, order)).toBe(false)
|
|
expect(pinnedAway({ assignment_id: null, day_id: 1 }, stopDays, order)).toBe(false)
|
|
expect(pinnedAway({ assignment_id: 43, day_id: null }, stopDays, order)).toBe(false)
|
|
expect(pinnedAway({ assignment_id: 43, day_id: 1 }, undefined, order)).toBe(false)
|
|
})
|
|
|
|
it("the timeline of the booking's own day leaves it to the stop, so it is listed once", () => {
|
|
const dinner = { id: 10, type: 'restaurant', day_id: 1, assignment_id: 43 }
|
|
const reservations = [dinner]
|
|
expect(getTransportForDay({ reservations, dayId: 1, dayAssignmentIds: [41], days, stopDays })).toHaveLength(0)
|
|
expect(getTransportForDay({ reservations, dayId: 3, dayAssignmentIds: [43, 44], days, stopDays })).toHaveLength(0)
|
|
expect(getAssignmentReservations(reservations, 43)).toEqual([dinner])
|
|
// Without the stops of the trip the old rule stands.
|
|
expect(getTransportForDay({ reservations, dayId: 1, dayAssignmentIds: [41], days })).toHaveLength(1)
|
|
})
|
|
|
|
it('a multi-day booking pinned to a stop on one of its days keeps its other days', () => {
|
|
const rental = { id: 11, type: 'event', day_id: 2, end_day_id: 4, assignment_id: 43 }
|
|
expect(getTransportForDay({ reservations: [rental], dayId: 2, dayAssignmentIds: [], days, stopDays })).toHaveLength(1)
|
|
expect(getTransportForDay({ reservations: [rental], dayId: 3, dayAssignmentIds: [43, 44], days, stopDays })).toHaveLength(0)
|
|
})
|
|
})
|
|
|
|
describe('getPlaceBookings (#2363)', () => {
|
|
const reservations = [
|
|
{ id: 1, assignment_id: 42, reservation_time: '2025-06-01T10:00:00' },
|
|
{ id: 2, assignment_id: null, reservation_time: '2025-06-01T15:00:00', accommodation_place_id: 9 },
|
|
{ id: 3, assignment_id: 42, reservation_time: '2025-06-01T09:00:00', accommodation_place_id: 9 },
|
|
{ id: 4, assignment_id: null, reservation_time: null, accommodation_place_id: 8 },
|
|
]
|
|
|
|
it('adds the stay booked for a hotel after the bookings pinned to the stop, each once', () => {
|
|
expect(getPlaceBookings(reservations, 42, 9).map(r => r.id)).toEqual([3, 1, 2])
|
|
})
|
|
|
|
it('finds the stay even when no stop is open, as from the pill in the day head', () => {
|
|
expect(getPlaceBookings(reservations, null, 9).map(r => r.id)).toEqual([2, 3])
|
|
})
|
|
|
|
it('without a place it is the pinned list alone', () => {
|
|
expect(getPlaceBookings(reservations, 42, null).map(r => r.id)).toEqual([3, 1])
|
|
expect(getPlaceBookings(reservations, null, 7)).toEqual([])
|
|
})
|
|
})
|
|
|
|
describe('getAssignmentReservations', () => {
|
|
it('returns every booking pinned to the assignment, not just the first (#2201)', () => {
|
|
const reservations = [
|
|
{ id: 1, assignment_id: 42, reservation_time: '2025-06-01T10:00:00' },
|
|
{ id: 2, assignment_id: 42, reservation_time: '2025-06-01T09:00:00' },
|
|
{ id: 3, assignment_id: 7, reservation_time: '2025-06-01T08:00:00' },
|
|
]
|
|
expect(getAssignmentReservations(reservations, 42).map(r => r.id)).toEqual([2, 1])
|
|
})
|
|
|
|
it('puts untimed bookings last and breaks ties on the id', () => {
|
|
const reservations = [
|
|
{ id: 5, assignment_id: 42, reservation_time: null },
|
|
{ id: 4, assignment_id: 42, reservation_time: null },
|
|
{ id: 6, assignment_id: 42, reservation_time: '2025-06-01T09:00:00' },
|
|
]
|
|
expect(getAssignmentReservations(reservations, 42).map(r => r.id)).toEqual([6, 4, 5])
|
|
})
|
|
|
|
it('returns nothing without an assignment', () => {
|
|
const reservations = [{ id: 1, assignment_id: 42, reservation_time: null }]
|
|
expect(getAssignmentReservations(reservations, null)).toEqual([])
|
|
expect(getAssignmentReservations(reservations, undefined)).toEqual([])
|
|
})
|
|
|
|
it('leaves the caller array untouched', () => {
|
|
const reservations = [
|
|
{ id: 1, assignment_id: 42, reservation_time: '2025-06-01T10:00:00' },
|
|
{ id: 2, assignment_id: 42, reservation_time: '2025-06-01T09:00:00' },
|
|
]
|
|
getAssignmentReservations(reservations, 42)
|
|
expect(reservations.map(r => r.id)).toEqual([1, 2])
|
|
})
|
|
})
|
|
|
|
describe('getMergedItems', () => {
|
|
it('merges places and notes sorted by sortKey', () => {
|
|
const dayAssignments = [
|
|
{ id: 1, order_index: 0, place: { place_time: null } },
|
|
{ id: 2, order_index: 2, place: { place_time: null } },
|
|
]
|
|
const dayNotes = [{ id: 10, sort_order: 1 }]
|
|
const result = getMergedItems({ dayAssignments, dayNotes, dayTransports: [], dayId: 5 })
|
|
expect(result.map(i => i.type)).toEqual(['place', 'note', 'place'])
|
|
expect(result[0].data.id).toBe(1)
|
|
expect(result[1].data.id).toBe(10)
|
|
expect(result[2].data.id).toBe(2)
|
|
})
|
|
|
|
it('inserts transport by time when no per-day position is set', () => {
|
|
const dayAssignments = [
|
|
{ id: 1, order_index: 0, place: { place_time: '08:00' } },
|
|
{ id: 2, order_index: 1, place: { place_time: '13:00' } },
|
|
]
|
|
const dayTransports = [
|
|
{ id: 20, type: 'flight', day_id: 5, end_day_id: 5, reservation_time: '10:30', day_positions: null },
|
|
]
|
|
const result = getMergedItems({ dayAssignments, dayNotes: [], dayTransports, dayId: 5 })
|
|
const types = result.map(i => i.type)
|
|
// transport (10:30) should be between place at 08:00 (idx 0) and place at 13:00 (idx 1)
|
|
expect(types).toEqual(['place', 'transport', 'place'])
|
|
})
|
|
|
|
it('orders a timed transport chronologically regardless of a stale per-day position', () => {
|
|
const dayAssignments = [
|
|
{ id: 1, order_index: 0, place: { place_time: '08:00' } },
|
|
{ id: 2, order_index: 1, place: { place_time: '13:00' } },
|
|
]
|
|
// The train is at 10:30, so it sorts between the 08:00 and 13:00 places by time —
|
|
// timed items are arranged chronologically even if an old manual position exists.
|
|
const dayTransports = [
|
|
{ id: 20, type: 'train', day_id: 5, end_day_id: 5, reservation_time: '10:30', day_positions: { 5: 1.5 } },
|
|
]
|
|
const result = getMergedItems({ dayAssignments, dayNotes: [], dayTransports, dayId: 5 })
|
|
const types = result.map(i => i.type)
|
|
expect(types).toEqual(['place', 'transport', 'place'])
|
|
})
|
|
|
|
// The same rule the server stores when a start time is saved, so on a day of places
|
|
// alone the day it sends back after the save and the day drawn before it agree.
|
|
it('keeps untimed places where they were put and sorts only the timed ones', () => {
|
|
const place = (id: number, order_index: number, place_time: string | null) => ({ id, order_index, place: { place_time } })
|
|
const ids = (dayAssignments: ReturnType<typeof place>[]) =>
|
|
getMergedItems({ dayAssignments, dayNotes: [], dayTransports: [], dayId: 5 }).map(i => i.data.id)
|
|
|
|
expect(ids([place(1, 0, null), place(2, 1, null), place(3, 2, '14:00')])).toEqual([1, 2, 3])
|
|
expect(ids([place(1, 0, '09:00'), place(2, 1, null), place(3, 2, '14:00')])).toEqual([1, 2, 3])
|
|
expect(ids([place(1, 0, null), place(2, 1, '15:00'), place(3, 2, '10:00')])).toEqual([1, 3, 2])
|
|
})
|
|
|
|
// Where the server's sort and this one part: the server sorts the stops alone, so
|
|
// for it place 2 follows the 09:00 place and stays in front of the 10:00 one. Here it
|
|
// follows the 12:00 note and is drawn behind both.
|
|
it('lets an untimed place take the time of a timed note in front of it', () => {
|
|
const dayAssignments = [
|
|
{ id: 1, order_index: 0, place: { place_time: '09:00' } },
|
|
{ id: 2, order_index: 1, place: { place_time: null } },
|
|
{ id: 3, order_index: 2, place: { place_time: '10:00' } },
|
|
]
|
|
const dayNotes = [{ id: 10, sort_order: 0.5, time: '12:00' }]
|
|
const result = getMergedItems({ dayAssignments, dayNotes, dayTransports: [], dayId: 5 })
|
|
expect(result.map(i => i.data.id)).toEqual([1, 3, 10, 2])
|
|
})
|
|
})
|
|
|
|
// The crossing from the report behind #2461: Amsterdam and Newcastle on the day, the
|
|
// ferry from IJmuiden to the Port of Tyne in the evening. The road trip seats its
|
|
// terminals by the same rule (`rideSeatAfter` in @trek/shared), so list and drive agree.
|
|
describe('getMergedItems: a ride within one day, seated by where it goes (#2461)', () => {
|
|
const place = (id: number, order_index: number, lat: number, lng: number, place_time: string | null = null) =>
|
|
({ id, order_index, place: { lat, lng, place_time } })
|
|
const amsterdam = (at: string | null = null) => place(1, 0, 52.3731, 4.8926, at)
|
|
const newcastle = (at: string | null = null) => place(2, 1, 54.9783, -1.6178, at)
|
|
const ferry = (over: Record<string, unknown> = {}) => ({
|
|
id: 69, type: 'ferry', title: 'IJmuiden to Newcastle', day_id: 5, end_day_id: 5,
|
|
reservation_time: '2026-10-06T17:30', reservation_end_time: '2026-10-06T23:00',
|
|
endpoints: [
|
|
{ role: 'from', sequence: 0, name: 'IJmuiden', lat: 52.4581, lng: 4.5879 },
|
|
{ role: 'to', sequence: 1, name: 'Port of Tyne', lat: 54.9925, lng: -1.4522 },
|
|
],
|
|
...over,
|
|
})
|
|
const read = (dayAssignments: unknown[], dayTransports: unknown[], dayNotes: unknown[] = []) =>
|
|
getMergedItems({ dayAssignments, dayNotes, dayTransports, dayId: 5 }).map(i => `${i.type}:${i.data.id}`)
|
|
|
|
it('puts a ferry between the stops on its two shores rather than at the end of the day', () => {
|
|
expect(read([amsterdam(), newcastle()], [ferry()])).toEqual(['place:1', 'transport:69', 'place:2'])
|
|
})
|
|
|
|
it('keeps it behind a stop timed before its departure, and leaves a ferry without terminals to the clock', () => {
|
|
expect(read([amsterdam(), newcastle('10:00')], [ferry()])).toEqual(['place:1', 'place:2', 'transport:69'])
|
|
expect(read([amsterdam(), newcastle()], [ferry({ endpoints: [] })])).toEqual(['place:1', 'place:2', 'transport:69'])
|
|
// One that lands tomorrow has no seat of its own on this day either.
|
|
expect(read([amsterdam(), newcastle()], [ferry({ end_day_id: 6 })])).toEqual(['place:1', 'place:2', 'transport:69'])
|
|
})
|
|
|
|
it('opens the day with a ride that lands next to its first stop, ahead of a note too', () => {
|
|
// The note keeps its place ahead of the stop; the ride goes ahead of both.
|
|
expect(read([newcastle()], [ferry()], [{ id: 10, sort_order: 0 }])).toEqual(['transport:69', 'note:10', 'place:2'])
|
|
expect(read([newcastle()], [ferry()], [{ id: 10, sort_order: 2 }])).toEqual(['transport:69', 'place:2', 'note:10'])
|
|
})
|
|
|
|
it('leaves a slot somebody stored where it is', () => {
|
|
expect(read([amsterdam(), newcastle()], [ferry({ day_positions: { 5: 1.5 } })])).toEqual(['place:1', 'place:2', 'transport:69'])
|
|
})
|
|
|
|
it('reads a note as nothing and another booking as its clock only', () => {
|
|
const rows = [
|
|
{ type: 'place' as const, sortKey: 0, data: amsterdam() },
|
|
{ type: 'note' as const, sortKey: 0.5, data: { id: 10, time: '20:00' } },
|
|
{ type: 'place' as const, sortKey: 1, data: newcastle() },
|
|
]
|
|
expect(rideSeatKey(ferry(), rows)).toBe(0)
|
|
// A bus at 18:00 between the two is a clock after the departure: the ferry stays ahead of it.
|
|
const bus = { type: 'transport' as const, sortKey: 0.5, data: { id: 11, type: 'bus', reservation_time: '18:00' } }
|
|
expect(rideSeatKey(ferry(), [rows[0], bus, rows[2]])).toBeNull()
|
|
expect(rideSeatKey({ ...ferry(), type: 'taxi' }, rows)).toBeNull()
|
|
})
|
|
})
|
|
|
|
// The slot the desktop stores for a ride nobody placed yet, worked out over the rows the
|
|
// road trip drives rather than the ones the list shows (#2461).
|
|
describe('storedRideSlot', () => {
|
|
const row = (id: number, order_index: number, lat: number | null, lng: number | null, place_time: string | null = null) =>
|
|
({ id, order_index, place_id: id * 10, place: { lat, lng, place_time } })
|
|
const amsterdam = row(1, 0, 52.3731, 4.8926)
|
|
// The hotel a booking put on the day: hidden in the list, a stop of the drive.
|
|
const hotel = row(3, 1, 54.975, -1.61)
|
|
const ferry = (over: Record<string, unknown> = {}) => ({
|
|
id: 69, type: 'ferry', title: 'IJmuiden to Newcastle', day_id: 5, end_day_id: 5,
|
|
reservation_time: '2026-10-06T17:30', reservation_end_time: '2026-10-06T23:00',
|
|
endpoints: [
|
|
{ role: 'from', sequence: 0, name: 'IJmuiden', lat: 52.4581, lng: 4.5879 },
|
|
{ role: 'to', sequence: 1, name: 'Port of Tyne', lat: 54.9925, lng: -1.4522 },
|
|
],
|
|
...over,
|
|
})
|
|
|
|
it('puts a ferry ahead of the hotel across the water that the list does not show', () => {
|
|
// Over the visible Amsterdam alone the clock closed the day at 1.5, behind the hotel,
|
|
// and the drive went there overland before the crossing.
|
|
expect(storedRideSlot(ferry(), [amsterdam, hotel], [{ place_id: 30, start_day_id: 5, check_in: null }], 5)).toBe(0.5)
|
|
})
|
|
|
|
it('times a night by the check-in of the stay that starts there, and the clock still binds', () => {
|
|
// Checked in at three, the hotel is behind the drive by the 17:30 sailing already.
|
|
const checkIn = [{ place_id: 30, start_day_id: 5, check_in: '15:00' }]
|
|
expect(storedRideSlot(ferry(), [amsterdam, hotel], checkIn, 5)).toBe(1.5)
|
|
// A stay that starts on another day says nothing about this one.
|
|
expect(storedRideSlot(ferry(), [amsterdam, hotel], [{ ...checkIn[0], start_day_id: 4 }], 5)).toBe(0.5)
|
|
})
|
|
|
|
it('times only the last visit of the hotel by its check-in, an earlier one is a stop (#2636)', () => {
|
|
// Checked in at six, after the 17:30 sailing: the night is behind the crossing, and so
|
|
// is the rest at the same hotel before it. Read as a second check-in it timed the rest
|
|
// at six too, and the slot went behind both, so the drive reached them overland.
|
|
const checkIn = [{ place_id: 30, start_day_id: 5, check_in: '18:00' }]
|
|
const night = { ...hotel, id: 4, order_index: 2 }
|
|
expect(storedRideSlot(ferry(), [amsterdam, hotel, night], checkIn, 5)).toBe(0.5)
|
|
})
|
|
|
|
it("reads the booking's stop as the night over a rest after it, and a visit that ends the day over both (#2636)", () => {
|
|
const stays = [{ place_id: 30, start_day_id: 5, check_in: '18:00' }]
|
|
// The booking seats its stop first on a day without hours, and Days does not show it.
|
|
const booked = { ...hotel, order_index: 0, accommodation_id: 7 }
|
|
const rest = { ...hotel, id: 4, order_index: 2 }
|
|
const after = row(5, 3, 54.9783, -1.6178)
|
|
expect([...nightRowsOf([booked, { ...amsterdam, order_index: 1 }, rest, after], stays, 5)]).toEqual([0])
|
|
expect([...nightRowsOf([booked, { ...amsterdam, order_index: 1 }, rest], stays, 5)]).toEqual([2])
|
|
// Without a stay starting there that day nothing is a night.
|
|
expect([...nightRowsOf([booked, rest], stays, 6)]).toEqual([])
|
|
})
|
|
|
|
it('opens the day, closes it, or sits behind a timed row, measured on order indexes', () => {
|
|
expect(storedRideSlot(ferry(), [row(2, 3, 54.9783, -1.6178)], [], 5)).toBe(2.5)
|
|
expect(storedRideSlot(ferry(), [amsterdam], [], 5)).toBe(0.5)
|
|
expect(storedRideSlot(ferry(), [amsterdam, row(2, 1, 54.9783, -1.6178, '10:00')], [], 5)).toBe(1.5)
|
|
// A row without coordinates is no stop of the drive, but the day still closes behind it.
|
|
expect(storedRideSlot(ferry(), [amsterdam, row(4, 1, null, null)], [], 5)).toBe(1.5)
|
|
})
|
|
|
|
it('leaves anything but a ride within one day to the clock', () => {
|
|
expect(storedRideSlot(ferry({ type: 'taxi' }), [amsterdam, hotel], [], 5)).toBeNull()
|
|
expect(storedRideSlot(ferry({ end_day_id: 6 }), [amsterdam, hotel], [], 5)).toBeNull()
|
|
expect(storedRideSlot(ferry(), [], [], 5)).toBeNull()
|
|
})
|
|
|
|
it('finds the stay by its place and the day it starts', () => {
|
|
const stays = [{ id: 1, place_id: 30, start_day_id: 4 }, { id: 2, place_id: 30, start_day_id: 5 }]
|
|
expect(stayStartingOn(stays, 30, 5)?.id).toBe(2)
|
|
expect(stayStartingOn(stays, 31, 5)).toBeUndefined()
|
|
})
|
|
})
|
|
|
|
// A stop with a start is drawn by it, and the road trip drives the stored order, so a
|
|
// stop joining a day from elsewhere is stored where the list will draw it.
|
|
describe('timedSlot', () => {
|
|
const visit = (order_index: number, place_time: string | null, accommodation_id: number | null = null) =>
|
|
({ order_index, accommodation_id, place: { place_time } })
|
|
const day = [visit(0, '09:00'), visit(1, '11:00'), visit(2, '14:00')]
|
|
|
|
it('leaves a stop without a start to the drop', () => {
|
|
expect(timedSlot(day, [], null, 1)).toBeNull()
|
|
expect(timedSlot(day, [], undefined)).toBeNull()
|
|
expect(timedSlot(day, [], 'soon')).toBeNull()
|
|
})
|
|
|
|
it('puts a stop between the stored stops its start falls between, wherever it was dropped', () => {
|
|
expect(timedSlot(day, [], '10:00')).toBe(1)
|
|
expect(timedSlot(day, [], '10:00', 2)).toBe(1)
|
|
expect(timedSlot(day, [], '10:00', 0)).toBe(1)
|
|
expect(timedSlot(day, [], '08:00')).toBe(0)
|
|
expect(timedSlot(day, [], '15:00', 0)).toBe(3)
|
|
})
|
|
|
|
it('keeps the drop among the stops without a time behind the same start', () => {
|
|
const loose = [visit(0, '09:00'), visit(1, null), visit(2, '11:00')]
|
|
expect(timedSlot(loose, [], '10:00')).toBe(2)
|
|
expect(timedSlot(loose, [], '10:00', 1)).toBe(1)
|
|
})
|
|
|
|
it('reads the day by order_index, not by the order the rows come in', () => {
|
|
const shuffled = [visit(2, '14:00'), visit(0, '09:00'), visit(1, '11:00')]
|
|
expect(timedSlot(shuffled, [], '12:00')).toBe(2)
|
|
expect(timedSlot([], [], '12:00')).toBe(0)
|
|
})
|
|
|
|
it('stores it right behind the stop the list draws it after on a day stored against its hours', () => {
|
|
// Stored 11:00 then 09:00: the list draws 09:00, 10:00, 11:00, so 10:00 goes behind 09:00.
|
|
expect(timedSlot([visit(0, '11:00'), visit(1, '09:00')], [], '10:00')).toBe(2)
|
|
})
|
|
|
|
it('counts the booked night the list hides, timed by its check-in', () => {
|
|
const nights = [{ id: 7, check_in: '15:00' }, { id: 8, check_in: null }]
|
|
const withCheckIn = [visit(0, '09:00'), visit(1, null, 7), visit(2, '16:00')]
|
|
expect(timedSlot(withCheckIn, nights, '12:00')).toBe(1)
|
|
expect(timedSlot(withCheckIn, nights, '15:30')).toBe(2)
|
|
// Without a check-in the night leads the day and stays in front.
|
|
const leading = [visit(0, null, 8), visit(1, '09:00')]
|
|
expect(timedSlot(leading, nights, '08:00')).toBe(1)
|
|
})
|
|
})
|
|
|
|
// #2631: a day with timed and untimed stops between timed transit rides. Dropping a
|
|
// ride against its time used to draw it back at its time with every untimed stop
|
|
// behind the drop, and the next drag stored that shuffle.
|
|
describe('seatTimedDrop', () => {
|
|
const DAY = 1
|
|
const stop = (id: number, name: string, time: string | null = null) =>
|
|
({ id, order_index: 0, place: { name, place_time: time } })
|
|
const ride = (id: number, time: string, pos: number) =>
|
|
({ id, type: 'transit', title: `ride ${time}`, day_id: DAY, reservation_time: `2026-11-20T${time}`, day_positions: { [DAY]: pos } })
|
|
const note = (id: number, time: string | null, sort_order: number) => ({ id, text: `note ${id}`, time, sort_order })
|
|
|
|
const setup = () => {
|
|
const stops = [
|
|
stop(1, 'Palacio', '07:30'), stop(2, 'Jardin', '10:30'), stop(3, 'Asamkirche', '14:00'), stop(4, 'StPeter', '14:30'),
|
|
stop(5, 'Sendlinger'), stop(6, 'Ayuntamiento'), stop(7, 'Isartor'), stop(8, 'Juliet'),
|
|
].map((a, i) => ({ ...a, order_index: i }))
|
|
return { stops, rides: [ride(101, '07:01', -0.5), ride(102, '12:01', 1.5), ride(103, '16:55', 3.5)], notes: [] as ReturnType<typeof note>[] }
|
|
}
|
|
type Day = ReturnType<typeof setup>
|
|
const draw = (day: Day) => getMergedItems({ dayAssignments: day.stops, dayNotes: day.notes, dayTransports: day.rides, dayId: DAY })
|
|
const label = (it: MergedItem) => it.type === 'place' ? it.data.place.name : it.type === 'note' ? it.data.text : it.data.title
|
|
|
|
/** What the day list does with a drop: insert, seat, store, and draw again. */
|
|
const drop = (day: Day, from: (it: MergedItem) => boolean, to: (it: MergedItem) => boolean, after = true) => {
|
|
const m = draw(day)
|
|
const order = [...m]
|
|
const [moved] = order.splice(order.findIndex(from), 1)
|
|
const at = order.findIndex(to) + (after ? 1 : 0)
|
|
order.splice(at, 0, moved)
|
|
const seated = seatTimedDrop(order, at, DAY)
|
|
const plan = planMergedOrder(seated)
|
|
const stored: Day = {
|
|
stops: day.stops.map(a => ({ ...a, order_index: plan.assignmentIds.indexOf(a.id) })),
|
|
rides: withTransportPositions(day.rides, plan.transportUpdates, DAY),
|
|
notes: day.notes.map(n => ({ ...n, sort_order: plan.noteUpdates.find(u => u.id === n.id)?.sort_order ?? n.sort_order })),
|
|
}
|
|
return { seated: seated.map(label), drawn: draw(stored).map(label), stored }
|
|
}
|
|
const isRide = (id: number) => (it: MergedItem) => it.type === 'transport' && it.data.id === id
|
|
const isStop = (name: string) => (it: MergedItem) => it.type === 'place' && it.data.place.name === name
|
|
const stopsOf = (labels: string[]) => labels.filter(l => !l.startsWith('ride') && !l.startsWith('note'))
|
|
|
|
it('draws the day as the setup expects', () => {
|
|
expect(draw(setup()).map(label)).toEqual([
|
|
'ride 07:01', 'Palacio', 'Jardin', 'ride 12:01', 'Asamkirche', 'StPeter', 'ride 16:55', 'Sendlinger', 'Ayuntamiento', 'Isartor', 'Juliet',
|
|
])
|
|
})
|
|
|
|
it('a ride dropped against its time goes back alone and the stops keep their order', () => {
|
|
const day = setup()
|
|
const before = stopsOf(draw(day).map(label))
|
|
const { seated, drawn } = drop(day, isRide(102), isStop('Sendlinger'))
|
|
expect(drawn).toEqual(seated)
|
|
expect(stopsOf(drawn)).toEqual(before)
|
|
expect(drawn.indexOf('ride 12:01')).toBe(drawn.indexOf('Asamkirche') - 1)
|
|
})
|
|
|
|
it('a later drag of another ride does not reshuffle the stops either', () => {
|
|
const first = drop(setup(), isRide(102), isStop('Sendlinger'))
|
|
const { seated, drawn } = drop(first.stored, isRide(101), isStop('Ayuntamiento'))
|
|
expect(drawn).toEqual(seated)
|
|
expect(stopsOf(drawn)).toEqual(['Palacio', 'Jardin', 'Asamkirche', 'StPeter', 'Sendlinger', 'Ayuntamiento', 'Isartor', 'Juliet'])
|
|
expect(drawn[0]).toBe('ride 07:01')
|
|
})
|
|
|
|
it('a ride dropped between untimed stops its time allows stays where it was dropped', () => {
|
|
const { seated, drawn } = drop(setup(), isRide(103), isStop('Isartor'))
|
|
expect(drawn).toEqual(seated)
|
|
expect(drawn.slice(-4)).toEqual(['Ayuntamiento', 'Isartor', 'ride 16:55', 'Juliet'])
|
|
})
|
|
|
|
it('leaves the untimed stops behind a ride where they are, as before', () => {
|
|
const day: Day = {
|
|
stops: [stop(1, 'Hotel'), stop(2, 'Museum'), stop(3, 'Dinner')].map((a, i) => ({ ...a, order_index: i })),
|
|
rides: [ride(101, '09:00', 0.5)],
|
|
notes: [],
|
|
}
|
|
expect(draw(day).map(label)).toEqual(['Hotel', 'ride 09:00', 'Museum', 'Dinner'])
|
|
const { seated, drawn } = drop(day, isRide(101), isStop('Museum'))
|
|
expect(drawn).toEqual(seated)
|
|
expect(drawn).toEqual(['Hotel', 'Museum', 'ride 09:00', 'Dinner'])
|
|
})
|
|
|
|
it('seats a timed note the same way and leaves an untimed one where it was dropped', () => {
|
|
const day = setup()
|
|
day.notes = [note(201, '12:30', 1.6), note(202, null, 6.5)]
|
|
const isNote = (id: number) => (it: MergedItem) => it.type === 'note' && it.data.id === id
|
|
const timed = drop(day, isNote(201), isStop('Isartor'))
|
|
expect(timed.drawn).toEqual(timed.seated)
|
|
expect(timed.drawn.indexOf('note 201')).toBe(timed.drawn.indexOf('Asamkirche') - 1)
|
|
const untimed = drop(day, isNote(202), isStop('Palacio'))
|
|
expect(untimed.drawn).toEqual(untimed.seated)
|
|
expect(untimed.drawn.indexOf('note 202')).toBe(untimed.drawn.indexOf('Palacio') + 1)
|
|
})
|
|
|
|
it('returns a dropped stop as it came', () => {
|
|
const order = draw(setup())
|
|
expect(seatTimedDrop(order, 1, DAY)).toEqual(order)
|
|
})
|
|
|
|
// #2983: a flight listed below the day's untimed stops held every slot among them.
|
|
const untimedDay = (rides: ReturnType<typeof ride>[]): Day => ({
|
|
stops: [stop(1, 'Hotel'), stop(2, 'Shrine'), stop(3, 'Crossing'), stop(4, 'Tower')].map((a, i) => ({ ...a, order_index: i })),
|
|
rides,
|
|
notes: [],
|
|
})
|
|
|
|
it('a ride dropped among untimed stops stays there, and an earlier booking below them makes room ahead of it', () => {
|
|
const day = untimedDay([ride(101, '06:30', 3.5), ride(102, '13:00', 3.6)])
|
|
expect(draw(day).map(label)).toEqual(['Hotel', 'Shrine', 'Crossing', 'Tower', 'ride 06:30', 'ride 13:00'])
|
|
const { seated, drawn } = drop(day, isRide(102), isStop('Shrine'))
|
|
expect(drawn).toEqual(seated)
|
|
expect(drawn).toEqual(['Hotel', 'Shrine', 'ride 06:30', 'ride 13:00', 'Crossing', 'Tower'])
|
|
})
|
|
|
|
it('a later booking ahead of the drop moves behind it, and the stops keep their order', () => {
|
|
const day = untimedDay([ride(101, '09:00', -0.5), ride(102, '18:00', 1.5)])
|
|
expect(draw(day).map(label)).toEqual(['ride 09:00', 'Hotel', 'Shrine', 'ride 18:00', 'Crossing', 'Tower'])
|
|
const { seated, drawn } = drop(day, isRide(101), isStop('Tower'))
|
|
expect(drawn).toEqual(seated)
|
|
expect(drawn).toEqual(['Hotel', 'Shrine', 'Crossing', 'Tower', 'ride 09:00', 'ride 18:00'])
|
|
})
|
|
|
|
it('a timed stop in the way still sends the ride back to its time, the bookings stay put', () => {
|
|
const day = untimedDay([ride(101, '06:30', 3.5), ride(102, '13:00', 3.6)])
|
|
day.stops[2] = { ...day.stops[2], place: { name: 'Crossing', place_time: '12:00' } }
|
|
expect(draw(day).map(label)).toEqual(['Hotel', 'Shrine', 'ride 06:30', 'Crossing', 'Tower', 'ride 13:00'])
|
|
const { seated, drawn } = drop(day, isRide(102), isStop('Shrine'))
|
|
expect(drawn).toEqual(seated)
|
|
expect(drawn).toEqual(['Hotel', 'Shrine', 'ride 06:30', 'Crossing', 'ride 13:00', 'Tower'])
|
|
})
|
|
})
|
|
|
|
describe('yieldTimedBookings', () => {
|
|
const DAY = 1
|
|
const row = (type: MergedItem['type'], data: Record<string, unknown>): MergedItem => ({ type, sortKey: 0, data })
|
|
const place = (id: number) => row('place', { id, place: { place_time: null } })
|
|
const booking = (id: number, time: string | null) => row('transport', { id, day_id: DAY, reservation_time: time })
|
|
|
|
it('leaves an untimed row, a stop and an order without a booking out of place to the caller', () => {
|
|
const order = [place(1), booking(2, null), booking(3, '2026-11-20T08:00')]
|
|
expect(yieldTimedBookings(order, 1, DAY)).toBeNull()
|
|
expect(yieldTimedBookings(order, 0, DAY)).toBeNull()
|
|
expect(yieldTimedBookings(order, 2, DAY)).toBeNull()
|
|
})
|
|
})
|
|
|
|
|
|
// The report behind #2929: Auckland to Los Angeles leaves at 20:20 and lands at 12:25 the
|
|
// same date, local time at each end; the flight on to Seattle leaves Los Angeles at 17:00.
|
|
// By the clock alone 17:00 comes first, so the second flight was drawn above the first.
|
|
describe('getMergedItems: bookings in different time zones (#2929)', () => {
|
|
const DAY = 5
|
|
const days = [{ id: DAY, day_number: 1, date: '2026-11-20' }]
|
|
const flight = (id: number, time: string, end: string, from: string | null, to: string | null) => ({
|
|
id, type: 'flight', day_id: DAY, end_day_id: DAY,
|
|
reservation_time: `2026-11-20T${time}`, reservation_end_time: `2026-11-20T${end}`,
|
|
metadata: JSON.stringify({ ...(from ? { departure_timezone: from } : {}), ...(to ? { arrival_timezone: to } : {}) }),
|
|
})
|
|
const toLA = flight(1, '20:20', '12:25', 'Pacific/Auckland', 'America/Los_Angeles')
|
|
const toSeattle = flight(2, '17:00', '19:45', 'America/Los_Angeles', 'America/Los_Angeles')
|
|
const ids = (items: MergedItem[]) => items.map(i => i.data.id)
|
|
|
|
it('puts the Auckland flight ahead of the Los Angeles one it connects to', () => {
|
|
for (const dayTransports of [[toLA, toSeattle], [toSeattle, toLA]]) {
|
|
expect(ids(getMergedItems({ dayAssignments: [], dayNotes: [], dayTransports, dayId: DAY }))).toEqual([1, 2])
|
|
}
|
|
})
|
|
|
|
it('keeps a stop with no location, and a note, where their clock puts them', () => {
|
|
const dayAssignments = [
|
|
{ id: 10, order_index: 0, place: { place_time: '09:00' } },
|
|
{ id: 11, order_index: 1, place: { place_time: '18:00' } },
|
|
]
|
|
const dayNotes = [{ id: 30, sort_order: 2, time: '18:30' }]
|
|
const result = getMergedItems({ dayAssignments, dayNotes, dayTransports: [toSeattle, toLA], dayId: DAY })
|
|
// The flights swap the slots they hold between them (17:00 and 20:20). Without
|
|
// coordinates there is no zone to read 18:00 or 18:30 in, so those keep their clock.
|
|
expect(result.map(i => `${i.type}:${i.data.id}`)).toEqual(['place:10', 'transport:1', 'place:11', 'note:30', 'transport:2'])
|
|
})
|
|
|
|
describe('a stop near an endpoint reads the zone of that endpoint', () => {
|
|
const AKL = { lat: -37.0, lng: 174.8, timezone: 'Pacific/Auckland' }
|
|
const LAX = { lat: 33.9, lng: -118.4, timezone: 'America/Los_Angeles' }
|
|
const SEA = { lat: 47.4, lng: -122.3, timezone: 'America/Los_Angeles' }
|
|
const ends = (from: typeof AKL, to: typeof AKL) => [
|
|
{ role: 'from', sequence: 0, name: 'A', code: null, local_time: null, local_date: null, ...from },
|
|
{ role: 'to', sequence: 1, name: 'B', code: null, local_time: null, local_date: null, ...to },
|
|
]
|
|
const aklLax = { ...toLA, endpoints: ends(AKL, LAX) }
|
|
const laxSea = { ...toSeattle, endpoints: ends(LAX, SEA) }
|
|
const stopAt = (id: number, time: string, lat: number, lng: number) =>
|
|
({ id, order_index: id, place: { place_time: time, lat, lng } })
|
|
const drawn = (dayAssignments: Parameters<typeof getMergedItems>[0]['dayAssignments'], dayTransports: Parameters<typeof getMergedItems>[0]['dayTransports']) =>
|
|
getMergedItems({ dayAssignments, dayNotes: [], dayTransports, dayId: DAY })
|
|
const labels = (items: MergedItem[]) => items.map(i => `${i.type}:${i.data.id}`)
|
|
|
|
it('draws a Seattle dinner after the flight to Seattle, and an Auckland breakfast first', () => {
|
|
const stops = [stopAt(10, '09:00', -36.85, 174.76), stopAt(12, '19:45', 47.61, -122.33)]
|
|
const items = drawn(stops, [laxSea, aklLax])
|
|
expect(labels(items)).toEqual(['place:10', 'transport:1', 'transport:2', 'place:12'])
|
|
// The move checks read the same keys, so the drawn order reads as in order.
|
|
const keys = items.map(chronoKeyOf(items, DAY, getDisplayTimeForDay))
|
|
expect(keys).toEqual([9 * 60, 17 * 60, 19 * 60 + 45, 20 * 60 + 20])
|
|
})
|
|
|
|
it('draws a dinner in Auckland at the same clock ahead of the flight out', () => {
|
|
expect(labels(drawn([stopAt(11, '19:45', -36.85, 174.76)], [laxSea, aklLax])))
|
|
.toEqual(['place:11', 'transport:1', 'transport:2'])
|
|
})
|
|
|
|
it('draws a lunch in Los Angeles after the Auckland flight that lands there', () => {
|
|
expect(labels(drawn([stopAt(13, '13:00', 34.05, -118.24)], [aklLax]))).toEqual(['transport:1', 'place:13'])
|
|
})
|
|
|
|
it('leaves a stop far from every endpoint on its clock', () => {
|
|
// Hawaii is no day out from Auckland, Los Angeles or Seattle, so its 19:45 reads no zone.
|
|
expect(labels(drawn([stopAt(14, '19:45', 21.3, -157.85)], [laxSea, aklLax])))
|
|
.toEqual(['transport:1', 'place:14', 'transport:2'])
|
|
})
|
|
|
|
it('changes nothing on a day whose stops and bookings share one zone', () => {
|
|
const hop = { ...laxSea, id: 4, reservation_time: '2026-11-20T08:00', endpoints: ends(LAX, SEA) }
|
|
const stops = [stopAt(15, '07:00', 34.05, -118.24), stopAt(16, '12:00', 47.61, -122.33), stopAt(17, '18:00', 47.61, -122.33)]
|
|
expect(labels(drawn(stops, [laxSea, hop]))).toEqual(['place:15', 'transport:4', 'place:16', 'transport:2', 'place:17'])
|
|
})
|
|
})
|
|
|
|
it('reads the zone from the endpoints when the metadata names none', () => {
|
|
const endpointsOf = (fromTz: string, toTz: string) => [
|
|
{ role: 'from', sequence: 0, name: 'A', code: null, lat: 0, lng: 0, timezone: fromTz, local_time: null, local_date: null },
|
|
{ role: 'to', sequence: 1, name: 'B', code: null, lat: 0, lng: 0, timezone: toTz, local_time: null, local_date: null },
|
|
]
|
|
const a = { ...flight(1, '20:20', '12:25', null, null), endpoints: endpointsOf('Pacific/Auckland', 'America/Los_Angeles') }
|
|
const b = { ...flight(2, '17:00', '19:45', null, null), endpoints: endpointsOf('America/Los_Angeles', 'America/Los_Angeles') }
|
|
expect(ids(getMergedItems({ dayAssignments: [], dayNotes: [], dayTransports: [b, a], dayId: DAY }))).toEqual([1, 2])
|
|
})
|
|
|
|
it('orders the legs of one multi-leg booking by when they leave', () => {
|
|
const booking = {
|
|
id: 3, type: 'flight', day_id: DAY, end_day_id: DAY,
|
|
reservation_time: '2026-11-20T20:20', reservation_end_time: '2026-11-20T19:45',
|
|
endpoints: [
|
|
{ role: 'from', sequence: 0, name: 'Auckland', code: 'AKL', lat: -37.0, lng: 174.8, timezone: 'Pacific/Auckland', local_time: null, local_date: null },
|
|
{ role: 'stop', sequence: 1, name: 'Los Angeles', code: 'LAX', lat: 33.9, lng: -118.4, timezone: 'America/Los_Angeles', local_time: null, local_date: null },
|
|
{ role: 'to', sequence: 2, name: 'Seattle', code: 'SEA', lat: 47.4, lng: -122.3, timezone: 'America/Los_Angeles', local_time: null, local_date: null },
|
|
],
|
|
metadata: JSON.stringify({ legs: [
|
|
{ from: 'AKL', to: 'LAX', dep_day_id: DAY, dep_time: '20:20', arr_day_id: DAY, arr_time: '12:25' },
|
|
{ from: 'LAX', to: 'SEA', dep_day_id: DAY, dep_time: '17:00', arr_day_id: DAY, arr_time: '19:45' },
|
|
] }),
|
|
}
|
|
const dayTransports = getTransportForDay({ reservations: [booking], dayId: DAY, dayAssignmentIds: [], days })
|
|
const legs = getMergedItems({ dayAssignments: [], dayNotes: [], dayTransports, dayId: DAY }).map(i => i.data.__leg.from)
|
|
expect(legs).toEqual(['AKL', 'LAX'])
|
|
})
|
|
|
|
it('orders by the clock when a booking names no zone', () => {
|
|
const noZone = flight(1, '20:20', '12:25', null, null)
|
|
expect(ids(getMergedItems({ dayAssignments: [], dayNotes: [], dayTransports: [noZone, toSeattle], dayId: DAY }))).toEqual([2, 1])
|
|
})
|
|
|
|
it('orders by the clock when the time carries no date', () => {
|
|
const a = { ...toLA, reservation_time: '20:20' }
|
|
const b = { ...toSeattle, reservation_time: '17:00' }
|
|
expect(ids(getMergedItems({ dayAssignments: [], dayNotes: [], dayTransports: [a, b], dayId: DAY }))).toEqual([2, 1])
|
|
})
|
|
|
|
it('reads the arrival zone on the day an overnight flight lands', () => {
|
|
const NEXT = 6
|
|
// Leaves Auckland the evening before and lands in Los Angeles at 12:25 local (20:25 UTC).
|
|
// A flight out of New York at 14:00 local (19:00 UTC) left before it, though its clock
|
|
// reads later, and 12:25 read in Auckland's zone would put the landing a day early.
|
|
const overnight = {
|
|
id: 1, type: 'flight', day_id: DAY, end_day_id: NEXT,
|
|
reservation_time: '2026-11-19T20:20', reservation_end_time: '2026-11-21T12:25',
|
|
metadata: JSON.stringify({ departure_timezone: 'Pacific/Auckland', arrival_timezone: 'America/Los_Angeles' }),
|
|
}
|
|
const hop = { id: 2, type: 'flight', day_id: NEXT, end_day_id: NEXT, reservation_time: '2026-11-21T14:00',
|
|
metadata: JSON.stringify({ departure_timezone: 'America/New_York' }) }
|
|
expect(ids(getMergedItems({ dayAssignments: [], dayNotes: [], dayTransports: [overnight, hop], dayId: NEXT }))).toEqual([2, 1])
|
|
})
|
|
|
|
it('seats a dragged flight where its zone puts it', () => {
|
|
const order = getMergedItems({ dayAssignments: [], dayNotes: [], dayTransports: [toLA, toSeattle], dayId: DAY })
|
|
expect(ids(seatTimedDrop([order[1], order[0]], 0, DAY))).toEqual([1, 2])
|
|
})
|
|
|
|
it('gives the zoned flights the key they are drawn by, so the drawn order reads as in order', () => {
|
|
const items = getMergedItems({ dayAssignments: [], dayNotes: [], dayTransports: [toSeattle, toLA], dayId: DAY })
|
|
const keyOf = chronoKeyOf(items, DAY, getDisplayTimeForDay)
|
|
// Drawn Auckland first: it takes the 17:00 slot, the Seattle flight the 20:20 one.
|
|
expect(items.map(keyOf)).toEqual([17 * 60, 20 * 60 + 20])
|
|
})
|
|
})
|