mirror of
https://github.com/mauriceboe/TREK.git
synced 2026-10-23 15:36:33 +00:00
jubnl
1259 lines
47 KiB
TypeScript
1259 lines
47 KiB
TypeScript
/**
|
|
* The pure half of the Dawarich integration — DAWARICH-TIME-001 through
|
|
* DAWARICH-CITIES-006. Everything under test is a free function over plain
|
|
* fixtures: no DB, no container, and no client. `dawarich.client` appears here
|
|
* only as a type-only import (erased at compile time), so nothing in this file
|
|
* can reach the network even by accident — there is no DawarichClient instance
|
|
* to mock because the helpers never construct one.
|
|
*
|
|
* Every timestamp is written with an explicit offset (`Z` or `+HH:MM`) so the
|
|
* cases mean the same thing on a CI runner in UTC and on a laptop in Berlin.
|
|
*/
|
|
import type {
|
|
DawarichSlimPoint,
|
|
DawarichTrackFeature,
|
|
DawarichVisitRaw,
|
|
} from '../../../src/nest/integrations/dawarich.client';
|
|
import {
|
|
bucketPointsByDay,
|
|
bucketTracksByDay,
|
|
capPoints,
|
|
countPoints,
|
|
distanceMeters,
|
|
geoJsonToLatLng,
|
|
localDateOf,
|
|
mergeVisitedCountries,
|
|
minutesBetween,
|
|
normalizeVisit,
|
|
offsetMinutesOf,
|
|
simplify,
|
|
splitWindow,
|
|
syncWindow,
|
|
toNumber,
|
|
visitHash,
|
|
} from '../../../src/nest/integrations/dawarich.helpers';
|
|
import type { DawarichTrackDay } from '@trek/shared';
|
|
|
|
import { describe, it, expect } from 'vitest';
|
|
|
|
// ── Fixtures ─────────────────────────────────────────────────────────────────
|
|
|
|
const BASE_VISIT: DawarichVisitRaw = {
|
|
id: 42,
|
|
area_id: null,
|
|
started_at: '2024-06-15T18:30:00+02:00',
|
|
ended_at: '2024-06-15T20:00:00+02:00',
|
|
duration: 5400,
|
|
name: ' Cafe Kranzler ',
|
|
status: 'confirmed',
|
|
confidence: '0.87',
|
|
confidence_band: 'high',
|
|
place: { latitude: '52.5', longitude: '13.4', id: 7, country_code: 'de' },
|
|
};
|
|
|
|
const visit = (over: Partial<DawarichVisitRaw> = {}): DawarichVisitRaw => ({ ...BASE_VISIT, ...over });
|
|
|
|
/** A fixture whose shape is deliberately wrong — the payload is a stranger's JSON. */
|
|
const malformedVisit = (over: Record<string, unknown>): DawarichVisitRaw =>
|
|
({ ...BASE_VISIT, ...over }) as unknown as DawarichVisitRaw;
|
|
|
|
const point = (iso: string, lat: number | string, lng: number | string): DawarichSlimPoint => ({
|
|
latitude: lat,
|
|
longitude: lng,
|
|
timestamp: Date.parse(iso) / 1000,
|
|
});
|
|
|
|
const track = (
|
|
startAt: string | undefined,
|
|
endAt: string | undefined,
|
|
coordinates: unknown,
|
|
props: { distance?: number | null; dominant_mode?: string | null } = {},
|
|
): DawarichTrackFeature => ({
|
|
geometry: { coordinates },
|
|
properties: { start_at: startAt, end_at: endAt, distance: null, dominant_mode: null, ...props },
|
|
});
|
|
|
|
// ── localDateOf / offsetMinutesOf ────────────────────────────────────────────
|
|
|
|
describe('localDateOf / offsetMinutesOf', () => {
|
|
it('DAWARICH-TIME-001: reads the local date off the string rather than converting it', () => {
|
|
// 23:30 in Tokyo is still the 15th there and the 15th in Dawarich, even
|
|
// though the same instant is the 15th 14:30 UTC.
|
|
expect(localDateOf('2024-06-15T23:30:00+09:00')).toBe('2024-06-15');
|
|
});
|
|
|
|
it('DAWARICH-TIME-002: takes a UTC instant as given — there is no local meaning to recover', () => {
|
|
expect(localDateOf('2024-06-15T23:30:00Z')).toBe('2024-06-15');
|
|
});
|
|
|
|
it('DAWARICH-TIME-003: reads a positive offset as minutes', () => {
|
|
expect(offsetMinutesOf('2024-06-15T10:00:00+02:00')).toBe(120);
|
|
});
|
|
|
|
it('DAWARICH-TIME-004: reads a negative half-hour offset as minutes', () => {
|
|
expect(offsetMinutesOf('2024-06-15T10:00:00-05:30')).toBe(-330);
|
|
});
|
|
|
|
it('DAWARICH-TIME-005: accepts the colon-less form', () => {
|
|
expect(offsetMinutesOf('2024-06-15T10:00:00+0200')).toBe(120);
|
|
});
|
|
|
|
it('DAWARICH-TIME-006: Z, a bare date and junk are all zero', () => {
|
|
expect(offsetMinutesOf('2024-06-15T10:00:00Z')).toBe(0);
|
|
// A bare date ends in `-15`, which must not be mistaken for an offset.
|
|
expect(offsetMinutesOf('2024-06-15')).toBe(0);
|
|
expect(offsetMinutesOf('not a timestamp')).toBe(0);
|
|
});
|
|
});
|
|
|
|
// ── minutesBetween ───────────────────────────────────────────────────────────
|
|
|
|
describe('minutesBetween', () => {
|
|
it('DAWARICH-TIME-007: whole minutes across a span', () => {
|
|
expect(minutesBetween('2024-06-15T10:00:00Z', '2024-06-15T11:30:00Z')).toBe(90);
|
|
});
|
|
|
|
it('DAWARICH-TIME-008: rounds to the nearest minute in both directions', () => {
|
|
expect(minutesBetween('2024-06-15T10:00:00Z', '2024-06-15T10:00:29Z')).toBe(0);
|
|
expect(minutesBetween('2024-06-15T10:00:00Z', '2024-06-15T10:00:31Z')).toBe(1);
|
|
});
|
|
|
|
it('DAWARICH-TIME-009: compares instants, not wall clocks', () => {
|
|
// 10:00+02:00 is 08:00Z; 11:00+01:00 is 10:00Z — two hours apart.
|
|
expect(minutesBetween('2024-06-15T10:00:00+02:00', '2024-06-15T11:00:00+01:00')).toBe(120);
|
|
});
|
|
|
|
it('DAWARICH-TIME-010: a backwards or zero-length span is zero, never negative', () => {
|
|
expect(minutesBetween('2024-06-15T11:00:00Z', '2024-06-15T10:00:00Z')).toBe(0);
|
|
expect(minutesBetween('2024-06-15T10:00:00Z', '2024-06-15T10:00:00Z')).toBe(0);
|
|
});
|
|
|
|
it('DAWARICH-TIME-011: an unparsable timestamp is zero rather than NaN', () => {
|
|
expect(minutesBetween('2024-06-15T10:00:00Z', 'nope')).toBe(0);
|
|
expect(minutesBetween('nope', '2024-06-15T10:00:00Z')).toBe(0);
|
|
});
|
|
});
|
|
|
|
// ── syncWindow ───────────────────────────────────────────────────────────────
|
|
|
|
describe('syncWindow', () => {
|
|
it('DAWARICH-WINDOW-001: widens backwards by the lookback and forwards by the lookahead', () => {
|
|
const window = syncWindow('2024-06-15', '2024-06-17', new Date('2026-01-01T00:00:00Z'), 2, 3);
|
|
expect(window?.from.toISOString()).toBe('2024-06-13T00:00:00.000Z');
|
|
expect(window?.to.toISOString()).toBe('2024-06-20T23:59:59.000Z');
|
|
});
|
|
|
|
it('DAWARICH-WINDOW-002: a zero lookback/lookahead still spans the trip itself', () => {
|
|
const window = syncWindow('2024-06-15', '2024-06-17', new Date('2026-01-01T00:00:00Z'), 0, 0);
|
|
expect(window?.from.toISOString()).toBe('2024-06-15T00:00:00.000Z');
|
|
expect(window?.to.toISOString()).toBe('2024-06-17T23:59:59.000Z');
|
|
});
|
|
|
|
it('DAWARICH-WINDOW-003: never asks past now — the lookahead is clamped', () => {
|
|
const now = new Date('2024-06-16T08:00:00Z');
|
|
const window = syncWindow('2024-06-15', '2024-06-17', now, 1, 5);
|
|
expect(window?.to.toISOString()).toBe(now.toISOString());
|
|
});
|
|
|
|
it('DAWARICH-WINDOW-004: an open-ended trip gets the lookback and stops at now', () => {
|
|
const now = new Date('2024-06-20T12:00:00Z');
|
|
const window = syncWindow('2024-06-15', null, now, 1, 7);
|
|
expect(window?.from.toISOString()).toBe('2024-06-14T00:00:00.000Z');
|
|
expect(window?.to.toISOString()).toBe(now.toISOString());
|
|
});
|
|
|
|
it('DAWARICH-WINDOW-005: an unparsable end date is treated as open-ended, not as a failure', () => {
|
|
const now = new Date('2024-06-20T12:00:00Z');
|
|
const window = syncWindow('2024-06-15', 'whenever', now, 1, 7);
|
|
expect(window?.to.toISOString()).toBe(now.toISOString());
|
|
});
|
|
|
|
it('DAWARICH-WINDOW-006: a missing start date yields no window at all', () => {
|
|
expect(syncWindow(null, '2024-06-17', new Date('2026-01-01T00:00:00Z'), 1, 1)).toBeNull();
|
|
});
|
|
|
|
it('DAWARICH-WINDOW-007: an unparsable or empty start date yields no window at all', () => {
|
|
expect(syncWindow('gibberish', '2024-06-17', new Date('2026-01-01T00:00:00Z'), 1, 1)).toBeNull();
|
|
expect(syncWindow('', null, new Date('2026-01-01T00:00:00Z'), 1, 1)).toBeNull();
|
|
});
|
|
|
|
it('DAWARICH-WINDOW-008: a trip that has not started yet collapses to nothing', () => {
|
|
// `now` is before the (already widened) start, so there is no recorded
|
|
// stretch to ask about: to <= from.
|
|
expect(syncWindow('2024-06-15', null, new Date('2024-06-10T00:00:00Z'), 1, 1)).toBeNull();
|
|
});
|
|
});
|
|
|
|
// ── visitHash ────────────────────────────────────────────────────────────────
|
|
|
|
describe('visitHash', () => {
|
|
it('DAWARICH-HASH-001: is a sha256 hex digest', () => {
|
|
expect(visitHash(BASE_VISIT)).toMatch(/^[0-9a-f]{64}$/);
|
|
});
|
|
|
|
it('DAWARICH-HASH-002: is stable for the same input — a re-run that changed nothing stays quiet', () => {
|
|
expect(visitHash(visit())).toBe(visitHash(visit()));
|
|
});
|
|
|
|
it('DAWARICH-HASH-003: changes when the visit is renamed', () => {
|
|
expect(visitHash(visit({ name: 'Cafe Einstein' }))).not.toBe(visitHash(BASE_VISIT));
|
|
});
|
|
|
|
it('DAWARICH-HASH-004: changes when either timestamp moves', () => {
|
|
expect(visitHash(visit({ started_at: '2024-06-15T18:45:00+02:00' }))).not.toBe(visitHash(BASE_VISIT));
|
|
expect(visitHash(visit({ ended_at: '2024-06-15T21:00:00+02:00' }))).not.toBe(visitHash(BASE_VISIT));
|
|
});
|
|
|
|
it('DAWARICH-HASH-005: changes when the place moves or is re-identified', () => {
|
|
const moved = visit({ place: { ...BASE_VISIT.place!, latitude: '52.6' } });
|
|
const shifted = visit({ place: { ...BASE_VISIT.place!, longitude: '13.5' } });
|
|
const reidentified = visit({ place: { ...BASE_VISIT.place!, id: 8 } });
|
|
expect(visitHash(moved)).not.toBe(visitHash(BASE_VISIT));
|
|
expect(visitHash(shifted)).not.toBe(visitHash(BASE_VISIT));
|
|
expect(visitHash(reidentified)).not.toBe(visitHash(BASE_VISIT));
|
|
});
|
|
|
|
it('DAWARICH-HASH-006: changes when the status changes', () => {
|
|
expect(visitHash(visit({ status: 'suggested' }))).not.toBe(visitHash(BASE_VISIT));
|
|
});
|
|
|
|
it('DAWARICH-HASH-007: ignores fields TREK does not show — a re-scored confidence is not a change', () => {
|
|
expect(visitHash(visit({ confidence: '0.11', confidence_band: 'low' }))).toBe(visitHash(BASE_VISIT));
|
|
expect(visitHash(visit({ area_id: 99, user_id: 3 }))).toBe(visitHash(BASE_VISIT));
|
|
});
|
|
|
|
it('DAWARICH-HASH-008: a missing name and an empty name are the same visit', () => {
|
|
expect(visitHash(visit({ name: null }))).toBe(visitHash(visit({ name: '' })));
|
|
});
|
|
|
|
it('DAWARICH-HASH-009: a missing place does not throw', () => {
|
|
expect(visitHash(visit({ place: null }))).toMatch(/^[0-9a-f]{64}$/);
|
|
});
|
|
|
|
it('DAWARICH-HASH-010: a missing status and an empty status are the same visit', () => {
|
|
// `status` is nullable in the payload, so it is folded to the same blank a
|
|
// visit with an empty one gets. Without that, a null would hash as the
|
|
// literal "null" and a provider filling the field in with "" later would
|
|
// look like every unscored visit changing at once.
|
|
expect(visitHash(visit({ status: null }))).toBe(visitHash(visit({ status: '' })));
|
|
expect(visitHash(visit({ status: null }))).not.toBe(visitHash(BASE_VISIT));
|
|
});
|
|
});
|
|
|
|
// ── toNumber ─────────────────────────────────────────────────────────────────
|
|
|
|
describe('toNumber', () => {
|
|
it('DAWARICH-NUM-001: passes finite numbers through and rejects the rest', () => {
|
|
expect(toNumber(52.5)).toBe(52.5);
|
|
expect(toNumber(0)).toBe(0);
|
|
expect(toNumber(Number.NaN)).toBeNull();
|
|
expect(toNumber(Number.POSITIVE_INFINITY)).toBeNull();
|
|
});
|
|
|
|
it('DAWARICH-NUM-002: parses numeric strings, rejecting blank and non-numeric ones', () => {
|
|
expect(toNumber('13.4')).toBe(13.4);
|
|
expect(toNumber(' ')).toBeNull();
|
|
expect(toNumber('north')).toBeNull();
|
|
});
|
|
|
|
it('DAWARICH-NUM-003: null, undefined and objects are not numbers', () => {
|
|
expect(toNumber(null)).toBeNull();
|
|
expect(toNumber(undefined)).toBeNull();
|
|
expect(toNumber({})).toBeNull();
|
|
});
|
|
});
|
|
|
|
// ── normalizeVisit ───────────────────────────────────────────────────────────
|
|
|
|
describe('normalizeVisit', () => {
|
|
it('DAWARICH-VISIT-001: reduces a full visit to what TREK stores', () => {
|
|
expect(normalizeVisit(BASE_VISIT)).toEqual({
|
|
sourceVisitId: '42',
|
|
name: 'Cafe Kranzler',
|
|
lat: 52.5,
|
|
lng: 13.4,
|
|
startedAt: '2024-06-15T18:30:00+02:00',
|
|
endedAt: '2024-06-15T20:00:00+02:00',
|
|
durationMinutes: 90,
|
|
localDate: '2024-06-15',
|
|
status: 'confirmed',
|
|
confidence: 0.87,
|
|
confidenceBand: 'high',
|
|
countryCodeFromSource: 'DE',
|
|
});
|
|
});
|
|
|
|
it('DAWARICH-VISIT-002: an empty visit keeps every optional field null instead of guessing', () => {
|
|
const sparse = visit({
|
|
id: '9',
|
|
started_at: '2024-06-15T18:30:00Z',
|
|
ended_at: '2024-06-15T19:15:00Z',
|
|
duration: null,
|
|
name: null,
|
|
status: null,
|
|
confidence: null,
|
|
confidence_band: null,
|
|
place: null,
|
|
});
|
|
expect(normalizeVisit(sparse)).toEqual({
|
|
sourceVisitId: '9',
|
|
name: 'Unnamed stay',
|
|
lat: null,
|
|
lng: null,
|
|
startedAt: '2024-06-15T18:30:00Z',
|
|
endedAt: '2024-06-15T19:15:00Z',
|
|
durationMinutes: 45,
|
|
localDate: '2024-06-15',
|
|
status: 'suggested',
|
|
confidence: null,
|
|
confidenceBand: null,
|
|
countryCodeFromSource: null,
|
|
});
|
|
});
|
|
|
|
it('DAWARICH-VISIT-003: a whitespace-only name falls back to the placeholder', () => {
|
|
expect(normalizeVisit(visit({ name: ' ' }))?.name).toBe('Unnamed stay');
|
|
});
|
|
|
|
it('DAWARICH-VISIT-004: a place without coordinates yields null lat/lng, not zeros', () => {
|
|
const result = normalizeVisit(visit({ place: { latitude: null, longitude: null, id: null } }));
|
|
expect(result?.lat).toBeNull();
|
|
expect(result?.lng).toBeNull();
|
|
});
|
|
|
|
it('DAWARICH-VISIT-005: "confirmed" is the only status taken at face value', () => {
|
|
expect(normalizeVisit(visit({ status: 'confirmed' }))?.status).toBe('confirmed');
|
|
expect(normalizeVisit(visit({ status: 'suggested' }))?.status).toBe('suggested');
|
|
});
|
|
|
|
it('DAWARICH-VISIT-006: an unknown status falls to "suggested" — the side that asks, not the side that acts', () => {
|
|
// "declined" stopped existing in Dawarich 1.12.0; a future value must not
|
|
// silently become a confirmation.
|
|
expect(normalizeVisit(visit({ status: 'declined' }))?.status).toBe('suggested');
|
|
expect(normalizeVisit(visit({ status: 'something_new' }))?.status).toBe('suggested');
|
|
expect(normalizeVisit(visit({ status: null }))?.status).toBe('suggested');
|
|
});
|
|
|
|
it('DAWARICH-VISIT-007: the span between the timestamps is the length, whatever duration says', () => {
|
|
// 18:30 to 20:00. The reported figure is ignored while there are two usable
|
|
// timestamps, because that is the pair shown beside it in the panel. It used
|
|
// to win and to be read as seconds, which divided Dawarich's minutes by sixty
|
|
// a second time and turned an eighteen-minute stop into "0 min".
|
|
expect(normalizeVisit(visit({ duration: 5400 }))?.durationMinutes).toBe(90);
|
|
expect(normalizeVisit(visit({ duration: '120' }))?.durationMinutes).toBe(90);
|
|
expect(normalizeVisit(visit({ duration: 18 }))?.durationMinutes).toBe(90);
|
|
});
|
|
|
|
it('DAWARICH-VISIT-008: a missing or zero duration is recomputed from the two timestamps', () => {
|
|
// 18:30 → 20:00 is 90 minutes whichever way it is derived.
|
|
expect(normalizeVisit(visit({ duration: null }))?.durationMinutes).toBe(90);
|
|
expect(normalizeVisit(visit({ duration: 0 }))?.durationMinutes).toBe(90);
|
|
expect(normalizeVisit(visit({ duration: -60 }))?.durationMinutes).toBe(90);
|
|
expect(normalizeVisit(visit({ duration: 'unknown' }))?.durationMinutes).toBe(90);
|
|
});
|
|
|
|
it('DAWARICH-VISIT-009: a two-letter country code from the source is upper-cased', () => {
|
|
expect(normalizeVisit(visit())?.countryCodeFromSource).toBe('DE');
|
|
const upper = visit({ place: { ...BASE_VISIT.place!, country_code: 'FR' } });
|
|
expect(normalizeVisit(upper)?.countryCodeFromSource).toBe('FR');
|
|
});
|
|
|
|
it('DAWARICH-VISIT-010: anything that is not a two-letter code is dropped', () => {
|
|
const three = visit({ place: { ...BASE_VISIT.place!, country_code: 'deu' } });
|
|
const empty = visit({ place: { ...BASE_VISIT.place!, country_code: '' } });
|
|
const absent = visit({ place: { latitude: '52.5', longitude: '13.4', id: 7 } });
|
|
expect(normalizeVisit(three)?.countryCodeFromSource).toBeNull();
|
|
expect(normalizeVisit(empty)?.countryCodeFromSource).toBeNull();
|
|
expect(normalizeVisit(absent)?.countryCodeFromSource).toBeNull();
|
|
});
|
|
|
|
it('DAWARICH-VISIT-011: the local date comes from the source offset, not from the host clock', () => {
|
|
const tokyoLateNight = visit({
|
|
started_at: '2024-06-15T23:30:00+09:00',
|
|
ended_at: '2024-06-16T00:30:00+09:00',
|
|
});
|
|
expect(normalizeVisit(tokyoLateNight)?.localDate).toBe('2024-06-15');
|
|
});
|
|
|
|
it('DAWARICH-VISIT-012: a visit without an id is unusable', () => {
|
|
expect(normalizeVisit(malformedVisit({ id: null }))).toBeNull();
|
|
expect(normalizeVisit(malformedVisit({ id: undefined }))).toBeNull();
|
|
});
|
|
|
|
it('DAWARICH-VISIT-013: non-string timestamps are unusable', () => {
|
|
expect(normalizeVisit(malformedVisit({ started_at: 1_718_476_200 }))).toBeNull();
|
|
expect(normalizeVisit(malformedVisit({ ended_at: null }))).toBeNull();
|
|
});
|
|
|
|
it('DAWARICH-VISIT-014: an unparsable start timestamp is unusable', () => {
|
|
expect(normalizeVisit(visit({ started_at: 'last Tuesday' }))).toBeNull();
|
|
});
|
|
|
|
it('DAWARICH-VISIT-015: an unreadable end collapses onto the arrival rather than staying unreadable', () => {
|
|
// The guard checks `started_at` alone, so an unreadable end does not drop
|
|
// the visit. It is repaired instead of passed through: kept as-is it would
|
|
// render as "Invalid Date" beside a perfectly good arrival time.
|
|
const result = normalizeVisit(visit({ duration: null, ended_at: 'sometime' }));
|
|
expect(result?.endedAt).toBe(new Date(Date.parse(result!.startedAt)).toISOString());
|
|
expect(result?.durationMinutes).toBe(0);
|
|
});
|
|
|
|
it('DAWARICH-VISIT-016: an unreadable end falls back to the reported duration', () => {
|
|
// With a duration to go on, the end is the arrival plus that span — which is
|
|
// what the stay actually was, and what the two timestamps then agree on.
|
|
// Minutes: Dawarich writes `duration_minutes = ((ended_at - started_at) / 60)`
|
|
// into this column (app/services/visits/create.rb).
|
|
const result = normalizeVisit(visit({ duration: 30, ended_at: 'sometime' }));
|
|
expect(Date.parse(result!.endedAt) - Date.parse(result!.startedAt)).toBe(1_800_000);
|
|
expect(result?.durationMinutes).toBe(30);
|
|
});
|
|
|
|
it('DAWARICH-VISIT-017: an unreadable end plus a duration of zero or less collapses onto the arrival', () => {
|
|
// A reported duration is only usable as a repair while it is positive: zero
|
|
// is "the detector had nothing", and a negative one is the same accident
|
|
// that produced the unreadable end. Either way the end moves to the
|
|
// arrival, which is the one timestamp that was actually readable. It never
|
|
// moves backwards from it.
|
|
for (const duration of [0, -45, '0'] as const) {
|
|
const result = normalizeVisit(visit({ duration, ended_at: 'sometime' }));
|
|
expect(result?.endedAt).toBe(new Date(Date.parse(result!.startedAt)).toISOString());
|
|
expect(result?.durationMinutes).toBe(0);
|
|
}
|
|
});
|
|
});
|
|
|
|
// ── distanceMeters ───────────────────────────────────────────────────────────
|
|
|
|
describe('distanceMeters', () => {
|
|
it('DAWARICH-GEO-001: a point is zero metres from itself', () => {
|
|
expect(distanceMeters(52.52, 13.405, 52.52, 13.405)).toBe(0);
|
|
});
|
|
|
|
it('DAWARICH-GEO-002: a small north-south step measures in metres', () => {
|
|
// 0.0009° of latitude is almost exactly 100 m anywhere on earth.
|
|
expect(distanceMeters(52.52, 13.405, 52.5209, 13.405)).toBeCloseTo(100, 0);
|
|
});
|
|
|
|
it('DAWARICH-GEO-003: a degree of longitude is ~111 km at the equator', () => {
|
|
expect(distanceMeters(0, 0, 0, 1)).toBeCloseTo(111_195, -2);
|
|
});
|
|
|
|
it('DAWARICH-GEO-004: a degree of longitude shrinks with the cosine of the latitude', () => {
|
|
// At 60° north a degree of longitude is half what it is at the equator.
|
|
expect(distanceMeters(60, 0, 60, 1)).toBeCloseTo(111_195 / 2, -2);
|
|
});
|
|
|
|
it('DAWARICH-GEO-005: distance is symmetric', () => {
|
|
const there = distanceMeters(48.85, 2.35, 52.52, 13.405);
|
|
const back = distanceMeters(52.52, 13.405, 48.85, 2.35);
|
|
expect(there).toBeCloseTo(back, 6);
|
|
});
|
|
});
|
|
|
|
// ── simplify ─────────────────────────────────────────────────────────────────
|
|
|
|
describe('simplify', () => {
|
|
it('DAWARICH-GEO-006: a straight line collapses to its two ends', () => {
|
|
expect(
|
|
simplify(
|
|
[
|
|
[0, 0],
|
|
[0, 0.5],
|
|
[0, 1],
|
|
],
|
|
0.00005,
|
|
),
|
|
).toEqual([
|
|
[0, 0],
|
|
[0, 1],
|
|
]);
|
|
});
|
|
|
|
it('DAWARICH-GEO-007: a long straight run collapses no matter how many points it has', () => {
|
|
const straight: Array<[number, number]> = Array.from({ length: 500 }, (_, i) => [0, i / 500]);
|
|
expect(simplify(straight, 0.00005)).toEqual([
|
|
[0, 0],
|
|
[0, 499 / 500],
|
|
]);
|
|
});
|
|
|
|
it('DAWARICH-GEO-008: a corner survives', () => {
|
|
expect(
|
|
simplify(
|
|
[
|
|
[0, 0],
|
|
[0, 1],
|
|
[1, 1],
|
|
],
|
|
0.00005,
|
|
),
|
|
).toEqual([
|
|
[0, 0],
|
|
[0, 1],
|
|
[1, 1],
|
|
]);
|
|
});
|
|
|
|
it('DAWARICH-GEO-009: a deviation under the tolerance is dropped, one over it is kept', () => {
|
|
const jitter: Array<[number, number]> = [
|
|
[0, 0],
|
|
[0.00001, 0.5],
|
|
[0, 1],
|
|
];
|
|
const corner: Array<[number, number]> = [
|
|
[0, 0],
|
|
[0.001, 0.5],
|
|
[0, 1],
|
|
];
|
|
expect(simplify(jitter, 0.00005)).toHaveLength(2);
|
|
expect(simplify(corner, 0.00005)).toHaveLength(3);
|
|
});
|
|
|
|
it('DAWARICH-GEO-010: two points or fewer are returned untouched', () => {
|
|
const pair: Array<[number, number]> = [
|
|
[0, 0],
|
|
[1, 1],
|
|
];
|
|
expect(simplify(pair, 0.00005)).toBe(pair);
|
|
expect(simplify([], 0.00005)).toEqual([]);
|
|
});
|
|
|
|
it('DAWARICH-GEO-024: a loop back to the start is measured from the point, not from a zero-length baseline', () => {
|
|
// A day that ends where it began gives the algorithm a segment whose two
|
|
// ends are the same coordinate. The gradient it normally projects onto does
|
|
// not exist there, so the distance has to fall back to "how far is this
|
|
// point from that one". Without it the division is 0/0 and every detour on
|
|
// a round trip would simplify away as NaN.
|
|
const loop: Array<[number, number]> = [
|
|
[0, 0],
|
|
[0, 1],
|
|
[0, 0],
|
|
];
|
|
expect(simplify(loop, 0.00005)).toEqual(loop);
|
|
// And the same shape, a metre wide instead of a degree, still collapses.
|
|
expect(
|
|
simplify(
|
|
[
|
|
[0, 0],
|
|
[0, 0.00001],
|
|
[0, 0],
|
|
],
|
|
0.00005,
|
|
),
|
|
).toEqual([
|
|
[0, 0],
|
|
[0, 0],
|
|
]);
|
|
});
|
|
|
|
it('DAWARICH-GEO-025: an unreadable latitude cannot collapse the longitude scale', () => {
|
|
// The metric scales longitude by the cosine of the latitude, and guards
|
|
// that scale so it is never zero. A latitude that is not a real number
|
|
// gives no cosine at all, and the fallback keeps the scale at 1 rather
|
|
// than multiplying every longitude by nothing. The bad point measures as
|
|
// no deviation and is dropped; the ends of the line still come back.
|
|
expect(
|
|
simplify(
|
|
[
|
|
[0, 0],
|
|
[NaN, 0.5],
|
|
[0, 1],
|
|
],
|
|
0.00005,
|
|
),
|
|
).toEqual([
|
|
[0, 0],
|
|
[0, 1],
|
|
]);
|
|
});
|
|
|
|
it('DAWARICH-GEO-011: the first and last point are always kept', () => {
|
|
const zigzag: Array<[number, number]> = [
|
|
[0, 0],
|
|
[1, 0.25],
|
|
[0, 0.5],
|
|
[1, 0.75],
|
|
[0, 1],
|
|
];
|
|
const out = simplify(zigzag, 0.00005);
|
|
expect(out[0]).toEqual([0, 0]);
|
|
expect(out[out.length - 1]).toEqual([0, 1]);
|
|
});
|
|
});
|
|
|
|
// ── capPoints ────────────────────────────────────────────────────────────────
|
|
|
|
describe('capPoints', () => {
|
|
it('DAWARICH-GEO-012: a line already under the cap is untouched', () => {
|
|
const line: Array<[number, number]> = [
|
|
[0, 0],
|
|
[1, 1],
|
|
[2, 2],
|
|
];
|
|
expect(capPoints(line, 5)).toBe(line);
|
|
expect(capPoints(line, 3)).toBe(line);
|
|
});
|
|
|
|
it('DAWARICH-GEO-013: thins to the cap on an even stride', () => {
|
|
const line: Array<[number, number]> = [
|
|
[0, 0],
|
|
[1, 1],
|
|
[2, 2],
|
|
[3, 3],
|
|
[4, 4],
|
|
];
|
|
expect(capPoints(line, 3)).toEqual([
|
|
[0, 0],
|
|
[2, 2],
|
|
[4, 4],
|
|
]);
|
|
});
|
|
|
|
it('DAWARICH-GEO-014: the line still starts and ends where the day did', () => {
|
|
const line: Array<[number, number]> = Array.from({ length: 1000 }, (_, i) => [i / 1000, 0]);
|
|
const out = capPoints(line, 100);
|
|
expect(out).toHaveLength(100);
|
|
expect(out[0]).toEqual(line[0]);
|
|
expect(out[out.length - 1]).toEqual(line[line.length - 1]);
|
|
});
|
|
|
|
it('DAWARICH-GEO-015: a cap below two is refused rather than producing a degenerate line', () => {
|
|
const line: Array<[number, number]> = [
|
|
[0, 0],
|
|
[1, 1],
|
|
[2, 2],
|
|
[3, 3],
|
|
[4, 4],
|
|
];
|
|
expect(capPoints(line, 1)).toBe(line);
|
|
expect(capPoints(line, 0)).toBe(line);
|
|
});
|
|
});
|
|
|
|
// ── geoJsonToLatLng ──────────────────────────────────────────────────────────
|
|
|
|
describe('geoJsonToLatLng', () => {
|
|
it('DAWARICH-GEO-016: swaps GeoJSON [lng, lat] into TREK [lat, lng]', () => {
|
|
expect(geoJsonToLatLng([[13.4, 52.5]])).toEqual([[52.5, 13.4]]);
|
|
});
|
|
|
|
it('DAWARICH-GEO-017: parses numeric strings as coordinates', () => {
|
|
expect(geoJsonToLatLng([['13.4', '52.5']])).toEqual([[52.5, 13.4]]);
|
|
});
|
|
|
|
it('DAWARICH-GEO-018: skips pairs that are not pairs', () => {
|
|
expect(geoJsonToLatLng([[13.4], 'nope', null, {}, []])).toEqual([]);
|
|
});
|
|
|
|
it('DAWARICH-GEO-019: skips pairs that are not numbers', () => {
|
|
expect(
|
|
geoJsonToLatLng([
|
|
['east', 'north'],
|
|
[null, 52.5],
|
|
[13.4, undefined],
|
|
]),
|
|
).toEqual([]);
|
|
});
|
|
|
|
it('DAWARICH-GEO-020: keeps the exact range limits and drops anything past them', () => {
|
|
expect(
|
|
geoJsonToLatLng([
|
|
[180, 90],
|
|
[-180, -90],
|
|
]),
|
|
).toEqual([
|
|
[90, 180],
|
|
[-90, -180],
|
|
]);
|
|
expect(
|
|
geoJsonToLatLng([
|
|
[180.1, 10],
|
|
[-180.1, 10],
|
|
[10, 90.1],
|
|
[10, -90.1],
|
|
]),
|
|
).toEqual([]);
|
|
});
|
|
|
|
it('DAWARICH-GEO-021: keeps the usable pairs out of a mixed list', () => {
|
|
expect(geoJsonToLatLng([[13.4, 52.5], 'nope', [999, 999], [2.35, 48.85]])).toEqual([
|
|
[52.5, 13.4],
|
|
[48.85, 2.35],
|
|
]);
|
|
});
|
|
|
|
it('DAWARICH-GEO-022: a non-array is an empty line, not a throw', () => {
|
|
expect(geoJsonToLatLng('nope')).toEqual([]);
|
|
expect(geoJsonToLatLng(null)).toEqual([]);
|
|
expect(geoJsonToLatLng(undefined)).toEqual([]);
|
|
});
|
|
|
|
it('DAWARICH-GEO-023: ignores anything past the first two entries of a pair', () => {
|
|
// GeoJSON positions may carry an elevation; TREK draws in two dimensions.
|
|
expect(geoJsonToLatLng([[13.4, 52.5, 34]])).toEqual([[52.5, 13.4]]);
|
|
});
|
|
});
|
|
|
|
// ── bucketPointsByDay ────────────────────────────────────────────────────────
|
|
|
|
describe('bucketPointsByDay', () => {
|
|
const acrossMidnight = (): DawarichSlimPoint[] => [
|
|
point('2024-06-15T10:00:00Z', 10, 10),
|
|
point('2024-06-15T23:59:59Z', 10, 11),
|
|
point('2024-06-16T00:00:00Z', 11, 11),
|
|
point('2024-06-16T10:00:00Z', 11, 12),
|
|
];
|
|
|
|
it('DAWARICH-BUCKET-001: midnight is exact — a point at 00:00:00 belongs to the new day', () => {
|
|
const days = bucketPointsByDay(acrossMidnight(), 0);
|
|
expect(days.map((d) => d.date)).toEqual(['2024-06-15', '2024-06-16']);
|
|
expect(days[0]!.segments[0]!.startedAt).toBe('2024-06-15T10:00:00.000Z');
|
|
expect(days[0]!.segments[0]!.endedAt).toBe('2024-06-15T23:59:59.000Z');
|
|
expect(days[1]!.segments[0]!.startedAt).toBe('2024-06-16T00:00:00.000Z');
|
|
expect(days[1]!.segments[0]!.endedAt).toBe('2024-06-16T10:00:00.000Z');
|
|
});
|
|
|
|
it('DAWARICH-BUCKET-002: the seam is stitched — a day starts where the previous one ended', () => {
|
|
const days = bucketPointsByDay(acrossMidnight(), 0);
|
|
const previousLast = days[0]!.segments[0]!.points.at(-1);
|
|
// The stitched point is drawn but does not move the day's own times.
|
|
expect(days[1]!.segments[0]!.points[0]).toEqual(previousLast);
|
|
expect(days[1]!.segments[0]!.points).toEqual([
|
|
[10, 11],
|
|
[11, 11],
|
|
[11, 12],
|
|
]);
|
|
});
|
|
|
|
it('DAWARICH-BUCKET-003: the first day is not stitched to anything', () => {
|
|
const days = bucketPointsByDay([point('2024-06-15T10:00:00Z', 10, 10), point('2024-06-15T12:00:00Z', 10, 11)], 0);
|
|
expect(days[0]!.segments[0]!.points).toEqual([
|
|
[10, 10],
|
|
[10, 11],
|
|
]);
|
|
});
|
|
|
|
it('DAWARICH-BUCKET-004: the offset decides the day — an early UTC point is still yesterday in New York', () => {
|
|
const days = bucketPointsByDay(
|
|
[point('2024-06-15T02:00:00Z', 10, 10), point('2024-06-15T03:00:00Z', 11, 11)],
|
|
-300,
|
|
);
|
|
expect(days).toHaveLength(1);
|
|
expect(days[0]!.date).toBe('2024-06-14');
|
|
// The segment times stay the real instants; only the bucket is local.
|
|
expect(days[0]!.segments[0]!.startedAt).toBe('2024-06-15T02:00:00.000Z');
|
|
});
|
|
|
|
it('DAWARICH-BUCKET-005: a positive offset pushes a late UTC point into tomorrow', () => {
|
|
const days = bucketPointsByDay([point('2024-06-15T22:00:00Z', 10, 10), point('2024-06-15T23:00:00Z', 11, 11)], 540);
|
|
expect(days.map((d) => d.date)).toEqual(['2024-06-16']);
|
|
});
|
|
|
|
it('DAWARICH-BUCKET-006: points arriving out of order are sorted by time', () => {
|
|
const days = bucketPointsByDay(
|
|
[
|
|
point('2024-06-15T18:00:00Z', 11, 11),
|
|
point('2024-06-15T06:00:00Z', 10, 10),
|
|
point('2024-06-15T12:00:00Z', 10, 11),
|
|
],
|
|
0,
|
|
);
|
|
expect(days[0]!.segments[0]!.startedAt).toBe('2024-06-15T06:00:00.000Z');
|
|
expect(days[0]!.segments[0]!.endedAt).toBe('2024-06-15T18:00:00.000Z');
|
|
expect(days[0]!.segments[0]!.points[0]).toEqual([10, 10]);
|
|
});
|
|
|
|
it('DAWARICH-BUCKET-007: unusable points are dropped and a day that loses its line is not emitted', () => {
|
|
const days = bucketPointsByDay(
|
|
[
|
|
{ latitude: 'north', longitude: 10, timestamp: 1_718_445_600 },
|
|
{ latitude: 95, longitude: 10, timestamp: 1_718_445_601 },
|
|
{ latitude: 10, longitude: 200, timestamp: 1_718_445_602 },
|
|
{ latitude: 10, longitude: 10, timestamp: null } as unknown as DawarichSlimPoint,
|
|
point('2024-06-15T10:00:00Z', 10, 10),
|
|
],
|
|
0,
|
|
);
|
|
// Only one usable point survived, so there is no line to draw.
|
|
expect(days).toEqual([]);
|
|
});
|
|
|
|
it('DAWARICH-BUCKET-008: an empty recording is an empty result', () => {
|
|
expect(bucketPointsByDay([], 0)).toEqual([]);
|
|
});
|
|
|
|
it('DAWARICH-BUCKET-009: honours the per-day cap and the tolerance', () => {
|
|
const days = bucketPointsByDay(
|
|
[
|
|
point('2024-06-15T00:00:00Z', 0, 0),
|
|
point('2024-06-15T01:00:00Z', 1, 0),
|
|
point('2024-06-15T02:00:00Z', 0, 1),
|
|
point('2024-06-15T03:00:00Z', 1, 1),
|
|
point('2024-06-15T04:00:00Z', 0, 2),
|
|
],
|
|
0,
|
|
{ maxPointsPerDay: 3, epsilon: 0.00005 },
|
|
);
|
|
const line = days[0]!.segments[0]!.points;
|
|
expect(line).toHaveLength(3);
|
|
expect(line[0]).toEqual([0, 0]);
|
|
expect(line.at(-1)).toEqual([0, 2]);
|
|
});
|
|
|
|
it('DAWARICH-BUCKET-010: a recorded day carries no mode and no measured distance', () => {
|
|
const days = bucketPointsByDay([point('2024-06-15T10:00:00Z', 10, 10), point('2024-06-15T12:00:00Z', 10, 11)], 0);
|
|
expect(days[0]!.segments[0]!.mode).toBeNull();
|
|
expect(days[0]!.segments[0]!.distanceMeters).toBeNull();
|
|
});
|
|
});
|
|
|
|
// ── bucketTracksByDay ────────────────────────────────────────────────────────
|
|
|
|
describe('bucketTracksByDay', () => {
|
|
it('DAWARICH-TRACK-001: a track inside one day stays whole and keeps its measured distance', () => {
|
|
const days = bucketTracksByDay([
|
|
track(
|
|
'2024-06-15T10:00:00Z',
|
|
'2024-06-15T12:00:00Z',
|
|
[
|
|
[10, 10],
|
|
[11, 11],
|
|
[11, 12],
|
|
],
|
|
{
|
|
distance: 4321,
|
|
dominant_mode: 'car',
|
|
},
|
|
),
|
|
]);
|
|
expect(days).toEqual([
|
|
{
|
|
date: '2024-06-15',
|
|
segments: [
|
|
{
|
|
// GeoJSON [lng, lat] in, TREK [lat, lng] out.
|
|
points: [
|
|
[10, 10],
|
|
[11, 11],
|
|
[12, 11],
|
|
],
|
|
mode: 'car',
|
|
startedAt: '2024-06-15T10:00:00Z',
|
|
endedAt: '2024-06-15T12:00:00Z',
|
|
distanceMeters: 4321,
|
|
},
|
|
],
|
|
},
|
|
]);
|
|
});
|
|
|
|
it('DAWARICH-TRACK-002: the local day comes from the offset the track carries', () => {
|
|
// 00:30+02:00 is still 22:30Z the day before, but the recording user saw
|
|
// the 16th, which is the day TREK must file it under.
|
|
const days = bucketTracksByDay([
|
|
track('2024-06-16T00:30:00+02:00', '2024-06-16T01:30:00+02:00', [
|
|
[10, 10],
|
|
[11, 11],
|
|
[11, 12],
|
|
]),
|
|
]);
|
|
expect(days.map((d) => d.date)).toEqual(['2024-06-16']);
|
|
});
|
|
|
|
it('DAWARICH-TRACK-003: a track over midnight is split, and the two halves meet at midnight', () => {
|
|
const days = bucketTracksByDay([
|
|
track(
|
|
'2024-06-15T23:00:00Z',
|
|
'2024-06-16T01:00:00Z',
|
|
[
|
|
[10, 10],
|
|
[10.5, 10.5],
|
|
[11, 11],
|
|
[11.5, 10.5],
|
|
[12, 11],
|
|
],
|
|
{ distance: 9000, dominant_mode: 'walk' },
|
|
),
|
|
]);
|
|
expect(days.map((d) => d.date)).toEqual(['2024-06-15', '2024-06-16']);
|
|
|
|
const first = days[0]!.segments[0]!;
|
|
const second = days[1]!.segments[0]!;
|
|
expect(first.startedAt).toBe('2024-06-15T23:00:00.000Z');
|
|
expect(first.endedAt).toBe('2024-06-16T00:00:00.000Z');
|
|
expect(second.startedAt).toBe('2024-06-16T00:00:00.000Z');
|
|
expect(second.endedAt).toBe('2024-06-16T01:00:00Z');
|
|
// The cut point belongs to both halves, so the line has no gap.
|
|
expect(second.points[0]).toEqual(first.points.at(-1));
|
|
expect(first.mode).toBe('walk');
|
|
expect(second.mode).toBe('walk');
|
|
});
|
|
|
|
it('DAWARICH-TRACK-004: a split piece reports no distance — only a whole track measured one', () => {
|
|
const days = bucketTracksByDay([
|
|
track(
|
|
'2024-06-15T23:00:00Z',
|
|
'2024-06-16T01:00:00Z',
|
|
[
|
|
[10, 10],
|
|
[10.5, 10.5],
|
|
[11, 11],
|
|
[11.5, 10.5],
|
|
[12, 11],
|
|
],
|
|
{ distance: 9000 },
|
|
),
|
|
]);
|
|
expect(days.flatMap((d) => d.segments).map((s) => s.distanceMeters)).toEqual([null, null]);
|
|
});
|
|
|
|
it('DAWARICH-TRACK-005: a track spanning three days is cut twice, by index proportion of its span', () => {
|
|
const days = bucketTracksByDay([
|
|
track(
|
|
'2024-06-15T12:00:00Z',
|
|
'2024-06-17T12:00:00Z',
|
|
[
|
|
[10, 10],
|
|
[10.5, 11],
|
|
[11, 10],
|
|
[11.5, 11],
|
|
[12, 10],
|
|
[12.5, 11],
|
|
[13, 10],
|
|
],
|
|
{ distance: 100 },
|
|
),
|
|
]);
|
|
expect(days.map((d) => ({ date: d.date, from: d.segments[0]!.startedAt, to: d.segments[0]!.endedAt }))).toEqual([
|
|
{ date: '2024-06-15', from: '2024-06-15T12:00:00.000Z', to: '2024-06-16T00:00:00.000Z' },
|
|
{ date: '2024-06-16', from: '2024-06-16T00:00:00.000Z', to: '2024-06-17T00:00:00.000Z' },
|
|
{ date: '2024-06-17', from: '2024-06-17T00:00:00.000Z', to: '2024-06-17T12:00:00Z' },
|
|
]);
|
|
});
|
|
|
|
it('DAWARICH-TRACK-006: days come back in calendar order however the features arrived', () => {
|
|
const days = bucketTracksByDay([
|
|
track('2024-06-17T08:00:00Z', '2024-06-17T09:00:00Z', [
|
|
[10, 10],
|
|
[11, 11],
|
|
[11, 12],
|
|
]),
|
|
track('2024-06-15T18:00:00Z', '2024-06-15T19:00:00Z', [
|
|
[20, 20],
|
|
[21, 21],
|
|
[21, 22],
|
|
]),
|
|
track('2024-06-16T06:00:00Z', '2024-06-16T07:00:00Z', [
|
|
[30, 30],
|
|
[31, 31],
|
|
[31, 32],
|
|
]),
|
|
]);
|
|
expect(days.map((d) => d.date)).toEqual(['2024-06-15', '2024-06-16', '2024-06-17']);
|
|
});
|
|
|
|
it('DAWARICH-TRACK-007: segments within a day come back in start order', () => {
|
|
const days = bucketTracksByDay([
|
|
track('2024-06-15T18:00:00Z', '2024-06-15T19:00:00Z', [
|
|
[20, 20],
|
|
[21, 21],
|
|
[21, 22],
|
|
]),
|
|
track('2024-06-15T06:00:00Z', '2024-06-15T07:00:00Z', [
|
|
[30, 30],
|
|
[31, 31],
|
|
[31, 32],
|
|
]),
|
|
track('2024-06-15T12:00:00Z', '2024-06-15T13:00:00Z', [
|
|
[40, 40],
|
|
[41, 41],
|
|
[41, 42],
|
|
]),
|
|
]);
|
|
expect(days).toHaveLength(1);
|
|
expect(days[0]!.segments.map((s) => s.startedAt)).toEqual([
|
|
'2024-06-15T06:00:00Z',
|
|
'2024-06-15T12:00:00Z',
|
|
'2024-06-15T18:00:00Z',
|
|
]);
|
|
});
|
|
|
|
it('DAWARICH-TRACK-008: a track without both timestamps is skipped', () => {
|
|
const days = bucketTracksByDay([
|
|
track(undefined, '2024-06-15T12:00:00Z', [
|
|
[10, 10],
|
|
[11, 11],
|
|
[11, 12],
|
|
]),
|
|
track('2024-06-15T10:00:00Z', undefined, [
|
|
[10, 10],
|
|
[11, 11],
|
|
[11, 12],
|
|
]),
|
|
{
|
|
geometry: {
|
|
coordinates: [
|
|
[10, 10],
|
|
[11, 11],
|
|
],
|
|
},
|
|
properties: null,
|
|
},
|
|
]);
|
|
expect(days).toEqual([]);
|
|
});
|
|
|
|
it('DAWARICH-TRACK-009: a track without a drawable line is skipped', () => {
|
|
const days = bucketTracksByDay([
|
|
track('2024-06-15T10:00:00Z', '2024-06-15T12:00:00Z', [[10, 10]]),
|
|
track('2024-06-15T10:00:00Z', '2024-06-15T12:00:00Z', 'nope'),
|
|
{ geometry: null, properties: { start_at: '2024-06-15T10:00:00Z', end_at: '2024-06-15T12:00:00Z' } },
|
|
]);
|
|
expect(days).toEqual([]);
|
|
});
|
|
|
|
it('DAWARICH-TRACK-010: a backwards or zero-length track is treated as whole, on its start day', () => {
|
|
const days = bucketTracksByDay([
|
|
track(
|
|
'2024-06-16T01:00:00Z',
|
|
'2024-06-15T23:00:00Z',
|
|
[
|
|
[10, 10],
|
|
[11, 11],
|
|
[11, 12],
|
|
],
|
|
{
|
|
distance: 50,
|
|
},
|
|
),
|
|
]);
|
|
expect(days.map((d) => d.date)).toEqual(['2024-06-16']);
|
|
expect(days[0]!.segments[0]!.distanceMeters).toBe(50);
|
|
});
|
|
|
|
it('DAWARICH-TRACK-011: a two-point track over midnight is not split at all', () => {
|
|
// One segment cannot become two drawable pieces: cutting it would hand one
|
|
// day a single point and the other nothing, and the tail would vanish. So
|
|
// the whole track goes on the day it started, with its real times intact —
|
|
// the split is declined rather than faked.
|
|
const days = bucketTracksByDay([
|
|
track(
|
|
'2024-06-15T23:00:00Z',
|
|
'2024-06-16T01:00:00Z',
|
|
[
|
|
[10, 10],
|
|
[11, 12],
|
|
],
|
|
{ distance: 100 },
|
|
),
|
|
]);
|
|
expect(days.map((d) => d.date)).toEqual(['2024-06-15']);
|
|
expect(days[0]!.segments[0]!.endedAt).toBe('2024-06-16T01:00:00Z');
|
|
// Whole, so it still reports the distance Dawarich actually measured.
|
|
expect(days[0]!.segments[0]!.distanceMeters).toBe(100);
|
|
});
|
|
|
|
it('DAWARICH-TRACK-014: enough points to split across midnight still splits', () => {
|
|
// The counterpart to 011: three segments over one midnight leave both days
|
|
// a drawable line, so the approximation is applied.
|
|
const days = bucketTracksByDay([
|
|
track('2024-06-15T22:00:00Z', '2024-06-16T02:00:00Z', [
|
|
[10, 10],
|
|
[10.5, 10.5],
|
|
[11, 11],
|
|
[11.5, 11.5],
|
|
]),
|
|
]);
|
|
expect(days.map((d) => d.date)).toEqual(['2024-06-15', '2024-06-16']);
|
|
for (const day of days) expect(day.segments[0]!.points.length).toBeGreaterThanOrEqual(2);
|
|
});
|
|
|
|
it('DAWARICH-TRACK-012: honours the per-day cap and the tolerance', () => {
|
|
const zigzag = Array.from({ length: 40 }, (_, i): [number, number] => [10 + i / 10, i % 2 === 0 ? 10 : 11]);
|
|
const days = bucketTracksByDay([track('2024-06-15T10:00:00Z', '2024-06-15T12:00:00Z', zigzag)], {
|
|
maxPointsPerDay: 5,
|
|
epsilon: 0.00005,
|
|
});
|
|
expect(days[0]!.segments[0]!.points).toHaveLength(5);
|
|
});
|
|
|
|
it('DAWARICH-TRACK-015: a cut that lands on the last point ends the walk instead of emitting an empty tail', () => {
|
|
// Midnight falls at 98% of this track's time span, so the proportional cut
|
|
// puts every point before it. What is left afterwards is one point, which
|
|
// is not a line: the loop stops there rather than pushing a tail piece that
|
|
// would render as nothing and carry a start after its own end.
|
|
const days = bucketTracksByDay([
|
|
track(
|
|
'2024-06-15T00:00:00Z',
|
|
'2024-06-16T00:30:00Z',
|
|
[
|
|
[10, 10],
|
|
[11, 12],
|
|
[12, 10],
|
|
],
|
|
{
|
|
distance: 7000,
|
|
},
|
|
),
|
|
]);
|
|
|
|
expect(days.map((d) => d.date)).toEqual(['2024-06-15']);
|
|
const segment = days[0]!.segments[0]!;
|
|
expect(segment.points).toEqual([
|
|
[10, 10],
|
|
[12, 11],
|
|
[10, 12],
|
|
]);
|
|
expect(segment.startedAt).toBe('2024-06-15T00:00:00.000Z');
|
|
expect(segment.endedAt).toBe('2024-06-16T00:00:00.000Z');
|
|
// It was cut, even though only one piece came out, so the measured distance
|
|
// no longer describes it.
|
|
expect(segment.distanceMeters).toBeNull();
|
|
});
|
|
|
|
it('DAWARICH-TRACK-013: an empty feature list is an empty result', () => {
|
|
expect(bucketTracksByDay([])).toEqual([]);
|
|
});
|
|
});
|
|
|
|
// ── countPoints ──────────────────────────────────────────────────────────────
|
|
|
|
describe('countPoints', () => {
|
|
const day = (...segments: Array<Array<[number, number]>>): DawarichTrackDay => ({
|
|
date: '2024-06-15',
|
|
segments: segments.map((points) => ({
|
|
points,
|
|
mode: null,
|
|
startedAt: '2024-06-15T10:00:00Z',
|
|
endedAt: '2024-06-15T12:00:00Z',
|
|
distanceMeters: null,
|
|
})),
|
|
});
|
|
|
|
it('DAWARICH-COUNT-001: nothing drawn is zero', () => {
|
|
expect(countPoints([])).toBe(0);
|
|
expect(countPoints([day()])).toBe(0);
|
|
});
|
|
|
|
it('DAWARICH-COUNT-002: sums every segment of every day', () => {
|
|
const days = [
|
|
day(
|
|
[
|
|
[0, 0],
|
|
[1, 1],
|
|
],
|
|
[
|
|
[0, 0],
|
|
[1, 1],
|
|
[2, 2],
|
|
],
|
|
),
|
|
day([
|
|
[0, 0],
|
|
[1, 1],
|
|
]),
|
|
];
|
|
expect(countPoints(days)).toBe(7);
|
|
});
|
|
|
|
it('DAWARICH-COUNT-003: agrees with what the bucketing actually produced', () => {
|
|
const days = bucketTracksByDay([
|
|
track('2024-06-15T10:00:00Z', '2024-06-15T12:00:00Z', [
|
|
[10, 10],
|
|
[11, 11],
|
|
[11, 12],
|
|
]),
|
|
track('2024-06-16T10:00:00Z', '2024-06-16T12:00:00Z', [
|
|
[20, 20],
|
|
[21, 21],
|
|
[21, 22],
|
|
]),
|
|
]);
|
|
expect(countPoints(days)).toBe(6);
|
|
});
|
|
});
|
|
|
|
describe('visited cities over a long range', () => {
|
|
const DAY = 86_400_000;
|
|
|
|
it('DAWARICH-CITIES-001: a range within one window stays one request, bounds untouched', () => {
|
|
const from = new Date('2026-09-01T00:00:00Z');
|
|
const to = new Date('2026-09-02T00:00:00Z');
|
|
expect(splitWindow(from, to, 30)).toEqual([{ from, to }]);
|
|
});
|
|
|
|
it('DAWARICH-CITIES-002: a year becomes months that cover it without a gap or an overlap', () => {
|
|
// Dawarich reads start_at..end_at as inclusive on both ends, so touching
|
|
// bounds would hand the point on the seam to two windows.
|
|
const from = new Date('2025-09-14T20:00:00Z');
|
|
const to = new Date(from.getTime() + 365 * DAY);
|
|
const windows = splitWindow(from, to, 30);
|
|
|
|
expect(windows).toHaveLength(13);
|
|
expect(windows[0].from).toEqual(from);
|
|
expect(windows[windows.length - 1].to).toEqual(to);
|
|
for (let i = 1; i < windows.length; i++) {
|
|
expect(windows[i].from.getTime() - windows[i - 1].to.getTime()).toBe(1000);
|
|
}
|
|
for (const window of windows) {
|
|
expect(window.to.getTime() - window.from.getTime()).toBeLessThanOrEqual(30 * DAY);
|
|
}
|
|
});
|
|
|
|
it('DAWARICH-CITIES-003: bounds are whole seconds, the unit that goes on the wire', () => {
|
|
const windows = splitWindow(new Date('2026-01-01T00:00:00.750Z'), new Date('2026-03-01T00:00:00.250Z'), 30);
|
|
for (const window of windows) {
|
|
expect(window.from.getMilliseconds()).toBe(0);
|
|
expect(window.to.getMilliseconds()).toBe(0);
|
|
}
|
|
});
|
|
|
|
it('DAWARICH-CITIES-004: a range that ends before it starts asks nothing', () => {
|
|
expect(splitWindow(new Date('2026-09-02T00:00:00Z'), new Date('2026-09-01T00:00:00Z'), 30)).toEqual([]);
|
|
});
|
|
|
|
it('DAWARICH-CITIES-005: a city seen in two months adds up its time and keeps the later visit', () => {
|
|
const merged = mergeVisitedCountries([
|
|
[{ country: 'Germany', cities: [{ city: 'Rostock', points: 10, stayed_for: 90, timestamp: 1_700_000_000 }] }],
|
|
[
|
|
{
|
|
country: 'Germany',
|
|
cities: [
|
|
{ city: 'Rostock', points: 5, stayed_for: 60, timestamp: 1_702_000_000 },
|
|
{ city: 'Berlin', stayed_for: 120 },
|
|
],
|
|
},
|
|
{ country: 'Poland', cities: [{ city: 'Szczecin', stayed_for: 75, timestamp: 1_701_000_000 }] },
|
|
],
|
|
]);
|
|
|
|
expect(merged).toEqual([
|
|
{
|
|
country: 'Germany',
|
|
cities: [
|
|
{ city: 'Rostock', points: 15, stayed_for: 150, timestamp: 1_702_000_000 },
|
|
{ city: 'Berlin', stayed_for: 120 },
|
|
],
|
|
},
|
|
{ country: 'Poland', cities: [{ city: 'Szczecin', stayed_for: 75, timestamp: 1_701_000_000 }] },
|
|
]);
|
|
});
|
|
|
|
it('DAWARICH-CITIES-006: an unvalidated payload loses its unnamed entries, not its countries', () => {
|
|
const merged = mergeVisitedCountries([
|
|
[null as never, { country: 42 as never, cities: [] }, { country: 'Denmark', cities: null as never }],
|
|
[{ country: 'Denmark', cities: [null as never, {} as never, { city: 'Gedser', points: '7' as never }] }],
|
|
]);
|
|
|
|
// A count that arrived as a string is still a count; a timestamp nobody sent
|
|
// stays absent instead of turning into -Infinity.
|
|
expect(merged).toEqual([{ country: 'Denmark', cities: [{ city: 'Gedser', points: '7' }] }]);
|
|
|
|
const again = mergeVisitedCountries([
|
|
[{ country: 'Denmark', cities: [{ city: 'Gedser', points: '7' as never }] }],
|
|
[{ country: 'Denmark', cities: [{ city: 'Gedser', points: 3 }] }],
|
|
]);
|
|
expect(again[0].cities[0]).toEqual({ city: 'Gedser', points: 10, stayed_for: undefined, timestamp: undefined });
|
|
});
|
|
});
|