mirror of
https://github.com/mauriceboe/TREK.git
synced 2026-10-22 15:06:32 +00:00
Maurice
848 lines
36 KiB
TypeScript
848 lines
36 KiB
TypeScript
/**
|
|
* Tours e2e for the planner's second round: the GPX export of one tour
|
|
* (PR1-06A), through the real JwtAuthGuard, AddonGuard and TripAccessGuard
|
|
* against a migrated and seeded temp SQLite db. The permission check is a
|
|
* container spy and the broadcast goes to a FakeRealtimeService, as in
|
|
* tours.e2e.test.ts.
|
|
*
|
|
* Fixtures: user 1 owns trips 5 and 6, user 2 is a member of trip 5 whom the
|
|
* permission spy denies 'place_edit', user 3 has no access to either trip.
|
|
*/
|
|
import { DayAssignments } from '../../src/db/entities/DayAssignments.entity';
|
|
import { Places } from '../../src/db/entities/Places.entity';
|
|
import { Tours } from '../../src/db/entities/Tours.entity';
|
|
import { Trips } from '../../src/db/entities/Trips.entity';
|
|
import { TrekExceptionFilter } from '../../src/nest/common/trek-exception.filter';
|
|
import { ZodValidationPipe } from '../../src/nest/common/zod-validation.pipe';
|
|
import { JourneyDomainService } from '../../src/nest/journey/journey-domain.service';
|
|
import { MapsService } from '../../src/nest/maps/maps.service';
|
|
import { PermissionsService } from '../../src/nest/permissions/permissions.service';
|
|
import { RealtimeModule } from '../../src/nest/realtime/realtime.module';
|
|
import { RealtimeService } from '../../src/nest/realtime/realtime.service';
|
|
import { ToursModule } from '../../src/nest/tours/tours.module';
|
|
import { createSnapshotTestDb } from '../helpers/db-mock';
|
|
import { makePlace } from '../helpers/factories/places';
|
|
import { countRows, deleteRows, findRow, insertRows } from '../helpers/factories/rows';
|
|
import { setAddonEnabled } from '../helpers/factories/settings';
|
|
import { makeTour } from '../helpers/factories/tours';
|
|
import { addTripMember } from '../helpers/factories/trips';
|
|
import { makeUser } from '../helpers/factories/users';
|
|
import { FakeRealtimeService } from '../helpers/fake-realtime';
|
|
import { createTestMikroOrmModule, createTestOrm, type TestOrm } from '../helpers/test-orm';
|
|
import { TestUnitOfWorkModule } from '../helpers/test-uow';
|
|
import { sessionCookie } from './harness';
|
|
import { Test } from '@nestjs/testing';
|
|
|
|
import cookieParser from 'cookie-parser';
|
|
import type { Server } from 'http';
|
|
import request from 'supertest';
|
|
import { describe, it, expect, beforeAll, afterAll, beforeEach, vi, type MockInstance } from 'vitest';
|
|
|
|
vi.mock('../../src/nest/audit/audit-log.logger', () => ({
|
|
LOG_LEVEL: 'error',
|
|
logInfo: vi.fn(),
|
|
logDebug: vi.fn(),
|
|
logError: vi.fn(),
|
|
logWarn: vi.fn(),
|
|
}));
|
|
|
|
const { journeyHooks } = vi.hoisted(() => ({
|
|
journeyHooks: {
|
|
reconcileTripSkeletons: vi.fn().mockResolvedValue(undefined),
|
|
onPlaceCreated: vi.fn().mockResolvedValue(undefined),
|
|
onPlaceUpdated: vi.fn().mockResolvedValue(undefined),
|
|
onPlaceDeleted: vi.fn().mockResolvedValue(undefined),
|
|
},
|
|
}));
|
|
|
|
const db = createSnapshotTestDb();
|
|
// The map search behind the POI search (PLN-02): no network in a test.
|
|
const mapsPoisAlong = vi.fn();
|
|
const realtime = new FakeRealtimeService();
|
|
|
|
let orm: TestOrm;
|
|
let checkPermission: MockInstance;
|
|
|
|
const OWNER = 1;
|
|
const VIEWER = 2;
|
|
const OUTSIDER = 3;
|
|
|
|
const GEOMETRY = [
|
|
[47, 11, 600],
|
|
[47.01, 11.01, 700],
|
|
[47.02, 11.02, 650],
|
|
];
|
|
const tourBody = (overrides: Record<string, unknown> = {}) => ({
|
|
name: 'Ridge walk',
|
|
route_geometry: GEOMETRY,
|
|
waypoints: [
|
|
{ lat: 47, lng: 11, role: 'start', sequence: 0 },
|
|
{ lat: 47.02, lng: 11.02, role: 'end', sequence: 1 },
|
|
],
|
|
max_hiking_difficulty: 3,
|
|
duration_seconds: 3600,
|
|
...overrides,
|
|
});
|
|
|
|
describe('Tours planned e2e (real guards + temp SQLite)', () => {
|
|
let server: Server;
|
|
let app: Awaited<ReturnType<typeof build>>;
|
|
|
|
async function build() {
|
|
const moduleRef = await Test.createTestingModule({
|
|
imports: [
|
|
await TestUnitOfWorkModule.forRoot(db),
|
|
await createTestMikroOrmModule(db),
|
|
RealtimeModule,
|
|
ToursModule,
|
|
],
|
|
})
|
|
.overrideProvider(RealtimeService)
|
|
.useValue(realtime)
|
|
.overrideProvider(JourneyDomainService)
|
|
.useValue(journeyHooks)
|
|
.overrideProvider(MapsService)
|
|
.useValue({ poisAlong: mapsPoisAlong })
|
|
.compile();
|
|
const nest = moduleRef.createNestApplication();
|
|
nest.use(cookieParser());
|
|
nest.useGlobalPipes(new ZodValidationPipe());
|
|
nest.useGlobalFilters(new TrekExceptionFilter());
|
|
await nest.init();
|
|
return nest;
|
|
}
|
|
|
|
const createViaApi = async (tripId = 5, body: Record<string, unknown> = tourBody()) => {
|
|
const res = await request(server).post(`/api/trips/${tripId}/tours`).set('Cookie', sessionCookie(OWNER)).send(body);
|
|
expect(res.status).toBe(201);
|
|
return res.body.tour.place_id as number;
|
|
};
|
|
|
|
beforeAll(async () => {
|
|
orm = await createTestOrm(db);
|
|
// Pinned ids: the session cookies sign for exactly these users.
|
|
await makeUser(orm, { id: 1, username: 'owner', email: 'owner@example.test', role: 'user', password_version: 0 });
|
|
await makeUser(orm, { id: 2, username: 'viewer', email: 'viewer@example.test', role: 'user', password_version: 0 });
|
|
await makeUser(orm, {
|
|
id: 3,
|
|
username: 'outsider',
|
|
email: 'outsider@example.test',
|
|
role: 'user',
|
|
password_version: 0,
|
|
});
|
|
await insertRows(orm, Trips, [
|
|
{ id: 5, user: 1, title: 'Alps' },
|
|
{ id: 6, user: 1, title: 'Other' },
|
|
]);
|
|
await addTripMember(orm, 5, 2);
|
|
app = await build();
|
|
checkPermission = vi.spyOn(app.get(PermissionsService), 'checkPermission');
|
|
server = app.getHttpServer();
|
|
});
|
|
|
|
beforeEach(async () => {
|
|
checkPermission.mockImplementation(
|
|
(action: string, _role: string, _owner: number, userId: number) =>
|
|
!(action === 'place_edit' && userId === VIEWER),
|
|
);
|
|
await setAddonEnabled(orm, 'tours', true);
|
|
realtime.broadcastMock.mockClear();
|
|
await deleteRows(orm, DayAssignments);
|
|
await deleteRows(orm, Places);
|
|
});
|
|
|
|
afterAll(async () => {
|
|
await app.close();
|
|
await orm.close();
|
|
});
|
|
|
|
describe('GET :placeId/export.gpx (PR1-06A)', () => {
|
|
const exportGpx = (userId: number, placeId: number, tripId = 5) =>
|
|
request(server)
|
|
.get(`/api/trips/${tripId}/tours/${placeId}/export.gpx`)
|
|
.set('Cookie', sessionCookie(userId))
|
|
.buffer(true)
|
|
.parse((res, done) => {
|
|
let text = '';
|
|
res.setEncoding('utf8');
|
|
res.on('data', (chunk: string) => (text += chunk));
|
|
res.on('end', () => done(null, text));
|
|
});
|
|
|
|
it('writes the whole saved line with its heights as one track, named after the tour', async () => {
|
|
const placeId = await createViaApi(5, tourBody({ name: 'Grat über Ü', description: 'Früh los.' }));
|
|
const res = await exportGpx(OWNER, placeId);
|
|
expect(res.status).toBe(200);
|
|
expect(res.headers['content-type']).toBe('application/gpx+xml; charset=utf-8');
|
|
expect(res.headers['content-disposition']).toContain("filename*=UTF-8''Grat-%C3%BCber-%C3%9C.gpx");
|
|
const gpx = res.body as string;
|
|
expect(gpx).toContain('<name>Grat über Ü</name>');
|
|
expect(gpx).toContain('<desc>Früh los.</desc>');
|
|
expect(gpx).toContain('<type>hiking</type>');
|
|
expect(gpx.match(/<trkpt /g)).toHaveLength(GEOMETRY.length);
|
|
expect(gpx).toContain('<trkpt lat="47.01" lon="11.01">');
|
|
expect(gpx).toContain('<ele>700</ele>');
|
|
});
|
|
|
|
it('writes no height a point lacks, and names a paddle tour by its boat', async () => {
|
|
const place = await makePlace(orm, 5, {
|
|
name: 'Canal',
|
|
route_geometry: JSON.stringify([
|
|
[48, 12],
|
|
[48.01, 12.01, 300],
|
|
]),
|
|
});
|
|
await makeTour(orm, place.id, {
|
|
tourTypeRef: 'kayak',
|
|
boat_type: 'canoe',
|
|
water_context: 'river',
|
|
origin: 'gpx',
|
|
});
|
|
const res = await exportGpx(OWNER, place.id);
|
|
expect(res.status).toBe(200);
|
|
const gpx = res.body as string;
|
|
expect(gpx).toContain('<type>canoeing</type>');
|
|
expect(gpx.match(/<ele>/g)).toHaveLength(1);
|
|
});
|
|
|
|
it('a member who may only read can export; the export changes nothing', async () => {
|
|
const placeId = await createViaApi();
|
|
const before = await findRow(orm, Tours, { place: placeId });
|
|
realtime.broadcastMock.mockClear();
|
|
const res = await exportGpx(VIEWER, placeId);
|
|
expect(res.status).toBe(200);
|
|
expect(await findRow(orm, Tours, { place: placeId })).toEqual(before);
|
|
expect(realtime.broadcastMock).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('422 for a tour without a line of two points, 404 for one of another trip or none', async () => {
|
|
const lonely = await makePlace(orm, 5, { name: 'Dot', route_geometry: JSON.stringify([[47, 11, 1]]) });
|
|
await makeTour(orm, lonely.id, { origin: 'gpx' });
|
|
const refused = await request(server)
|
|
.get(`/api/trips/5/tours/${lonely.id}/export.gpx`)
|
|
.set('Cookie', sessionCookie(OWNER));
|
|
expect(refused.status).toBe(422);
|
|
expect(refused.body).toEqual({ error: 'This tour has no route to export' });
|
|
|
|
const elsewhere = await createViaApi(6);
|
|
const wrongTrip = await request(server)
|
|
.get(`/api/trips/5/tours/${elsewhere}/export.gpx`)
|
|
.set('Cookie', sessionCookie(OWNER));
|
|
expect(wrongTrip.status).toBe(404);
|
|
expect(wrongTrip.body).toEqual({ error: 'Tour not found' });
|
|
const plain = await makePlace(orm, 5, { name: 'Cafe' });
|
|
expect(
|
|
(await request(server).get(`/api/trips/5/tours/${plain.id}/export.gpx`).set('Cookie', sessionCookie(OWNER)))
|
|
.status,
|
|
).toBe(404);
|
|
});
|
|
|
|
it('404 Trip not found for an outsider, 404 while the addon is off, 401 without a cookie', async () => {
|
|
const placeId = await createViaApi();
|
|
const outsider = await request(server)
|
|
.get(`/api/trips/5/tours/${placeId}/export.gpx`)
|
|
.set('Cookie', sessionCookie(OUTSIDER));
|
|
expect(outsider.status).toBe(404);
|
|
expect(outsider.body).toEqual({ error: 'Trip not found' });
|
|
expect((await request(server).get(`/api/trips/5/tours/${placeId}/export.gpx`)).status).toBe(401);
|
|
await setAddonEnabled(orm, 'tours', false);
|
|
const off = await request(server)
|
|
.get(`/api/trips/5/tours/${placeId}/export.gpx`)
|
|
.set('Cookie', sessionCookie(OWNER));
|
|
expect(off.status).toBe(404);
|
|
expect(off.body).toEqual({ error: 'Tours addon is not enabled' });
|
|
});
|
|
});
|
|
|
|
describe('revisions and conflicts (P2C-03)', () => {
|
|
const put = (placeId: number, body: Record<string, unknown>) =>
|
|
request(server).put(`/api/trips/5/tours/${placeId}`).set('Cookie', sessionCookie(OWNER)).send(body);
|
|
|
|
it('a tour starts at 1, and every saved change raises it by one, in the list and the detail', async () => {
|
|
const placeId = await createViaApi();
|
|
const detail = await request(server).get(`/api/trips/5/tours/${placeId}`).set('Cookie', sessionCookie(OWNER));
|
|
expect(detail.body.tour.revision).toBe(1);
|
|
|
|
const saved = await put(placeId, tourBody({ name: 'Renamed', expected_revision: 1 }));
|
|
expect(saved.status).toBe(200);
|
|
expect(saved.body.tour).toMatchObject({ name: 'Renamed', revision: 2 });
|
|
const list = await request(server).get('/api/trips/5/tours').set('Cookie', sessionCookie(OWNER));
|
|
expect(list.body.tours[0].revision).toBe(2);
|
|
});
|
|
|
|
it('409 for a draft based on a revision the tour has left, and nothing of it is written', async () => {
|
|
const placeId = await createViaApi();
|
|
expect((await put(placeId, tourBody({ name: 'First', expected_revision: 1 }))).status).toBe(200);
|
|
realtime.broadcastMock.mockClear();
|
|
|
|
const stale = await put(
|
|
placeId,
|
|
tourBody({
|
|
name: 'Stale',
|
|
expected_revision: 1,
|
|
waypoints: [
|
|
{ lat: 47, lng: 11, role: 'start', sequence: 0 },
|
|
{ lat: 47.01, lng: 11.01, role: 'via', sequence: 1 },
|
|
{ lat: 47.02, lng: 11.02, role: 'end', sequence: 2 },
|
|
],
|
|
}),
|
|
);
|
|
expect(stale.status).toBe(409);
|
|
expect(stale.body).toEqual({
|
|
error: 'This tour was changed in the meantime',
|
|
code: 'tour_revision_conflict',
|
|
revision: 2,
|
|
});
|
|
const after = await request(server).get(`/api/trips/5/tours/${placeId}`).set('Cookie', sessionCookie(OWNER));
|
|
expect(after.body.tour).toMatchObject({ name: 'First', revision: 2 });
|
|
expect(after.body.waypoints).toHaveLength(2);
|
|
expect(realtime.broadcastMock).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('a write naming no revision writes as before, so an older client or a queued write still lands', async () => {
|
|
const placeId = await createViaApi();
|
|
expect((await put(placeId, tourBody({ name: 'One', expected_revision: 1 }))).status).toBe(200);
|
|
const blind = await put(placeId, tourBody({ name: 'Two' }));
|
|
expect(blind.status).toBe(200);
|
|
expect(blind.body.tour).toMatchObject({ name: 'Two', revision: 3 });
|
|
});
|
|
|
|
it('a copy starts at 1 of its own, and the original keeps its count', async () => {
|
|
const placeId = await createViaApi();
|
|
await put(placeId, tourBody({ expected_revision: 1 }));
|
|
const copy = await request(server)
|
|
.post(`/api/trips/5/tours/${placeId}/copy`)
|
|
.set('Cookie', sessionCookie(OWNER))
|
|
.send({ name: 'Copy' });
|
|
expect(copy.status).toBe(201);
|
|
expect(copy.body.tour.revision).toBe(1);
|
|
expect((await findRow(orm, Tours, { place: placeId }))?.revision).toBe(2);
|
|
});
|
|
|
|
it('the plan laid onto a recorded paddle track names its revision too', async () => {
|
|
const place = await makePlace(orm, 5, {
|
|
name: 'Canal',
|
|
route_geometry: JSON.stringify([
|
|
[48, 12],
|
|
[48.01, 12.01],
|
|
]),
|
|
});
|
|
await makeTour(orm, place.id, {
|
|
tourTypeRef: 'kayak',
|
|
boat_type: 'kayak',
|
|
water_context: 'river',
|
|
origin: 'gpx',
|
|
});
|
|
const plan = { paddle_speed_kmh: 5, portage_speed_kmh: null, track_marks: { portages: [], locks: [] } };
|
|
const putPlan = (body: Record<string, unknown>) =>
|
|
request(server)
|
|
.put(`/api/trips/5/tours/${place.id}/paddle-plan`)
|
|
.set('Cookie', sessionCookie(OWNER))
|
|
.send(body);
|
|
|
|
const first = await putPlan({ ...plan, expected_revision: 1 });
|
|
expect(first.status).toBe(200);
|
|
expect(first.body.tour.revision).toBe(2);
|
|
const stale = await putPlan({ ...plan, paddle_speed_kmh: 3, expected_revision: 1 });
|
|
expect(stale.status).toBe(409);
|
|
expect(stale.body).toMatchObject({ code: 'tour_revision_conflict', revision: 2 });
|
|
expect((await findRow(orm, Tours, { place: place.id }))?.paddle_speed_kmh).toBe(5);
|
|
});
|
|
|
|
it('rejects a revision below 1 at the boundary', async () => {
|
|
const placeId = await createViaApi();
|
|
expect((await put(placeId, tourBody({ expected_revision: 0 }))).status).toBe(400);
|
|
});
|
|
});
|
|
|
|
describe('trip places as waypoints (PR1-10)', () => {
|
|
const linked = (placeId: number | null) => [
|
|
{ lat: 47, lng: 11, role: 'start', sequence: 0 },
|
|
{ lat: 47.01, lng: 11.01, role: 'via', sequence: 1, linked_place_id: placeId },
|
|
{ lat: 47.02, lng: 11.02, role: 'end', sequence: 2 },
|
|
];
|
|
|
|
it('a waypoint stands for a place of the trip, read back with it, and the place stays as it was', async () => {
|
|
const hut = await makePlace(orm, 5, { name: 'Höllentalangerhütte', lat: 47.4, lng: 11.0 });
|
|
const placeId = await createViaApi(5, tourBody({ waypoints: linked(hut.id) }));
|
|
const detail = await request(server).get(`/api/trips/5/tours/${placeId}`).set('Cookie', sessionCookie(OWNER));
|
|
expect(detail.body.waypoints.map((point: { linked_place_id?: number }) => point.linked_place_id ?? null)).toEqual(
|
|
[null, hut.id, null],
|
|
);
|
|
// The waypoint keeps its own coordinates; the place keeps its own.
|
|
expect(detail.body.waypoints[1]).toMatchObject({ lat: 47.01, lng: 11.01 });
|
|
expect(await findRow(orm, Places, { id: hut.id })).toMatchObject({ name: 'Höllentalangerhütte', lat: 47.4 });
|
|
expect(await countRows(orm, DayAssignments, { place: hut.id })).toBe(0);
|
|
});
|
|
|
|
it('a place of another trip, or one that is gone, leaves the point unlinked; a tour cannot be stood for', async () => {
|
|
const foreign = await makePlace(orm, 6, { name: 'Elsewhere' });
|
|
const placeId = await createViaApi(5, tourBody({ waypoints: linked(foreign.id) }));
|
|
const detail = await request(server).get(`/api/trips/5/tours/${placeId}`).set('Cookie', sessionCookie(OWNER));
|
|
expect(detail.body.waypoints[1].linked_place_id).toBeUndefined();
|
|
|
|
const missing = await request(server)
|
|
.put(`/api/trips/5/tours/${placeId}`)
|
|
.set('Cookie', sessionCookie(OWNER))
|
|
.send(tourBody({ waypoints: linked(999_999) }));
|
|
expect(missing.status).toBe(200);
|
|
expect(missing.body.waypoints[1].linked_place_id).toBeUndefined();
|
|
|
|
const otherTour = await createViaApi();
|
|
const refused = await request(server)
|
|
.put(`/api/trips/5/tours/${placeId}`)
|
|
.set('Cookie', sessionCookie(OWNER))
|
|
.send(tourBody({ waypoints: linked(otherTour) }));
|
|
expect(refused.status).toBe(400);
|
|
expect(refused.body).toEqual({ error: 'A waypoint cannot stand for a tour', code: 'waypoint_links_a_tour' });
|
|
});
|
|
|
|
it('deleting the place keeps the waypoint and only drops the link; the GPX names the stops that stand for a place', async () => {
|
|
const hut = await makePlace(orm, 5, { name: 'Kreuzeckhaus' });
|
|
const lake = await makePlace(orm, 5, { name: 'Eibsee' });
|
|
const placeId = await createViaApi(
|
|
5,
|
|
tourBody({
|
|
waypoints: [
|
|
{ lat: 47, lng: 11, role: 'start', sequence: 0, linked_place_id: lake.id },
|
|
{ lat: 47.01, lng: 11.01, role: 'via', sequence: 1, linked_place_id: hut.id },
|
|
{ lat: 47.02, lng: 11.02, role: 'end', sequence: 2 },
|
|
],
|
|
}),
|
|
);
|
|
const gpx = await request(server)
|
|
.get(`/api/trips/5/tours/${placeId}/export.gpx`)
|
|
.set('Cookie', sessionCookie(OWNER))
|
|
.buffer(true)
|
|
.parse((res, done) => {
|
|
let text = '';
|
|
res.setEncoding('utf8');
|
|
res.on('data', (chunk: string) => (text += chunk));
|
|
res.on('end', () => done(null, text));
|
|
});
|
|
expect((gpx.body as string).match(/<wpt /g)).toHaveLength(2);
|
|
expect(gpx.body).toContain('<name>Kreuzeckhaus</name>');
|
|
|
|
await deleteRows(orm, Places, { id: hut.id });
|
|
const detail = await request(server).get(`/api/trips/5/tours/${placeId}`).set('Cookie', sessionCookie(OWNER));
|
|
expect(detail.body.waypoints).toHaveLength(3);
|
|
expect(detail.body.waypoints[1].linked_place_id).toBeUndefined();
|
|
expect(detail.body.waypoints[0].linked_place_id).toBe(lake.id);
|
|
});
|
|
});
|
|
|
|
describe('hiking preferences (MF-08)', () => {
|
|
it('a hike keeps the preferences switched on, reads them back, and a copy carries them', async () => {
|
|
const placeId = await createViaApi(
|
|
5,
|
|
tourBody({ hiking_preferences: { avoid_climbs: true, avoid_steps: true, avoid_ferries: false } }),
|
|
);
|
|
const detail = await request(server).get(`/api/trips/5/tours/${placeId}`).set('Cookie', sessionCookie(OWNER));
|
|
expect(detail.body.tour.hiking_preferences).toEqual({ avoid_climbs: true, avoid_steps: true });
|
|
const copy = await request(server)
|
|
.post(`/api/trips/5/tours/${placeId}/copy`)
|
|
.set('Cookie', sessionCookie(OWNER))
|
|
.send({ name: 'Copy' });
|
|
expect(copy.body.tour.hiking_preferences).toEqual({ avoid_climbs: true, avoid_steps: true });
|
|
|
|
// An edit that switches them all off keeps none; one without the field keeps none too.
|
|
const off = await request(server)
|
|
.put(`/api/trips/5/tours/${placeId}`)
|
|
.set('Cookie', sessionCookie(OWNER))
|
|
.send(tourBody({ hiking_preferences: { avoid_steps: false } }));
|
|
expect(off.body.tour.hiking_preferences).toBeNull();
|
|
expect((await findRow(orm, Tours, { place: placeId }))?.hiking_preferences).toBeNull();
|
|
});
|
|
|
|
it('a tour saved before keeps none, an unknown preference is refused, and a paddle tour has none', async () => {
|
|
const plain = await createViaApi();
|
|
const detail = await request(server).get(`/api/trips/5/tours/${plain}`).set('Cookie', sessionCookie(OWNER));
|
|
expect(detail.body.tour.hiking_preferences).toBeNull();
|
|
const unknown = await request(server)
|
|
.post('/api/trips/5/tours')
|
|
.set('Cookie', sessionCookie(OWNER))
|
|
.send(tourBody({ hiking_preferences: { avoid_hills: true } }));
|
|
expect(unknown.status).toBe(400);
|
|
const paddle = await request(server)
|
|
.post('/api/trips/5/tours')
|
|
.set('Cookie', sessionCookie(OWNER))
|
|
.send(
|
|
tourBody({
|
|
tour_type: 'kayak',
|
|
boat_type: 'kayak',
|
|
water_context: 'lake',
|
|
max_hiking_difficulty: null,
|
|
hiking_preferences: { avoid_steps: true },
|
|
}),
|
|
);
|
|
expect(paddle.status).toBe(400);
|
|
});
|
|
});
|
|
describe('taking a tour over from another trip (LIB-02)', () => {
|
|
beforeAll(async () => {
|
|
// A trip of someone else's, which the owner never sees.
|
|
await insertRows(orm, Trips, [{ id: 7, user: 3, title: 'Elsewhere' }]);
|
|
});
|
|
|
|
const outsiderTour = async () => {
|
|
const res = await request(server)
|
|
.post('/api/trips/7/tours')
|
|
.set('Cookie', sessionCookie(OUTSIDER))
|
|
.send(tourBody({ name: 'Secret ridge' }));
|
|
expect(res.status).toBe(201);
|
|
return res.body.tour.place_id as number;
|
|
};
|
|
|
|
it('lists the tours of the trips the user can open, with their trip, never one of another user', async () => {
|
|
const ridge = await createViaApi(5, tourBody({ name: 'Ridge 100% walk' }));
|
|
await createViaApi(
|
|
5,
|
|
tourBody({
|
|
name: 'Lake loop',
|
|
tour_type: 'kayak',
|
|
boat_type: 'kayak',
|
|
water_context: 'lake',
|
|
max_hiking_difficulty: null,
|
|
}),
|
|
);
|
|
await createViaApi(6, tourBody({ name: 'Valley walk' }));
|
|
await outsiderTour();
|
|
|
|
const all = await request(server).get('/api/tours/library').set('Cookie', sessionCookie(OWNER));
|
|
expect(all.status).toBe(200);
|
|
expect(all.body.tours.map((tour: { name: string }) => tour.name).sort()).toEqual([
|
|
'Lake loop',
|
|
'Ridge 100% walk',
|
|
'Valley walk',
|
|
]);
|
|
expect(all.body.tours.find((tour: { place_id: number }) => tour.place_id === ridge)).toMatchObject({
|
|
trip: { id: 5, title: 'Alps' },
|
|
tour_type: 'hike',
|
|
has_waypoints: true,
|
|
origin: 'trek',
|
|
});
|
|
expect(all.body.trips).toEqual([
|
|
{ id: 6, title: 'Other', tour_count: 1 },
|
|
{ id: 5, title: 'Alps', tour_count: 2 },
|
|
]);
|
|
expect(all.body.truncated).toBe(false);
|
|
expect(JSON.stringify(all.body)).not.toContain('Secret ridge');
|
|
|
|
// Leaving the asking trip out, by name (case and a literal "%" alike), by type and by trip.
|
|
const from6 = await request(server)
|
|
.get('/api/tours/library?exclude_trip_id=6')
|
|
.set('Cookie', sessionCookie(OWNER));
|
|
expect(from6.body.tours.every((tour: { trip: { id: number } }) => tour.trip.id === 5)).toBe(true);
|
|
expect(from6.body.trips).toEqual([{ id: 5, title: 'Alps', tour_count: 2 }]);
|
|
const named = await request(server).get('/api/tours/library?q=100%25').set('Cookie', sessionCookie(OWNER));
|
|
expect(named.body.tours.map((tour: { name: string }) => tour.name)).toEqual(['Ridge 100% walk']);
|
|
const anyCase = await request(server).get('/api/tours/library?q=VALLEY').set('Cookie', sessionCookie(OWNER));
|
|
expect(anyCase.body.tours.map((tour: { name: string }) => tour.name)).toEqual(['Valley walk']);
|
|
const paddle = await request(server).get('/api/tours/library?type=kayak').set('Cookie', sessionCookie(OWNER));
|
|
expect(paddle.body.tours.map((tour: { name: string }) => tour.name)).toEqual(['Lake loop']);
|
|
const trip6 = await request(server).get('/api/tours/library?trip_id=6').set('Cookie', sessionCookie(OWNER));
|
|
expect(trip6.body.tours.map((tour: { name: string }) => tour.name)).toEqual(['Valley walk']);
|
|
const bad = await request(server).get('/api/tours/library?type=car').set('Cookie', sessionCookie(OWNER));
|
|
expect(bad.status).toBe(400);
|
|
|
|
// A member sees the trips they belong to.
|
|
const member = await request(server).get('/api/tours/library').set('Cookie', sessionCookie(VIEWER));
|
|
expect(member.body.trips.map((trip: { id: number }) => trip.id)).toEqual([5]);
|
|
});
|
|
|
|
it("previews one tour with its line and control points; another user's tour or none is not found", async () => {
|
|
const ridge = await createViaApi(5);
|
|
const preview = await request(server).get(`/api/tours/library/${ridge}`).set('Cookie', sessionCookie(OWNER));
|
|
expect(preview.status).toBe(200);
|
|
expect(preview.body.line).toEqual(GEOMETRY.map(([lat, lng]) => [lat, lng]));
|
|
expect(preview.body.waypoint_count).toBe(2);
|
|
expect(preview.body.tour).toMatchObject({ name: 'Ridge walk', trip: { id: 5, title: 'Alps' } });
|
|
|
|
const secret = await outsiderTour();
|
|
const hidden = await request(server).get(`/api/tours/library/${secret}`).set('Cookie', sessionCookie(OWNER));
|
|
expect(hidden.status).toBe(404);
|
|
expect(hidden.body).toEqual({ error: 'Tour not found' });
|
|
expect((await request(server).get('/api/tours/library/999999').set('Cookie', sessionCookie(OWNER))).status).toBe(
|
|
404,
|
|
);
|
|
expect((await request(server).get('/api/tours/library/abc').set('Cookie', sessionCookie(OWNER))).status).toBe(
|
|
404,
|
|
);
|
|
});
|
|
|
|
it('a long line is thinned for the preview, its ends kept', async () => {
|
|
const long = Array.from({ length: 1200 }, (_, index) => [47 + index / 10000, 11 + index / 10000, 600]);
|
|
const placeId = await createViaApi(5, tourBody({ route_geometry: long }));
|
|
const preview = await request(server).get(`/api/tours/library/${placeId}`).set('Cookie', sessionCookie(OWNER));
|
|
expect(preview.body.line).toHaveLength(400);
|
|
expect(preview.body.line[0]).toEqual([47, 11]);
|
|
const last = long[long.length - 1] ?? [];
|
|
expect(preview.body.line[399]).toEqual([last[0], last[1]]);
|
|
});
|
|
|
|
it('takes a tour over as an independent tour of this trip, remembering where it came from', async () => {
|
|
const hut = await makePlace(orm, 5, { name: 'Hut', lat: 47.01, lng: 11.01 });
|
|
const source = await createViaApi(
|
|
5,
|
|
tourBody({
|
|
waypoints: [
|
|
{ lat: 47, lng: 11, role: 'start', sequence: 0 },
|
|
{ lat: 47.01, lng: 11.01, role: 'via', sequence: 1, linked_place_id: hut.id },
|
|
{ lat: 47.02, lng: 11.02, role: 'end', sequence: 2 },
|
|
],
|
|
}),
|
|
);
|
|
realtime.broadcastMock.mockClear();
|
|
const res = await request(server)
|
|
.post('/api/trips/6/tours/take-over')
|
|
.set('Cookie', sessionCookie(OWNER))
|
|
.send({ source_trip_id: 5, source_place_id: source });
|
|
expect(res.status).toBe(201);
|
|
const copy = res.body.tour.place_id as number;
|
|
expect(copy).not.toBe(source);
|
|
expect(res.body.tour).toMatchObject({
|
|
name: 'Ridge walk',
|
|
revision: 1,
|
|
planned: false,
|
|
max_hiking_difficulty: 3,
|
|
});
|
|
expect(res.body.provenance).toMatchObject({
|
|
derivedFrom: null,
|
|
takenOverFrom: { tripTitle: 'Alps', tourName: 'Ridge walk' },
|
|
});
|
|
// The stop stood for a place of the other trip: in this one it stands for nothing.
|
|
expect(
|
|
res.body.waypoints.map((point: { linked_place_id?: number | null }) => point.linked_place_id ?? null),
|
|
).toEqual([null, null, null]);
|
|
expect(await findRow(orm, Places, { id: copy })).toMatchObject({ trip_id: 6 });
|
|
expect(await countRows(orm, DayAssignments, { place: copy })).toBe(0);
|
|
expect(realtime.broadcastMock.mock.calls.every(([tripId]) => String(tripId) === '6')).toBe(true);
|
|
|
|
// The source is untouched, and a later change to one leaves the other as it is.
|
|
const original = await request(server).get(`/api/trips/5/tours/${source}`).set('Cookie', sessionCookie(OWNER));
|
|
expect(original.body.provenance.takenOverFrom).toBeNull();
|
|
expect(original.body.waypoints[1].linked_place_id).toBe(hut.id);
|
|
await request(server)
|
|
.put(`/api/trips/6/tours/${copy}`)
|
|
.set('Cookie', sessionCookie(OWNER))
|
|
.send(tourBody({ name: 'Renamed copy' }));
|
|
expect((await findRow(orm, Places, { id: source }))?.name).toBe('Ridge walk');
|
|
|
|
// A copy of the copy still names where the line came from.
|
|
const again = await request(server)
|
|
.post(`/api/trips/6/tours/${copy}/copy`)
|
|
.set('Cookie', sessionCookie(OWNER))
|
|
.send({ name: 'Again' });
|
|
expect(again.body.provenance.takenOverFrom).toEqual({ tripTitle: 'Alps', tourName: 'Ridge walk' });
|
|
});
|
|
|
|
it('a name can be given; a source out of reach or gone is not found and leaves nothing behind', async () => {
|
|
const source = await createViaApi(5);
|
|
const named = await request(server)
|
|
.post('/api/trips/6/tours/take-over')
|
|
.set('Cookie', sessionCookie(OWNER))
|
|
.send({ source_trip_id: 5, source_place_id: source, name: 'My ridge' });
|
|
expect(named.body.tour.name).toBe('My ridge');
|
|
|
|
const before = await countRows(orm, Places, { trip: 7 });
|
|
const stolen = await request(server)
|
|
.post('/api/trips/7/tours/take-over')
|
|
.set('Cookie', sessionCookie(OUTSIDER))
|
|
.send({ source_trip_id: 5, source_place_id: source });
|
|
expect(stolen.status).toBe(404);
|
|
expect(stolen.body).toEqual({ error: 'Tour not found' });
|
|
// The place id named with the wrong trip is not found either.
|
|
const mismatched = await request(server)
|
|
.post('/api/trips/6/tours/take-over')
|
|
.set('Cookie', sessionCookie(OWNER))
|
|
.send({ source_trip_id: 6, source_place_id: source });
|
|
expect(mismatched.status).toBe(404);
|
|
expect(await countRows(orm, Places, { trip: 7 })).toBe(before);
|
|
});
|
|
|
|
it('needs place_edit on the trip it writes into, the addon on, a session and a well-formed body', async () => {
|
|
const source = await createViaApi(6);
|
|
const viewer = await request(server)
|
|
.post('/api/trips/5/tours/take-over')
|
|
.set('Cookie', sessionCookie(VIEWER))
|
|
.send({ source_trip_id: 6, source_place_id: source });
|
|
expect(viewer.status).toBe(403);
|
|
const extra = await request(server)
|
|
.post('/api/trips/5/tours/take-over')
|
|
.set('Cookie', sessionCookie(OWNER))
|
|
.send({ source_trip_id: 6, source_place_id: source, day_id: 1 });
|
|
expect(extra.status).toBe(400);
|
|
expect((await request(server).get('/api/tours/library')).status).toBe(401);
|
|
await setAddonEnabled(orm, 'tours', false);
|
|
const off = await request(server).get('/api/tours/library').set('Cookie', sessionCookie(OWNER));
|
|
expect(off.status).toBe(404);
|
|
expect(off.body).toEqual({ error: 'Tours addon is not enabled' });
|
|
});
|
|
});
|
|
describe('places along a tour (PLN-02)', () => {
|
|
const body = {
|
|
tour_type: 'hike',
|
|
categories: ['drinking_water'],
|
|
corridor_m: 500,
|
|
line: [
|
|
[47, 11],
|
|
[47.02, 11],
|
|
],
|
|
};
|
|
const spring = {
|
|
osm_id: 'node:7',
|
|
name: 'Spring',
|
|
lat: 47.01,
|
|
lng: 11.001,
|
|
category: 'drinking_water',
|
|
poi_type: 'amenity=drinking_water',
|
|
address: null,
|
|
website: null,
|
|
phone: null,
|
|
opening_hours: null,
|
|
cuisine: null,
|
|
brand: null,
|
|
brand_wikidata: null,
|
|
charging: null,
|
|
source: 'openstreetmap',
|
|
};
|
|
|
|
it('answers the places along a draft line to anyone who sees the trip, and writes nothing', async () => {
|
|
mapsPoisAlong.mockResolvedValue({ pois: [spring], failed: [], partial: false, truncated: false, capped: false });
|
|
const places = await countRows(orm, Places);
|
|
const res = await request(server)
|
|
.post('/api/trips/5/tours/poi-search')
|
|
.set('Cookie', sessionCookie(VIEWER))
|
|
.send(body);
|
|
expect(res.status).toBe(200);
|
|
expect(res.body.pois).toEqual([
|
|
expect.objectContaining({ id: 'node:7', name: 'Spring', category: 'drinking_water' }),
|
|
]);
|
|
expect(res.body).toMatchObject({ truncated: false, partial: false, capped: false, unavailable: [] });
|
|
expect(await countRows(orm, Places)).toBe(places);
|
|
expect(realtime.broadcastMock).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('names the kinds that could not be searched right now instead of reporting nothing found', async () => {
|
|
mapsPoisAlong.mockResolvedValue({
|
|
pois: [],
|
|
failed: ['viewpoint', 'shelter'],
|
|
partial: false,
|
|
truncated: false,
|
|
capped: false,
|
|
});
|
|
const res = await request(server)
|
|
.post('/api/trips/5/tours/poi-search')
|
|
.set('Cookie', sessionCookie(VIEWER))
|
|
.send({ ...body, categories: ['viewpoint', 'shelter', 'drinking_water'] });
|
|
expect(res.status).toBe(200);
|
|
expect(res.body).toEqual({
|
|
pois: [],
|
|
truncated: false,
|
|
partial: false,
|
|
capped: false,
|
|
unavailable: ['viewpoint', 'shelter'],
|
|
});
|
|
});
|
|
|
|
it('says how many seconds until asking again makes sense while the map search holds back', async () => {
|
|
mapsPoisAlong.mockResolvedValue({
|
|
pois: [],
|
|
failed: ['viewpoint'],
|
|
partial: false,
|
|
truncated: false,
|
|
capped: false,
|
|
retryAfterS: 20,
|
|
});
|
|
const res = await request(server)
|
|
.post('/api/trips/5/tours/poi-search')
|
|
.set('Cookie', sessionCookie(VIEWER))
|
|
.send({ ...body, categories: ['viewpoint'] });
|
|
expect(res.status).toBe(200);
|
|
expect(res.body).toEqual({
|
|
pois: [],
|
|
truncated: false,
|
|
partial: false,
|
|
capped: false,
|
|
unavailable: ['viewpoint'],
|
|
retry_after_s: 20,
|
|
});
|
|
});
|
|
|
|
it('finds e-bike charging along a bike tour with what the point states, and only there (BIK-07)', async () => {
|
|
const charging = {
|
|
sockets: [{ type: 'schuko', count: 2, kw: null }],
|
|
capacity: null,
|
|
fee: false,
|
|
bicycle: 'designated',
|
|
access: 'customers',
|
|
};
|
|
const charger = {
|
|
...spring,
|
|
osm_id: 'node:8',
|
|
name: '',
|
|
category: 'ebike_charging',
|
|
poi_type: 'amenity=charging_station&bicycle=designated',
|
|
charging,
|
|
};
|
|
mapsPoisAlong.mockResolvedValue({
|
|
pois: [charger, spring],
|
|
failed: [],
|
|
partial: false,
|
|
truncated: false,
|
|
capped: false,
|
|
});
|
|
const res = await request(server)
|
|
.post('/api/trips/5/tours/poi-search')
|
|
.set('Cookie', sessionCookie(VIEWER))
|
|
.send({ ...body, tour_type: 'bike', categories: ['ebike_charging', 'drinking_water'], corridor_m: 1000 });
|
|
expect(res.status).toBe(200);
|
|
expect(mapsPoisAlong.mock.calls.at(-1)?.[0]).toEqual(['ebike_charging', 'drinking_water']);
|
|
expect(res.body.pois).toEqual([
|
|
{
|
|
id: 'node:8',
|
|
name: '',
|
|
lat: 47.01,
|
|
lng: 11.001,
|
|
category: 'ebike_charging',
|
|
kind: 'amenity=charging_station&bicycle=designated',
|
|
source: 'openstreetmap',
|
|
address: null,
|
|
website: null,
|
|
phone: null,
|
|
opening_hours: null,
|
|
distance_m: expect.any(Number),
|
|
along_m: expect.any(Number),
|
|
charging,
|
|
},
|
|
expect.not.objectContaining({ charging: expect.anything() }),
|
|
]);
|
|
});
|
|
|
|
it('404 for someone outside the trip, 400 for a body it does not know, 401 without a session', async () => {
|
|
const outsider = await request(server)
|
|
.post('/api/trips/5/tours/poi-search')
|
|
.set('Cookie', sessionCookie(OUTSIDER))
|
|
.send(body);
|
|
expect(outsider.status).toBe(404);
|
|
const bad = [
|
|
{ ...body, categories: ['fuel'] },
|
|
{ ...body, corridor_m: 9000 },
|
|
{ ...body, line: [[47, 11]] },
|
|
{ ...body, add: 1 },
|
|
];
|
|
// One after another: the server under test takes one connection at a time.
|
|
const refused = await bad.reduce<Promise<number[]>>(
|
|
async (done, sent) => [
|
|
...(await done),
|
|
(await request(server).post('/api/trips/5/tours/poi-search').set('Cookie', sessionCookie(OWNER)).send(sent))
|
|
.status,
|
|
],
|
|
Promise.resolve([]),
|
|
);
|
|
expect(refused).toEqual([400, 400, 400, 400]);
|
|
expect((await request(server).post('/api/trips/5/tours/poi-search').send(body)).status).toBe(401);
|
|
});
|
|
});
|
|
});
|