/** * HikeWaysMcp and HikeWaysService: the planner's round hikes of a wished * length and its other ways for one leg, over MCP. The search is the shared * one, asked of a stubbed RoadtripRouterService that walks straight between * the points it is given; each way found is proposed through a stub of * HikePlanService.propose (its own suite plans the hike). The trip and a * saved hike are seeded through the ORM factories over a snapshot test db. */ import type { McpContext } from '../../../src/nest-mcp'; import { RoadtripRouterService, RouteRefusal } from '../../../src/nest/roadtrip/roadtrip-router.service'; import { HikePlanService } from '../../../src/nest/tours/hike-plan.service'; import { HikeWaysMcp } from '../../../src/nest/tours/hike-ways.mcp'; import { ToursModule } from '../../../src/nest/tours/tours.module'; import { createSnapshotTestDb } from '../../helpers/db-mock'; import { makePlace } from '../../helpers/factories/places'; import { makeTour } from '../../helpers/factories/tours'; import { makeTrip } from '../../helpers/factories/trips'; import { makeUser } from '../../helpers/factories/users'; import { resetTestDb } from '../../helpers/test-db'; import { createTestModule, type TestModule } from '../../helpers/test-module'; import { MikroORM } from '@mikro-orm/core'; import type { HikeProposeRequest } from '@trek/shared'; import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'; // HIKE-WAYS-MCP-001 to HIKE-WAYS-MCP-009 type Spot = { lat: number; lng: number }; const db = createSnapshotTestDb(); const route = vi.fn(); const alternatesOnFoot = vi.fn(); const propose = vi.fn(); let t: TestModule; let mcp: HikeWaysMcp; const orm = () => t.get(MikroORM); /** The router's answer for points walked straight between, each met where it was asked. */ function straight(points: Spot[]) { return { leg: { line: points.map(({ lat, lng }): [number, number] => [lat, lng]), seg: { distance: 0, duration: 0 }, }, parts: points.slice(1).map(() => ({ distance: 0, duration: 0 })), snapped: points.map(({ lat, lng }) => ({ asked: [lat, lng], at: [lat, lng], meters: 0 })), avoidMissed: [], } as unknown as Awaited>; } /** The stub's proposal: the request's points given back, a length and a line. */ async function proposal(_userId: number, _tripId: number, request: HikeProposeRequest) { return { name: request.name, variant_label: request.variant_label ?? null, route: { planned: true }, distance_m: 10_400, ascent_m: 420, duration_minutes: 190, waypoints: request.waypoints, round_trip: request.round_trip ?? false, line_geometry: request.waypoints.map(({ lat, lng }): [number, number] => [lat, lng]), } as unknown as Awaited>; } beforeAll(async () => { t = await createTestModule({ db, imports: [ToursModule], overrides: [ { provide: RoadtripRouterService, useValue: { route, alternatesOnFoot } }, { provide: HikePlanService, useValue: { propose } }, ], }); mcp = t.get(HikeWaysMcp); }); beforeEach(() => { resetTestDb(db); route.mockReset().mockImplementation(async (_u, _t, _d, points) => straight(points)); alternatesOnFoot.mockReset(); propose.mockReset().mockImplementation(proposal); }); afterAll(async () => { await t.close(); db.close(); }); const ctx = (userId: number) => ({ userId }) as McpContext; /** The JSON a tool answered, or the error text it refused with. */ function read(result: { content: Array<{ type: string; text: string }>; isError?: boolean }) { const text = result.content[0]?.text ?? ''; return result.isError ? { error: text } : JSON.parse(text); } async function tripOf() { const { user } = await makeUser(orm()); const trip = await makeTrip(orm(), user.id); return { userId: user.id, tripId: trip.id }; } const START = { lat: 47.5, lng: 11.1, name: 'Car park' }; describe('propose_round_hike', () => { it('HIKE-WAYS-MCP-001: proposes the round asked for as a hike back to its start, with the points to create it', async () => { const { userId, tripId } = await tripOf(); const answer = read( await mcp.proposeRoundHike({ tripId, name: 'Round', start: START, distance_km: 10, round: 'b' }, ctx(userId)), ); expect(answer.found).toBe(true); expect(answer.round).toMatchObject({ key: 'b', target_m: 10_000, deviation_pct: 4, rounds_found: 3 }); expect(answer.create_with.round_trip).toBe(true); expect(answer.create_with.waypoints).toHaveLength(4); expect(answer.create_with.waypoints[0]).toEqual(START); const [, , asked] = propose.mock.calls[0] ?? []; expect(asked).toMatchObject({ name: 'Round', round_trip: true, along: false }); // Every loop was asked on foot under the hike's own costing, out of the start and back. for (const [, , , points, profile, , options] of route.mock.calls) { expect(points[0]).toEqual({ lat: START.lat, lng: START.lng }); expect(points.at(-1)).toEqual({ lat: START.lat, lng: START.lng }); expect(profile).toBe('walking'); expect(options?.costingOptions).toMatchObject({ max_hiking_difficulty: 2 }); } }); it('HIKE-WAYS-MCP-002: the rounds of one search are asked for one after another without asking the router again', async () => { const { userId, tripId } = await tripOf(); const request = { tripId, name: 'Round', start: START, distance_km: 10 }; await mcp.proposeRoundHike({ ...request, round: 'a' }, ctx(userId)); const asked = route.mock.calls.length; const c = read(await mcp.proposeRoundHike({ ...request, round: 'c' }, ctx(userId))); expect(c.round.key).toBe('c'); expect(route.mock.calls.length).toBe(asked); }); it('HIKE-WAYS-MCP-003: a router that never answers, or no Valhalla, finds no round and says why', async () => { const { userId, tripId } = await tripOf(); route.mockRejectedValue(new Error('down')); const down = read(await mcp.proposeRoundHike({ tripId, name: 'R', start: START, distance_km: 8 }, ctx(userId))); expect(down).toEqual({ found: false, way: 'a', ways_found: 0, why: 'router_unavailable' }); route.mockReset().mockRejectedValue(new RouteRefusal('no_valhalla', 'none')); const none = read(await mcp.proposeRoundHike({ tripId, name: 'R', start: START, distance_km: 9 }, ctx(userId))); expect(none.why).toBe('no_valhalla'); // Without a Valhalla the search stops at its first question. expect(route).toHaveBeenCalledTimes(1); expect(propose).not.toHaveBeenCalled(); }); it('HIKE-WAYS-MCP-004: a trip the caller cannot see is not found', async () => { const { tripId } = await tripOf(); const { user: stranger } = await makeUser(orm()); const answer = read( await mcp.proposeRoundHike({ tripId, name: 'R', start: START, distance_km: 8 }, ctx(stranger.id)), ); expect(answer.error).toBeDefined(); expect(route).not.toHaveBeenCalled(); }); }); const A = { lat: 47.5, lng: 11.1, name: 'Car park' }; const B = { lat: 47.52, lng: 11.1, name: 'Hut' }; const OWN: Array<[number, number]> = [ [47.5, 11.1], [47.52, 11.1], ]; const OTHER: Array<[number, number]> = [ [47.5, 11.1], [47.51, 11.12], [47.52, 11.1], ]; describe('propose_hike_leg_way', () => { it('HIKE-WAYS-MCP-005: the other way of a leg is the whole hike with the way held by a pin, beside the hike as it runs', async () => { const { userId, tripId } = await tripOf(); alternatesOnFoot.mockResolvedValue([OWN, OTHER]); const answer = read( await mcp.proposeHikeLegWay( { tripId, name: 'Hike', waypoints: [A, B], leg: 1, include_geometry: true }, ctx(userId), ), ); expect(answer.found).toBe(true); expect(answer.leg_way).toEqual({ key: 'a', leg: 1, ways_found: 1, tour_id: null }); expect(answer.create_with).toEqual({ waypoints: [A, { lat: 47.51, lng: 11.12 }, B], round_trip: false }); expect(answer.current).toEqual({ distance_m: 10_400, ascent_m: 420, duration_minutes: 190 }); expect(answer.current_geometry).toHaveLength(2); const [, from, to, costing, count] = alternatesOnFoot.mock.calls[0] ?? []; expect([from, to, count]).toEqual([{ lat: A.lat, lng: A.lng }, { lat: B.lat, lng: B.lng }, 3]); expect(costing).toMatchObject({ max_hiking_difficulty: 2 }); }); it('HIKE-WAYS-MCP-006: a router that knows only its own way, or a way it does not keep to, offers none', async () => { const { userId, tripId } = await tripOf(); alternatesOnFoot.mockResolvedValue([OWN, OWN]); const same = read(await mcp.proposeHikeLegWay({ tripId, name: 'H', waypoints: [A, B], leg: 1 }, ctx(userId))); expect(same).toEqual({ found: false, way: 'a', ways_found: 0, why: 'none_found' }); alternatesOnFoot.mockResolvedValue([OWN, OTHER]); route.mockRejectedValue(new Error('down')); const held = read( await mcp.proposeHikeLegWay( { tripId, name: 'H', waypoints: [A, B], leg: 1, max_hiking_difficulty: 3 }, ctx(userId), ), ); expect(held.found).toBe(false); alternatesOnFoot.mockRejectedValue(new RouteRefusal('no_way', 'none')); const none = read( await mcp.proposeHikeLegWay( { tripId, name: 'H', waypoints: [A, B], leg: 1, max_hiking_difficulty: 4 }, ctx(userId), ), ); expect(none.why).toBe('no_way'); }); it('HIKE-WAYS-MCP-007: a leg the hike does not have is refused', async () => { const { userId, tripId } = await tripOf(); const answer = read(await mcp.proposeHikeLegWay({ tripId, name: 'H', waypoints: [A, B], leg: 2 }, ctx(userId))); expect(answer.error).toContain('no such leg'); expect(alternatesOnFoot).not.toHaveBeenCalled(); }); it('HIKE-WAYS-MCP-008: the way of a saved hike names that hike', async () => { const { userId, tripId } = await tripOf(); const place = await makePlace(orm(), tripId, { name: 'Saved hike', lat: A.lat, lng: A.lng }); await makeTour(orm(), place.id); alternatesOnFoot.mockResolvedValue([OWN, OTHER]); const answer = read( await mcp.proposeHikeLegWay({ tripId, name: 'H', waypoints: [A, B], leg: 1, tour_id: place.id }, ctx(userId)), ); expect(answer.leg_way.tour_id).toBe(place.id); }); it('HIKE-WAYS-MCP-009: a later call over the same spots asks the router nothing new, and its way follows its own points', async () => { const { userId, tripId } = await tripOf(); // The way back of a round trip, B to A. alternatesOnFoot.mockResolvedValue([[...OWN].reverse(), [...OTHER].reverse()]); const pin = { lat: 47.51, lng: 11.12 }; const round = read( await mcp.proposeHikeLegWay({ tripId, name: 'H', waypoints: [A, B], round_trip: true, leg: 2 }, ctx(userId)), ); expect(round.create_with).toEqual({ waypoints: [A, B, pin], round_trip: true }); const asked = route.mock.calls.length; // The same hike as get_tour_plan reads it: the way back given as its last point, and a night at the hut. const hut = { ...B, stage_end: true }; const saved = read(await mcp.proposeHikeLegWay({ tripId, name: 'H', waypoints: [A, hut, A], leg: 2 }, ctx(userId))); expect(alternatesOnFoot).toHaveBeenCalledTimes(1); expect(route.mock.calls.length).toBe(asked); expect(saved.leg_way).toMatchObject({ key: 'a', leg: 2, ways_found: 1 }); expect(saved.create_with).toEqual({ waypoints: [A, hut, pin, A], round_trip: false }); expect(propose.mock.calls.at(-1)?.[2]).toMatchObject({ waypoints: [A, hut, pin, A], round_trip: false }); }); });