k1nq/TREK
1
0
Fork 0
mirror of https://github.com/mauriceboe/TREK.git synced 2026-10-19 05:26:47 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
da97d7535f14aaca4ec00d2e04c6b35076ec1d05
TREK/server/tests/unit/nest/accommodations.service.test.ts
T
Maurice be016f180e test(server): seed the session, lease and rollback specs through the factories 
The specs written alongside the session, transaction and lifecycle work
still seeded and read with raw statements. They go through the ORM
factories now; the few that test SQL below the ORM carry a test-sql-allow
reason. The raw SQL baseline holds 177 statements in 6 files.
2026-10-08 19:05:04 +02:00

1530 lines
82 KiB
TypeScript
Raw Blame History

/**
* Unit tests for AccommodationsService. DAY-SVC-016..026, 029 and 035 moved here
* 1:1 with the SQL they cover when accommodations became their own domain; the
* case ids are unchanged so the diff reads as a move. Real in-memory SQLite.
*/
import { describe, it, expect, vi, beforeAll, beforeEach, afterAll } from 'vitest';
vi.mock('../../../src/db/database', async () => {
const { createSnapshotTestDb } = await import('../../helpers/db-mock');
const db = createSnapshotTestDb();
return {
db,
closeDb: () => {},
reinitialize: () => {},
};
});
const { broadcast } = vi.hoisted(() => ({ broadcast: vi.fn() }));
vi.mock('../../../src/websocket', () => ({ broadcast }));
import { db as testDb } from '../../../src/db/database';
import { resetTestDb } from '../../helpers/test-db';
import { createUser, createTrip, createDay, createPlace, createDayAccommodation, createDayAssignment, addTripMember } from '../../helpers/factories';
import { PermissionsService } from '../../../src/nest/permissions/permissions.service';
import { RealtimeService } from '../../../src/nest/realtime/realtime.service';
import { AccommodationsService } from '../../../src/nest/accommodations/accommodations.service';
import { makeAccommodationsService } from '../../helpers/accommodations-service';
import { AccommodationsModule } from '../../../src/nest/accommodations/accommodations.module';
import { AccommodationsDomainModule } from '../../../src/nest/accommodations/accommodations-domain.module';
import { AccommodationsController } from '../../../src/nest/accommodations/accommodations.controller';
import { expectRegisteredProvider, expectRegisteredController } from '../../helpers/module-providers';
import { createTestUnitOfWork, createTestAppSettingsRepo, createTestReservationsRepo } from '../../helpers/test-uow';
import type { FilterQuery } from '@mikro-orm/core';
import { sharedTestOrm } from '../../helpers/test-uow';
import { countRows, deleteRows, findRow, findRows, insertRow, updateRows } from '../../helpers/factories/rows';
import { AppSettings } from '../../../src/db/entities/AppSettings.entity';
import { AssignmentParticipants } from '../../../src/db/entities/AssignmentParticipants.entity';
import { BudgetItems } from '../../../src/db/entities/BudgetItems.entity';
import { DayAccommodations } from '../../../src/db/entities/DayAccommodations.entity';
import { DayAssignments } from '../../../src/db/entities/DayAssignments.entity';
import { Places } from '../../../src/db/entities/Places.entity';
import { Reservations } from '../../../src/db/entities/Reservations.entity';
import { RoadtripVias } from '../../../src/db/entities/RoadtripVias.entity';
import { legacyBoundIntegerText } from '../../../src/nest/common/row-id';
const orm = () => sharedTestOrm(testDb);
/** The first booking linked to a stay, or null. */
async function linkedReservation(accommodationId: number) {
return findRow(await orm(), Reservations, { accommodation_id: legacyBoundIntegerText(accommodationId) });
}
/** Every booking linked to a stay. */
async function linkedReservations(accommodationId: number) {
return findRows(await orm(), Reservations, { accommodation_id: legacyBoundIntegerText(accommodationId) }, { id: 'asc' });
}
/** How many bookings a stay holds. */
async function linkedCount(accommodationId: number): Promise<{ n: number }> {
return { n: await countRows(await orm(), Reservations, { accommodation_id: legacyBoundIntegerText(accommodationId) }) };
}
/** A second hotel booking on the same stay. */
async function addSecondBooking(tripId: number, accommodationId: number): Promise<number> {
return insertRow(await orm(), Reservations, { trip: tripId, type: 'hotel', title: 'Second booking', accommodation_id: legacyBoundIntegerText(accommodationId) });
}
/** An expense, optionally on a booking. */
async function addExpense(tripId: number, name: string, category: string, totalPrice: number, reservationId: number | null): Promise<number> {
return insertRow(await orm(), BudgetItems, { trip: tripId, name, category, total_price: totalPrice, reservation: reservationId });
}
/** Sets columns on day assignments. */
async function setStops(where: FilterQuery<DayAssignments>, data: Partial<Pick<DayAssignments, 'assignment_time' | 'order_index' | 'notes' | 'end_day'>>) {
await updateRows(await orm(), DayAssignments, where, data);
}
// Named `svc` so the moved cases read exactly as they did on DaysService.
let svc: Awaited<ReturnType<typeof makeAccommodationsService>>;
beforeAll(async () => {
svc = await makeAccommodationsService(testDb);
});
beforeEach(() => {
resetTestDb(testDb);
});
afterAll(() => {
testDb.close();
});
describe('validateAccommodationRefs', () => {
it('DAY-SVC-016 — returns no errors when all refs are valid', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id) as any;
const place = createPlace(testDb, trip.id, { name: 'Hotel' }) as any;
const errors = await svc.validateAccommodationRefs(trip.id, place.id, day.id, day.id);
expect(errors).toHaveLength(0);
});
it('DAY-SVC-017 — returns error when place does not exist in trip', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id) as any;
const errors = await svc.validateAccommodationRefs(trip.id, 99999, day.id, day.id);
expect(errors.some((e: any) => e.field === 'place_id')).toBe(true);
});
it('DAY-SVC-018 — returns error when start_day_id is invalid', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id) as any;
const place = createPlace(testDb, trip.id, { name: 'Hotel' }) as any;
const errors = await svc.validateAccommodationRefs(trip.id, place.id, 99999, day.id);
expect(errors.some((e: any) => e.field === 'start_day_id')).toBe(true);
});
it('ACC-003 — reports every bad ref, end_day_id included', async () => {
// The controller only surfaces errors[0], so an unchecked end_day_id would let a
// stay point at a day from another trip and never be reported.
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const errors = await svc.validateAccommodationRefs(trip.id, 99999, 99998, 99997);
expect(errors.map((e: any) => e.field)).toEqual(['place_id', 'start_day_id', 'end_day_id']);
});
it('ACC-004 — skips the refs the caller left undefined', async () => {
// The plugin update path (accommodations.rpc) passes only the fields it changes.
// If an absent ref were validated, every partial update would 403 "Place not found".
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
expect(await svc.validateAccommodationRefs(trip.id)).toHaveLength(0);
expect(await svc.validateAccommodationRefs(trip.id, undefined, undefined, undefined)).toHaveLength(0);
});
});
describe('createAccommodation', () => {
it('DAY-SVC-019 — creates accommodation and returns it with place info', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id) as any;
const place = createPlace(testDb, trip.id, { name: 'Grand Hotel' }) as any;
const { accommodation: accom } = (await svc.createAccommodation(trip.id, {
place_id: place.id,
start_day_id: day.id,
end_day_id: day.id,
check_in: '15:00',
check_out: '11:00',
})) as any;
expect(accom).toBeDefined();
expect(accom.place_name).toBe('Grand Hotel');
});
it('DAY-SVC-020 — auto-creates a linked reservation', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id) as any;
const place = createPlace(testDb, trip.id, { name: 'City Hotel' }) as any;
const { accommodation: accom } = (await svc.createAccommodation(trip.id, {
place_id: place.id, start_day_id: day.id, end_day_id: day.id,
})) as any;
const reservation = await linkedReservation(accom.id);
expect(reservation).not.toBeNull();
expect(reservation.type).toBe('hotel');
expect(reservation.status).toBe('confirmed');
});
it('ACC-005 — titles the partner reservation "Hotel" when the stay has no place', async () => {
// day_accommodations.place_id is nullable (ON DELETE SET NULL) while
// reservations.title is NOT NULL: without the fallback the reservation insert
// fails and takes the whole transaction — and the stay — down with it.
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id) as any;
const { accommodation: accom } = (await svc.createAccommodation(trip.id, {
place_id: null as unknown as number, start_day_id: day.id, end_day_id: day.id,
})) as any;
expect(accom.place_name).toBeNull();
const reservation = (await linkedReservation(accom.id))!;
expect(reservation.title).toBe('Hotel');
});
});
describe('getAccommodation', () => {
it('DAY-SVC-021 — returns accommodation for valid id and trip', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id) as any;
const place = createPlace(testDb, trip.id, { name: 'Hotel' }) as any;
const accom = createDayAccommodation(testDb, trip.id, place.id, day.id, day.id) as any;
const found = await svc.getAccommodation(accom.id, trip.id) as any;
expect(found).toBeDefined();
expect(found.id).toBe(accom.id);
});
it('DAY-SVC-022 — returns undefined for non-existent accommodation', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
expect(await svc.getAccommodation(99999, trip.id)).toBeUndefined();
});
});
describe('updateAccommodation', () => {
it('DAY-SVC-TX-001: a failing booking sync rolls the stay edit back with it', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const place = createPlace(testDb, trip.id, { name: 'Hotel' });
await svc.createAccommodation(trip.id, { place_id: place.id, start_day_id: day.id, end_day_id: day.id, check_in: '14:00' });
const { id } = (await findRow(await orm(), DayAccommodations, { trip: trip.id }))!;
const existing = (await svc.getAccommodation(id, trip.id))!;
const reservations = await createTestReservationsRepo(testDb);
const spy = vi.spyOn(reservations, 'setMetadataAndConfirmation').mockRejectedValueOnce(new Error('boom'));
await expect(svc.updateAccommodation(id, existing, { check_in: '18:00' })).rejects.toThrow('boom');
expect((await findRow(await orm(), DayAccommodations, { id }))!.check_in).toBe('14:00');
spy.mockRestore();
});
it('DAY-SVC-023 — updates check-in and check-out times', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id) as any;
const place = createPlace(testDb, trip.id, { name: 'Hotel' }) as any;
const { accommodation: accom } = (await svc.createAccommodation(trip.id, {
place_id: place.id, start_day_id: day.id, end_day_id: day.id,
})) as any;
const existing = (await svc.getAccommodation(accom.id, trip.id))!;
const { accommodation: updated } = (await svc.updateAccommodation(accom.id, existing as any, { check_in: '16:00', check_out: '12:00' })) as any;
expect(updated).toBeDefined();
// Verify linked reservation metadata was synced
const reservation = await linkedReservation(accom.id);
expect(reservation).not.toBeNull();
const meta = JSON.parse(reservation.metadata || '{}');
expect(meta.check_in_time).toBe('16:00');
expect(meta.check_out_time).toBe('12:00');
});
it('DAY-SVC-024 — preserves existing fields when not updated', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id) as any;
const place = createPlace(testDb, trip.id, { name: 'Hotel' }) as any;
const { accommodation: accom } = (await svc.createAccommodation(trip.id, {
place_id: place.id, start_day_id: day.id, end_day_id: day.id,
confirmation: 'ABC123',
})) as any;
const existing = (await svc.getAccommodation(accom.id, trip.id))!;
await svc.updateAccommodation(accom.id, existing as any, { check_in: '14:00' });
const row = await svc.getAccommodation(accom.id, trip.id) as any;
expect(row.confirmation).toBe('ABC123');
});
it('ACC-006 — updates a stay that has no linked reservation', async () => {
// Stays imported before the auto-reservation existed have no partner row. The sync
// block must be skipped for them, not throw on a missing reservation.
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id) as any;
const place = createPlace(testDb, trip.id, { name: 'Hotel' }) as any;
// The factory writes the stay row directly, without the partner reservation.
const accom = createDayAccommodation(testDb, trip.id, place.id, day.id, day.id) as any;
const existing = (await svc.getAccommodation(accom.id, trip.id))!;
const { accommodation: updated } = (await svc.updateAccommodation(accom.id, existing as any, { check_in: '15:00' })) as any;
expect(updated.check_in).toBe('15:00');
expect(await linkedCount(accom.id)).toMatchObject({ n: 0 });
});
it('ACC-007 — merges into the reservation metadata instead of replacing it', async () => {
// The stay is created with a check-in, so the reservation already carries metadata.
// An update that only moves the check-out must parse and extend that object —
// writing a fresh one would silently drop the check-in window.
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id) as any;
const place = createPlace(testDb, trip.id, { name: 'Hotel' }) as any;
const { accommodation: accom } = (await svc.createAccommodation(trip.id, {
place_id: place.id, start_day_id: day.id, end_day_id: day.id, check_in: '15:00',
})) as any;
const existing = (await svc.getAccommodation(accom.id, trip.id))!;
await svc.updateAccommodation(accom.id, existing as any, { check_in_end: '20:00', check_out: '11:00' });
const reservation = (await linkedReservation(accom.id))!;
expect(JSON.parse(reservation.metadata)).toEqual({
check_in_time: '15:00', check_in_end_time: '20:00', check_out_time: '11:00',
});
});
it('ACC-008 — leaves the reservation confirmation number alone when the stay has none', async () => {
// COALESCE(?, confirmation_number): a stay without a confirmation must not null out
// a number that was typed on the reservation itself.
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id) as any;
const place = createPlace(testDb, trip.id, { name: 'Hotel' }) as any;
const { accommodation: accom } = (await svc.createAccommodation(trip.id, {
place_id: place.id, start_day_id: day.id, end_day_id: day.id,
})) as any;
await updateRows(await orm(), Reservations, { accommodation_id: legacyBoundIntegerText(accom.id) }, { confirmation_number: 'RES-9' });
const existing = (await svc.getAccommodation(accom.id, trip.id))!;
await svc.updateAccommodation(accom.id, existing as any, { check_in: '15:00' });
const reservation = (await linkedReservation(accom.id))!;
expect(reservation.confirmation_number).toBe('RES-9');
});
it('H1 (Plan 3h Task 7 review): a new confirmation on the stay OVERRIDES the linked reservation\'s existing, different confirmation — the new value wins, matching legacy COALESCE(?, confirmation_number)', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id) as any;
const place = createPlace(testDb, trip.id, { name: 'Hotel' }) as any;
const { accommodation: accom } = (await svc.createAccommodation(trip.id, {
place_id: place.id, start_day_id: day.id, end_day_id: day.id,
})) as any;
// The linked reservation already carries a DIFFERENT, non-null confirmation —
// if the stay-side update used `coalesceParam`'s (existing-wins) direction
// instead of `coalesceOverride`'s (new-wins), it would keep this value.
await updateRows(await orm(), Reservations, { accommodation_id: legacyBoundIntegerText(accom.id) }, { confirmation_number: 'RES-OLD' });
const existing = (await svc.getAccommodation(accom.id, trip.id))!;
await svc.updateAccommodation(accom.id, existing as any, { confirmation: 'ACC-CHANGED' });
const reservation = (await linkedReservation(accom.id))!;
expect(reservation.confirmation_number).toBe('ACC-CHANGED');
});
});
describe('deleteAccommodation', () => {
it('DAY-SVC-025 — deletes accommodation and its linked reservation', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id) as any;
const place = createPlace(testDb, trip.id, { name: 'Hotel' }) as any;
const { accommodation: accom } = (await svc.createAccommodation(trip.id, {
place_id: place.id, start_day_id: day.id, end_day_id: day.id,
})) as any;
const reservation = (await linkedReservation(accom.id))!;
const result = await svc.deleteAccommodation(accom.id);
expect(result.linkedReservationId).toBe(reservation.id);
// Accommodation is gone
expect(await svc.getAccommodation(accom.id, trip.id)).toBeUndefined();
// Reservation is gone
const deletedRes = await findRow(await orm(), Reservations, { id: reservation.id });
expect(deletedRes).toBeNull();
});
it('DAY-SVC-026 — returns null linkedReservationId when no reservation was linked', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id) as any;
const place = createPlace(testDb, trip.id, { name: 'Hotel' }) as any;
const accom = createDayAccommodation(testDb, trip.id, place.id, day.id, day.id) as any;
// Remove the auto-created reservation so there's no linked one
await deleteRows(await orm(), Reservations, { accommodation_id: legacyBoundIntegerText(accom.id) });
const result = await svc.deleteAccommodation(accom.id);
expect(result.linkedReservationId).toBeNull();
});
it('ACC-009 — also deletes the budget item that hangs off the linked reservation', async () => {
// The cost row references the reservation, not the stay, so the delete has to
// cascade twice. Skipping the second hop strands a budget line whose reservation
// is gone, and the costs view can no longer reach it to remove it.
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id) as any;
const place = createPlace(testDb, trip.id, { name: 'Hotel' }) as any;
const { accommodation: accom } = (await svc.createAccommodation(trip.id, {
place_id: place.id, start_day_id: day.id, end_day_id: day.id,
})) as any;
const reservation = (await linkedReservation(accom.id))!;
const budgetItemId = await addExpense(trip.id, 'Hotel stay', 'Accommodation', 240, reservation.id);
const result = await svc.deleteAccommodation(accom.id);
expect(result).toEqual({
linkedReservationId: reservation.id,
deletedBudgetItemId: budgetItemId,
linkedReservationIds: [reservation.id],
deletedBudgetItemIds: [budgetItemId],
mirror: { created: null, moved: null, updated: [], removed: [{ id: expect.any(Number), dayId: day.id }], stamped: null },
});
expect(await findRow(await orm(), BudgetItems, { id: budgetItemId })).toBeNull();
});
it('ACC-035 — every expense on every linked booking goes with the stay (#2084)', async () => {
// A booking can carry several expenses now; taking only the first stranded the
// rest on a reservation id that no longer exists.
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id) as any;
const place = createPlace(testDb, trip.id, { name: 'Hotel' }) as any;
const { accommodation: accom } = (await svc.createAccommodation(trip.id, {
place_id: place.id, start_day_id: day.id, end_day_id: day.id,
})) as any;
const first = (await linkedReservation(accom.id))!;
const second = await addSecondBooking(trip.id, accom.id);
const expense = (reservationId: number | null, name: string) => addExpense(trip.id, name, 'accommodation', 50, reservationId);
const room = await expense(first.id, 'Room');
const breakfast = await expense(first.id, 'Breakfast');
const parking = await expense(second, 'Parking');
const unrelated = await expense(null, 'Coffee');
const result = await svc.deleteAccommodation(accom.id);
expect(result.deletedBudgetItemIds).toEqual([room, breakfast, parking]);
expect(result.deletedBudgetItemId).toBe(room);
expect((await findRows(await orm(), BudgetItems, { trip: trip.id }, { id: 'asc' })).map(row => ({ id: row.id }))).toEqual([{ id: unrelated }]);
});
it('ACC-010 — a second booking pointed at the same stay goes too, instead of being orphaned', async () => {
// reservations.accommodation_id carries no foreign key and no unique constraint,
// and the booking form lets a hotel booking pick an existing stay. Deleting only
// the first left the second behind, referencing a stay that no longer exists.
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id) as any;
const place = createPlace(testDb, trip.id, { name: 'Hotel' }) as any;
const { accommodation: accom } = (await svc.createAccommodation(trip.id, {
place_id: place.id, start_day_id: day.id, end_day_id: day.id,
})) as any;
const first = (await linkedReservation(accom.id))!;
const second = await addSecondBooking(trip.id, accom.id);
const result = await svc.deleteAccommodation(accom.id);
expect(result.linkedReservationIds).toEqual([first.id, second]);
expect(result.linkedReservationId).toBe(first.id);
expect(await linkedCount(accom.id)).toMatchObject({ n: 0 });
});
it('ACC-011 — updating the stay syncs the times onto every linked booking', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id) as any;
const place = createPlace(testDb, trip.id, { name: 'Hotel' }) as any;
const { accommodation: accom } = (await svc.createAccommodation(trip.id, {
place_id: place.id, start_day_id: day.id, end_day_id: day.id,
})) as any;
await addSecondBooking(trip.id, accom.id);
const existing = (await findRow(await orm(), DayAccommodations, { id: accom.id }))!;
await svc.updateAccommodation(accom.id, existing as Parameters<typeof svc.updateAccommodation>[1], { check_in: '15:00', check_out: '11:00' });
const rows = await linkedReservations(accom.id);
expect(rows).toHaveLength(2);
for (const row of rows) {
expect(JSON.parse(row.metadata || '{}')).toMatchObject({ check_in_time: '15:00', check_out_time: '11:00' });
}
});
});
describe('listAccommodations', () => {
it('DAY-SVC-029 — listAccommodations returns the hydrated stays', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const place = createPlace(testDb, trip.id, { name: 'Ryokan' });
createDayAccommodation(testDb, trip.id, place.id, day.id, day.id);
const rows = await svc.listAccommodations(trip.id) as { place_name: string }[];
expect(rows).toHaveLength(1);
expect(rows[0].place_name).toBe('Ryokan');
});
});
describe('quirk fixes', () => {
it('DAY-SVC-035 — deleteAccommodation is atomic: a failed stay delete keeps the linked reservation', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const place = createPlace(testDb, trip.id, { name: 'Hotel' });
const { accommodation: accom } = (await svc.createAccommodation(trip.id, {
place_id: place.id, start_day_id: day.id, end_day_id: day.id,
})) as { accommodation: { id: number } };
testDb.exec("CREATE TRIGGER boom BEFORE DELETE ON day_accommodations BEGIN SELECT RAISE(ABORT, 'boom'); END");
try {
await expect(svc.deleteAccommodation(accom.id)).rejects.toThrow();
// The earlier reservation delete inside the transaction rolled back.
expect(await linkedCount(accom.id)).toMatchObject({ n: 1 });
} finally {
testDb.exec('DROP TRIGGER boom');
}
});
});
describe('route-facing delegators', () => {
// list/validateRefs/get/create/update/remove are what the controller, the plugin RPC
// and trip-read-model call; the MCP tools call the long names. Both sets have to land
// on the same SQL, and the short ones get raw route params — strings where the long
// ones get numbers.
it('ACC-010 — list() returns what listAccommodations() returns, for a string and a number trip id', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id) as any;
const place = createPlace(testDb, trip.id, { name: 'Pension Alpen' }) as any;
createDayAccommodation(testDb, trip.id, place.id, day.id, day.id);
expect(await svc.list(String(trip.id))).toEqual(await svc.listAccommodations(trip.id));
expect((await svc.list(trip.id) as any[])[0].place_name).toBe('Pension Alpen');
});
it('ACC-011 — validateRefs() returns the same errors validateAccommodationRefs() does', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id) as any;
const place = createPlace(testDb, trip.id, { name: 'Hotel' }) as any;
expect(await svc.validateRefs(trip.id, place.id, day.id, day.id)).toHaveLength(0);
// The controller 404s with errors[0].message, so the shape matters, not just the count.
expect(await svc.validateRefs(trip.id, 99999, day.id, day.id)).toEqual([{ field: 'place_id', message: 'Place not found' }]);
});
it('ACC-012 — create() writes the stay, get() reads it back trip-scoped', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const otherTrip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id) as any;
const place = createPlace(testDb, trip.id, { name: 'Hotel' }) as any;
// Both ids arrive from the route as strings.
const { accommodation: created } = (await svc.create(String(trip.id), {
place_id: place.id, start_day_id: day.id, end_day_id: day.id, confirmation: 'XY-1',
})) as any;
expect(await svc.get(String(created.id), String(trip.id))).toMatchObject({ id: created.id, confirmation: 'XY-1' });
// Trip-scoped: a stay must not be readable through another trip's URL.
expect(await svc.get(created.id, otherTrip.id)).toBeUndefined();
});
it('ACC-013 — update() syncs the partner reservation even when the id is a string', async () => {
// updateAccommodation looks the reservation up with Number(id); if that coercion
// regresses, the REST path silently stops syncing check-in times.
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id) as any;
const place = createPlace(testDb, trip.id, { name: 'Hotel' }) as any;
const { accommodation: accom } = (await svc.create(trip.id, { place_id: place.id, start_day_id: day.id, end_day_id: day.id })) as any;
const existing = (await svc.get(accom.id, trip.id))!;
const { accommodation: updated } = (await svc.update(String(accom.id), existing as any, { check_in: '16:00', notes: 'late arrival' })) as any;
expect(updated).toMatchObject({ check_in: '16:00', notes: 'late arrival' });
const reservation = (await linkedReservation(accom.id))!;
expect(JSON.parse(reservation.metadata).check_in_time).toBe('16:00');
});
it('ACC-014 — remove() reports the partner reservation it took with it', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id) as any;
const place = createPlace(testDb, trip.id, { name: 'Hotel' }) as any;
const { accommodation: accom } = (await svc.create(trip.id, { place_id: place.id, start_day_id: day.id, end_day_id: day.id })) as any;
const reservation = (await linkedReservation(accom.id))!;
// The controller broadcasts reservation:deleted off this return value.
expect(await svc.remove(String(accom.id))).toEqual({
linkedReservationId: reservation.id,
deletedBudgetItemId: null,
linkedReservationIds: [reservation.id],
deletedBudgetItemIds: [],
mirror: { created: null, moved: null, updated: [], removed: [{ id: expect.any(Number), dayId: day.id }], stamped: null },
});
expect(await svc.get(accom.id, trip.id)).toBeUndefined();
});
});
describe('trip access and edit permission', () => {
it('ACC-015 — verifyTripAccess resolves the trip from a string id and from a number', async () => {
// The REST path hands over the raw :tripId param, the MCP tools the parsed number.
// Without the Number() coercion one of the two callers stops finding its trip.
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
expect(await svc.verifyTripAccess(String(trip.id), user.id)).toMatchObject({ id: trip.id, user_id: user.id });
expect(await svc.verifyTripAccess(trip.id, user.id)).toMatchObject({ id: trip.id, user_id: user.id });
});
it('ACC-016 — verifyTripAccess returns nothing for a user who is neither owner nor member', async () => {
const { user: owner } = createUser(testDb);
const { user: stranger } = createUser(testDb);
const trip = createTrip(testDb, owner.id);
expect(await svc.verifyTripAccess(trip.id, stranger.id)).toBeUndefined();
});
it('ACC-017 — canEdit lets the owner through on the default day_edit level', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const access = (await svc.verifyTripAccess(trip.id, user.id))!;
expect(await svc.canEdit(access, user as any)).toBe(true);
});
it('ACC-018 — canEdit lets a member through: it derives isMember from the trip owner id', async () => {
// day_edit defaults to trip_member. canEdit passes `trip.user_id !== user.id` as the
// isMember flag, so inverting that comparison would lock every invited traveller out
// of the day plan while the owner still edits fine.
const { user: owner } = createUser(testDb);
const { user: member } = createUser(testDb);
const trip = createTrip(testDb, owner.id);
addTripMember(testDb, trip.id, member.id);
const access = (await svc.verifyTripAccess(trip.id, member.id))!;
expect(await svc.canEdit(access, member as any)).toBe(true);
});
it('ACC-019 — canEdit denies a member once day_edit is raised to trip_owner', async () => {
const { user: owner } = createUser(testDb);
const { user: member } = createUser(testDb);
const trip = createTrip(testDb, owner.id);
addTripMember(testDb, trip.id, member.id);
const permissions = new PermissionsService(await createTestAppSettingsRepo(testDb), await createTestUnitOfWork(testDb));
try {
await permissions.savePermissions({ day_edit: 'trip_owner' });
expect(await svc.canEdit((await svc.verifyTripAccess(trip.id, member.id))!, member as any)).toBe(false);
// The owner keeps the right, otherwise the setting would lock out the whole trip.
expect(await svc.canEdit((await svc.verifyTripAccess(trip.id, owner.id))!, owner as any)).toBe(true);
} finally {
// The permission cache is module-scoped and outlives resetTestDb — drop the row and
// the cache together, or every later case in this file inherits the raised level.
await deleteRows(await orm(), AppSettings, { key: 'perm_day_edit' });
await permissions.invalidatePermissionsCache();
}
});
it('ACC-020 — broadcast forwards the socket id so the originating client is not echoed', () => {
// The X-Socket-Id contract: the facade must pass the id straight through as the
// fourth argument. Dropping it makes the sender apply its own change twice.
broadcast.mockClear();
svc.broadcast('5', 'accommodation:deleted', { accommodationId: 9 }, 'sock-1');
expect(broadcast).toHaveBeenCalledWith('5', 'accommodation:deleted', { accommodationId: 9 }, 'sock-1');
svc.broadcast('5', 'accommodation:updated', { accommodation: { id: 9 } }, undefined);
expect(broadcast).toHaveBeenLastCalledWith('5', 'accommodation:updated', { accommodation: { id: 9 } }, undefined);
});
});
/**
* Booking a night also puts its place on the check-in day, because that stop is what
* the road trip routes and the map draws. Reported from Discord: a hotel entered in
* the day planner never reached the road-trip view, so the same place had to be
* entered a second time as an ordinary stop.
*/
describe('the day stop a booking implies', () => {
const stopsOn = async (dayId: number) =>
(await findRows(await orm(), DayAssignments, { day: dayId }, { order_index: 'asc' }))
.map(row => ({ id: row.id, place_id: row.place_id, order_index: row.order_index, accommodation_id: row.accommodation_id ?? null }));
const book = async (tripId: number, placeId: number | null, startDayId: number, endDayId: number) =>
(await svc.createAccommodation(tripId, { place_id: placeId as number, start_day_id: startDayId, end_day_id: endDayId })) as any;
it('ACC-021 the booked night puts its place on the check-in day and marks the stop as its own', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const place = createPlace(testDb, trip.id, { name: 'Hotel Adlon' });
const { accommodation, mirror } = await book(trip.id, place.id, day.id, day.id);
const stops = (await stopsOn(day.id));
expect(stops).toHaveLength(1);
expect(stops[0]).toMatchObject({ place_id: place.id, accommodation_id: accommodation.id });
expect(mirror.created).toMatchObject({ id: stops[0].id, day_id: day.id, place_id: place.id });
// On the answer, not only in the table. This copy is what the client that booked
// the night puts in its store, and accommodation_id is the only thing telling the
// day list this row is the booking it already shows in the header. Without it the
// hotel appears a second time among the day's places until the next reload.
expect(mirror.created.accommodation_id).toBe(accommodation.id);
});
it('ACC-022 the stop lands first: the hotel is where the day is based', async () => {
// It used to go last, and a night booked for the morning sat behind a whole day
// of unpinned stops. The stops the traveller placed without an hour follow the
// hotel; only a clock of their own can put one ahead of it (ACC-022c).
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const museum = createPlace(testDb, trip.id, { name: 'Pergamon' });
const hotel = createPlace(testDb, trip.id, { name: 'Hotel Adlon' });
createDayAssignment(testDb, day.id, museum.id);
await book(trip.id, hotel.id, day.id, day.id);
expect((await stopsOn(day.id)).map(a => a.place_id)).toEqual([hotel.id, museum.id]);
expect((await stopsOn(day.id)).map(a => a.order_index)).toEqual([0, 1]);
});
it('ACC-022b a check-in puts the night before whatever is pinned to a later hour', async () => {
// A stop pinned to the afternoon cannot stand ahead of a check-in at eleven.
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const afternoon = createPlace(testDb, trip.id, { name: 'Mercure' });
const hotel = createPlace(testDb, trip.id, { name: 'Billstedt' });
const pinned = createDayAssignment(testDb, day.id, afternoon.id);
await setStops({ id: pinned.id }, { assignment_time: '16:00' });
await svc.createAccommodation(trip.id, { place_id: hotel.id, start_day_id: day.id, end_day_id: day.id, check_in: '11:00' });
expect((await stopsOn(day.id)).map(a => a.place_id)).toEqual([hotel.id, afternoon.id]);
});
it('ACC-022c a stop pinned to an earlier hour stays ahead of the check-in', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const morning = createPlace(testDb, trip.id, { name: 'Museum' });
const hotel = createPlace(testDb, trip.id, { name: 'Billstedt' });
const pinned = createDayAssignment(testDb, day.id, morning.id);
await setStops({ id: pinned.id }, { assignment_time: '09:00' });
await svc.createAccommodation(trip.id, { place_id: hotel.id, start_day_id: day.id, end_day_id: day.id, check_in: '18:00' });
expect((await stopsOn(day.id)).map(a => a.place_id)).toEqual([morning.id, hotel.id]);
});
it('ACC-022d a stop without an hour of its own follows the night, whatever the check-in', async () => {
// A stop with no clock is planned from the hotel, not the other way round. This
// is the day from Discord: two unpinned stops and a night booked for ten in the
// morning, which the drive used to reach at a quarter past twelve.
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const fuel = createPlace(testDb, trip.id, { name: 'Aral' });
const farm = createPlace(testDb, trip.id, { name: 'Karls Erdbeerhof' });
const hotel = createPlace(testDb, trip.id, { name: 'Rostock' });
createDayAssignment(testDb, day.id, fuel.id);
createDayAssignment(testDb, day.id, farm.id);
await svc.createAccommodation(trip.id, { place_id: hotel.id, start_day_id: day.id, end_day_id: day.id, check_in: '10:00' });
expect((await stopsOn(day.id)).map(a => a.place_id)).toEqual([hotel.id, fuel.id, farm.id]);
});
it('ACC-022f the night goes behind the last stop whose own hour is at or before the check-in', async () => {
// Pinned eight, unpinned, pinned two: a check-in at ten sits behind the eight and
// ahead of everything else, the unpinned stop included.
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const [early, loose, late, hotel] = ['Aral', 'Hafen', 'Museum', 'Rostock'].map(name => createPlace(testDb, trip.id, { name }));
const first = createDayAssignment(testDb, day.id, early.id);
createDayAssignment(testDb, day.id, loose.id);
const third = createDayAssignment(testDb, day.id, late.id);
await setStops({ id: first.id }, { assignment_time: '08:00' });
await setStops({ id: third.id }, { assignment_time: '14:00' });
await svc.createAccommodation(trip.id, { place_id: hotel.id, start_day_id: day.id, end_day_id: day.id, check_in: '10:00' });
expect((await stopsOn(day.id)).map(a => a.place_id)).toEqual([early.id, hotel.id, loose.id, late.id]);
});
it('ACC-022g a new check-in seats the night afresh, a change of notes leaves a dragged night alone', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const [harbour, market, hotel] = ['Hafen', 'Markt', 'Rostock'].map(name => createPlace(testDb, trip.id, { name }));
createDayAssignment(testDb, day.id, harbour.id);
createDayAssignment(testDb, day.id, market.id);
const { accommodation } = (await svc.createAccommodation(trip.id, { place_id: hotel.id, start_day_id: day.id, end_day_id: day.id })) as any;
expect((await stopsOn(day.id)).map(a => a.place_id)).toEqual([hotel.id, harbour.id, market.id]);
// Dragged to the end of the day by hand.
const own = (await stopsOn(day.id)).find(a => a.place_id === hotel.id)!;
for (const later of await findRows(await orm(), DayAssignments, { day: day.id, order_index: { $gt: own.order_index } })) {
await setStops({ id: later.id }, { order_index: later.order_index - 1 });
}
await setStops({ id: own.id }, { order_index: 2 });
expect((await stopsOn(day.id)).map(a => a.place_id)).toEqual([harbour.id, market.id, hotel.id]);
let existing = (await svc.getAccommodation(accommodation.id, trip.id))!;
const quiet = (await svc.updateAccommodation(accommodation.id, existing, { notes: 'late arrival' })) as any;
expect(quiet.mirror.moved).toBeNull();
expect((await stopsOn(day.id)).map(a => a.place_id)).toEqual([harbour.id, market.id, hotel.id]);
existing = (await svc.getAccommodation(accommodation.id, trip.id))!;
const reseated = (await svc.updateAccommodation(accommodation.id, existing, { check_in: '10:00' })) as any;
expect(reseated.mirror.moved).toMatchObject({ oldDayId: day.id, assignment: { id: own.id } });
expect((await stopsOn(day.id)).map(a => a.place_id)).toEqual([hotel.id, harbour.id, market.id]);
});
it('ACC-022e moving the check-in later re-seats the night', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const afternoon = createPlace(testDb, trip.id, { name: 'Mercure' });
const hotel = createPlace(testDb, trip.id, { name: 'Billstedt' });
const pinned = createDayAssignment(testDb, day.id, afternoon.id);
await setStops({ id: pinned.id }, { assignment_time: '16:00' });
const { accommodation } = (await svc.createAccommodation(trip.id, {
place_id: hotel.id, start_day_id: day.id, end_day_id: day.id, check_in: '11:00',
})) as any;
expect((await stopsOn(day.id)).map(a => a.place_id)).toEqual([hotel.id, afternoon.id]);
const existing = (await svc.getAccommodation(accommodation.id, trip.id))!;
await svc.updateAccommodation(accommodation.id, existing, { check_in: '20:00' });
expect((await stopsOn(day.id)).map(a => a.place_id)).toEqual([afternoon.id, hotel.id]);
});
it('ACC-022i a second night on the day counts by its check-in', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const [noon, morning] = ['Rue de Paris', 'Brandenburger Tor'].map(name => createPlace(testDb, trip.id, { name }));
await svc.createAccommodation(trip.id, { place_id: noon.id, start_day_id: day.id, end_day_id: day.id, check_in: '12:00' });
await svc.createAccommodation(trip.id, { place_id: morning.id, start_day_id: day.id, end_day_id: day.id, check_in: '10:00' });
expect((await stopsOn(day.id)).map(a => a.place_id)).toEqual([morning.id, noon.id]);
const evening = createPlace(testDb, trip.id, { name: 'Late' });
await svc.createAccommodation(trip.id, { place_id: evening.id, start_day_id: day.id, end_day_id: day.id, check_in: '18:00' });
expect((await stopsOn(day.id)).map(a => a.place_id)).toEqual([morning.id, noon.id, evening.id]);
});
it('ACC-022h an edit that leaves the check-in alone still corrects a night the clocks contradict', async () => {
// Dragged behind a stop pinned to the afternoon, with a check-in at ten: a change of
// notes puts it back ahead of that stop, because a night sitting after an afternoon it
// was booked before is the plan reading back wrong. Dragged behind a stop without an
// hour, the same edit leaves it where the traveller put it.
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const [harbour, museum, hotel] = ['Hafen', 'Museum', 'Rostock'].map(name => createPlace(testDb, trip.id, { name }));
createDayAssignment(testDb, day.id, harbour.id);
const pinned = createDayAssignment(testDb, day.id, museum.id);
await setStops({ id: pinned.id }, { assignment_time: '14:00' });
const { accommodation } = (await svc.createAccommodation(trip.id, { place_id: hotel.id, start_day_id: day.id, end_day_id: day.id, check_in: '10:00' })) as any;
expect((await stopsOn(day.id)).map(a => a.place_id)).toEqual([hotel.id, harbour.id, museum.id]);
const own = (await stopsOn(day.id)).find(a => a.place_id === hotel.id)!;
// Behind the harbour only: allowed, and left alone.
await setStops({ day: day.id, place: harbour.id }, { order_index: 0 });
await setStops({ id: own.id }, { order_index: 1 });
let existing = (await svc.getAccommodation(accommodation.id, trip.id))!;
expect(((await svc.updateAccommodation(accommodation.id, existing, { notes: 'late' })) as any).mirror.moved).toBeNull();
expect((await stopsOn(day.id)).map(a => a.place_id)).toEqual([harbour.id, hotel.id, museum.id]);
// Behind the afternoon: contradicted by the clocks, and seated afresh, which is
// the front, ahead of the harbour that has no hour of its own.
await setStops({ day: day.id, place: museum.id }, { order_index: 1 });
await setStops({ id: own.id }, { order_index: 2 });
existing = (await svc.getAccommodation(accommodation.id, trip.id))!;
expect(((await svc.updateAccommodation(accommodation.id, existing, { notes: 'later' })) as any).mirror.moved).not.toBeNull();
expect((await stopsOn(day.id)).map(a => a.place_id)).toEqual([hotel.id, harbour.id, museum.id]);
});
it('ACC-022j two nights with the same check-in settle by their booking and stay settled through a change of notes', async () => {
// Each used to read the other as "at or before" its own check-in, so a notes edit on
// the front one moved it behind the other, took the road between them with it, and
// a notes edit on the other swapped them back.
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const [first, second] = ['Adlon', 'Mercure'].map(name => createPlace(testDb, trip.id, { name }));
const a = await svc.createAccommodation(trip.id, { place_id: first.id, start_day_id: day.id, end_day_id: day.id, check_in: '15:00' }) as any;
const b = await svc.createAccommodation(trip.id, { place_id: second.id, start_day_id: day.id, end_day_id: day.id, check_in: '15:00' }) as any;
expect((await stopsOn(day.id)).map(s => s.place_id)).toEqual([first.id, second.id]);
const between = await insertRow(await orm(), RoadtripVias, { day: day.id, after_order_index: 0, sequence: 0, lat: 52.5, lng: 13.4 });
for (const booked of [a, b]) {
const existing = (await svc.getAccommodation(booked.accommodation.id, trip.id))!;
const quiet = await svc.updateAccommodation(booked.accommodation.id, existing, { notes: 'late arrival' }) as any;
expect(quiet.mirror.moved).toBeNull();
expect(quiet.mirror.vias).toBeUndefined();
}
expect((await stopsOn(day.id)).map(s => s.place_id)).toEqual([first.id, second.id]);
expect({ after_order_index: (await findRow(await orm(), RoadtripVias, { id: between }))!.after_order_index }).toEqual({ after_order_index: 0 });
// Dragged the other way round on purpose: an equal clock is no contradiction.
await setStops({ day: day.id, place: first.id }, { order_index: 1 });
await setStops({ day: day.id, place: { $ne: first.id } }, { order_index: 0 });
for (const booked of [a, b]) {
const existing = (await svc.getAccommodation(booked.accommodation.id, trip.id))!;
expect((await svc.updateAccommodation(booked.accommodation.id, existing, { notes: 'later' }) as any).mirror.moved).toBeNull();
}
expect((await stopsOn(day.id)).map(s => s.place_id)).toEqual([second.id, first.id]);
});
it('ACC-022k two nights without a check-in: the earlier booking leads', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const [museum, first, second] = ['Pergamon', 'Adlon', 'Mercure'].map(name => createPlace(testDb, trip.id, { name }));
createDayAssignment(testDb, day.id, museum.id);
await svc.createAccommodation(trip.id, { place_id: first.id, start_day_id: day.id, end_day_id: day.id });
const b = await svc.createAccommodation(trip.id, { place_id: second.id, start_day_id: day.id, end_day_id: day.id }) as any;
expect((await stopsOn(day.id)).map(s => s.place_id)).toEqual([first.id, second.id, museum.id]);
const existing = (await svc.getAccommodation(b.accommodation.id, trip.id))!;
expect((await svc.updateAccommodation(b.accommodation.id, existing, { notes: 'late' }) as any).mirror.moved).toBeNull();
expect((await stopsOn(day.id)).map(s => s.place_id)).toEqual([first.id, second.id, museum.id]);
});
it('ACC-022l a night on a day dragged out of clock order is settled where a fresh seat puts it', async () => {
// Pinned two, then pinned eight, on purpose. A check-in at ten goes behind the eight,
// and nothing else satisfies both clocks; a change of notes used to relocate it to
// the very same seat and report a move for it.
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const [late, early, hotel] = ['Museum', 'Aral', 'Rostock'].map(name => createPlace(testDb, trip.id, { name }));
await setStops({ id: createDayAssignment(testDb, day.id, late.id).id }, { assignment_time: '14:00' });
await setStops({ id: createDayAssignment(testDb, day.id, early.id).id }, { assignment_time: '08:00' });
const { accommodation } = await svc.createAccommodation(trip.id, { place_id: hotel.id, start_day_id: day.id, end_day_id: day.id, check_in: '10:00' }) as any;
expect((await stopsOn(day.id)).map(s => s.place_id)).toEqual([late.id, early.id, hotel.id]);
const existing = (await svc.getAccommodation(accommodation.id, trip.id))!;
const quiet = await svc.updateAccommodation(accommodation.id, existing, { notes: 'late arrival' }) as any;
expect(quiet.mirror.moved).toBeNull();
expect((await stopsOn(day.id)).map(s => s.place_id)).toEqual([late.id, early.id, hotel.id]);
});
it('ACC-023 the place is typed as lodging, so the rail draws it as a service stop', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const place = createPlace(testDb, trip.id, { name: 'Hotel Adlon' });
const { mirror } = await book(trip.id, place.id, day.id, day.id);
expect(await findRow(await orm(), Places, { id: place.id })).toMatchObject({ stop_type: 'hotel' });
// Announced, or the places list keeps the stale null until a reload.
expect(mirror.stamped).toMatchObject({ id: place.id, stop_type: 'hotel' });
// And the stop carries it, so the rail does not number it.
expect(mirror.created.place.stop_type).toBe('hotel');
});
it('ACC-024 a stop type the traveller picked is never overwritten', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const place = createPlace(testDb, trip.id, { name: 'Camping Isar' });
await updateRows(await orm(), Places, { id: place.id }, { stop_type: 'campsite' });
const { mirror } = await book(trip.id, place.id, day.id, day.id);
expect(await findRow(await orm(), Places, { id: place.id })).toMatchObject({ stop_type: 'campsite' });
expect(mirror.stamped).toBeNull();
});
it('ACC-025 a place already planned for that day gets no second stop, and the booking claims neither', async () => {
// This is the road-trip flow: it assigns the place to the day and only then books
// the night. A second stop would draw the hotel twice, and claiming the existing
// one would let cancelling the booking delete a stop the traveller placed.
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const place = createPlace(testDb, trip.id, { name: 'Hotel Adlon' });
const own = createDayAssignment(testDb, day.id, place.id);
const { mirror } = await book(trip.id, place.id, day.id, day.id);
expect((await stopsOn(day.id))).toEqual([expect.objectContaining({ id: own.id, accommodation_id: null })]);
expect(mirror.created).toBeNull();
});
it('ACC-026 only the check-in day, not every night of a long stay', async () => {
// You drive there once. The later nights ride on the stay row, which is where the
// rail reads check-out from.
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const arrive = createDay(testDb, trip.id);
const middle = createDay(testDb, trip.id);
const leave = createDay(testDb, trip.id);
const place = createPlace(testDb, trip.id, { name: 'Hotel Adlon' });
await book(trip.id, place.id, arrive.id, leave.id);
expect((await stopsOn(arrive.id))).toHaveLength(1);
expect((await stopsOn(middle.id))).toHaveLength(0);
expect((await stopsOn(leave.id))).toHaveLength(0);
});
it('ACC-027 a stay with no place writes no stop instead of throwing', async () => {
// day_accommodations.place_id is nullable (ON DELETE SET NULL) and the booking form
// writes stays that never had one.
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const { mirror } = await book(trip.id, null, day.id, day.id);
expect(mirror).toEqual({ created: null, moved: null, updated: [], removed: [], stamped: null });
expect((await stopsOn(day.id))).toHaveLength(0);
});
it('ACC-028 moving the booking to another day moves its stop with it', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day1 = createDay(testDb, trip.id);
const day2 = createDay(testDb, trip.id);
const place = createPlace(testDb, trip.id, { name: 'Hotel Adlon' });
const { accommodation } = await book(trip.id, place.id, day1.id, day1.id);
const before = (await stopsOn(day1.id))[0];
const existing = (await svc.getAccommodation(accommodation.id, trip.id))!;
const { mirror } = (await svc.updateAccommodation(accommodation.id, existing, { start_day_id: day2.id, end_day_id: day2.id })) as any;
expect((await stopsOn(day1.id))).toHaveLength(0);
// The same row, carried over. Not a delete and a fresh insert: everything the
// traveller hung on this stop is keyed by its id.
expect((await stopsOn(day2.id))).toEqual([expect.objectContaining({ id: before.id, place_id: place.id, accommodation_id: accommodation.id })]);
expect(mirror.removed).toEqual([]);
expect(mirror.created).toBeNull();
expect(mirror.moved).toMatchObject({ oldDayId: day1.id, assignment: { id: before.id, day_id: day2.id } });
});
it('ACC-028b moving the booking keeps the note, the hour and the end-of-day flag on the stop', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day1 = createDay(testDb, trip.id);
const day2 = createDay(testDb, trip.id);
const place = createPlace(testDb, trip.id, { name: 'Hotel Adlon' });
const { accommodation } = await book(trip.id, place.id, day1.id, day1.id);
const stop = (await stopsOn(day1.id))[0];
await setStops({ id: stop.id }, { notes: 'ask for the quiet side', assignment_time: '15:30', end_day: 1 });
const existing = (await svc.getAccommodation(accommodation.id, trip.id))!;
await svc.updateAccommodation(accommodation.id, existing, { start_day_id: day2.id, end_day_id: day2.id });
const after = (await findRow(await orm(), DayAssignments, { id: stop.id }))!;
expect(after).toMatchObject({ day_id: day2.id, notes: 'ask for the quiet side', assignment_time: '15:30', end_day: 1 });
});
it('ACC-028c moving the booking keeps the people assigned to the stop', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day1 = createDay(testDb, trip.id);
const day2 = createDay(testDb, trip.id);
const place = createPlace(testDb, trip.id, { name: 'Hotel Adlon' });
const { accommodation } = await book(trip.id, place.id, day1.id, day1.id);
const stop = (await stopsOn(day1.id))[0];
// assignment_participants.assignment_id is ON DELETE CASCADE, so a delete and
// re-insert would take these with it without a word.
await insertRow(await orm(), AssignmentParticipants, { assignment: stop.id, user: user.id });
const existing = (await svc.getAccommodation(accommodation.id, trip.id))!;
await svc.updateAccommodation(accommodation.id, existing, { start_day_id: day2.id, end_day_id: day2.id });
const kept = (await findRows(await orm(), AssignmentParticipants, { assignment: stop.id })).map(row => ({ user_id: row.user_id }));
expect(kept).toEqual([{ user_id: user.id }]);
});
it('ACC-028d a move onto a day that already holds the place by hand drops the booking stop instead of doubling it', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day1 = createDay(testDb, trip.id);
const day2 = createDay(testDb, trip.id);
const place = createPlace(testDb, trip.id, { name: 'Hotel Adlon' });
const { accommodation } = await book(trip.id, place.id, day1.id, day1.id);
const own = (await stopsOn(day1.id))[0];
const byHand = createDayAssignment(testDb, day2.id, place.id) as { id: number };
const existing = (await svc.getAccommodation(accommodation.id, trip.id))!;
const { mirror } = (await svc.updateAccommodation(accommodation.id, existing, { start_day_id: day2.id, end_day_id: day2.id })) as any;
expect((await stopsOn(day1.id))).toHaveLength(0);
expect((await stopsOn(day2.id)).map((row: { id: number }) => row.id)).toEqual([byHand.id]);
expect(mirror.removed).toEqual([{ id: own.id, dayId: day1.id }]);
expect(mirror.moved).toBeNull();
});
it('ACC-028e the day the stop left closes the gap it made in the order', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day1 = createDay(testDb, trip.id);
const day2 = createDay(testDb, trip.id);
const hotel = createPlace(testDb, trip.id, { name: 'Hotel Adlon' });
const museum = createPlace(testDb, trip.id, { name: 'Pergamon' });
const { accommodation } = await book(trip.id, hotel.id, day1.id, day1.id);
createDayAssignment(testDb, day1.id, museum.id);
const existing = (await svc.getAccommodation(accommodation.id, trip.id))!;
await svc.updateAccommodation(accommodation.id, existing, { start_day_id: day2.id, end_day_id: day2.id });
expect((await stopsOn(day1.id)).map((row: { order_index: number }) => row.order_index)).toEqual([0]);
});
it('ACC-029 editing an unrelated field leaves the stop exactly where it is', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const place = createPlace(testDb, trip.id, { name: 'Hotel Adlon' });
const { accommodation } = await book(trip.id, place.id, day.id, day.id);
const before = (await stopsOn(day.id));
const existing = (await svc.getAccommodation(accommodation.id, trip.id))!;
const { mirror } = (await svc.updateAccommodation(accommodation.id, existing, { check_in: '16:00' })) as any;
expect((await stopsOn(day.id))).toEqual(before);
expect(mirror).toEqual({ created: null, moved: null, updated: [], removed: [], stamped: null });
});
it('ACC-029b a night sitting behind a later afternoon is re-seated, keeping its row', async () => {
// The state the migration backfill leaves: every pre-existing stay's stop was
// appended last, whatever its check-in says. Giving the booking an hour has to
// move it ahead of the evening it was booked around.
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const dinner = createPlace(testDb, trip.id, { name: 'Osteria' });
const hotel = createPlace(testDb, trip.id, { name: 'Hotel Adlon' });
await updateRows(await orm(), Places, { id: dinner.id }, { place_time: '19:00' });
createDayAssignment(testDb, day.id, dinner.id);
const { accommodation } = await book(trip.id, hotel.id, day.id, day.id);
const stop = (await stopsOn(day.id)).find((row: { place_id: number }) => row.place_id === hotel.id)!;
// The backfill's placement, written by hand: the night behind the dinner.
await setStops({ day: day.id, place: dinner.id }, { order_index: 0 });
await setStops({ id: stop.id }, { order_index: 1 });
expect((await stopsOn(day.id)).map((row: { place_id: number }) => row.place_id)).toEqual([dinner.id, hotel.id]);
const existing = (await svc.getAccommodation(accommodation.id, trip.id))!;
const { mirror } = (await svc.updateAccommodation(accommodation.id, existing, { check_in: '15:00' })) as any;
expect((await stopsOn(day.id)).map((row: { place_id: number }) => row.place_id)).toEqual([hotel.id, dinner.id]);
// Re-seated, not rebuilt: the same row, one place further forward.
expect(mirror.moved).toMatchObject({ oldDayId: day.id, assignment: { id: stop.id } });
expect(mirror.removed).toEqual([]);
});
it('ACC-030 a stay whose stop belongs to the traveller does not get a second one', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const second = createDay(testDb, trip.id);
const place = createPlace(testDb, trip.id, { name: 'Hotel Adlon' });
// The road trip books a night on a place it put on the day first, so the stop is
// the traveller's and the booking owns nothing.
createDayAssignment(testDb, day.id, place.id);
const stay = createDayAccommodation(testDb, trip.id, place.id, day.id, day.id) as any;
const existing = (await svc.getAccommodation(stay.id, trip.id))!;
await svc.updateAccommodation(stay.id, existing, { start_day_id: second.id, end_day_id: second.id });
expect((await stopsOn(second.id))).toEqual([]);
expect((await stopsOn(day.id))).toEqual([expect.objectContaining({ place_id: place.id, accommodation_id: null })]);
});
it('ACC-031 cancelling a booking takes back its own stop and leaves the other one', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const hotel = createPlace(testDb, trip.id, { name: 'Hotel Adlon' });
const museum = createPlace(testDb, trip.id, { name: 'Pergamon' });
const own = createDayAssignment(testDb, day.id, museum.id);
const { accommodation } = await book(trip.id, hotel.id, day.id, day.id);
const mirrored = (await stopsOn(day.id)).find(a => a.place_id === hotel.id)!;
const { mirror } = await svc.deleteAccommodation(accommodation.id);
expect((await stopsOn(day.id))).toEqual([expect.objectContaining({ id: own.id })]);
expect(mirror.removed).toEqual([{ id: mirrored.id, dayId: day.id }]);
});
it('ACC-032 cancelling a night booked in the road trip keeps the stop standing', async () => {
// The rail turns a night back into a pause by deleting the stay alone; the stop is
// the thing being edited there and has to survive.
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const place = createPlace(testDb, trip.id, { name: 'Hotel Adlon' });
const own = createDayAssignment(testDb, day.id, place.id);
const { accommodation } = await book(trip.id, place.id, day.id, day.id);
const { mirror } = await svc.deleteAccommodation(accommodation.id);
expect((await stopsOn(day.id))).toEqual([expect.objectContaining({ id: own.id })]);
expect(mirror.removed).toEqual([]);
});
it('ACC-032b keepStop hands the mirrored stop to the traveller instead of taking it away', async () => {
// The road trip popup switching a night back to an ordinary pause: the booking is
// what was cancelled, not the place, and the stop sits mid-drive where re-adding it
// would land it at the end of the day instead.
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const place = createPlace(testDb, trip.id, { name: 'Hotel Adlon' });
const { accommodation } = await book(trip.id, place.id, day.id, day.id);
const mirrored = (await stopsOn(day.id))[0];
const { mirror } = await svc.deleteAccommodation(accommodation.id, { keepStop: true });
// Still there, and now unmarked: nothing may move or delete it on the next edit.
expect((await stopsOn(day.id))).toEqual([expect.objectContaining({ id: mirrored.id, place_id: place.id, accommodation_id: null })]);
// Nothing to announce either — no session has to take a stop off its day plan.
expect(mirror.removed).toEqual([]);
expect(await findRow(await orm(), DayAccommodations, { id: accommodation.id })).toBeNull();
});
it('ACC-032c remove() forwards keepStop, which is the only door the REST route uses', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const place = createPlace(testDb, trip.id, { name: 'Hotel Adlon' });
const { accommodation } = await book(trip.id, place.id, day.id, day.id);
await svc.remove(accommodation.id, { keepStop: true });
expect((await stopsOn(day.id))).toEqual([expect.objectContaining({ place_id: place.id, accommodation_id: null })]);
});
it('ACC-033 announceMirror sends the removal before the arrival', async () => {
// Order matters on a move: the day plan would briefly hold the place twice if the
// arrival went first.
const sent: string[] = [];
await svc.announceMirror(5, {
created: { id: 78, day_id: 11 } as never,
moved: null,
updated: [],
removed: [{ id: 77, dayId: 10 }],
stamped: { id: 3 } as never,
}, event => { sent.push(event); });
// The two days whose order changed follow, arrival first (see touchedDays).
expect(sent).toEqual([
'assignment:deleted', 'assignment:created', 'place:updated',
'assignment:reordered', 'assignment:reordered',
]);
});
it('ACC-033b announceMirror reports a move as one event, not a delete and a create', async () => {
const sent: Array<{ event: string; payload: unknown }> = [];
await svc.announceMirror(5, {
created: null,
moved: { assignment: { id: 78, day_id: 11 } as never, oldDayId: 10 },
updated: [],
removed: [],
stamped: null,
}, (event, payload) => { sent.push({ event, payload }); });
expect(sent.map(e => e.event)).toEqual(['assignment:moved', 'assignment:reordered', 'assignment:reordered']);
expect(sent[0].payload).toMatchObject({ oldDayId: 10, newDayId: 11 });
});
it('ACC-033c a kept stop is announced as updated, so the day list stops hiding it', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const place = createPlace(testDb, trip.id, { name: 'Hotel Adlon' });
const { accommodation } = await book(trip.id, place.id, day.id, day.id);
const stop = (await stopsOn(day.id))[0];
const { mirror } = (await svc.remove(accommodation.id, { keepStop: true })) as any;
// Days hides a stop that carries an accommodation_id, so a client still holding
// the old row keeps the place invisible on a day it is standing on.
expect(mirror.updated).toEqual([expect.objectContaining({ id: stop.id, accommodation_id: null })]);
const sent: string[] = [];
await svc.announceMirror(trip.id, mirror, event => { sent.push(event); });
expect(sent).toContain('assignment:updated');
});
});
describe('the drawn roads a booking moves', () => {
// A via is pinned to a POSITION among the day's located stops, not to a row. A
// night seated by its check-in ahead of the afternoon renumbers every stop behind
// it, and every road drawn behind those stops has to move with them, or the
// detour is driven on the wrong leg for everyone.
const stopsOn = async (dayId: number) =>
(await findRows(await orm(), DayAssignments, { day: dayId }, { order_index: 'asc' })).map(row => row.place_id);
const addVia = async (dayId: number, afterOrderIndex: number): Promise<number> =>
insertRow(await orm(), RoadtripVias, { day: dayId, after_order_index: afterOrderIndex, sequence: 0, lat: 48.1, lng: 11.5 });
const viaAnchors = async (dayId: number) =>
(await findRows(await orm(), RoadtripVias, { day: dayId }, { id: 'asc' })).map(row => ({ id: row.id, after_order_index: row.after_order_index }));
/** The day's roads as the route reads them: leg by leg, and in order within a leg. */
const legOrder = async (dayId: number) =>
(await findRows(await orm(), RoadtripVias, { day: dayId }, { after_order_index: 'asc', sequence: 'asc', id: 'asc' }))
.map(row => ({ id: row.id, after_order_index: row.after_order_index, sequence: row.sequence }));
const pin = (assignmentId: number, time: string) => setStops({ id: assignmentId }, { assignment_time: time });
/** A(0) pinned to nine, B(1) pinned to noon, C(2): the day a check-in at eleven lands in the middle of. */
async function afternoonDay() {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const [a, b, c, hotel] = ['Harbour', 'Mercure', 'Museum', 'Billstedt'].map(name => createPlace(testDb, trip.id, { name }));
await pin(createDayAssignment(testDb, day.id, a.id).id, '09:00');
await pin(createDayAssignment(testDb, day.id, b.id).id, '12:00');
createDayAssignment(testDb, day.id, c.id);
return { trip, day, a, b, c, hotel };
}
it('ACC-034 a night seated ahead of the afternoon carries the roads behind it along', async () => {
const { trip, day, a, b, c, hotel } = await afternoonDay();
const afterA = await addVia(day.id, 0);
const afterB = await addVia(day.id, 1);
// Behind the last stop: the drive into the next day. It stays with C, which is
// still last, rather than being dropped as a leg C never had.
const intoTomorrow = await addVia(day.id, 2);
const { mirror } = (await svc.createAccommodation(trip.id, { place_id: hotel.id, start_day_id: day.id, end_day_id: day.id, check_in: '11:00' })) as any;
expect((await stopsOn(day.id))).toEqual([a.id, hotel.id, b.id, c.id]);
expect((await viaAnchors(day.id))).toEqual([
{ id: afterA, after_order_index: 0 },
{ id: afterB, after_order_index: 2 },
{ id: intoTomorrow, after_order_index: 3 },
]);
// Reported on the mirror in the shape the road trip broadcasts, so every planner
// routes the new anchors against the new order.
expect(mirror.vias).toEqual([{
dayId: day.id,
vias: [
expect.objectContaining({ id: afterA, day_id: day.id, after_order_index: 0 }),
expect.objectContaining({ id: afterB, day_id: day.id, after_order_index: 2 }),
expect.objectContaining({ id: intoTomorrow, day_id: day.id, after_order_index: 3 }),
],
}]);
});
it('ACC-034b a night seated behind every drawn road moves none and reports none', async () => {
const { trip, day, a, b, c, hotel } = await afternoonDay();
const afterA = await addVia(day.id, 0);
const afterB = await addVia(day.id, 1);
const { mirror } = (await svc.createAccommodation(trip.id, { place_id: hotel.id, start_day_id: day.id, end_day_id: day.id, check_in: '18:00' })) as any;
expect((await stopsOn(day.id))).toEqual([a.id, b.id, hotel.id, c.id]);
expect((await viaAnchors(day.id))).toEqual([{ id: afterA, after_order_index: 0 }, { id: afterB, after_order_index: 1 }]);
expect(mirror.vias).toBeUndefined();
});
it('ACC-034c re-seating the night by a later check-in re-pins the roads around it', async () => {
const { trip, day, a, b, c, hotel } = await afternoonDay();
// C pinned to the afternoon as well, so an evening check-in puts the night last.
await setStops({ day: day.id, place: c.id }, { assignment_time: '15:00' });
const { accommodation } = (await svc.createAccommodation(trip.id, { place_id: hotel.id, start_day_id: day.id, end_day_id: day.id, check_in: '11:00' })) as any;
expect((await stopsOn(day.id))).toEqual([a.id, hotel.id, b.id, c.id]);
const afterA = await addVia(day.id, 0);
const afterHotel = await addVia(day.id, 1);
const afterB = await addVia(day.id, 2);
const afterC = await addVia(day.id, 3);
const existing = (await svc.getAccommodation(accommodation.id, trip.id))!;
const { mirror } = (await svc.updateAccommodation(accommodation.id, existing, { check_in: '20:00' })) as any;
// The night is last now. The road out of it has no leg left and goes; the road
// behind B follows it one number up. The one behind C was the drive into the next
// day, which leaves from the hotel now, so it goes as well rather than bending the
// drive from C to the hotel through a point on the road to tomorrow.
expect((await stopsOn(day.id))).toEqual([a.id, b.id, c.id, hotel.id]);
expect((await viaAnchors(day.id))).toEqual([
{ id: afterA, after_order_index: 0 },
{ id: afterB, after_order_index: 1 },
]);
expect((await viaAnchors(day.id)).map(via => via.id)).not.toContain(afterHotel);
expect((await viaAnchors(day.id)).map(via => via.id)).not.toContain(afterC);
expect(mirror.moved).not.toBeNull();
expect(mirror.vias).toEqual([{ dayId: day.id, vias: expect.arrayContaining([expect.objectContaining({ id: afterB, after_order_index: 1 })]) }]);
});
it('ACC-034d cancelling the booking takes its stop out and re-pins the roads behind it', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day = createDay(testDb, trip.id);
const [a, b, hotel] = ['Harbour', 'Mercure', 'Billstedt'].map(name => createPlace(testDb, trip.id, { name }));
await pin(createDayAssignment(testDb, day.id, a.id).id, '09:00');
await pin(createDayAssignment(testDb, day.id, b.id).id, '12:00');
const { accommodation } = (await svc.createAccommodation(trip.id, { place_id: hotel.id, start_day_id: day.id, end_day_id: day.id, check_in: '11:00' })) as any;
expect((await stopsOn(day.id))).toEqual([a.id, hotel.id, b.id]);
// The road out of the hotel is drawn first: by id alone it would lead the leg
// it ends up sharing with A's road.
const afterHotel = await addVia(day.id, 1);
const afterA = await addVia(day.id, 0);
const intoTomorrow = await addVia(day.id, 2);
const { mirror } = await svc.deleteAccommodation(accommodation.id);
expect((await stopsOn(day.id))).toEqual([a.id, b.id]);
// The two legs around the hotel are one leg now, A to B, and the road out of the
// hotel joins A's road on it, behind it: the drive runs A's point first, then the
// hotel's, then B. The drive into the next day stays behind B, which is still last.
expect((await legOrder(day.id))).toEqual([
{ id: afterA, after_order_index: 0, sequence: 0 },
{ id: afterHotel, after_order_index: 0, sequence: 1 },
{ id: intoTomorrow, after_order_index: 1, sequence: 0 },
]);
expect(mirror.vias).toEqual([{ dayId: day.id, vias: [
expect.objectContaining({ id: afterA, after_order_index: 0, sequence: 0 }),
expect.objectContaining({ id: afterHotel, after_order_index: 0, sequence: 1 }),
expect.objectContaining({ id: intoTomorrow, after_order_index: 1 }),
] }]);
});
it('ACC-034e moving the booking to another day re-pins the roads on both days', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
const day1 = createDay(testDb, trip.id);
const day2 = createDay(testDb, trip.id);
const [a, b, c, hotel] = ['Harbour', 'Mercure', 'Museum', 'Billstedt'].map(name => createPlace(testDb, trip.id, { name }));
await pin(createDayAssignment(testDb, day1.id, a.id).id, '09:00');
await pin(createDayAssignment(testDb, day1.id, b.id).id, '12:00');
await pin(createDayAssignment(testDb, day2.id, c.id).id, '14:00');
const { accommodation } = (await svc.createAccommodation(trip.id, { place_id: hotel.id, start_day_id: day1.id, end_day_id: day1.id, check_in: '11:00' })) as any;
expect((await stopsOn(day1.id))).toEqual([a.id, hotel.id, b.id]);
const afterA = await addVia(day1.id, 0);
const afterHotel = await addVia(day1.id, 1);
const outOfC = await addVia(day2.id, 0);
const existing = (await svc.getAccommodation(accommodation.id, trip.id))!;
const { mirror } = (await svc.updateAccommodation(accommodation.id, existing, { start_day_id: day2.id, end_day_id: day2.id })) as any;
expect((await stopsOn(day1.id))).toEqual([a.id, b.id]);
expect((await stopsOn(day2.id))).toEqual([hotel.id, c.id]);
// The hotel's road on day one joins A's on the leg that is left, behind it.
expect((await legOrder(day1.id))).toEqual([
{ id: afterA, after_order_index: 0, sequence: 0 },
{ id: afterHotel, after_order_index: 0, sequence: 1 },
]);
// C is still the last stop of its day, one number further on.
expect((await viaAnchors(day2.id))).toEqual([{ id: outOfC, after_order_index: 1 }]);
expect(mirror.vias.map((day: { dayId: number }) => day.dayId).sort()).toEqual([day1.id, day2.id].sort());
});
it('ACC-034f a stop the booking hands to the traveller moves no road', async () => {
const { trip, day, hotel } = await afternoonDay();
const { accommodation } = (await svc.createAccommodation(trip.id, { place_id: hotel.id, start_day_id: day.id, end_day_id: day.id, check_in: '11:00' })) as any;
const afterB = await addVia(day.id, 2);
const { mirror } = await svc.deleteAccommodation(accommodation.id, { keepStop: true });
expect((await viaAnchors(day.id))).toEqual([{ id: afterB, after_order_index: 2 }]);
expect(mirror.vias).toBeUndefined();
});
it('ACC-034h a booking rebuilt from two stops reports its day once, as it stands at the end', async () => {
// A stay that owns two stops on one day cannot be carried across, so both go and
// one comes back, and the day's roads are re-pinned at each step. What the mirror
// reports is the state that was left behind, not both steps.
const { trip, day, a, b, c, hotel } = await afternoonDay();
const { accommodation } = (await svc.createAccommodation(trip.id, { place_id: hotel.id, start_day_id: day.id, end_day_id: day.id, check_in: '11:00' })) as any;
await insertRow(await orm(), DayAssignments, { day: day.id, place: hotel.id, order_index: 4, accommodation_id: accommodation.id });
const afterA = await addVia(day.id, 0);
const afterHotel = await addVia(day.id, 1);
const afterB = await addVia(day.id, 2);
await addVia(day.id, 3);
const existing = (await svc.getAccommodation(accommodation.id, trip.id))!;
const { mirror } = (await svc.updateAccommodation(accommodation.id, existing, { notes: 'late arrival' })) as any;
expect((await stopsOn(day.id))).toEqual([a.id, hotel.id, b.id, c.id]);
expect(mirror.removed).toHaveLength(2);
expect(mirror.created).not.toBeNull();
// Both stops went, so the hotel's road joined A's; then the night came back
// behind A, and B's road moved up with B. C's road was the last stop's leg
// once the second stop was gone, and stayed gone.
expect(mirror.vias).toEqual([{ dayId: day.id, vias: [
expect.objectContaining({ id: afterA, after_order_index: 0, sequence: 0 }),
expect.objectContaining({ id: afterHotel, after_order_index: 0, sequence: 1 }),
expect.objectContaining({ id: afterB, after_order_index: 2 }),
] }]);
});
it('ACC-034g announceMirror sends the re-pinned roads behind the day order', async () => {
const sent: Array<{ event: string; payload: unknown }> = [];
await svc.announceMirror(5, {
created: { id: 78, day_id: 11 } as never,
moved: null,
updated: [],
removed: [],
stamped: null,
vias: [{ dayId: 11, vias: [] }],
}, (event, payload) => { sent.push({ event, payload }); });
expect(sent.map(e => e.event)).toEqual(['assignment:created', 'assignment:reordered', 'roadtripVia:changed']);
expect(sent[2].payload).toEqual({ dayId: 11, vias: [] });
});
});
describe('AccommodationsService wiring', () => {
it('ACC-001: the module carries the controller and the RPC surface, and re-exports the service', () => {
expectRegisteredController(AccommodationsModule, AccommodationsController);
// The service itself lives in the domain module now, so places can delete the
// nights booked at a place without the surfaces coming along and closing a loop
// back through PlacesModule. Still exported from here: everything that imported
// AccommodationsModule for the service keeps working.
expectRegisteredProvider(AccommodationsDomainModule, AccommodationsService);
const imports = Reflect.getMetadata('imports', AccommodationsModule) as unknown[];
expect(imports).toEqual(expect.arrayContaining([AccommodationsDomainModule]));
// The MODULE is re-exported, not the provider: Nest refuses to export a provider
// belonging to an imported module, and a boot that fails on that only shows up when
// the container is actually built.
const exports = Reflect.getMetadata('exports', AccommodationsModule) as unknown[];
expect(Array.isArray(exports)).toBe(true);
expect(exports).toEqual(expect.arrayContaining([AccommodationsDomainModule]));
});
it('ACC-001b: the domain module reaches neither places nor the surfaces', () => {
// The whole point of the split: PlacesModule imports this one, so a path back to
// places from here would be the loop it exists to avoid.
const imports = (Reflect.getMetadata('imports', AccommodationsDomainModule) as { name?: string }[]) ?? [];
expect(imports.map(m => m?.name)).not.toContain('PlacesModule');
});
it('ACC-002: it does not import the days or reservations modules', () => {
const imports = (Reflect.getMetadata('imports', AccommodationsModule) as { name?: string }[]) ?? [];
expect(Array.isArray(imports)).toBe(true);
const names = imports.map((m) => m?.name);
expect(names).not.toContain('DaysModule');
expect(names).not.toContain('ReservationsModule');
});
});
Reference in New Issue View Git Blame Copy Permalink