/** * MAPS-ALONG-010..019: places near a line (PLN-02), from the index in circles * along it and from Overpass, in stretches of the whole line, for the kinds * the index does not know. After every Overpass mirror failed, its kinds are * named unavailable at once for a cooldown instead of after its deadline, * unless Overpass answered meanwhile, the stretch is still cached or a probe * is due; the answer then says how many seconds until it is asked again. * * The index is asked through a stub here, Overpass through a spy on the OSM * client: these cases are about who is asked for what, and how a source that * fails is reported instead of reading as nothing found. */ import type { AppSettingsRepository } from '../../../src/db/repositories/AppSettings.repository'; import type { UsersRepository } from '../../../src/db/repositories/Users.repository'; import { ownedByAsked } from '../../../src/nest/maps/maps-index.helpers'; import { OVERPASS_ALONG_COOLDOWN_MS } from '../../../src/nest/maps/providers/osm.client'; import { INDEX_MAX_CATEGORY_CHARS, INDEX_MAX_LIMIT } from '../../../src/nest/maps/trek-places.client'; import type { PlacePhotoCacheService } from '../../../src/nest/place-photos/place-photo-cache.service'; import { noGoogleQuota } from '../../helpers/google-quota'; import { buildMapsParts } from '../../helpers/maps-service'; import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'; const { mockNearby, mockHighlights, logWarn } = vi.hoisted(() => ({ logWarn: vi.fn(), mockHighlights: vi.fn( async ( _lat: number, _lng: number, _opts?: { radius?: number; limit?: number; lang?: string }, ): Promise<{ highlights: unknown[]; qrankRelease: string | null }> => ({ highlights: [], qrankRelease: null }), ), mockNearby: vi.fn( async ( _lat: number, _lng: number, _opts?: { radius?: number; limit?: number; category?: string }, ): Promise => [], ), })); // The log line is the operator's only trace of a source that failed; the logger itself writes to trek.log. vi.mock('../../../src/nest/audit/audit-log.logger', async (importOriginal) => ({ ...(await importOriginal()), logWarn, })); vi.mock('../../../src/nest/maps/trek-places.client', async (importOriginal) => ({ ...(await importOriginal()), trekPlacesNearby: mockNearby, trekPlacesHighlights: mockHighlights, })); const noAppSettings = { getValue: async () => null } as unknown as AppSettingsRepository; const noUsers = { getApiKeyColumn: async () => null } as unknown as UsersRepository; // Just under 3 km due north at 500 m: four circles about a kilometre apart, each reaching 1000 m. const LINE = [ { lat: 47, lng: 11 }, { lat: 47.0269, lng: 11 }, ]; /** An index row of one category path. */ function row(gers: string, name: string, categoryPath: string, over: Record = {}) { return { gers, name, lat: 47.01, lng: 11.001, category: categoryPath.slice(categoryPath.lastIndexOf('>') + 1), categoryPath, confidence: 0.9, address: null, contact: null, brand: null, source: 'overture', hours: null, distanceMetres: 100, ...over, }; } const CAFE = 'food_and_drink>casual_eatery>cafe'; const MUSEUM = 'arts_and_entertainment>museum'; const SPRING = { osm_id: 'node:7', name: '', lat: 47.012, lng: 11.002, 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' as const, }; const ORIGINAL_TREK_PLACES = process.env.TREK_PLACES_ENABLED; function make(enabled = true) { if (enabled) delete process.env.TREK_PLACES_ENABLED; else process.env.TREK_PLACES_ENABLED = 'false'; const { svc, osm } = buildMapsParts( {} as PlacePhotoCacheService, noAppSettings, noUsers, {} as never, {} as never, noGoogleQuota, ); const overpass = vi .spyOn(osm, 'searchOverpassPoisAlong') .mockResolvedValue({ pois: [SPRING], source: 'openstreetmap', truncated: false, clamped: false }); return { svc, overpass, osm }; } /** The lines logged as warnings. */ const mapsWarnings = () => logWarn.mock.calls.map((call) => String(call[0])); /** What every Overpass mirror answers while it is down. */ const DOWN = { ok: false, status: 504, json: async () => ({}) }; /** How many different Overpass queries a stubbed fetch was sent; each goes to every mirror. */ const queriesSent = (fetchMock: { mock: { calls: unknown[][] } }) => new Set(fetchMock.mock.calls.map((call) => decodeURIComponent(String((call[1] as RequestInit).body)))).size; /** A line due north from 47°N 11°E, `degrees` of latitude long: about 111 km each. */ const north = (degrees: number) => [ { lat: 47, lng: 11 }, { lat: 47 + degrees, lng: 11 }, ]; /** Counts the Overpass queries in flight, each answering after a turn of the event loop. */ function inFlight(overpass: ReturnType['overpass']) { const seen = { now: 0, most: 0 }; overpass.mockImplementation(async () => { seen.now += 1; seen.most = Math.max(seen.most, seen.now); await new Promise((resolve) => setTimeout(resolve, 5)); seen.now -= 1; return { pois: [SPRING], source: 'openstreetmap', truncated: false, clamped: false }; }); return seen; } beforeEach(() => { mockNearby.mockReset(); mockNearby.mockResolvedValue([]); mockHighlights.mockReset(); mockHighlights.mockResolvedValue({ highlights: [], qrankRelease: null }); logWarn.mockClear(); }); afterEach(() => { if (ORIGINAL_TREK_PLACES === undefined) delete process.env.TREK_PLACES_ENABLED; else process.env.TREK_PLACES_ENABLED = ORIGINAL_TREK_PLACES; }); describe('MapsService.poisAlong', () => { it('MAPS-ALONG-010: asks the index in every circle for its kinds only, and Overpass once for the rest', async () => { const { svc, overpass } = make(); const out = await svc.poisAlong(['cafe', 'drinking_water'], LINE, 500, 'de', 30); expect(mockNearby).toHaveBeenCalledTimes(4); const centres = mockNearby.mock.calls.map(([lat, lng]) => [Number(lat.toFixed(3)), Number(lng.toFixed(3))]); expect(centres).toEqual([ [47, 11], [47.009, 11], [47.018, 11], [47.027, 11], ]); for (const [, , opts] of mockNearby.mock.calls) { expect(opts).toEqual({ radius: 1000, limit: 30, category: 'food_and_drink>casual_eatery>cafe,food_and_drink>non_alcoholic_beverage_venue>coffee_shop', }); } expect(overpass).toHaveBeenCalledTimes(1); expect(overpass).toHaveBeenCalledWith('drinking_water', LINE, 500, 'de', 30); // The unnamed spring stays: a tap is what a walk looks for. expect(out).toEqual({ pois: [SPRING], failed: [], partial: false, truncated: false, capped: false }); }); it('MAPS-ALONG-011: a walk asks one request per kind when they would not fit one, each inside the limits', async () => { const { svc, overpass } = make(); await svc.poisAlong(['sights', 'museum', 'park', 'cafe', 'restaurant', 'market'], LINE, 500, 'de', 30); // Six kinds in four circles; none of them is asked of Overpass. expect(mockNearby).toHaveBeenCalledTimes(24); for (const [, , opts] of mockNearby.mock.calls) { expect(opts?.limit).toBe(30); expect(opts?.limit).toBeLessThanOrEqual(INDEX_MAX_LIMIT); expect(opts?.category?.length).toBeLessThanOrEqual(INDEX_MAX_CATEGORY_CHARS); } expect(mockNearby.mock.calls.slice(0, 6).map(([, , opts]) => opts?.category)).toEqual([ 'cultural_and_historic>historic_site,cultural_and_historic>memorial_site>monument', 'arts_and_entertainment>museum,arts_and_entertainment>arts_and_crafts_space>art_gallery,arts_and_entertainment>performing_arts_venue,arts_and_entertainment>movie_theater', 'sports_and_recreation>park,geographic_entities>built_feature>garden', 'food_and_drink>casual_eatery>cafe,food_and_drink>non_alcoholic_beverage_venue>coffee_shop', 'food_and_drink>restaurant,food_and_drink>casual_eatery', 'shopping>market', ]); // An empty circle is an answer: Overpass is never asked for what the index knows. expect(overpass).not.toHaveBeenCalled(); }); it('MAPS-ALONG-011b: kinds that would fit one request are still asked one by one, so a market is not crowded out', async () => { const { svc } = make(); await svc.poisAlong(['restaurant', 'cafe', 'market'], LINE, 500, 'de', 30); expect(mockNearby).toHaveBeenCalledTimes(12); expect(mockNearby.mock.calls.slice(0, 3).map(([, , opts]) => [opts?.category, opts?.limit])).toEqual([ ['food_and_drink>restaurant,food_and_drink>casual_eatery', 30], ['food_and_drink>casual_eatery>cafe,food_and_drink>non_alcoholic_beverage_venue>coffee_shop', 30], ['shopping>market', 30], ]); }); it('MAPS-ALONG-012: an index that answers no circle hands its kinds to Overpass once, and says why', async () => { mockNearby.mockRejectedValue(new Error('places api down')); const { svc, overpass } = make(); const seen = inFlight(overpass); const out = await svc.poisAlong(['cafe', 'drinking_water'], LINE, 500, 'de', 30); expect(overpass).toHaveBeenCalledTimes(2); expect(overpass).toHaveBeenLastCalledWith('cafe', LINE, 500, 'de', 30); // The index's kinds are asked while the others still are, not one deadline after the other. expect(seen.most).toBe(2); expect(out.failed).toEqual([]); // Nothing of the line was left out: Overpass searched all of it. expect(out.partial).toBe(false); expect(mapsWarnings()).toEqual([ expect.stringContaining('[Maps] TREK places index along a line: 4 of 4 requests failed: places api down'), ]); }); it('MAPS-ALONG-013: one circle failing keeps the places of the others and marks the answer partial', async () => { mockNearby.mockRejectedValueOnce('timeout').mockResolvedValue([row('c-1', 'Kaffeehaus', CAFE)]); const { svc, overpass } = make(); const out = await svc.poisAlong(['cafe'], LINE, 500, 'de', 30); expect(overpass).not.toHaveBeenCalled(); expect(out.partial).toBe(true); // The same cafe in three overlapping circles is one place. expect(out.pois.map((poi) => [poi.osm_id, poi.category])).toEqual([['gers:c-1', 'cafe']]); expect(mapsWarnings()).toEqual([expect.stringContaining('1 of 4 requests failed: timeout')]); }); it('MAPS-ALONG-014: Overpass failing names its kinds as failed, keeps the index places and is logged once', async () => { mockNearby.mockResolvedValue([row('c-1', 'Kaffeehaus', CAFE)]); const { svc, overpass } = make(); overpass.mockRejectedValue(new Error('Could not reach any Overpass endpoint')); const out = await svc.poisAlong(['cafe', 'viewpoint', 'drinking_water'], LINE, 500, 'de', 30); expect(out.failed).toEqual(['viewpoint', 'drinking_water']); expect(out.pois.map((poi) => poi.name)).toEqual(['Kaffeehaus']); expect(out.partial).toBe(false); expect(mapsWarnings()).toEqual([ expect.stringContaining( '[Maps] OpenStreetMap along a line: viewpoint, drinking_water: 1 of 1 requests failed: Could not reach any', ), ]); }); it('MAPS-ALONG-015: with the index switched off every kind goes to Overpass in one query', async () => { const { svc, overpass } = make(false); await svc.poisAlong(['cafe', 'drinking_water'], LINE, 500); expect(mockNearby).not.toHaveBeenCalled(); expect(overpass).toHaveBeenCalledTimes(1); expect(overpass).toHaveBeenCalledWith('cafe,drinking_water', LINE, 500, undefined, 30); }); it('MAPS-ALONG-016: each hit is labelled with the kind that produced it, its hours kept; a full page is cut', async () => { const hours = { osm: 'Tu-Su 10:00-18:00', source: 'openstreetmap', sourceUrl: null }; mockNearby.mockImplementation(async (_lat, _lng, opts) => opts?.category?.startsWith('arts') ? [ row('m-1', 'Lenbachhaus', MUSEUM, { hours }), ...Array.from({ length: 29 }, (_, i) => row(`m-${i + 2}`, `Museum ${i}`, MUSEUM)), ] : opts?.category?.startsWith('sports') ? [ row('p-1', 'Englischer Garten', 'sports_and_recreation>park'), row('p-2', 'Therme Erding', 'sports_and_recreation>park>water_park'), ] : [row('s-1', 'Siegestor', 'cultural_and_historic>memorial_site>monument')], ); const { svc } = make(); const out = await svc.poisAlong(['sights', 'museum', 'park'], LINE, 500, 'de', 30); expect(out.truncated).toBe(true); const byName = new Map(out.pois.map((poi) => [poi.name, poi])); expect(byName.get('Lenbachhaus')).toMatchObject({ category: 'museum', opening_hours: 'Tu-Su 10:00-18:00' }); expect(byName.get('Siegestor')).toMatchObject({ category: 'sights', opening_hours: null }); expect(byName.get('Englischer Garten')).toMatchObject({ category: 'park' }); // A water park lies under the parks' path, but it is the activity pill's: no park of a walk. expect(byName.has('Therme Erding')).toBe(false); }); it('MAPS-ALONG-016b: a row goes to the kind that names its path most closely, a row no kind knows is left as it is', () => { const waterPark = { category: 'water_park', categoryPath: 'sports_and_recreation>park>water_park' }; expect(ownedByAsked(waterPark, ['park'])).toBe(false); expect(ownedByAsked(waterPark, ['park', 'activity'])).toBe(true); expect(ownedByAsked({ category: 'park', categoryPath: 'sports_and_recreation>park' }, ['park'])).toBe(true); // Judged by its leaf where the index left the path empty. expect(ownedByAsked({ category: 'water_park', categoryPath: null }, ['park'])).toBe(false); expect(ownedByAsked({ category: null, categoryPath: null }, ['park'])).toBe(true); expect(ownedByAsked({ category: 'pier', categoryPath: 'travel>pier' }, ['park'])).toBe(true); }); it('MAPS-ALONG-017: an index and an Overpass that both fail name every kind as failed', async () => { mockNearby.mockRejectedValue(new Error('places api down')); const { svc, overpass } = make(); overpass.mockRejectedValue(new Error('Could not reach any Overpass endpoint')); const out = await svc.poisAlong(['cafe', 'viewpoint'], LINE, 500, 'de', 30); expect(out).toEqual({ pois: [], failed: ['viewpoint', 'cafe'], partial: false, truncated: false, capped: false }); expect(mapsWarnings()).toHaveLength(3); }); it('MAPS-ALONG-018: a line longer than the circles reach has its index kinds searched along its start, and says so', async () => { const { svc, overpass } = make(); const long = north(1); const out = await svc.poisAlong(['cafe', 'viewpoint'], long, 250, 'de', 30); expect(out.capped).toBe(true); expect(mockNearby).toHaveBeenCalledTimes(24); expect(Math.max(...mockNearby.mock.calls.map(([lat]) => lat))).toBeLessThan(47.32); // Overpass searches the whole line in three stretches of about 37 km, the last one ending where the line does. expect(overpass).toHaveBeenCalledTimes(3); const stretches = overpass.mock.calls.map((call) => call[1]); expect(stretches[0]?.[0]).toEqual(long[0]); expect(stretches[1]?.[0]).toEqual(stretches[0]?.at(-1)); expect(stretches[2]?.[0]).toEqual(stretches[1]?.at(-1)); expect(stretches[2]?.at(-1)).toEqual(long[1]); }); it('MAPS-ALONG-019: the kinds Overpass answers are searched along the whole line, a few stretches at a time', async () => { const { svc, overpass } = make(); const seen = inFlight(overpass); const ride = await svc.poisAlong(['drinking_water', 'toilets'], north(1), 500, 'de', 30); expect(ride).toMatchObject({ capped: false, partial: false, failed: [] }); expect(overpass.mock.calls.map((call) => call[0])).toEqual([ 'drinking_water,toilets', 'drinking_water,toilets', 'drinking_water,toilets', ]); // An index that answers nothing leaves its kinds to Overpass, which reaches the whole line. overpass.mockClear(); mockNearby.mockRejectedValue(new Error('places api down')); const fallback = await svc.poisAlong(['cafe'], north(1), 500, 'de', 30); expect(fallback).toMatchObject({ capped: false, failed: [] }); expect(overpass).toHaveBeenCalledTimes(3); // Past 400 km the line is searched along its start; never more than three stretches are in flight. overpass.mockClear(); seen.most = 0; const crossing = await svc.poisAlong(['viewpoint'], north(4.5), 500, 'de', 30); expect(crossing.capped).toBe(true); expect(overpass).toHaveBeenCalledTimes(8); expect(seen.most).toBe(3); }); it('MAPS-ALONG-019c: after every Overpass mirror failed, the next searches name its kinds at once and say when to retry', async () => { vi.useFakeTimers({ now: new Date('2026-10-19T10:00:00Z') }); vi.spyOn(console, 'error').mockImplementation(() => {}); // Mirrors that never answer: each request waits out its deadline and is aborted. const fetchMock = vi.fn( (_url: unknown, init?: RequestInit) => new Promise((_resolve, reject) => init?.signal?.addEventListener('abort', () => reject(new Error('aborted')))), ); vi.stubGlobal('fetch', fetchMock); mockNearby.mockResolvedValue([row('c-1', 'Kaffeehaus', CAFE)]); const { svc, overpass } = make(); overpass.mockRestore(); try { const first = svc.poisAlong(['cafe', 'viewpoint', 'drinking_water'], LINE, 500, 'de', 30); // The four mirrors asked a second and a half apart, each waiting out its seventeen seconds. await vi.advanceTimersByTimeAsync(25_000); expect(await first).toMatchObject({ failed: ['viewpoint', 'drinking_water'], partial: false, retryAfterS: 20 }); const asked = fetchMock.mock.calls.length; expect(asked).toBe(4); // Without waiting for any deadline: nothing is asked, the index places stay, the kinds are named. const again = await svc.poisAlong(['cafe', 'viewpoint', 'drinking_water'], LINE, 500, 'de', 30); const hike = await svc.poisAlong(['viewpoint', 'shelter'], north(0.1), 500, 'de', 30); expect(fetchMock).toHaveBeenCalledTimes(asked); // Three and a half seconds after the failure, the first probe is due in sixteen and a half. expect(again).toMatchObject({ failed: ['viewpoint', 'drinking_water'], partial: false, retryAfterS: 17 }); expect(again.pois.map((poi) => poi.name)).toEqual(['Kaffeehaus']); expect(hike.failed).toEqual(['viewpoint', 'shelter']); // The search that waited out its deadline says why; the skips after it are one line for the // whole cooldown, three minutes from that failure. expect(mapsWarnings()).toEqual([ expect.stringContaining('[Maps] OpenStreetMap along a line: viewpoint, drinking_water: 1 of 1 requests failed'), expect.stringContaining('so only a probe now and then asks it until 2026-10-19T10:03:21.500Z'), ]); // After the cooldown it is asked again for real, and an answer ends the pause for good. vi.advanceTimersByTime(OVERPASS_ALONG_COOLDOWN_MS); fetchMock.mockResolvedValue({ ok: true, json: async () => ({ elements: [] }) }); const later = await svc.poisAlong(['viewpoint'], LINE, 500, 'de', 30); expect(later.failed).toEqual([]); expect(later).not.toHaveProperty('retryAfterS'); expect(fetchMock.mock.calls.length).toBeGreaterThan(asked); const answered = fetchMock.mock.calls.length; await svc.poisAlong(['shelter'], LINE, 500, 'de', 30); expect(fetchMock.mock.calls.length).toBeGreaterThan(answered); expect(mapsWarnings()).toHaveLength(2); } finally { vi.useRealTimers(); vi.unstubAllGlobals(); vi.restoreAllMocks(); } }); it('MAPS-ALONG-019b: one stretch failing keeps the places of the others and marks the answer partial', async () => { const { svc, overpass } = make(); overpass.mockRejectedValueOnce(new Error('rate limited')); const out = await svc.poisAlong(['drinking_water'], north(1), 500, 'de', 30); expect(out).toMatchObject({ pois: [SPRING], failed: [], partial: true, capped: false }); expect(mapsWarnings()).toEqual([ expect.stringContaining( '[Maps] OpenStreetMap along a line: drinking_water: 1 of 3 requests failed: rate limited', ), ]); }); it('MAPS-ALONG-019d: a stretch failing after the others answered starts no cooldown, so the rest of a long line is asked', async () => { vi.spyOn(console, 'error').mockImplementation(() => {}); // The first of five stretches fails on every mirror, after the two asked beside it answered. const fetchMock = vi.fn(async (_url: unknown, init?: RequestInit) => { const first = decodeURIComponent(String(init?.body)).includes('47.00000,11.00000'); await new Promise((resolve) => setTimeout(resolve, first ? 30 : 5)); return first ? DOWN : { ok: true, json: async () => ({ elements: [] }) }; }); vi.stubGlobal('fetch', fetchMock); const { svc, overpass, osm } = make(); overpass.mockRestore(); try { const out = await svc.poisAlong(['viewpoint'], north(2), 500, 'de', 30); expect(out).toMatchObject({ failed: [], partial: true }); // Stretches 4 and 5 are asked as well: Overpass answered while the first one was failing. expect(queriesSent(fetchMock)).toBe(5); expect(osm.skipsOverpassAlong()).toBe(false); expect(mapsWarnings()).toEqual([ expect.stringContaining('OpenStreetMap along a line: viewpoint: 1 of 5 requests failed: Could not reach any'), ]); } finally { vi.unstubAllGlobals(); vi.restoreAllMocks(); } }); it('MAPS-ALONG-019e: a line answered before the cooldown keeps its Overpass places during it, from the cache', async () => { vi.useFakeTimers({ now: new Date('2026-10-19T11:00:00Z'), toFake: ['Date'] }); vi.spyOn(console, 'error').mockImplementation(() => {}); const view = { type: 'node', id: 77, lat: 47.01, lon: 12, tags: { tourism: 'viewpoint', name: 'Aussicht' } }; const fetchMock = vi .fn<(url: unknown, init?: RequestInit) => Promise>() .mockResolvedValue({ ok: true, json: async () => ({ elements: [view] }) }); vi.stubGlobal('fetch', fetchMock); const { svc, overpass } = make(); overpass.mockRestore(); const at = (lng: number) => [ { lat: 47, lng }, { lat: 47.0269, lng }, ]; try { const first = await svc.poisAlong(['viewpoint'], at(12), 500, 'de', 30); expect(first.pois.map((poi) => poi.name)).toEqual(['Aussicht']); // A second later every mirror fails another line, and the cooldown starts. vi.setSystemTime(new Date('2026-10-19T11:00:01Z')); fetchMock.mockResolvedValue(DOWN); expect((await svc.poisAlong(['viewpoint'], at(12.5), 500, 'de', 30)).failed).toEqual(['viewpoint']); const asked = fetchMock.mock.calls.length; // Ten seconds on, before the first probe, the first line is answered from the cache as before; a // line not asked yet is named at once. vi.setSystemTime(new Date('2026-10-19T11:00:11Z')); const again = await svc.poisAlong(['viewpoint'], at(12), 500, 'de', 30); expect(again).toMatchObject({ failed: [], partial: false }); expect(again.pois.map((poi) => poi.name)).toEqual(['Aussicht']); expect((await svc.poisAlong(['viewpoint'], at(13), 500, 'de', 30)).failed).toEqual(['viewpoint']); expect(fetchMock).toHaveBeenCalledTimes(asked); expect(mapsWarnings()).toEqual([ expect.stringContaining('OpenStreetMap along a line: viewpoint: 1 of 1 requests failed: Could not reach any'), expect.stringContaining('so only a probe now and then asks it until 2026-10-19T11:03:01.000Z'), ]); } finally { vi.useRealTimers(); vi.unstubAllGlobals(); vi.restoreAllMocks(); } }); it('MAPS-ALONG-019f: the stretches a cooldown leaves out are counted, and the log names why the first ones failed', async () => { vi.spyOn(console, 'error').mockImplementation(() => {}); const fetchMock = vi.fn(async (_url: unknown, _init?: RequestInit) => DOWN); vi.stubGlobal('fetch', fetchMock); const { svc, overpass } = make(); overpass.mockRestore(); try { const out = await svc.poisAlong(['shelter'], north(2), 500, 'de', 30); expect(out).toMatchObject({ pois: [], failed: ['shelter'], partial: false }); // Stretches 4 and 5 are not sent: every mirror had just failed the first three. expect(queriesSent(fetchMock)).toBe(3); expect(mapsWarnings()).toEqual([ expect.stringContaining('every Overpass endpoint failed, so only a probe now and then asks it until'), expect.stringContaining('OpenStreetMap along a line: shelter: 5 of 5 requests failed: Could not reach any'), ]); } finally { vi.unstubAllGlobals(); vi.restoreAllMocks(); } }); }); describe('MapsService.highlightsAlong', () => { /** A well known place of the index's OpenStreetMap layer. */ const famous = (osmType: string, osmId: number, qrank: number) => ({ osmType, osmId, name: `${osmType} ${osmId}`, lat: 47.01, lng: 11, category: 'sehenswuerdigkeit', osmTag: 'place=square', wikidata: 'Q1', qrank, distanceMetres: 10, }); it('MAPS-ALONG-030: asks the best known places in the circles the kinds are asked in, each place once', async () => { const { svc } = make(); mockHighlights .mockResolvedValueOnce({ highlights: [famous('way', 1, 900), famous('node', 1, 50)], qrankRelease: null }) .mockResolvedValueOnce({ highlights: [famous('way', 1, 900), famous('relation', 2, 70)], qrankRelease: null }); const out = await svc.highlightsAlong(LINE, 500, 'de'); expect(mockHighlights).toHaveBeenCalledTimes(4); for (const [, , opts] of mockHighlights.mock.calls) expect(opts).toEqual({ radius: 1000, limit: 20, lang: 'de' }); expect(out.map((row) => `${row.osmType}:${row.osmId}`)).toEqual(['way:1', 'node:1', 'relation:2']); expect(mockNearby).not.toHaveBeenCalled(); }); it('MAPS-ALONG-031: a circle failing keeps the others, an index down or switched off answers none, never an error', async () => { const { svc } = make(); mockHighlights .mockRejectedValueOnce(new Error('TREK Places API 503')) .mockResolvedValue({ highlights: [famous('way', 1, 900)], qrankRelease: null }); expect((await svc.highlightsAlong(LINE, 500)).map((row) => row.osmId)).toEqual([1]); expect(mapsWarnings()).toEqual(['[Maps] TREK places highlights along a line: TREK Places API 503']); mockHighlights.mockReset(); mockHighlights.mockRejectedValue(new Error('timeout')); await expect(svc.highlightsAlong(LINE, 500)).resolves.toEqual([]); mockHighlights.mockClear(); const off = make(false); await expect(off.svc.highlightsAlong(LINE, 500)).resolves.toEqual([]); expect(mockHighlights).not.toHaveBeenCalled(); }); });