mirror of
https://github.com/mauriceboe/TREK.git
synced 2026-10-18 21:16:47 +00:00
Maurice
269bd9140f
Every country now carries the status of the strongest source it came from: a country reached by both a past and a future trip is visited, one that only appears in upcoming trips is planned. Marking a country by hand still wins over everything, since that is a statement of fact rather than a date. totalCountries drops to the visited ones and totalCountriesPlanned sits beside it; continents and mostVisited follow the same rule. countries[] stays a superset of what it returned before, so an older client keeps painting the map exactly as it did. The endpoint query has to select trip_id to know which trip a leg belongs to, which makes its DISTINCT per trip — the coordinates are collapsed again in JS so the point-in-polygon lookup still runs once per location.
1402 lines
68 KiB
TypeScript
1402 lines
68 KiB
TypeScript
/**
|
|
* Unit tests for the DI-native AtlasService and the atlas-geo helper module —
|
|
* ATLAS-UNIT-001..028 and ATLAS-SVC-001..028 moved 1:1 from the legacy
|
|
* tests/unit/services/atlasService.test.ts (case IDs preserved), plus
|
|
* Uses a real in-memory SQLite DB so the SQL
|
|
* logic is exercised faithfully; the pure-geo functions are imported straight
|
|
* from atlas-geo (their caches are module-scoped there on purpose).
|
|
*/
|
|
import { describe, it, expect, vi, beforeAll, beforeEach, afterAll } from 'vitest';
|
|
|
|
// ── DB setup (real in-memory SQLite — same pattern as mcp unit tests) ────────
|
|
|
|
const { testDb, dbMock } = vi.hoisted(() => {
|
|
const Database = require('better-sqlite3');
|
|
const db = new Database(':memory:');
|
|
db.exec('PRAGMA journal_mode = WAL');
|
|
db.exec('PRAGMA foreign_keys = ON');
|
|
db.exec('PRAGMA busy_timeout = 5000');
|
|
const mock = {
|
|
db,
|
|
closeDb: () => {},
|
|
reinitialize: () => {},
|
|
getPlaceWithTags: () => null,
|
|
canAccessTrip: (tripId: any, userId: number) =>
|
|
db.prepare(`
|
|
SELECT t.id, t.user_id FROM trips t
|
|
LEFT JOIN trip_members m ON m.trip_id = t.id AND m.user_id = ?
|
|
WHERE t.id = ? AND (t.user_id = ? OR m.user_id IS NOT NULL)
|
|
`).get(userId, tripId, userId),
|
|
isOwner: (tripId: any, userId: number) =>
|
|
!!db.prepare('SELECT id FROM trips WHERE id = ? AND user_id = ?').get(tripId, userId),
|
|
};
|
|
return { testDb: db, dbMock: mock };
|
|
});
|
|
|
|
vi.mock('../../../src/db/database', () => dbMock);
|
|
|
|
import { createTables } from '../../../src/db/schema';
|
|
import { runMigrations } from '../../../src/db/migrations';
|
|
import { resetTestDb } from '../../helpers/test-db';
|
|
import { createUser, createTrip, createReservation } from '../../helpers/factories';
|
|
import { getCached, setCache, getCountryFromCoords, getCountryFromAddress, isPointInCountryBox, reverseGeocodeCountry, getRegionGeo, getCountryGeo } from '../../../src/nest/atlas/atlas-geo';
|
|
import { DatabaseService } from '../../../src/nest/database/database.service';
|
|
import { AtlasService } from '../../../src/nest/atlas/atlas.service';
|
|
|
|
// Direct construction over the shared test connection — no TestingModule (repo
|
|
// convention for DI-native service unit tests).
|
|
const atlas = new AtlasService(new DatabaseService(testDb));
|
|
|
|
function insertReservationEndpoint(
|
|
db: any,
|
|
reservationId: number,
|
|
role: 'from' | 'to' | 'stop',
|
|
sequence: number,
|
|
lat: number,
|
|
lng: number
|
|
) {
|
|
db.prepare(
|
|
'INSERT INTO reservation_endpoints (reservation_id, role, sequence, name, lat, lng) VALUES (?, ?, ?, ?, ?, ?)'
|
|
).run(reservationId, role, sequence, `Endpoint ${sequence}`, lat, lng);
|
|
}
|
|
|
|
function insertPlace(db: any, tripId: number, name: string, address: string | null = null) {
|
|
const cat = db.prepare('SELECT id FROM categories LIMIT 1').get() as { id: number } | undefined;
|
|
const result = db.prepare(
|
|
'INSERT INTO places (trip_id, name, address, category_id) VALUES (?, ?, ?, ?)'
|
|
).run(tripId, name, address, cat?.id ?? null);
|
|
return db.prepare('SELECT * FROM places WHERE id = ?').get(result.lastInsertRowid);
|
|
}
|
|
|
|
beforeAll(() => {
|
|
createTables(testDb);
|
|
runMigrations(testDb);
|
|
});
|
|
|
|
beforeEach(() => {
|
|
resetTestDb(testDb);
|
|
// Stub fetch so reverseGeocodeCountry never makes real HTTP calls
|
|
vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
|
|
ok: false,
|
|
json: async () => ({}),
|
|
}));
|
|
});
|
|
|
|
afterAll(() => {
|
|
vi.unstubAllGlobals();
|
|
testDb.close();
|
|
});
|
|
|
|
// ── Tests ────────────────────────────────────────────────────────────────────
|
|
|
|
describe('getStats', () => {
|
|
it('ATLAS-UNIT-001: returns mostVisited null when trips have no resolvable countries (guards reduce on empty array)', async () => {
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'Mystery Trip' });
|
|
// Place with no address and no coordinates → can't resolve country
|
|
insertPlace(testDb, trip.id, 'Unknown Place', null);
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
expect(stats.mostVisited).toBeNull();
|
|
expect(stats.countries).toEqual([]);
|
|
expect(stats.stats.totalPlaces).toBe(1);
|
|
expect(stats.stats.totalCountries).toBe(0);
|
|
});
|
|
|
|
it('ATLAS-UNIT-002: returns the country with the highest placeCount as mostVisited', async () => {
|
|
const { user } = createUser(testDb);
|
|
// Dated in the past on purpose: since #1048 only a trip that has already started
|
|
// counts as visited, and mostVisited/totalCountries only look at visited countries.
|
|
const trip = createTrip(testDb, user.id, { title: 'Euro Tour', start_date: '2023-05-01', end_date: '2023-05-10' });
|
|
|
|
// 3 places in France, 1 in Germany → France should win
|
|
for (let i = 0; i < 3; i++) {
|
|
insertPlace(testDb, trip.id, `Paris Place ${i}`, `Street ${i}, Paris, France`);
|
|
}
|
|
insertPlace(testDb, trip.id, 'Berlin Place', 'Some Street, Berlin, Germany');
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
expect(stats.mostVisited).not.toBeNull();
|
|
expect(stats.mostVisited!.code).toBe('FR');
|
|
expect(stats.mostVisited!.placeCount).toBe(3);
|
|
expect(stats.countries).toHaveLength(2);
|
|
expect(stats.stats.totalCountries).toBe(2);
|
|
});
|
|
|
|
it('ATLAS-UNIT-003: returns manually marked countries when user has no trips', async () => {
|
|
const { user } = createUser(testDb);
|
|
testDb.prepare('INSERT INTO visited_countries (user_id, country_code) VALUES (?, ?)').run(user.id, 'JP');
|
|
testDb.prepare('INSERT INTO visited_countries (user_id, country_code) VALUES (?, ?)').run(user.id, 'AU');
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
expect(stats.countries).toHaveLength(2);
|
|
expect(stats.countries.map((c: { code: string }) => c.code).sort()).toEqual(['AU', 'JP']);
|
|
expect(stats.stats.totalTrips).toBe(0);
|
|
expect(stats.stats.totalCountries).toBe(2);
|
|
});
|
|
|
|
it('ATLAS-UNIT-004: single country yields mostVisited equal to that country', async () => {
|
|
const { user } = createUser(testDb);
|
|
// Past dates — see ATLAS-UNIT-002; a dateless trip is an 'idea' and never mostVisited.
|
|
const trip = createTrip(testDb, user.id, { title: 'Italy Trip', start_date: '2023-05-01', end_date: '2023-05-10' });
|
|
insertPlace(testDb, trip.id, 'Colosseum', 'Piazza del Colosseo, Rome, Italy');
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
expect(stats.mostVisited).not.toBeNull();
|
|
expect(stats.mostVisited!.code).toBe('IT');
|
|
expect(stats.mostVisited!.placeCount).toBe(1);
|
|
});
|
|
|
|
it('ATLAS-UNIT-022 (#1366): a country reached only via a real flight leg (from/to) counts as visited', async () => {
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'Tokyo Layover Trip' });
|
|
const reservation = createReservation(testDb, trip.id, { type: 'flight' });
|
|
// Tokyo: 35.6762°N, 139.6503°E — inside the JP bounding box, no place row.
|
|
insertReservationEndpoint(testDb, reservation.id, 'from', 0, 35.6762, 139.6503);
|
|
insertReservationEndpoint(testDb, reservation.id, 'to', 1, 51.4700, -0.4543);
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
const codes = stats.countries.map((c: { code: string }) => c.code);
|
|
expect(codes).toContain('JP');
|
|
expect(codes).toContain('GB');
|
|
});
|
|
|
|
it('ATLAS-UNIT-023 (#1366 regression): a country only touched as a connecting-flight stop does NOT count as visited', async () => {
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'Tokyo Connection Trip' });
|
|
const reservation = createReservation(testDb, trip.id, { type: 'flight' });
|
|
// Departs Belgium, connects through Tokyo (role: stop — never leaves the airport),
|
|
// lands in Australia. Only BE/AU were actually reached.
|
|
insertReservationEndpoint(testDb, reservation.id, 'from', 0, 50.9014, 4.4844);
|
|
insertReservationEndpoint(testDb, reservation.id, 'stop', 1, 35.6762, 139.6503);
|
|
insertReservationEndpoint(testDb, reservation.id, 'to', 2, -33.8688, 151.2093);
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
const codes = stats.countries.map((c: { code: string }) => c.code);
|
|
expect(codes).toContain('BE');
|
|
expect(codes).toContain('AU');
|
|
expect(codes).not.toContain('JP');
|
|
});
|
|
|
|
it('ATLAS-UNIT-024 (#1490): a flight endpoint in southern Spain counts as ES, not DZ', async () => {
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'Malaga Trip' });
|
|
const reservation = createReservation(testDb, trip.id, { type: 'flight' });
|
|
// Brussels -> Malaga airport (36.6749, -4.4991). The destination sits inside both
|
|
// the ES and DZ bounding boxes; without the ES entry it geocoded to Algeria.
|
|
insertReservationEndpoint(testDb, reservation.id, 'from', 0, 50.9014, 4.4844);
|
|
insertReservationEndpoint(testDb, reservation.id, 'to', 1, 36.6749, -4.4991);
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
const codes = stats.countries.map((c: { code: string }) => c.code);
|
|
expect(codes).toContain('ES');
|
|
expect(codes).not.toContain('DZ');
|
|
});
|
|
});
|
|
|
|
// ── getCached / setCache ────────────────────────────────────────────────────
|
|
|
|
describe('getCached and setCache', () => {
|
|
it('ATLAS-SVC-001: getCached returns undefined for unknown coordinates', () => {
|
|
// Use uniquely large lat values to guarantee no prior cache entry
|
|
const result = getCached(9001.001, 9001.001);
|
|
expect(result).toBeUndefined();
|
|
});
|
|
|
|
it('ATLAS-SVC-002: setCache then getCached returns the stored code', () => {
|
|
setCache(9002.002, 9002.002, 'DE');
|
|
const result = getCached(9002.002, 9002.002);
|
|
expect(result).toBe('DE');
|
|
});
|
|
|
|
it('ATLAS-SVC-003: setCache can store null (country unknown)', () => {
|
|
setCache(9003.003, 9003.003, null);
|
|
const result = getCached(9003.003, 9003.003);
|
|
expect(result).toBeNull();
|
|
});
|
|
|
|
it('ATLAS-SVC-004: different coordinates return different cached values', () => {
|
|
setCache(9004.004, 9004.004, 'FR');
|
|
setCache(9004.005, 9004.005, 'ES');
|
|
expect(getCached(9004.004, 9004.004)).toBe('FR');
|
|
expect(getCached(9004.005, 9004.005)).toBe('ES');
|
|
});
|
|
});
|
|
|
|
// ── getCountryFromCoords ────────────────────────────────────────────────────
|
|
|
|
describe('getCountryFromCoords', () => {
|
|
it('ATLAS-SVC-005: returns country code for Paris coordinates (France)', () => {
|
|
// Paris: approximately 48.85°N, 2.35°E — well inside FR bounding box
|
|
const code = getCountryFromCoords(48.85, 2.35);
|
|
expect(code).toBe('FR');
|
|
});
|
|
|
|
it('ATLAS-SVC-006: returns country code for NYC coordinates (USA)', () => {
|
|
// New York City: approximately 40.71°N, -74.0°W — inside US bounding box
|
|
const code = getCountryFromCoords(40.71, -74.0);
|
|
expect(code).toBe('US');
|
|
});
|
|
|
|
it('ATLAS-SVC-007: returns null for coordinates with no country match (0,0)', () => {
|
|
// Gulf of Guinea — no COUNTRY_BOXES entry covers 0°N, 0°E
|
|
const code = getCountryFromCoords(0.0, 0.0);
|
|
expect(code).toBeNull();
|
|
});
|
|
|
|
it('ATLAS-SVC-005b: #1331 a point inside France near the German border resolves to FR, not the smaller overlapping box', () => {
|
|
// Strasbourg (48.573, 7.752) sits inside BOTH the FR and DE bounding boxes; the old
|
|
// smallest-box rule mis-picked DE (its box is smaller). Point-in-polygon picks FR.
|
|
expect(getCountryFromCoords(48.5734, 7.7521)).toBe('FR');
|
|
});
|
|
|
|
it('ATLAS-SVC-005c: #1331 a point inside Germany near the French border resolves to DE', () => {
|
|
// Kehl (48.575, 7.815) — the German side of the same border.
|
|
expect(getCountryFromCoords(48.5750, 7.8150)).toBe('DE');
|
|
});
|
|
|
|
it('ATLAS-SVC-005d: #1331 a micro-territory without an admin0 polygon keeps the smallest-box win (Hong Kong)', () => {
|
|
// HK is not a separate admin0 polygon (it falls inside CN there), so the smallest
|
|
// bounding box still wins for it.
|
|
expect(getCountryFromCoords(22.30, 114.17)).toBe('HK');
|
|
});
|
|
|
|
it('ATLAS-SVC-005e: #1490 a point in southern Spain resolves to ES, not the overlapping Algeria box', () => {
|
|
// The ES entry was dropped when the lookup tables were expanded, leaving DZ as the
|
|
// only box covering Malaga (36.72, -4.42) — so flights into southern Spain marked
|
|
// Algeria as visited, and it could not be removed because it was re-derived on
|
|
// every Atlas load.
|
|
expect(getCountryFromCoords(36.7213, -4.4215)).toBe('ES');
|
|
});
|
|
|
|
it('ATLAS-SVC-005f: #1490 Barcelona resolves to ES, not the overlapping FR box', () => {
|
|
// Barcelona sits inside the FR box too (lat > 41.3); with no ES entry it was
|
|
// assigned to France outright.
|
|
expect(getCountryFromCoords(41.3874, 2.1686)).toBe('ES');
|
|
});
|
|
|
|
it('ATLAS-SVC-005g: #1490 a country the hand-written box table omitted resolves correctly (Nigeria)', () => {
|
|
// NG had no bounding box at all, so Lagos fell into Benin's box as the only
|
|
// candidate and phantom-marked BJ as visited. Same class for Kano -> CM.
|
|
expect(getCountryFromCoords(6.5244, 3.3792)).toBe('NG'); // Lagos
|
|
expect(getCountryFromCoords(12.0022, 8.5920)).toBe('NG'); // Kano
|
|
expect(getCountryFromCoords(9.0765, 7.3986)).toBe('NG'); // Abuja
|
|
});
|
|
|
|
it('ATLAS-SVC-005h: #1490 other previously box-less countries resolve (BY, GL, KP, TD, SS)', () => {
|
|
expect(getCountryFromCoords(53.9006, 27.5590)).toBe('BY'); // Minsk (was RU)
|
|
expect(getCountryFromCoords(64.1836, -51.7214)).toBe('GL'); // Nuuk
|
|
expect(getCountryFromCoords(39.0392, 125.7625)).toBe('KP'); // Pyongyang
|
|
expect(getCountryFromCoords(12.1348, 15.0557)).toBe('TD'); // N'Djamena
|
|
expect(getCountryFromCoords(4.8594, 31.5713)).toBe('SS'); // Juba
|
|
});
|
|
|
|
it('ATLAS-SVC-005i: #1490 countries straddling the antimeridian resolve per-part, not to a globe-spanning box', () => {
|
|
// Boxes are derived one-per-geometry-part. A single box around RU/US/FJ would span
|
|
// nearly the whole globe and swallow unrelated points.
|
|
expect(getCountryFromCoords(61.2181, -149.9003)).toBe('US'); // Anchorage
|
|
expect(getCountryFromCoords(64.4230, -173.2260)).toBe('RU'); // Provideniya, east of 180
|
|
expect(getCountryFromCoords(-18.1416, 178.4419)).toBe('FJ'); // Suva
|
|
});
|
|
|
|
it('ATLAS-SVC-005j: a loose polygon-less box (PS) does not steal Israeli points inside the IL polygon', () => {
|
|
// PS has no admin0 polygon and its box sprawls across most of Israel. It must NOT win
|
|
// the smallest-box tie-break over IL's real polygon: Tel Aviv, Jerusalem, Eilat and
|
|
// Beersheba all lie in the IL polygon and must resolve to IL, not PS.
|
|
expect(getCountryFromCoords(32.0853, 34.7818)).toBe('IL'); // Tel Aviv
|
|
expect(getCountryFromCoords(31.7683, 35.2137)).toBe('IL'); // Jerusalem
|
|
expect(getCountryFromCoords(29.5577, 34.9519)).toBe('IL'); // Eilat
|
|
expect(getCountryFromCoords(31.2518, 34.7913)).toBe('IL'); // Beersheba
|
|
});
|
|
|
|
it('ATLAS-SVC-005k: a genuine West Bank / Gaza point still resolves to PS via the deferred box', () => {
|
|
// The fix only defers the loose box behind real polygons; a point that lies in NO
|
|
// sovereign polygon (the West Bank / Gaza are excluded from the IL polygon) still
|
|
// lands on the PS box.
|
|
expect(getCountryFromCoords(31.9038, 35.2034)).toBe('PS'); // Ramallah
|
|
expect(getCountryFromCoords(31.5017, 34.4668)).toBe('PS'); // Gaza City
|
|
});
|
|
|
|
it('ATLAS-SVC-005l: the loose XK box does not steal North Macedonian points inside the MK polygon', () => {
|
|
// Same mechanism as PS: XK is polygon-less and its box overlaps North Macedonia.
|
|
// Skopje and Tetovo lie in the MK polygon and must resolve to MK, not XK — while
|
|
// Pristina (in no neighbouring polygon) still resolves to XK.
|
|
expect(getCountryFromCoords(41.9973, 21.4280)).toBe('MK'); // Skopje
|
|
expect(getCountryFromCoords(42.0106, 20.9714)).toBe('MK'); // Tetovo
|
|
expect(getCountryFromCoords(42.6629, 21.1655)).toBe('XK'); // Pristina
|
|
});
|
|
});
|
|
|
|
// ── isPointInCountryBox — sanity gate for the address-derived region fallback ──────
|
|
|
|
describe('isPointInCountryBox', () => {
|
|
it('ATLAS-SVC-006a: accepts a country whose box genuinely covers the point, even where the exact border excludes it', () => {
|
|
// Bollendorf-Pont: on the Luxembourg side of the border, but outside LU's exact
|
|
// simplified polygon (see getCountryFromCoords returning DE for this same point in
|
|
// atlasService.test.ts's region-resolution tests). The box gate must stay loose
|
|
// enough to admit this, or the Luxembourg address-fallback fix would regress.
|
|
expect(isPointInCountryBox('LU', 49.8502458, 6.3576404)).toBe(true);
|
|
});
|
|
|
|
it('ATLAS-SVC-006b: rejects a country whose box is nowhere near the point', () => {
|
|
// Mid-Atlantic, nowhere close to Japan under any simplification.
|
|
expect(isPointInCountryBox('JP', 20, -35)).toBe(false);
|
|
});
|
|
|
|
it('ATLAS-SVC-006c: returns false for an unknown/garbage country code', () => {
|
|
expect(isPointInCountryBox('ZZ', 48.85, 2.35)).toBe(false);
|
|
});
|
|
});
|
|
|
|
// ── Removing a visited country sticks (#1490) ───────────────────────────────
|
|
|
|
describe('unmarkCountryVisited — tombstones', () => {
|
|
it('ATLAS-SVC-021: #1490 a country derived from a flight endpoint stays removed across reloads', async () => {
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'Layover Trip' });
|
|
const reservation = createReservation(testDb, trip.id, { type: 'flight' });
|
|
// Brussels -> Tokyo. JP is derived from the endpoint; it has no visited_countries
|
|
// row, so the DELETE in unmarkCountryVisited used to affect nothing and getStats
|
|
// re-derived JP on the very next call.
|
|
insertReservationEndpoint(testDb, reservation.id, 'from', 0, 50.9014, 4.4844);
|
|
insertReservationEndpoint(testDb, reservation.id, 'to', 1, 35.6762, 139.6503);
|
|
|
|
const before = await atlas.stats(user.id);
|
|
expect(before.countries.map((c: { code: string }) => c.code)).toContain('JP');
|
|
|
|
atlas.unmarkCountry(user.id, 'JP');
|
|
|
|
const after = await atlas.stats(user.id);
|
|
expect(after.countries.map((c: { code: string }) => c.code)).not.toContain('JP');
|
|
// BE is untouched — removal is scoped to the one country.
|
|
expect(after.countries.map((c: { code: string }) => c.code)).toContain('BE');
|
|
});
|
|
|
|
it('ATLAS-SVC-022: #1490 re-marking a removed country brings it back', async () => {
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'Layover Trip' });
|
|
const reservation = createReservation(testDb, trip.id, { type: 'flight' });
|
|
insertReservationEndpoint(testDb, reservation.id, 'from', 0, 50.9014, 4.4844);
|
|
insertReservationEndpoint(testDb, reservation.id, 'to', 1, 35.6762, 139.6503);
|
|
|
|
atlas.unmarkCountry(user.id, 'JP');
|
|
expect((await atlas.stats(user.id)).countries.map((c: { code: string }) => c.code)).not.toContain('JP');
|
|
|
|
atlas.markCountry(user.id, 'JP');
|
|
expect((await atlas.stats(user.id)).countries.map((c: { code: string }) => c.code)).toContain('JP');
|
|
});
|
|
|
|
it('ATLAS-SVC-023: #1490 a removed country reappears once it has a real place', async () => {
|
|
// The tombstone only suppresses zero-count derivations. Planning an actual place in
|
|
// the country is an unambiguous signal it was visited, so it should show again.
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'Japan Trip' });
|
|
const reservation = createReservation(testDb, trip.id, { type: 'flight' });
|
|
insertReservationEndpoint(testDb, reservation.id, 'from', 0, 50.9014, 4.4844);
|
|
insertReservationEndpoint(testDb, reservation.id, 'to', 1, 35.6762, 139.6503);
|
|
|
|
atlas.unmarkCountry(user.id, 'JP');
|
|
expect((await atlas.stats(user.id)).countries.map((c: { code: string }) => c.code)).not.toContain('JP');
|
|
|
|
insertPlace(testDb, trip.id, 'Senso-ji', 'Asakusa, Tokyo, Japan');
|
|
|
|
const after = await atlas.stats(user.id);
|
|
const jp = after.countries.find((c: { code: string }) => c.code === 'JP');
|
|
expect(jp).toBeDefined();
|
|
expect(jp!.placeCount).toBe(1);
|
|
});
|
|
});
|
|
|
|
// ── getCountryFromAddress ───────────────────────────────────────────────────
|
|
|
|
describe('getCountryFromAddress', () => {
|
|
it('ATLAS-SVC-008: returns null for null address', () => {
|
|
expect(getCountryFromAddress(null)).toBeNull();
|
|
});
|
|
|
|
it('ATLAS-SVC-009: returns null for empty string', () => {
|
|
expect(getCountryFromAddress('')).toBeNull();
|
|
});
|
|
|
|
it('ATLAS-SVC-010: parses "France" in last position to "FR"', () => {
|
|
expect(getCountryFromAddress('Eiffel Tower, Paris, France')).toBe('FR');
|
|
});
|
|
|
|
it('ATLAS-SVC-011: returns 2-letter ISO code directly when last part is uppercase 2-letter', () => {
|
|
// "US" is uppercase and exactly 2 characters — returned verbatim
|
|
expect(getCountryFromAddress('123 Main St, New York, US')).toBe('US');
|
|
});
|
|
|
|
it('ATLAS-SVC-012: returns null for unrecognized country name', () => {
|
|
expect(getCountryFromAddress('Unknown City, Unknown Country')).toBeNull();
|
|
});
|
|
});
|
|
|
|
// ── reverseGeocodeCountry ───────────────────────────────────────────────────
|
|
|
|
describe('reverseGeocodeCountry', () => {
|
|
it('ATLAS-SVC-013: returns null when fetch fails (ok:false)', async () => {
|
|
// The beforeEach stub already returns ok:false — this is the default path
|
|
const code = await reverseGeocodeCountry(9013.013, 9013.013);
|
|
expect(code).toBeNull();
|
|
});
|
|
|
|
it('ATLAS-SVC-014: returns country code when Nominatim returns valid response', async () => {
|
|
vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
|
|
ok: true,
|
|
json: async () => ({ address: { country_code: 'fr' } }),
|
|
}));
|
|
// Berlin-ish coords not used elsewhere — unique to avoid cache collision
|
|
const code = await reverseGeocodeCountry(52.52, 13.40);
|
|
expect(code).toBe('FR');
|
|
});
|
|
|
|
it('ATLAS-SVC-015: returns null when fetch throws a network error', async () => {
|
|
vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('Network error')));
|
|
const code = await reverseGeocodeCountry(9015.015, 9015.015);
|
|
expect(code).toBeNull();
|
|
});
|
|
|
|
it('ATLAS-SVC-016: returns cached result on second call (fetch called only once)', async () => {
|
|
const mockFetch = vi.fn().mockResolvedValue({
|
|
ok: true,
|
|
json: async () => ({ address: { country_code: 'gb' } }),
|
|
});
|
|
vi.stubGlobal('fetch', mockFetch);
|
|
|
|
// Use unique coords so neither call hits a prior cache entry
|
|
const first = await reverseGeocodeCountry(9016.016, 9016.016);
|
|
const second = await reverseGeocodeCountry(9016.016, 9016.016);
|
|
|
|
expect(first).toBe('GB');
|
|
expect(second).toBe('GB');
|
|
// fetch should have been invoked only once; the second call uses the in-memory cache
|
|
expect(mockFetch).toHaveBeenCalledTimes(1);
|
|
});
|
|
});
|
|
|
|
// ── getRegionGeo ────────────────────────────────────────────────────────────
|
|
|
|
// These read the committed geoBoundaries bundle (server/assets/atlas/admin1.geojson.gz),
|
|
// so they double as a guard that the bundle ships current sub-national data (#1119).
|
|
describe('getRegionGeo', () => {
|
|
it('ATLAS-SVC-017: returns an empty FeatureCollection for a country with no admin-1 features', async () => {
|
|
const result = await getRegionGeo(['ZZ']);
|
|
expect(result).toEqual({ type: 'FeatureCollection', features: [] });
|
|
});
|
|
|
|
it('ATLAS-SVC-018: returns the current geoBoundaries regions for a country, case-insensitively', async () => {
|
|
// Pass lowercase 'no' — getRegionGeo uppercases internally for matching.
|
|
const result = await getRegionGeo(['no']);
|
|
|
|
expect(result.type).toBe('FeatureCollection');
|
|
expect(result.features.length).toBeGreaterThan(0);
|
|
expect(result.features.every((f: any) => f.properties.iso_a2 === 'NO')).toBe(true);
|
|
|
|
const names = result.features.map((f: any) => f.properties.name);
|
|
const codes = result.features.map((f: any) => f.properties.iso_3166_2);
|
|
// Post-2020 reform is present…
|
|
expect(codes).toContain('NO-34'); // Innlandet
|
|
expect(codes).toContain('NO-46'); // Vestland
|
|
// …and the merged-away pre-2020 counties are gone (the original #1119 bug).
|
|
expect(names).not.toContain('Oppland');
|
|
expect(names).not.toContain('Hordaland');
|
|
expect(names).not.toContain('Sogn og Fjordane');
|
|
});
|
|
});
|
|
|
|
describe('getCountryGeo', () => {
|
|
it('ATLAS-SVC-019: returns the admin-0 FeatureCollection with ISO_A2/ADM0_A3 properties', () => {
|
|
const geo = getCountryGeo();
|
|
expect(geo.type).toBe('FeatureCollection');
|
|
expect(geo.features.length).toBeGreaterThan(0);
|
|
const no = geo.features.find((f: any) => f.properties.ISO_A2 === 'NO');
|
|
expect(no).toBeDefined();
|
|
expect(no.properties.ADM0_A3).toBe('NOR');
|
|
expect(no.properties.NAME).toBe('Norway');
|
|
});
|
|
|
|
it('ATLAS-SVC-020: includes territories that the curated list dropped (Greenland + Svalbard)', () => {
|
|
const geo = getCountryGeo();
|
|
// Greenland is its own feature.
|
|
expect(geo.features.some((f: any) => f.properties.ISO_A2 === 'GL')).toBe(true);
|
|
// Svalbard has no separate ISO entity in geoBoundaries; it sits inside Norway's
|
|
// geometry (lat ~74-81°N). Guard that the country polygon reaches those latitudes.
|
|
const no = geo.features.find((f: any) => f.properties.ISO_A2 === 'NO');
|
|
const maxLat = (function max(coords: any): number {
|
|
if (typeof coords[0] === 'number') return coords[1];
|
|
return Math.max(...coords.map(max));
|
|
})(no.geometry.coordinates);
|
|
expect(maxLat).toBeGreaterThan(78);
|
|
});
|
|
});
|
|
|
|
// ── Helpers for new tests ────────────────────────────────────────────────────
|
|
|
|
function insertPlaceWithCoords(db: any, tripId: number, name: string, lat: number, lng: number, address: string | null = null) {
|
|
const cat = db.prepare('SELECT id FROM categories LIMIT 1').get() as { id: number } | undefined;
|
|
const result = db.prepare(
|
|
'INSERT INTO places (trip_id, name, address, lat, lng, category_id) VALUES (?, ?, ?, ?, ?, ?)'
|
|
).run(tripId, name, address, lat, lng, cat?.id ?? null);
|
|
return db.prepare('SELECT * FROM places WHERE id = ?').get(result.lastInsertRowid);
|
|
}
|
|
|
|
// ── getStats — extended ──────────────────────────────────────────────────────
|
|
|
|
describe('getStats — extended', () => {
|
|
it('ATLAS-UNIT-005: totalDays is calculated when trip has start_date and end_date', async () => {
|
|
const { user } = createUser(testDb);
|
|
createTrip(testDb, user.id, { title: 'Short Trip', start_date: '2024-03-01', end_date: '2024-03-03' });
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
// March 1, 2, 3 → diff = 2 + 1 = 3
|
|
expect(stats.stats.totalDays).toBe(3);
|
|
});
|
|
|
|
it('ATLAS-UNIT-006: totalDays is 0 when trip has no dates', async () => {
|
|
const { user } = createUser(testDb);
|
|
createTrip(testDb, user.id, { title: 'Dateless' });
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
expect(stats.stats.totalDays).toBe(0);
|
|
});
|
|
|
|
it('ATLAS-UNIT-007: manually marked country is merged when user has trips but no resolvable places for that country', async () => {
|
|
const { user } = createUser(testDb);
|
|
createTrip(testDb, user.id, { title: 'Japan Trip', start_date: '2024-01-01', end_date: '2024-01-10' });
|
|
testDb.prepare('INSERT INTO visited_countries (user_id, country_code) VALUES (?, ?)').run(user.id, 'JP');
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
const codes = stats.countries.map((c: any) => c.code);
|
|
expect(codes).toContain('JP');
|
|
const jp = stats.countries.find((c: any) => c.code === 'JP');
|
|
expect(jp?.placeCount).toBe(0);
|
|
});
|
|
|
|
it('ATLAS-UNIT-008: lastTrip is resolved with a country code when its places have an address', async () => {
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'Past France Trip', start_date: '2023-05-01', end_date: '2023-05-10' });
|
|
insertPlace(testDb, trip.id, 'Eiffel Tower', 'Champ de Mars, Paris, France');
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
expect(stats.lastTrip).not.toBeNull();
|
|
expect(stats.lastTrip!.countryCode).toBe('FR');
|
|
});
|
|
|
|
it('ATLAS-UNIT-009: nextTrip has daysUntil calculated', async () => {
|
|
const { user } = createUser(testDb);
|
|
const futureDate = new Date();
|
|
futureDate.setFullYear(futureDate.getFullYear() + 1);
|
|
const futureDateStr = futureDate.toISOString().split('T')[0];
|
|
createTrip(testDb, user.id, { title: 'Future Trip', start_date: futureDateStr });
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
expect(stats.nextTrip).not.toBeNull();
|
|
expect(stats.nextTrip!.daysUntil).toBeGreaterThan(0);
|
|
});
|
|
|
|
it('ATLAS-UNIT-010: streak counts consecutive years with trips and firstYear is the earliest', async () => {
|
|
const { user } = createUser(testDb);
|
|
const currentYear = new Date().getFullYear();
|
|
createTrip(testDb, user.id, { title: 'This Year', start_date: `${currentYear}-06-01`, end_date: `${currentYear}-06-10` });
|
|
createTrip(testDb, user.id, { title: 'Last Year', start_date: `${currentYear - 1}-07-01`, end_date: `${currentYear - 1}-07-10` });
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
expect(stats.streak).toBeGreaterThanOrEqual(1);
|
|
expect(stats.firstYear).toBe(currentYear - 1);
|
|
});
|
|
|
|
it('ATLAS-UNIT-011: tripsThisYear counts only trips whose start_date is in the current year', async () => {
|
|
const { user } = createUser(testDb);
|
|
const currentYear = new Date().getFullYear();
|
|
createTrip(testDb, user.id, { title: 'This Year', start_date: `${currentYear}-03-01` });
|
|
createTrip(testDb, user.id, { title: 'Last Year', start_date: `${currentYear - 1}-03-01` });
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
expect(stats.tripsThisYear).toBe(1);
|
|
});
|
|
|
|
it('ATLAS-UNIT-012: lastTrip is null when all trips end in the future', async () => {
|
|
const { user } = createUser(testDb);
|
|
const nextYear = new Date().getFullYear() + 1;
|
|
createTrip(testDb, user.id, { title: 'Future', start_date: `${nextYear}-01-01`, end_date: `${nextYear}-01-10` });
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
expect(stats.lastTrip).toBeNull();
|
|
});
|
|
|
|
it('ATLAS-UNIT-027: a US place whose address ends in a state abbreviation resolves to US, not the colliding ISO country', async () => {
|
|
// getCountryFromAddress()'s "2-letter uppercase last segment = ISO code" heuristic
|
|
// parses "..., CA" as Canada (a real ISO code), not California. resolveCountryCodeSync
|
|
// used to try the address FIRST, so a place with coordinates that plainly resolve to the
|
|
// US via getCountryFromCoords would still get bucketed under Canada. Mirrors the
|
|
// region-level fix (ATLAS-UNIT-024) at the country level.
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'San Francisco Trip' });
|
|
insertPlaceWithCoords(testDb, trip.id, 'Hotel Pickwick', 37.7830549, -122.4066689, '85 5th St, San Francisco, CA');
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
const codes = stats.countries.map((c: any) => c.code);
|
|
expect(codes).toContain('US');
|
|
expect(codes).not.toContain('CA');
|
|
});
|
|
|
|
it('ATLAS-UNIT-028: lastTrip.countryCode resolves via coordinates, not a misparsed state-abbreviation address', async () => {
|
|
// lastTrip.countryCode calls resolveCountryCodeSync directly (not through the
|
|
// place_regions cache), so this exercises the fix independently of ATLAS-UNIT-027.
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'Past NY Trip', start_date: '2023-05-01', end_date: '2023-05-10' });
|
|
insertPlaceWithCoords(testDb, trip.id, 'Imperial Court Hotel', 40.7848394, -73.981643, '307 W 79th Street, New York, NY');
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
expect(stats.lastTrip).not.toBeNull();
|
|
expect(stats.lastTrip!.countryCode).toBe('US');
|
|
});
|
|
});
|
|
|
|
// ── getCountryPlaces ─────────────────────────────────────────────────────────
|
|
|
|
describe('getCountryPlaces', () => {
|
|
it('ATLAS-UNIT-013: returns empty result when user has no trips', () => {
|
|
const { user } = createUser(testDb);
|
|
|
|
const result = atlas.countryPlaces(user.id, 'FR');
|
|
|
|
expect(result.places).toHaveLength(0);
|
|
expect(result.trips).toHaveLength(0);
|
|
expect(result.manually_marked).toBe(false);
|
|
});
|
|
|
|
it('ATLAS-UNIT-014: returns matching places when place address resolves to the requested country', () => {
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'France Trip' });
|
|
insertPlace(testDb, trip.id, 'Louvre', '75001 Paris, France');
|
|
insertPlace(testDb, trip.id, 'Berlin Wall', 'Bernauer Str., Berlin, Germany');
|
|
|
|
const result = atlas.countryPlaces(user.id, 'FR');
|
|
|
|
expect(result.places).toHaveLength(1);
|
|
expect(result.places[0].name).toBe('Louvre');
|
|
expect(result.trips).toHaveLength(1);
|
|
expect(result.trips[0].id).toBe(trip.id);
|
|
});
|
|
|
|
it('ATLAS-UNIT-015: manually_marked is true when country is in visited_countries', () => {
|
|
const { user } = createUser(testDb);
|
|
testDb.prepare('INSERT INTO visited_countries (user_id, country_code) VALUES (?, ?)').run(user.id, 'JP');
|
|
createTrip(testDb, user.id, { title: 'Japan' });
|
|
|
|
const result = atlas.countryPlaces(user.id, 'JP');
|
|
|
|
expect(result.manually_marked).toBe(true);
|
|
});
|
|
|
|
it('ATLAS-UNIT-016: place with coordinates resolves via bbox when address is absent', () => {
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'Coord Trip' });
|
|
// Paris coordinates (48.85°N, 2.35°E) — falls inside FR bounding box
|
|
insertPlaceWithCoords(testDb, trip.id, 'Secret Paris Spot', 48.85, 2.35);
|
|
|
|
const result = atlas.countryPlaces(user.id, 'FR');
|
|
|
|
expect(result.places).toHaveLength(1);
|
|
expect(result.places[0].name).toBe('Secret Paris Spot');
|
|
});
|
|
});
|
|
|
|
// ── getVisitedRegions ────────────────────────────────────────────────────────
|
|
|
|
describe('getVisitedRegions', () => {
|
|
it('ATLAS-UNIT-017: returns empty regions object when user has no trips', async () => {
|
|
const { user } = createUser(testDb);
|
|
|
|
const result = await atlas.visitedRegions(user.id);
|
|
|
|
expect(result.regions).toEqual({});
|
|
});
|
|
|
|
it('ATLAS-UNIT-018: returns manually marked regions even when user has no places with coordinates', async () => {
|
|
const { user } = createUser(testDb);
|
|
testDb.prepare('INSERT INTO visited_countries (user_id, country_code) VALUES (?, ?)').run(user.id, 'DE');
|
|
testDb.prepare('INSERT INTO visited_regions (user_id, region_code, region_name, country_code) VALUES (?, ?, ?, ?)').run(user.id, 'DE-BY', 'Bayern', 'DE');
|
|
|
|
const result = await atlas.visitedRegions(user.id);
|
|
|
|
expect(result.regions['DE']).toBeDefined();
|
|
const codes = result.regions['DE'].map((r: any) => r.code);
|
|
expect(codes).toContain('DE-BY');
|
|
const bayernRegion = result.regions['DE'].find((r: any) => r.code === 'DE-BY');
|
|
expect(bayernRegion?.manuallyMarked).toBe(true);
|
|
});
|
|
|
|
it('ATLAS-UNIT-019: geocodes places with lat/lng using reverseGeocodeRegion via fetch', async () => {
|
|
vi.useFakeTimers();
|
|
vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
|
|
ok: true,
|
|
json: async () => ({
|
|
address: {
|
|
country_code: 'fr',
|
|
'ISO3166-2-lvl4': 'FR-75',
|
|
state: 'Île-de-France',
|
|
},
|
|
}),
|
|
}));
|
|
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'Paris Trip' });
|
|
insertPlaceWithCoords(testDb, trip.id, 'Paris Hotel', 48.85, 2.35);
|
|
|
|
// First call triggers the background geocoding fire-and-forget
|
|
await atlas.visitedRegions(user.id);
|
|
// Advance all pending timers (including the 1100ms Nominatim rate-limit delay)
|
|
await vi.runAllTimersAsync();
|
|
// Second call returns now-cached data
|
|
const result = await atlas.visitedRegions(user.id);
|
|
|
|
expect(result.regions['FR']).toBeDefined();
|
|
|
|
vi.useRealTimers();
|
|
});
|
|
|
|
it('ATLAS-UNIT-020: places already cached in place_regions are not re-geocoded', async () => {
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'Cached Trip' });
|
|
const place = insertPlaceWithCoords(testDb, trip.id, 'Cached Place', 48.85, 2.35);
|
|
|
|
// Pre-populate the place_regions cache so the fetch path is never reached
|
|
testDb.prepare(
|
|
'INSERT OR REPLACE INTO place_regions (place_id, country_code, region_code, region_name) VALUES (?, ?, ?, ?)'
|
|
).run(place.id, 'FR', 'FR-75', 'Île-de-France');
|
|
|
|
const mockFetch = vi.fn().mockResolvedValue({ ok: true, json: async () => ({}) });
|
|
vi.stubGlobal('fetch', mockFetch);
|
|
|
|
const result = await atlas.visitedRegions(user.id);
|
|
|
|
expect(mockFetch).not.toHaveBeenCalled();
|
|
expect(result.regions['FR']).toBeDefined();
|
|
const codes = result.regions['FR'].map((r: any) => r.code);
|
|
expect(codes).toContain('FR-75');
|
|
});
|
|
|
|
it('ATLAS-UNIT-021: a GB place resolves against the bundled admin1 polygon without calling Nominatim', async () => {
|
|
// The shipped geoBoundaries bundle only carries GB's 4 constituent countries
|
|
// (England/Scotland/Wales/Northern Ireland) — no county/borough level. Resolving
|
|
// Old Trafford's coordinates directly against those polygons lands on GB-ENG, the
|
|
// same feature the client highlights, with no reverse-geocode round trip at all.
|
|
const mockFetch = vi.fn();
|
|
vi.stubGlobal('fetch', mockFetch);
|
|
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'Manchester Trip' });
|
|
insertPlaceWithCoords(testDb, trip.id, 'Old Trafford', 53.4631, -2.2913);
|
|
|
|
await atlas.visitedRegions(user.id);
|
|
// The background geocode is fire-and-forget; give its microtasks a turn to settle
|
|
// before reading the now-cached result back.
|
|
await new Promise(resolve => setTimeout(resolve, 10));
|
|
const result = await atlas.visitedRegions(user.id);
|
|
|
|
expect(mockFetch).not.toHaveBeenCalled();
|
|
expect(result.regions['GB']).toBeDefined();
|
|
const codes = result.regions['GB'].map((r: any) => r.code);
|
|
expect(codes).toContain('GB-ENG');
|
|
});
|
|
|
|
it('ATLAS-UNIT-022: a place whose Nominatim region level is finer than the bundle (Spain province vs autonomous community) still resolves to a bundle-matching feature', async () => {
|
|
// Regression for the Barcelona/Madrid bug: Nominatim's ISO3166-2-lvl6 gives the
|
|
// *province* (ES-B), but the bundle only has the *autonomous-community* level
|
|
// (Catalonia). Resolving by coordinates instead of trusting the geocoder's level
|
|
// guarantees a code the client bundle actually carries.
|
|
const mockFetch = vi.fn();
|
|
vi.stubGlobal('fetch', mockFetch);
|
|
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'Barcelona Trip' });
|
|
insertPlaceWithCoords(testDb, trip.id, 'Sagrada Familia', 41.4036, 2.1744);
|
|
|
|
await atlas.visitedRegions(user.id);
|
|
// The background geocode is fire-and-forget; give its microtasks a turn to settle
|
|
// before reading the now-cached result back.
|
|
await new Promise(resolve => setTimeout(resolve, 10));
|
|
const result = await atlas.visitedRegions(user.id);
|
|
|
|
expect(mockFetch).not.toHaveBeenCalled();
|
|
expect(result.regions['ES']).toBeDefined();
|
|
expect(result.regions['ES'][0].code).not.toBe('ES-B');
|
|
});
|
|
|
|
it('ATLAS-UNIT-023: a place address disambiguates a border point the simplified admin0 polygon puts in the wrong country', async () => {
|
|
// A real Airbnb at Bollendorf-Pont sits on the Luxembourg side of the Sauer river,
|
|
// but the coordinates alone fall inside Germany's simplified admin0 polygon
|
|
// (border-simplification slop) — getCountryFromCoords(lat, lng) returns DE, so a
|
|
// coordinate-only region lookup finds nothing in DE. The place's own stored address
|
|
// says Luxembourg, so it is retried as a fallback before ever reaching Nominatim.
|
|
const mockFetch = vi.fn();
|
|
vi.stubGlobal('fetch', mockFetch);
|
|
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'Luxembourg Trip' });
|
|
insertPlaceWithCoords(
|
|
testDb, trip.id, 'Airbnb - Welcome Home', 49.8502458, 6.3576404,
|
|
'4 Gruusswiss, Bollendorf-Pont, Distrikt Gréiwemaacher 6555, Luxembourg'
|
|
);
|
|
|
|
await atlas.visitedRegions(user.id);
|
|
await new Promise(resolve => setTimeout(resolve, 10));
|
|
const result = await atlas.visitedRegions(user.id);
|
|
|
|
expect(mockFetch).not.toHaveBeenCalled();
|
|
expect(result.regions['LU']).toBeDefined();
|
|
expect(result.regions['DE']).toBeUndefined();
|
|
});
|
|
|
|
it('ATLAS-UNIT-024: a US place whose address ends in a state abbreviation still resolves by coordinates, ignoring the address', async () => {
|
|
// getCountryFromAddress() treats any 2-letter uppercase last address segment as an
|
|
// ISO country code — "...CA" parses as Canada, not California. Trusting the address
|
|
// FIRST (as ATLAS-UNIT-023 might suggest) would send a San Francisco hotel's region
|
|
// lookup to Canada and fail to find one, costing a needless Nominatim round trip (or
|
|
// worse, a wrong match) for every US place whose address ends in a state code.
|
|
// Coordinates resolve this correctly on their own, so the address must only be
|
|
// consulted when the coordinate-only lookup finds nothing.
|
|
const mockFetch = vi.fn();
|
|
vi.stubGlobal('fetch', mockFetch);
|
|
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'San Francisco Trip' });
|
|
insertPlaceWithCoords(
|
|
testDb, trip.id, 'Hotel Pickwick', 37.7830549, -122.4066689,
|
|
'85 5th St, San Francisco, CA'
|
|
);
|
|
|
|
await atlas.visitedRegions(user.id);
|
|
await new Promise(resolve => setTimeout(resolve, 10));
|
|
const result = await atlas.visitedRegions(user.id);
|
|
|
|
expect(mockFetch).not.toHaveBeenCalled();
|
|
expect(result.regions['US']).toBeDefined();
|
|
expect(result.regions['CA']).toBeUndefined();
|
|
});
|
|
|
|
it('ATLAS-UNIT-025: when the bundle-only lookup finds nothing, the Nominatim fallback keeps the coarse GB constituent-country code instead of rescuing to a finer one', async () => {
|
|
// Mid-Atlantic open ocean — getCountryFromCoords finds no country and there's no
|
|
// address, so this always falls through to the Nominatim path. That path used to re-query at a
|
|
// finer zoom for GB and swap in a county/borough code (GB-MAN, GB-LND, …) that targeted
|
|
// Natural Earth's old, finer GB polygons — the current geoBoundaries bundle only has the
|
|
// 4 constituent countries, so that rescued code could never match anything and the
|
|
// region would never highlight. The coarse Nominatim result (GB-ENG) IS a real bundle
|
|
// feature and must be kept as-is, with a single geocode call (no zoom=10 re-query).
|
|
vi.useFakeTimers();
|
|
const mockFetch = vi.fn().mockResolvedValue({
|
|
ok: true,
|
|
json: async () => ({ address: { country_code: 'gb', 'ISO3166-2-lvl4': 'GB-ENG', state: 'England' } }),
|
|
});
|
|
vi.stubGlobal('fetch', mockFetch);
|
|
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'Middle of the ocean' });
|
|
insertPlaceWithCoords(testDb, trip.id, 'Buoy', 10, -40);
|
|
|
|
await atlas.visitedRegions(user.id);
|
|
await vi.runAllTimersAsync();
|
|
const result = await atlas.visitedRegions(user.id);
|
|
|
|
expect(mockFetch).toHaveBeenCalledTimes(1);
|
|
expect(result.regions['GB']).toBeDefined();
|
|
const codes = result.regions['GB'].map((r: any) => r.code);
|
|
expect(codes).toContain('GB-ENG');
|
|
|
|
vi.useRealTimers();
|
|
});
|
|
|
|
it('ATLAS-UNIT-026: an address country nowhere near the coordinates is rejected before it can produce a bogus region match', async () => {
|
|
// Coordinates in the open mid-Atlantic (no country polygon contains them) paired
|
|
// with a stored address ending in "JP" — getCountryFromAddress()'s 2-letter-uppercase
|
|
// heuristic returns 'JP' regardless of how implausible that is for these coordinates.
|
|
// Without a sanity check, getRegionFromCoords('JP', ...) would only return null because
|
|
// no Japanese region polygon happens to reach the mid-Atlantic — but that's incidental,
|
|
// not a guarantee, for some other coordinate/bogus-code combination. The admin0 box
|
|
// gate rejects JP outright (its bounding box is nowhere near these coordinates) so the
|
|
// address is never even tried against JP's regions, and resolution correctly falls
|
|
// through to Nominatim instead of risking a wrong match.
|
|
vi.useFakeTimers();
|
|
const mockFetch = vi.fn().mockResolvedValue({
|
|
ok: true,
|
|
json: async () => ({ address: {} }), // Nominatim finds nothing here either
|
|
});
|
|
vi.stubGlobal('fetch', mockFetch);
|
|
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'Mid-Atlantic buoy' });
|
|
// Different coordinates than ATLAS-UNIT-025's mid-Atlantic point — reverseGeocodeRegion's
|
|
// regionCache is an in-memory Map keyed by rounded lat/lng and persists across tests in
|
|
// this file, so reusing the same point would silently hit that cached result instead of
|
|
// exercising this test's fetch/gate path.
|
|
insertPlaceWithCoords(testDb, trip.id, 'Weather buoy', 20, -35, '123 Nowhere Rd, JP');
|
|
|
|
await atlas.visitedRegions(user.id);
|
|
await vi.runAllTimersAsync();
|
|
const result = await atlas.visitedRegions(user.id);
|
|
|
|
expect(mockFetch).toHaveBeenCalledTimes(1); // fell through to Nominatim, not a fabricated JP match
|
|
expect(result.regions['JP']).toBeUndefined();
|
|
|
|
vi.useRealTimers();
|
|
});
|
|
});
|
|
|
|
// ── unmarkRegionVisited — tombstones + country cascade ──────────────────────
|
|
|
|
// Places are region-resolved by a fire-and-forget background task (see reverseGeocodeRegion
|
|
// callers); a single atlas.visitedRegions() call returns before it settles. Populate the cache
|
|
// deterministically before asserting against it or calling unmarkRegionVisited (which reads
|
|
// place_regions directly, not through this function).
|
|
async function primeRegionCache(userId: number): Promise<void> {
|
|
await atlas.visitedRegions(userId);
|
|
await new Promise(resolve => setTimeout(resolve, 10));
|
|
}
|
|
|
|
describe('unmarkRegionVisited — tombstones + country cascade', () => {
|
|
it('ATLAS-SVC-024: hides a region derived from a real place, not just a manually-marked one', async () => {
|
|
// Unlike unmarkCountryVisited (ATLAS-SVC-023), a region hide is NOT lifted just
|
|
// because it has a real place — that is exactly the case this feature exists for (a
|
|
// real place that resolved to a region the user doesn't want highlighted, e.g. a
|
|
// border-simplification misassignment), so it must stay hidden regardless of
|
|
// placeCount until explicitly re-marked.
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'SF Trip' });
|
|
insertPlaceWithCoords(testDb, trip.id, 'Golden Gate Park', 37.7694, -122.4862);
|
|
await primeRegionCache(user.id);
|
|
|
|
const before = await atlas.visitedRegions(user.id);
|
|
expect(before.regions['US']?.map((r: any) => r.code)).toContain('US-CA');
|
|
|
|
atlas.unmarkRegion(user.id, 'US-CA');
|
|
|
|
const after = await atlas.visitedRegions(user.id);
|
|
expect(after.regions['US']?.map((r: any) => r.code) ?? []).not.toContain('US-CA');
|
|
});
|
|
|
|
it('ATLAS-SVC-025: re-marking a hidden region brings it back', async () => {
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'SF Trip' });
|
|
insertPlaceWithCoords(testDb, trip.id, 'Golden Gate Park', 37.7694, -122.4862);
|
|
await primeRegionCache(user.id);
|
|
|
|
atlas.unmarkRegion(user.id, 'US-CA');
|
|
expect((await atlas.visitedRegions(user.id)).regions['US']?.map((r: any) => r.code) ?? []).not.toContain('US-CA');
|
|
|
|
atlas.markRegion(user.id, 'US-CA', 'California', 'US');
|
|
expect((await atlas.visitedRegions(user.id)).regions['US']?.map((r: any) => r.code)).toContain('US-CA');
|
|
});
|
|
|
|
it('ATLAS-SVC-026: hiding a country\'s only visible region also hides the country', async () => {
|
|
// Uses a manually-marked region rather than a real place: getStats' places-derived
|
|
// country entries are never suppressed by hidden_countries (#1490 — a country with a
|
|
// real place always reappears, see ATLAS-SVC-023), so the cascade can only ever have a
|
|
// visible effect on a country with no real place backing it, exactly like
|
|
// unmarkCountryVisited's own tombstone tests above use flight-endpoint-derived
|
|
// countries rather than real places for the same reason.
|
|
const { user } = createUser(testDb);
|
|
atlas.markRegion(user.id, 'JP-13', 'Tokyo', 'JP'); // also auto-marks JP visited
|
|
|
|
const beforeStats = await atlas.stats(user.id);
|
|
expect(beforeStats.countries.map((c: any) => c.code)).toContain('JP');
|
|
|
|
atlas.unmarkRegion(user.id, 'JP-13');
|
|
|
|
const afterStats = await atlas.stats(user.id);
|
|
expect(afterStats.countries.map((c: any) => c.code)).not.toContain('JP');
|
|
});
|
|
|
|
it('ATLAS-SVC-027: hiding one of a country\'s several regions does NOT cascade-hide the country', async () => {
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'NY road trip' });
|
|
insertPlaceWithCoords(testDb, trip.id, 'Boston hotel', 42.3588336, -71.0578303); // MA
|
|
insertPlaceWithCoords(testDb, trip.id, 'Philly hotel', 39.9527237, -75.1635262); // PA
|
|
await primeRegionCache(user.id);
|
|
|
|
atlas.unmarkRegion(user.id, 'US-MA');
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
expect(stats.countries.map((c: any) => c.code)).toContain('US');
|
|
const regions = (await atlas.visitedRegions(user.id)).regions['US'].map((r: any) => r.code);
|
|
expect(regions).not.toContain('US-MA');
|
|
expect(regions).toContain('US-PA');
|
|
});
|
|
|
|
it('ATLAS-SVC-028: re-marking a region whose country was cascade-hidden brings the country back too', async () => {
|
|
const { user } = createUser(testDb);
|
|
atlas.markRegion(user.id, 'JP-13', 'Tokyo', 'JP');
|
|
|
|
atlas.unmarkRegion(user.id, 'JP-13');
|
|
expect((await atlas.stats(user.id)).countries.map((c: any) => c.code)).not.toContain('JP');
|
|
|
|
atlas.markRegion(user.id, 'JP-13', 'Tokyo', 'JP');
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
expect(stats.countries.map((c: any) => c.code)).toContain('JP');
|
|
});
|
|
});
|
|
|
|
// ── atlas.bridge.ts delegation ───────────────────────────────────────────────
|
|
// ATLAS-SVC-029/030 retired with atlas.bridge.ts itself: the sole consumer
|
|
// (legacy authService) went DI-native and injects AtlasService now. 030's
|
|
// coordinate pin lives on in ATLAS-SVC-030b below.
|
|
|
|
describe('getCountryFromCoords coordinate pin', () => {
|
|
it('ATLAS-SVC-030b: resolves Paris coordinates to FR (shared atlas-geo indexes)', () => {
|
|
expect(getCountryFromCoords(48.85, 2.35)).toBe('FR');
|
|
});
|
|
});
|
|
|
|
// ── Quirks fixed after the DI fold (trailing fix(server) commit) ─────────────
|
|
|
|
describe('atlas quirk fixes', () => {
|
|
it('ATLAS-SVC-031: countryPlaces reports manually_marked for a trip-less user', () => {
|
|
// The legacy early return hardcoded manually_marked: false, so a user who
|
|
// marked a country visited before creating any trip saw it as unmarked.
|
|
const { user } = createUser(testDb);
|
|
testDb.prepare('INSERT INTO visited_countries (user_id, country_code) VALUES (?, ?)').run(user.id, 'JP');
|
|
|
|
const result = atlas.countryPlaces(user.id, 'JP');
|
|
|
|
// status rides along since #1048 — a manual mark is a visit even with no trips.
|
|
expect(result).toEqual({ places: [], trips: [], manually_marked: true, status: 'visited' });
|
|
expect(atlas.countryPlaces(user.id, 'FR').manually_marked).toBe(false);
|
|
});
|
|
|
|
it('ATLAS-SVC-032: updateBucketItem persists lat/lng of exactly 0 (equator/prime meridian)', () => {
|
|
const { user } = createUser(testDb);
|
|
const item = atlas.createBucketItem(user.id, { name: 'Null Island', lat: 10, lng: 10 }) as { id: number };
|
|
|
|
const updated = atlas.updateBucketItem(user.id, item.id, { lat: 0, lng: 0 }) as { lat: number; lng: number };
|
|
|
|
// The legacy `|| null` binding read 0 as "clear" and wrote NULL.
|
|
expect(updated.lat).toBe(0);
|
|
expect(updated.lng).toBe(0);
|
|
});
|
|
|
|
it('ATLAS-SVC-033: updateBucketItem persists an explicit empty-string notes value', () => {
|
|
const { user } = createUser(testDb);
|
|
const item = atlas.createBucketItem(user.id, { name: 'Kyoto', notes: 'old notes' }) as { id: number };
|
|
|
|
const updated = atlas.updateBucketItem(user.id, item.id, { notes: '' }) as { notes: string | null };
|
|
|
|
// The legacy `|| null` binding collapsed '' to NULL.
|
|
expect(updated.notes).toBe('');
|
|
});
|
|
|
|
it("ATLAS-SVC-034: bucket update/delete cannot touch another user's row (user-scoped SQL)", () => {
|
|
const { user } = createUser(testDb);
|
|
const { user: other } = createUser(testDb);
|
|
const item = atlas.createBucketItem(user.id, { name: 'Mine' }) as { id: number; name: string };
|
|
|
|
expect(atlas.updateBucketItem(other.id, item.id, { name: 'Stolen' })).toBeNull();
|
|
expect(atlas.deleteBucketItem(other.id, item.id)).toBe(false);
|
|
const row = testDb.prepare('SELECT name FROM bucket_list WHERE id = ?').get(item.id) as { name: string };
|
|
expect(row.name).toBe('Mine');
|
|
});
|
|
|
|
it('ATLAS-SVC-035: unmarkRegion is atomic — a failure mid-flow rolls the region delete back', () => {
|
|
const { user } = createUser(testDb);
|
|
atlas.markRegion(user.id, 'JP-13', 'Tokyo', 'JP');
|
|
|
|
// Force the tombstone insert (statement 2 of the flow) to fail by hiding
|
|
// the hidden_regions table; the visited_regions DELETE must roll back.
|
|
testDb.exec('ALTER TABLE hidden_regions RENAME TO hidden_regions_gone');
|
|
try {
|
|
expect(() => atlas.unmarkRegion(user.id, 'JP-13')).toThrow();
|
|
} finally {
|
|
testDb.exec('ALTER TABLE hidden_regions_gone RENAME TO hidden_regions');
|
|
}
|
|
|
|
const row = testDb
|
|
.prepare('SELECT 1 FROM visited_regions WHERE user_id = ? AND region_code = ?')
|
|
.get(user.id, 'JP-13');
|
|
expect(row).toBeDefined();
|
|
});
|
|
|
|
it('ATLAS-SVC-036: markCountry is atomic — a failure on the tombstone lift rolls the insert back', () => {
|
|
const { user } = createUser(testDb);
|
|
|
|
testDb.exec('ALTER TABLE hidden_countries RENAME TO hidden_countries_gone');
|
|
try {
|
|
expect(() => atlas.markCountry(user.id, 'DE')).toThrow();
|
|
} finally {
|
|
testDb.exec('ALTER TABLE hidden_countries_gone RENAME TO hidden_countries');
|
|
}
|
|
|
|
const row = testDb
|
|
.prepare('SELECT 1 FROM visited_countries WHERE user_id = ? AND country_code = ?')
|
|
.get(user.id, 'DE');
|
|
expect(row).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
// ── #1048: visited vs planned vs idea ────────────────────────────────────────
|
|
//
|
|
// Before this, every trip painted its countries as visited — a flight booked for
|
|
// next summer coloured the map as if the traveller had already been there. The
|
|
// trip's dates now decide, and countries[] carries that verdict as `status`.
|
|
|
|
// Offsets from "now", never literal dates: a hardcoded 2026 date stops being the
|
|
// future at some point and would silently flip these assertions to green-for-the-
|
|
// wrong-reason (or red) months after the fact.
|
|
function isoOffsetDays(days: number): string {
|
|
return new Date(Date.now() + days * 86_400_000).toISOString().slice(0, 10);
|
|
}
|
|
const PAST_START = isoOffsetDays(-40);
|
|
const PAST_END = isoOffsetDays(-30);
|
|
const FUTURE_START = isoOffsetDays(30);
|
|
const FUTURE_END = isoOffsetDays(40);
|
|
|
|
describe('getStats — visited vs planned vs idea (#1048)', () => {
|
|
it('ATLAS-UNIT-029: a country from a trip that already happened is visited', async () => {
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'Rome, last month', start_date: PAST_START, end_date: PAST_END });
|
|
insertPlace(testDb, trip.id, 'Colosseum', 'Piazza del Colosseo, Rome, Italy');
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
expect(stats.countries).toEqual([expect.objectContaining({ code: 'IT', status: 'visited' })]);
|
|
expect(stats.stats.totalCountries).toBe(1);
|
|
expect(stats.stats.totalCountriesPlanned).toBe(0);
|
|
expect(stats.stats.totalCountriesIdea).toBe(0);
|
|
});
|
|
|
|
it('ATLAS-UNIT-030: a country from a future trip is planned — listed, but not counted as visited', async () => {
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'Japan, next month', start_date: FUTURE_START, end_date: FUTURE_END });
|
|
insertPlace(testDb, trip.id, 'Senso-ji', 'Asakusa, Tokyo, Japan');
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
// Still in countries[] — the client needs it to draw the dashed outline — but it
|
|
// must not inflate the "countries visited" counter.
|
|
expect(stats.countries.find((c: any) => c.code === 'JP')).toMatchObject({ status: 'planned' });
|
|
expect(stats.stats.totalCountries).toBe(0);
|
|
expect(stats.stats.totalCountriesPlanned).toBe(1);
|
|
expect(stats.countries.length).toBeGreaterThan(stats.stats.totalCountries);
|
|
});
|
|
|
|
it('ATLAS-UNIT-031: a trip that has started but not ended counts as visited — you are there now', async () => {
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, {
|
|
title: 'Currently in Berlin',
|
|
start_date: isoOffsetDays(-2),
|
|
end_date: isoOffsetDays(5),
|
|
});
|
|
insertPlace(testDb, trip.id, 'Brandenburger Tor', 'Pariser Platz, Berlin, Germany');
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
expect(stats.countries.find((c: any) => c.code === 'DE')).toMatchObject({ status: 'visited' });
|
|
expect(stats.stats.totalCountries).toBe(1);
|
|
});
|
|
|
|
it('ATLAS-UNIT-032: a trip starting today is already visited (the <= boundary)', async () => {
|
|
const { user } = createUser(testDb);
|
|
const today = isoOffsetDays(0);
|
|
const trip = createTrip(testDb, user.id, { title: 'Flying out today', start_date: today, end_date: isoOffsetDays(6) });
|
|
insertPlace(testDb, trip.id, 'Louvre', '75001 Paris, France');
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
expect(stats.countries.find((c: any) => c.code === 'FR')).toMatchObject({ status: 'visited' });
|
|
expect(stats.stats.totalCountriesPlanned).toBe(0);
|
|
});
|
|
|
|
it('ATLAS-UNIT-033: a trip with no dates at all is an idea, not a plan', async () => {
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'Someday: Japan' });
|
|
insertPlace(testDb, trip.id, 'Senso-ji', 'Asakusa, Tokyo, Japan');
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
expect(stats.countries.find((c: any) => c.code === 'JP')).toMatchObject({ status: 'idea' });
|
|
expect(stats.stats.totalCountries).toBe(0);
|
|
expect(stats.stats.totalCountriesPlanned).toBe(0);
|
|
expect(stats.stats.totalCountriesIdea).toBe(1);
|
|
});
|
|
|
|
it('ATLAS-UNIT-034: a country with both a past and a future trip takes the stronger status', async () => {
|
|
const { user } = createUser(testDb);
|
|
const past = createTrip(testDb, user.id, { title: 'Munich 2023', start_date: PAST_START, end_date: PAST_END });
|
|
const future = createTrip(testDb, user.id, { title: 'Munich again', start_date: FUTURE_START, end_date: FUTURE_END });
|
|
insertPlace(testDb, past.id, 'Marienplatz', 'Marienplatz, Munich, Germany');
|
|
insertPlace(testDb, future.id, 'Englischer Garten', 'Englischer Garten, Munich, Germany');
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
const de = stats.countries.find((c: any) => c.code === 'DE');
|
|
expect(de).toMatchObject({ status: 'visited', tripCount: 2, placeCount: 2 });
|
|
expect(stats.stats.totalCountries).toBe(1);
|
|
expect(stats.stats.totalCountriesPlanned).toBe(0);
|
|
});
|
|
|
|
it('ATLAS-UNIT-035: marking a country by hand outranks a future trip going there', async () => {
|
|
// "I have been to Japan" is a statement of fact; a booking for next month cannot
|
|
// downgrade it back to a plan.
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'Japan, next month', start_date: FUTURE_START, end_date: FUTURE_END });
|
|
insertPlace(testDb, trip.id, 'Senso-ji', 'Asakusa, Tokyo, Japan');
|
|
testDb.prepare('INSERT INTO visited_countries (user_id, country_code) VALUES (?, ?)').run(user.id, 'JP');
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
const jp = stats.countries.filter((c: any) => c.code === 'JP');
|
|
expect(jp).toHaveLength(1); // upgraded in place, not appended a second time
|
|
expect(jp[0]).toMatchObject({ status: 'visited', placeCount: 1 });
|
|
expect(stats.stats.totalCountries).toBe(1);
|
|
expect(stats.stats.totalCountriesPlanned).toBe(0);
|
|
});
|
|
|
|
it('ATLAS-UNIT-036: removing a country hides it even while it is only planned (#1490 tombstone)', async () => {
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'Tokyo, next month', start_date: FUTURE_START, end_date: FUTURE_END });
|
|
const reservation = createReservation(testDb, trip.id, { type: 'flight' });
|
|
insertReservationEndpoint(testDb, reservation.id, 'from', 0, 50.9014, 4.4844); // Brussels
|
|
insertReservationEndpoint(testDb, reservation.id, 'to', 1, 35.6762, 139.6503); // Tokyo
|
|
|
|
const before = await atlas.stats(user.id);
|
|
expect(before.countries.find((c: any) => c.code === 'JP')).toMatchObject({ status: 'planned' });
|
|
|
|
atlas.unmarkCountry(user.id, 'JP');
|
|
|
|
const after = await atlas.stats(user.id);
|
|
expect(after.countries.map((c: any) => c.code)).not.toContain('JP');
|
|
expect(after.countries.map((c: any) => c.code)).toContain('BE');
|
|
expect(after.stats.totalCountriesPlanned).toBe(1);
|
|
});
|
|
|
|
it('ATLAS-UNIT-037: continents counts visited only; the planned ones live in continentsPlanned', async () => {
|
|
const { user } = createUser(testDb);
|
|
const past = createTrip(testDb, user.id, { title: 'Paris 2023', start_date: PAST_START, end_date: PAST_END });
|
|
const future = createTrip(testDb, user.id, { title: 'Tokyo soon', start_date: FUTURE_START, end_date: FUTURE_END });
|
|
insertPlace(testDb, past.id, 'Louvre', '75001 Paris, France');
|
|
insertPlace(testDb, future.id, 'Senso-ji', 'Asakusa, Tokyo, Japan');
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
expect(stats.continents).toEqual({ Europe: 1 });
|
|
expect(stats.continentsPlanned).toEqual({ Asia: 1 });
|
|
});
|
|
|
|
it('ATLAS-UNIT-038: mostVisited ignores planned countries even when they have more places', async () => {
|
|
const { user } = createUser(testDb);
|
|
const past = createTrip(testDb, user.id, { title: 'Rome 2023', start_date: PAST_START, end_date: PAST_END });
|
|
const future = createTrip(testDb, user.id, { title: 'Japan soon', start_date: FUTURE_START, end_date: FUTURE_END });
|
|
insertPlace(testDb, past.id, 'Colosseum', 'Piazza del Colosseo, Rome, Italy');
|
|
for (let i = 0; i < 3; i++) insertPlace(testDb, future.id, `Tokyo Place ${i}`, `Street ${i}, Tokyo, Japan`);
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
// JP has 3 places to IT's 1, but you have not been there yet.
|
|
expect(stats.mostVisited).not.toBeNull();
|
|
expect(stats.mostVisited!.code).toBe('IT');
|
|
expect(stats.mostVisited!.placeCount).toBe(1);
|
|
});
|
|
|
|
it('ATLAS-UNIT-039: countries reached only by a future flight leg are planned, not visited (#1366 path)', async () => {
|
|
// Endpoint-derived countries go through their own dedupe-per-coordinate branch,
|
|
// so they need their own guard that the trip's dates still decide.
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id, { title: 'Tokyo, next month', start_date: FUTURE_START, end_date: FUTURE_END });
|
|
const reservation = createReservation(testDb, trip.id, { type: 'flight' });
|
|
insertReservationEndpoint(testDb, reservation.id, 'from', 0, 50.9014, 4.4844); // Brussels
|
|
insertReservationEndpoint(testDb, reservation.id, 'to', 1, 35.6762, 139.6503); // Tokyo
|
|
|
|
const stats = await atlas.stats(user.id);
|
|
|
|
expect(stats.countries.find((c: any) => c.code === 'BE')).toMatchObject({ status: 'planned' });
|
|
expect(stats.countries.find((c: any) => c.code === 'JP')).toMatchObject({ status: 'planned' });
|
|
expect(stats.stats.totalCountries).toBe(0);
|
|
expect(stats.stats.totalCountriesPlanned).toBe(2);
|
|
});
|
|
});
|
|
|
|
describe('getCountryPlaces — status (#1048)', () => {
|
|
it('ATLAS-UNIT-040: the country sheet reports the same status the map paints', async () => {
|
|
const { user } = createUser(testDb);
|
|
const past = createTrip(testDb, user.id, { title: 'Paris 2023', start_date: PAST_START, end_date: PAST_END });
|
|
const future = createTrip(testDb, user.id, { title: 'Tokyo soon', start_date: FUTURE_START, end_date: FUTURE_END });
|
|
insertPlace(testDb, past.id, 'Louvre', '75001 Paris, France');
|
|
insertPlace(testDb, future.id, 'Senso-ji', 'Asakusa, Tokyo, Japan');
|
|
|
|
expect(atlas.countryPlaces(user.id, 'FR').status).toBe('visited');
|
|
expect(atlas.countryPlaces(user.id, 'JP').status).toBe('planned');
|
|
// A country with no trip and no manual mark has nothing behind it at all.
|
|
expect(atlas.countryPlaces(user.id, 'BR').status).toBe('idea');
|
|
});
|
|
|
|
it('ATLAS-UNIT-041: a manual mark makes the sheet visited even for a future-only country', async () => {
|
|
const { user } = createUser(testDb);
|
|
const future = createTrip(testDb, user.id, { title: 'Tokyo soon', start_date: FUTURE_START, end_date: FUTURE_END });
|
|
insertPlace(testDb, future.id, 'Senso-ji', 'Asakusa, Tokyo, Japan');
|
|
atlas.markCountry(user.id, 'JP');
|
|
|
|
const result = atlas.countryPlaces(user.id, 'JP');
|
|
|
|
expect(result.manually_marked).toBe(true);
|
|
expect(result.status).toBe('visited');
|
|
expect(result.places).toHaveLength(1);
|
|
});
|
|
});
|
|
|
|
describe('getVisitedRegions — status (#1048)', () => {
|
|
it('ATLAS-UNIT-042: a region inherits its trip status; a manually marked one is visited', async () => {
|
|
const { user } = createUser(testDb);
|
|
const future = createTrip(testDb, user.id, { title: 'Paris soon', start_date: FUTURE_START, end_date: FUTURE_END });
|
|
const place = insertPlaceWithCoords(testDb, future.id, 'Paris Hotel', 48.85, 2.35);
|
|
// Pre-seed the region cache so nothing geocodes in the background (see ATLAS-UNIT-020).
|
|
testDb
|
|
.prepare('INSERT OR REPLACE INTO place_regions (place_id, country_code, region_code, region_name) VALUES (?, ?, ?, ?)')
|
|
.run(place.id, 'FR', 'FR-75', 'Île-de-France');
|
|
testDb
|
|
.prepare('INSERT INTO visited_regions (user_id, region_code, region_name, country_code) VALUES (?, ?, ?, ?)')
|
|
.run(user.id, 'DE-BY', 'Bayern', 'DE');
|
|
|
|
const result = await atlas.visitedRegions(user.id);
|
|
|
|
// Zooming into a merely planned country must not reveal regions painted as visited.
|
|
expect(result.regions['FR']).toEqual([expect.objectContaining({ code: 'FR-75', status: 'planned' })]);
|
|
expect(result.regions['DE']).toEqual([expect.objectContaining({ code: 'DE-BY', status: 'visited' })]);
|
|
});
|
|
|
|
it('ATLAS-UNIT-043: marking a planned region by hand upgrades it to visited', async () => {
|
|
const { user } = createUser(testDb);
|
|
const future = createTrip(testDb, user.id, { title: 'Paris soon', start_date: FUTURE_START, end_date: FUTURE_END });
|
|
const place = insertPlaceWithCoords(testDb, future.id, 'Paris Hotel', 48.85, 2.35);
|
|
testDb
|
|
.prepare('INSERT OR REPLACE INTO place_regions (place_id, country_code, region_code, region_name) VALUES (?, ?, ?, ?)')
|
|
.run(place.id, 'FR', 'FR-75', 'Île-de-France');
|
|
|
|
expect((await atlas.visitedRegions(user.id)).regions['FR'][0].status).toBe('planned');
|
|
|
|
atlas.markRegion(user.id, 'FR-75', 'Île-de-France', 'FR');
|
|
|
|
const after = await atlas.visitedRegions(user.id);
|
|
// Still one entry — the manual mark upgrades the derived region rather than duplicating it.
|
|
expect(after.regions['FR']).toHaveLength(1);
|
|
expect(after.regions['FR'][0].status).toBe('visited');
|
|
});
|
|
});
|