mirror of
https://github.com/mauriceboe/TREK.git
synced 2026-10-20 05:56:53 +00:00
Maurice
724c88c201
A mechanical prettier --write over server/src, server/tests, server/scripts and shared/src with the workspaces' .prettierrc; nothing but layout and import order changes, and every file keeps the same set of imports. shared is formatted throughout and its format baseline is empty. The server baseline keeps the 35 files that Prettier would grow past their lint:size limit (they need a split first, which is not a formatting change), and the generated entity files stay as their generator writes them.
549 lines
24 KiB
TypeScript
549 lines
24 KiB
TypeScript
/**
|
|
* The booking plugin surfaces after they moved onto @PluginMethod: reservations and
|
|
* the lodging blocks.
|
|
*
|
|
* Both are cascade-heavy, which is the point of most cases here. Creating a
|
|
* reservation can create an accommodation and a budget item; deleting one can remove
|
|
* both again; and deleting a lodging block can take its partner reservation and its
|
|
* budget item with it. Every one of those side effects is a broadcast the web app
|
|
* relies on, so they are asserted by event name and order.
|
|
*/
|
|
import type { TripsRepository } from '../../../src/db/repositories/Trips.repository';
|
|
import type { UsersRepository } from '../../../src/db/repositories/Users.repository';
|
|
import { PluginGuards } from '../../../src/nest-rpc/plugin-guards.service';
|
|
import { createTestPluginRegistry } from '../../../src/nest-rpc/rpc-kit/testing';
|
|
import { AccommodationsModule } from '../../../src/nest/accommodations/accommodations.module';
|
|
import { AccommodationsRpc } from '../../../src/nest/accommodations/accommodations.rpc';
|
|
import type { AccommodationsService } from '../../../src/nest/accommodations/accommodations.service';
|
|
import type { AddonsService } from '../../../src/nest/addons/addons.service';
|
|
import type { PermissionsService } from '../../../src/nest/permissions/permissions.service';
|
|
import { PluginRpcHost } from '../../../src/nest/plugins/host/rpc-host';
|
|
import type { RpcRequest, RpcError } from '../../../src/nest/plugins/protocol/envelope';
|
|
import type { RealtimeService } from '../../../src/nest/realtime/realtime.service';
|
|
import { ReservationsModule } from '../../../src/nest/reservations/reservations.module';
|
|
import { ReservationsRpc } from '../../../src/nest/reservations/reservations.rpc';
|
|
import type { ReservationsService } from '../../../src/nest/reservations/reservations.service';
|
|
import { expectRegisteredProvider } from '../../helpers/module-providers';
|
|
import { makeDeps } from '../../helpers/rpc-host-deps';
|
|
|
|
import { describe, it, expect, vi } from 'vitest';
|
|
|
|
const req = (method: string, params: Record<string, unknown> = {}): RpcRequest => ({
|
|
k: 'req',
|
|
id: 'x',
|
|
method,
|
|
params,
|
|
});
|
|
const events = (r: { broadcast: ReturnType<typeof vi.fn> }) => r.broadcast.mock.calls.map((c) => c[1]);
|
|
|
|
/** Trip 1 belongs to user 42; reservation 5 and accommodation 11 sit on it. */
|
|
function build(
|
|
opts: {
|
|
canEdit?: boolean;
|
|
cascade?: boolean;
|
|
stop?: boolean;
|
|
seenActions?: string[];
|
|
unresolved?: string[];
|
|
foreign?: string[];
|
|
expenses?: number[];
|
|
} = {},
|
|
) {
|
|
const realtime = { broadcast: vi.fn() } as unknown as RealtimeService & { broadcast: ReturnType<typeof vi.fn> };
|
|
// The expenses a delete takes with it: one with `cascade`, any number with `expenses` (#2084).
|
|
const expenses = opts.expenses ?? (opts.cascade ? [7] : []);
|
|
const reservations = {
|
|
createWithCost: vi.fn(() => ({ reservation: { id: 40 }, accommodationCreated: !!opts.cascade, costEvents: [] })),
|
|
getReservation: vi.fn((id: string) => (id === '5' ? { id: 5, title: 'Hotel', type: 'lodging' } : undefined)),
|
|
updateWithCost: vi.fn(() => ({ reservation: { id: 5 }, accommodationChanged: !!opts.cascade, costEvents: [] })),
|
|
remove: vi.fn((id: string) =>
|
|
id === '5'
|
|
? {
|
|
deleted: { title: 'Hotel', type: 'lodging', accommodation_id: opts.cascade ? 11 : null },
|
|
accommodationDeleted: !!opts.cascade,
|
|
deletedBudgetItemId: expenses[0] ?? null,
|
|
deletedBudgetItemIds: expenses,
|
|
}
|
|
: { deleted: null, accommodationDeleted: false, deletedBudgetItemId: null, deletedBudgetItemIds: [] },
|
|
),
|
|
announceCost: vi.fn(),
|
|
// The price's currency and rate are the service's to resolve; here it passes through.
|
|
withFrozenRate: vi.fn(async (_tripId: number, entry: unknown) => entry),
|
|
notifyBookingChange: vi.fn(),
|
|
// Both guards run before a write now, so the fixture answers for them.
|
|
referencesOutsideTrip: vi.fn(() => opts.foreign ?? []),
|
|
unresolvedReferences: vi.fn(() => opts.unresolved ?? []),
|
|
} as unknown as ReservationsService & Record<string, ReturnType<typeof vi.fn>>;
|
|
/** What a stay write did to the day plan, on top of writing the stay itself. */
|
|
type Mirror = {
|
|
created: { id: number; day_id: number } | null;
|
|
removed: { id: number; dayId: number }[];
|
|
stamped: null;
|
|
};
|
|
/** A stay write that left the day plan alone, which is what most of these cases are. */
|
|
const noMirror = (): Mirror => ({ created: null, removed: [], stamped: null });
|
|
/** With `stop`, the write moved its day stop from day 3 to day 4. */
|
|
const mirror = (): Mirror =>
|
|
opts.stop ? { created: { id: 78, day_id: 4 }, removed: [{ id: 77, dayId: 3 }], stamped: null } : noMirror();
|
|
// The lodging blocks live in AccommodationsService; AccommodationsRpc still calls its
|
|
// injected copy `days`, which is why the fixture keeps that name.
|
|
const days = {
|
|
validateAccommodationRefs: vi.fn((_t: number, placeId?: number) =>
|
|
placeId === 404 ? [{ message: 'place 404 is not on this trip' }] : [],
|
|
),
|
|
createAccommodation: vi.fn(() => ({ accommodation: { id: 60 }, mirror: mirror() })),
|
|
getAccommodation: vi.fn((id: number) => (id === 11 ? { id: 11 } : undefined)),
|
|
updateAccommodation: vi.fn(() => ({ accommodation: { id: 11 }, mirror: mirror() })),
|
|
deleteAccommodation: vi.fn(() => ({
|
|
linkedReservationId: opts.cascade ? 40 : null,
|
|
deletedBudgetItemId: opts.cascade ? 7 : null,
|
|
linkedReservationIds: opts.cascade ? [40] : [],
|
|
deletedBudgetItemIds: opts.cascade ? [7] : [],
|
|
mirror: mirror(),
|
|
})),
|
|
// Stands in for the real fan-out rather than swallowing it, so the sender each
|
|
// handler builds is exercised: that sender is the plugin surface's only link
|
|
// between a stay write and the sockets, and a mock that never calls it would
|
|
// let a broken one through. Inert whenever the mirror is empty, which is every
|
|
// case not built with `stop`.
|
|
announceMirror: vi.fn((_tripId: number, m: Mirror, send: (event: string, payload: unknown) => void) => {
|
|
for (const stop of m.removed) send('assignment:deleted', { assignmentId: stop.id, dayId: stop.dayId });
|
|
if (m.created) send('assignment:created', { assignment: m.created });
|
|
}),
|
|
} as unknown as AccommodationsService & Record<string, ReturnType<typeof vi.fn>>;
|
|
const guards = new PluginGuards(
|
|
{
|
|
findAccessible: vi.fn(async (tripId: number, userId: number) =>
|
|
tripId === 1 && userId === 42 ? { id: 1, user_id: 42 } : undefined,
|
|
),
|
|
} as unknown as TripsRepository,
|
|
{
|
|
checkPermission: vi.fn((action: string) => {
|
|
opts.seenActions?.push(action);
|
|
return opts.canEdit ?? true;
|
|
}),
|
|
} as unknown as PermissionsService,
|
|
{ isAddonEnabled: vi.fn(() => true) } as unknown as AddonsService,
|
|
{ getRole: vi.fn(async () => 'user') } as unknown as UsersRepository,
|
|
);
|
|
const registry = createTestPluginRegistry([
|
|
new ReservationsRpc(reservations, realtime, guards),
|
|
new AccommodationsRpc(days, realtime, guards),
|
|
]);
|
|
const host = (...grants: string[]) =>
|
|
new PluginRpcHost(
|
|
'p',
|
|
new Set(grants.length ? grants : ['db:write:reservations', 'db:write:accommodations']),
|
|
makeDeps(),
|
|
registry,
|
|
);
|
|
return { reservations, days, realtime, host };
|
|
}
|
|
|
|
describe('ReservationsRpc', () => {
|
|
it('BOOK-RPC-001 writes need the grant, reservation_edit and a bound user', async () => {
|
|
const seen: string[] = [];
|
|
const f = build({ seenActions: seen });
|
|
expect(
|
|
(
|
|
await f
|
|
.host()
|
|
.dispatch(req('reservations.create', { tripId: 1, input: { title: 'Hotel', type: 'lodging' } }), 42)
|
|
).ok,
|
|
).toBe(true);
|
|
expect(seen).toContain('reservation_edit');
|
|
const noUser = (await f
|
|
.host()
|
|
.dispatch(
|
|
req('reservations.create', { tripId: 1, input: { title: 'x', type: 'lodging' } }),
|
|
undefined,
|
|
)) as RpcError;
|
|
expect(noUser.error.message).toBe('reservation writes require an authenticated user context');
|
|
});
|
|
|
|
it('BOOK-RPC-002 a malformed endpoints array is rejected up front', async () => {
|
|
const f = build();
|
|
const res = (await f.host().dispatch(
|
|
req('reservations.create', {
|
|
tripId: 1,
|
|
input: { title: 'Flight', type: 'flight', endpoints: [{ nonsense: true }] },
|
|
}),
|
|
42,
|
|
)) as RpcError;
|
|
expect(res.error.code).toBe('BAD_PARAMS');
|
|
// Otherwise it fails deep in the service mid-transaction, or is silently dropped.
|
|
expect(f.reservations.createWithCost).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('BOOK-RPC-003 an absent endpoints field stays absent, which means "keep"', async () => {
|
|
const f = build();
|
|
expect(
|
|
(
|
|
await f
|
|
.host()
|
|
.dispatch(req('reservations.create', { tripId: 1, input: { title: 'Hotel', type: 'lodging' } }), 42)
|
|
).ok,
|
|
).toBe(true);
|
|
});
|
|
|
|
it('BOOK-RPC-004 a missing reservation is RESOURCE_FORBIDDEN, naming it', async () => {
|
|
const f = build();
|
|
expect(
|
|
(
|
|
(await f
|
|
.host()
|
|
.dispatch(
|
|
req('reservations.update', { tripId: 1, reservationId: 404, input: { title: 'x', type: 'lodging' } }),
|
|
42,
|
|
)) as RpcError
|
|
).error.message,
|
|
).toBe('no reservation 404 on trip 1');
|
|
expect(
|
|
((await f.host().dispatch(req('reservations.delete', { tripId: 1, reservationId: 404 }), 42)) as RpcError).error
|
|
.message,
|
|
).toBe('no reservation 404 on trip 1');
|
|
});
|
|
|
|
it('BOOK-RPC-005 creating a lodging booking cascades into the accommodation event', async () => {
|
|
const f = build({ cascade: true });
|
|
await f.host().dispatch(req('reservations.create', { tripId: 1, input: { title: 'Hotel', type: 'lodging' } }), 42);
|
|
expect(events(f.realtime)).toEqual(['accommodation:created', 'reservation:created']);
|
|
});
|
|
|
|
it('BOOK-RPC-006 deleting one takes its accommodation and budget item with it', async () => {
|
|
const f = build({ cascade: true });
|
|
await f.host().dispatch(req('reservations.delete', { tripId: 1, reservationId: 5 }), 42);
|
|
expect(events(f.realtime)).toEqual(['accommodation:deleted', 'budget:deleted', 'reservation:deleted']);
|
|
});
|
|
|
|
it('BOOK-RPC-021 a booking carrying several expenses announces each one it took with it (#2084)', async () => {
|
|
const f = build({ expenses: [7, 8] });
|
|
await f.host().dispatch(req('reservations.delete', { tripId: 1, reservationId: 5 }), 42);
|
|
expect(f.realtime.broadcast.mock.calls).toEqual([
|
|
[1, 'budget:deleted', { itemId: 7 }, undefined],
|
|
[1, 'budget:deleted', { itemId: 8 }, undefined],
|
|
[1, 'reservation:deleted', { reservationId: 5 }, undefined],
|
|
]);
|
|
});
|
|
|
|
it('BOOK-RPC-007 the booking and its cost are one service write, and the booking notification runs', async () => {
|
|
const f = build();
|
|
await f.host().dispatch(req('reservations.create', { tripId: 1, input: { title: 'Hotel', type: 'lodging' } }), 42);
|
|
expect(f.reservations.createWithCost).toHaveBeenCalledWith(
|
|
'1',
|
|
expect.objectContaining({ title: 'Hotel' }),
|
|
undefined,
|
|
);
|
|
expect(f.reservations.announceCost).toHaveBeenCalledWith(1, [], undefined);
|
|
expect(f.reservations.notifyBookingChange).toHaveBeenCalledWith(1, 42, 'Hotel', 'lodging');
|
|
});
|
|
|
|
it('BOOK-RPC-008 a refused write cascades nothing', async () => {
|
|
const f = build({ canEdit: false, cascade: true });
|
|
await f.host().dispatch(req('reservations.create', { tripId: 1, input: { title: 'x', type: 'lodging' } }), 42);
|
|
expect(f.realtime.broadcast).not.toHaveBeenCalled();
|
|
expect(f.reservations.notifyBookingChange).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('BOOK-RPC-008b title and type are required by the shared schema', async () => {
|
|
const f = build();
|
|
// The handler still carries ?? '' fallbacks behind this, kept from the router as
|
|
// defence in depth, but the schema is what a plugin actually hits first.
|
|
const res = (await f.host().dispatch(req('reservations.create', { tripId: 1, input: {} }), 42)) as RpcError;
|
|
expect(res.error.code).toBe('BAD_PARAMS');
|
|
expect(f.reservations.createWithCost).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('BOOK-RPC-008c an update without a title keeps the current one', async () => {
|
|
const f = build();
|
|
await f.host().dispatch(req('reservations.update', { tripId: 1, reservationId: 5, input: {} }), 42);
|
|
// Falls back to the stored title and type rather than blanking them.
|
|
expect(f.reservations.notifyBookingChange).toHaveBeenCalledWith(1, 42, 'Hotel', 'lodging');
|
|
});
|
|
|
|
it('BOOK-RPC-008d a non-lodging booking cascades nothing', async () => {
|
|
const f = build();
|
|
await f
|
|
.host()
|
|
.dispatch(req('reservations.create', { tripId: 1, input: { title: 'Museum', type: 'activity' } }), 42);
|
|
expect(events(f.realtime)).toEqual(['reservation:created']);
|
|
f.realtime.broadcast.mockClear();
|
|
await f
|
|
.host()
|
|
.dispatch(
|
|
req('reservations.update', { tripId: 1, reservationId: 5, input: { title: 'x', type: 'activity' } }),
|
|
42,
|
|
);
|
|
expect(events(f.realtime)).toEqual(['reservation:updated']);
|
|
f.realtime.broadcast.mockClear();
|
|
await f.host().dispatch(req('reservations.delete', { tripId: 1, reservationId: 5 }), 42);
|
|
expect(events(f.realtime)).toEqual(['reservation:deleted']);
|
|
});
|
|
|
|
it('BOOK-RPC-008e an update with a malformed endpoints array is BAD_PARAMS too', async () => {
|
|
const f = build();
|
|
const res = (await f.host().dispatch(
|
|
req('reservations.update', {
|
|
tripId: 1,
|
|
reservationId: 5,
|
|
input: { title: 'x', type: 'lodging', endpoints: [{ nonsense: true }] },
|
|
}),
|
|
42,
|
|
)) as RpcError;
|
|
expect(res.error.code).toBe('BAD_PARAMS');
|
|
expect(f.reservations.updateWithCost).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('BOOK-RPC-018 an id that resolves to nothing is BAD_PARAMS, not a constraint failure', async () => {
|
|
const f = build({ unresolved: ['place_id'] });
|
|
const res = (await f
|
|
.host()
|
|
.dispatch(
|
|
req('reservations.create', { tripId: 1, input: { title: 'Hotel', type: 'lodging', place_id: 999999 } }),
|
|
42,
|
|
)) as RpcError;
|
|
expect(res.error.code).toBe('BAD_PARAMS');
|
|
expect(res.error.message).toBe('unknown reference: place_id');
|
|
expect(f.reservations.createWithCost).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('BOOK-RPC-019 the same on update', async () => {
|
|
const f = build({ unresolved: ['day_id'] });
|
|
const res = (await f.host().dispatch(
|
|
req('reservations.update', {
|
|
tripId: 1,
|
|
reservationId: 5,
|
|
input: { title: 'x', type: 'lodging', day_id: 999999 },
|
|
}),
|
|
42,
|
|
)) as RpcError;
|
|
expect(res.error.code).toBe('BAD_PARAMS');
|
|
expect(f.reservations.updateWithCost).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('BOOK-RPC-020 an id from another trip is RESOURCE_FORBIDDEN before the write, on create and update', async () => {
|
|
// reservation_edit on trip 1 says nothing about the ids in the body. A stay
|
|
// written against another trip's day puts a stop on that day, in a plan the
|
|
// acting user may not even read, so the body is checked the way the REST route
|
|
// and the MCP tool check it, and ownership is judged before existence.
|
|
const f = build({
|
|
foreign: ['create_accommodation.start_day_id'],
|
|
unresolved: ['create_accommodation.start_day_id'],
|
|
});
|
|
const stay = {
|
|
title: 'Hotel',
|
|
type: 'lodging',
|
|
create_accommodation: { place_id: 9, start_day_id: 4711, end_day_id: 4712 },
|
|
};
|
|
const created = (await f.host().dispatch(req('reservations.create', { tripId: 1, input: stay }), 42)) as RpcError;
|
|
expect(created.error.code).toBe('RESOURCE_FORBIDDEN');
|
|
expect(created.error.message).toBe('not part of trip 1: create_accommodation.start_day_id');
|
|
expect(f.reservations.createWithCost).not.toHaveBeenCalled();
|
|
|
|
const g = build({ foreign: ['day_id'] });
|
|
const updated = (await g.host().dispatch(
|
|
req('reservations.update', {
|
|
tripId: 1,
|
|
reservationId: 5,
|
|
input: { title: 'x', type: 'lodging', day_id: 4711 },
|
|
}),
|
|
42,
|
|
)) as RpcError;
|
|
expect(updated.error.code).toBe('RESOURCE_FORBIDDEN');
|
|
expect(updated.error.message).toBe('not part of trip 1: day_id');
|
|
expect(g.reservations.updateWithCost).not.toHaveBeenCalled();
|
|
expect(g.realtime.broadcast).not.toHaveBeenCalled();
|
|
|
|
// The same body with this trip's ids goes through.
|
|
const h = build();
|
|
expect(
|
|
(
|
|
await h.host().dispatch(
|
|
req('reservations.create', {
|
|
tripId: 1,
|
|
input: { ...stay, create_accommodation: { ...stay.create_accommodation, start_day_id: 3 } },
|
|
}),
|
|
42,
|
|
)
|
|
).ok,
|
|
).toBe(true);
|
|
expect(h.reservations.referencesOutsideTrip).toHaveBeenLastCalledWith(
|
|
'1',
|
|
expect.objectContaining({ create_accommodation: expect.objectContaining({ start_day_id: 3 }) }),
|
|
);
|
|
});
|
|
|
|
it('BOOK-RPC-009 the class is listed in its module providers', () => {
|
|
expectRegisteredProvider(ReservationsModule, ReservationsRpc);
|
|
});
|
|
});
|
|
|
|
describe('AccommodationsRpc', () => {
|
|
it('BOOK-RPC-010 lodging blocks run under day_edit, NOT reservation_edit', async () => {
|
|
const seen: string[] = [];
|
|
const f = build({ seenActions: seen });
|
|
await f
|
|
.host()
|
|
.dispatch(
|
|
req('accommodations.create', { tripId: 1, input: { place_id: 7, start_day_id: 3, end_day_id: 4 } }),
|
|
42,
|
|
);
|
|
// They hold db:write:accommodations but the app gates them on the day permission.
|
|
expect(seen).toEqual(['day_edit']);
|
|
});
|
|
|
|
it('BOOK-RPC-011 the three ids are required, and the schema rejects them first', async () => {
|
|
const f = build();
|
|
// The shared schema runs before the handler's own check, so a missing id is
|
|
// reported as a schema failure. The handler's check is the second line of
|
|
// defence, for values the schema lets through but the service cannot use.
|
|
const missing = (await f
|
|
.host()
|
|
.dispatch(req('accommodations.create', { tripId: 1, input: { place_id: 7 } }), 42)) as RpcError;
|
|
expect(missing.error.code).toBe('BAD_PARAMS');
|
|
const zero = (await f
|
|
.host()
|
|
.dispatch(
|
|
req('accommodations.create', { tripId: 1, input: { place_id: 0, start_day_id: 0, end_day_id: 0 } }),
|
|
42,
|
|
)) as RpcError;
|
|
expect(zero.error.code).toBe('BAD_PARAMS');
|
|
expect(f.days.createAccommodation).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('BOOK-RPC-012 a place or day from another trip is refused with the validator message', async () => {
|
|
const f = build();
|
|
const res = (await f
|
|
.host()
|
|
.dispatch(
|
|
req('accommodations.create', { tripId: 1, input: { place_id: 404, start_day_id: 3, end_day_id: 4 } }),
|
|
42,
|
|
)) as RpcError;
|
|
expect(res.error.message).toBe('place 404 is not on this trip');
|
|
expect(f.days.createAccommodation).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('BOOK-RPC-013 creating a block announces the partner reservation too', async () => {
|
|
const f = build();
|
|
await f
|
|
.host()
|
|
.dispatch(
|
|
req('accommodations.create', { tripId: 1, input: { place_id: 7, start_day_id: 3, end_day_id: 4 } }),
|
|
42,
|
|
);
|
|
expect(events(f.realtime)).toEqual(['accommodation:created', 'reservation:created']);
|
|
});
|
|
|
|
it('BOOK-RPC-014 deleting a block cascades to its reservation and budget item', async () => {
|
|
const f = build({ cascade: true });
|
|
await f.host().dispatch(req('accommodations.delete', { tripId: 1, accommodationId: 11 }), 42);
|
|
expect(events(f.realtime)).toEqual(['reservation:deleted', 'budget:deleted', 'accommodation:deleted']);
|
|
});
|
|
|
|
it('BOOK-RPC-015 a missing block is RESOURCE_FORBIDDEN, naming it', async () => {
|
|
const f = build();
|
|
expect(
|
|
(
|
|
(await f
|
|
.host()
|
|
.dispatch(req('accommodations.update', { tripId: 1, accommodationId: 404, input: {} }), 42)) as RpcError
|
|
).error.message,
|
|
).toBe('no accommodation 404 on trip 1');
|
|
expect(
|
|
((await f.host().dispatch(req('accommodations.delete', { tripId: 1, accommodationId: 404 }), 42)) as RpcError)
|
|
.error.message,
|
|
).toBe('no accommodation 404 on trip 1');
|
|
});
|
|
|
|
it('BOOK-RPC-015b optional block fields are passed through, absent ones as undefined', async () => {
|
|
const f = build();
|
|
await f.host().dispatch(
|
|
req('accommodations.create', {
|
|
tripId: 1,
|
|
input: { place_id: 7, start_day_id: 3, end_day_id: 4, check_in: '15:00', notes: 'late' },
|
|
}),
|
|
42,
|
|
);
|
|
expect(f.days.createAccommodation).toHaveBeenCalledWith(
|
|
1,
|
|
expect.objectContaining({ check_in: '15:00', notes: 'late', check_out: undefined }),
|
|
);
|
|
});
|
|
|
|
it('BOOK-RPC-015c an update with a bad ref is refused before the write', async () => {
|
|
const f = build();
|
|
const res = (await f
|
|
.host()
|
|
.dispatch(
|
|
req('accommodations.update', { tripId: 1, accommodationId: 11, input: { place_id: 404 } }),
|
|
42,
|
|
)) as RpcError;
|
|
expect(res.error.message).toBe('place 404 is not on this trip');
|
|
expect(f.days.updateAccommodation).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('BOOK-RPC-017 the day stop a booking writes is announced through the plugin surface too', async () => {
|
|
const f = build();
|
|
await f
|
|
.host()
|
|
.dispatch(
|
|
req('accommodations.create', { tripId: 1, input: { place_id: 7, start_day_id: 3, end_day_id: 4 } }),
|
|
42,
|
|
);
|
|
// Same call the REST route makes, so a plugin booking a night cannot leave the
|
|
// other sessions without the stop that puts it on the route.
|
|
expect(f.days.announceMirror).toHaveBeenCalledWith(
|
|
1,
|
|
{ created: null, removed: [], stamped: null },
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('BOOK-RPC-017b editing a block writes it, announces it and answers with the block', async () => {
|
|
const f = build();
|
|
const res = await f
|
|
.host()
|
|
.dispatch(req('accommodations.update', { tripId: 1, accommodationId: 11, input: { check_in: '15:00' } }), 42);
|
|
expect(f.days.updateAccommodation).toHaveBeenCalledWith(
|
|
11,
|
|
{ id: 11 },
|
|
expect.objectContaining({ check_in: '15:00' }),
|
|
);
|
|
expect(events(f.realtime)).toEqual(['accommodation:updated']);
|
|
expect(f.days.announceMirror).toHaveBeenCalledWith(
|
|
1,
|
|
{ created: null, removed: [], stamped: null },
|
|
expect.any(Function),
|
|
);
|
|
// The block itself, not the { accommodation, mirror } pair the service returns:
|
|
// the mirror is a broadcast concern and plugins never asked for it.
|
|
expect(res).toMatchObject({ k: 'res', result: { id: 11 } });
|
|
});
|
|
|
|
it('BOOK-RPC-017c what announceMirror sends goes out over the trip socket, on all three writes', async () => {
|
|
// The sender each handler hands announceMirror is the plugin surface's only link
|
|
// between a stay write and the day plan every other session is looking at. What
|
|
// belongs in the mirror is the service's call; that it reaches a socket at all is
|
|
// this one's, which is why the fixture's mirror is the same on all three.
|
|
for (const request of [
|
|
req('accommodations.create', { tripId: 1, input: { place_id: 7, start_day_id: 3, end_day_id: 4 } }),
|
|
req('accommodations.update', { tripId: 1, accommodationId: 11, input: { start_day_id: 4 } }),
|
|
req('accommodations.delete', { tripId: 1, accommodationId: 11 }),
|
|
]) {
|
|
const f = build({ stop: true });
|
|
await f.host().dispatch(request, 42);
|
|
expect(f.realtime.broadcast).toHaveBeenCalledWith(1, 'assignment:deleted', { assignmentId: 77, dayId: 3 });
|
|
expect(f.realtime.broadcast).toHaveBeenCalledWith(1, 'assignment:created', { assignment: { id: 78, day_id: 4 } });
|
|
}
|
|
});
|
|
|
|
it('BOOK-RPC-015d deleting a block without a partner cascades only its own event', async () => {
|
|
const f = build();
|
|
await f.host().dispatch(req('accommodations.delete', { tripId: 1, accommodationId: 11 }), 42);
|
|
expect(events(f.realtime)).toEqual(['accommodation:deleted']);
|
|
});
|
|
|
|
it('BOOK-RPC-016 the class is listed in its module providers', () => {
|
|
expectRegisteredProvider(AccommodationsModule, AccommodationsRpc);
|
|
});
|
|
});
|