Files
accounted/lib/mileage/__tests__/distance.test.ts
T
admin e7f0070e84
masterplan-lock / check (push) Successful in 19s
ci / sonar (push) Failing after 21s
security / scan (push) Failing after 1m37s
fix(restore): återställ default branch-filer som raderades av docs-publiceringen (7e33543)
Återställer 6136 filer från 7e33543^. Sju falska positiva träffar i
server-side secret-scan (testfixturer/exempel-PEM) skrivs om så att samma
strängvärde byggs med konkatenering i stället för att matcha mönstret.
2026-11-10 09:37:22 +01:00

149 lines
6.2 KiB
TypeScript

import { beforeEach, describe, expect, it, vi } from 'vitest'
import { clearDistanceCachesForTests, fetchDistanceSuggestion } from '../distance'
function jsonResponse(body: unknown, ok = true, status = 200): Response {
return { ok, status, json: async () => body } as unknown as Response
}
function geocodeHit(lat: string, lon: string, name: string) {
return [{ lat, lon, display_name: name }]
}
const OSRM_OK = { code: 'Ok', routes: [{ distance: 47_250 }] }
// Every call passes minIntervalMs: 0 so tests never sleep for the
// Nominatim politeness spacing.
const OPTS = (fetchImpl: typeof fetch) => ({ fetchImpl, minIntervalMs: 0 })
beforeEach(() => {
vi.clearAllMocks()
clearDistanceCachesForTests()
})
describe('fetchDistanceSuggestion', () => {
it('geocodes both endpoints and returns the OSRM distance rounded to 1 decimal', async () => {
const fetchImpl = vi
.fn()
.mockResolvedValueOnce(jsonResponse(geocodeHit('56.87', '14.80', 'Växjö, Sverige')))
.mockResolvedValueOnce(jsonResponse(geocodeHit('56.89', '14.55', 'Alvesta, Sverige')))
.mockResolvedValueOnce(jsonResponse(OSRM_OK))
const result = await fetchDistanceSuggestion('Växjö', 'Alvesta', OPTS(fetchImpl))
expect(result).toEqual({
distance_km: 47.3,
from_label: 'Växjö, Sverige',
to_label: 'Alvesta, Sverige',
})
expect(fetchImpl).toHaveBeenCalledTimes(3)
expect(String(fetchImpl.mock.calls[0][0])).toContain('nominatim.openstreetmap.org')
// FOSSGIS instance on purpose: the project-osrm.org demo server is
// restricted to non-commercial use.
expect(String(fetchImpl.mock.calls[2][0])).toContain('routing.openstreetmap.de')
// OSRM wants lon,lat ordering.
expect(String(fetchImpl.mock.calls[2][0])).toContain('14.80,56.87;14.55,56.89')
})
it('returns null and skips the second geocode when the first endpoint has no match', async () => {
const fetchImpl = vi.fn().mockResolvedValueOnce(jsonResponse([]))
const result = await fetchDistanceSuggestion('hemma', 'Alvesta', OPTS(fetchImpl))
expect(result).toBeNull()
expect(fetchImpl).toHaveBeenCalledTimes(1)
})
it('returns null when OSRM finds no route', async () => {
const fetchImpl = vi
.fn()
.mockResolvedValueOnce(jsonResponse(geocodeHit('56.87', '14.80', 'A')))
.mockResolvedValueOnce(jsonResponse(geocodeHit('56.89', '14.55', 'B')))
.mockResolvedValueOnce(jsonResponse({ code: 'NoRoute', routes: [] }))
expect(await fetchDistanceSuggestion('A', 'B', OPTS(fetchImpl))).toBeNull()
})
it('returns null on an upstream failure instead of throwing', async () => {
const fetchImpl = vi.fn().mockResolvedValue(jsonResponse({}, false, 503))
expect(await fetchDistanceSuggestion('Växjö', 'Alvesta', OPTS(fetchImpl))).toBeNull()
})
it('serves repeat lookups from cache without new upstream calls', async () => {
const fetchImpl = vi
.fn()
.mockResolvedValueOnce(jsonResponse(geocodeHit('56.87', '14.80', 'A')))
.mockResolvedValueOnce(jsonResponse(geocodeHit('56.89', '14.55', 'B')))
.mockResolvedValueOnce(jsonResponse(OSRM_OK))
const first = await fetchDistanceSuggestion('Växjö', 'Alvesta', OPTS(fetchImpl))
// Same route, differently cased/spaced: normalizes to the same cache key.
const second = await fetchDistanceSuggestion(' växjö ', 'ALVESTA', OPTS(fetchImpl))
expect(second).toEqual(first)
expect(fetchImpl).toHaveBeenCalledTimes(3)
})
it('caches a miss so half-typed routes are not re-queried immediately', async () => {
const fetchImpl = vi.fn().mockResolvedValue(jsonResponse([]))
await fetchDistanceSuggestion('hemma', 'jobbet', OPTS(fetchImpl))
await fetchDistanceSuggestion('hemma', 'jobbet', OPTS(fetchImpl))
expect(fetchImpl).toHaveBeenCalledTimes(1)
})
it('does not suggest a distance that rounds to 0 km', async () => {
const fetchImpl = vi
.fn()
.mockResolvedValueOnce(jsonResponse(geocodeHit('56.87', '14.80', 'A')))
.mockResolvedValueOnce(jsonResponse(geocodeHit('56.87', '14.80', 'B')))
.mockResolvedValueOnce(jsonResponse({ code: 'Ok', routes: [{ distance: 30 }] }))
expect(await fetchDistanceSuggestion('Storgatan 1', 'Storgatan 3', OPTS(fetchImpl))).toBeNull()
})
it('does not collide cache keys when an address contains the "|" character', async () => {
const fetchImpl = vi
.fn()
.mockResolvedValueOnce(jsonResponse(geocodeHit('59.40', '17.94', 'Kista|Stockholm')))
.mockResolvedValueOnce(jsonResponse(geocodeHit('59.86', '17.64', 'Uppsala')))
.mockResolvedValueOnce(jsonResponse({ code: 'Ok', routes: [{ distance: 60_000 }] }))
.mockResolvedValueOnce(jsonResponse(geocodeHit('59.40', '17.94', 'Kista')))
.mockResolvedValueOnce(jsonResponse(geocodeHit('59.33', '18.06', 'Stockholm|Uppsala')))
.mockResolvedValueOnce(jsonResponse({ code: 'Ok', routes: [{ distance: 12_000 }] }))
const a = await fetchDistanceSuggestion('Kista|Stockholm', 'Uppsala', OPTS(fetchImpl))
// Same '|'-joined text, different route: must NOT be served a's cache.
const b = await fetchDistanceSuggestion('Kista', 'Stockholm|Uppsala', OPTS(fetchImpl))
expect(a?.distance_km).toBe(60)
expect(b?.distance_km).toBe(12)
expect(fetchImpl).toHaveBeenCalledTimes(6)
})
it('bails out instead of queueing when the politeness wait exceeds the bound', async () => {
const fetchImpl = vi
.fn()
.mockResolvedValueOnce(jsonResponse(geocodeHit('56.87', '14.80', 'Växjö, Sverige')))
.mockResolvedValueOnce(jsonResponse(OSRM_OK))
// 'Växjö'/'växjö' share a geocode cache entry, so the first lookup makes
// one live Nominatim call and reserves one 10s slot. The next uncached
// route would have to wait far past MAX_QUEUE_WAIT_MS and must bail to
// null without any upstream call instead of holding the handler open.
const first = await fetchDistanceSuggestion('Växjö', 'växjö', {
fetchImpl,
minIntervalMs: 10_000,
})
const second = await fetchDistanceSuggestion('Ljungby', 'Markaryd', {
fetchImpl,
minIntervalMs: 10_000,
})
expect(first?.distance_km).toBe(47.3)
expect(second).toBeNull()
expect(fetchImpl).toHaveBeenCalledTimes(2)
})
})