mirror of
https://github.com/mauriceboe/TREK.git
synced 2026-11-20 11:06:06 +00:00
8c1395c8f1
They reset through resetDatabase and seed through the ORM factories instead of the SQLite snapshot mock, so they run in the Postgres lane as well.
626 lines
25 KiB
TypeScript
626 lines
25 KiB
TypeScript
/**
|
|
* Atlas integration tests.
|
|
* Covers ATLAS-001 to ATLAS-008.
|
|
*/
|
|
import { buildApp } from '../../src/bootstrap';
|
|
import { PlaceRegions } from '../../src/db/entities/PlaceRegions.entity';
|
|
import { authCookie } from '../helpers/auth';
|
|
import type { FactoryOrm } from '../helpers/factories/context';
|
|
import { makePlace } from '../helpers/factories/places';
|
|
import { findRow } from '../helpers/factories/rows';
|
|
import { makeTrip } from '../helpers/factories/trips';
|
|
import { makeUser } from '../helpers/factories/users';
|
|
import { resetDatabase } from '../helpers/reset-database';
|
|
import { resetRateLimits } from '../helpers/test-db';
|
|
import { MikroORM } from '@mikro-orm/core';
|
|
import type { INestApplication } from '@nestjs/common';
|
|
|
|
import type { Application } from 'express';
|
|
import request from 'supertest';
|
|
import { describe, it, expect, vi, beforeAll, beforeEach, afterAll } from 'vitest';
|
|
|
|
let nestApp: INestApplication;
|
|
let app: Application;
|
|
/** The app's own ORM, which the factories seed and read through. */
|
|
const orm = (): FactoryOrm => nestApp.get(MikroORM);
|
|
|
|
beforeAll(async () => {
|
|
// Stub the admin-1 GeoJSON download so /regions/geo is deterministic and never
|
|
// hits the real network (the un-stubbed fetch of a ~4600-feature file from
|
|
// raw.githubusercontent.com is what made ATLAS-013 hang/time out under load).
|
|
// Any other outbound fetch (e.g. background reverse-geocoding) returns empty so
|
|
// no test depends on live network.
|
|
vi.stubGlobal('fetch', async (url: unknown) => {
|
|
if (String(url).includes('natural-earth-vector')) {
|
|
return new Response(
|
|
JSON.stringify({
|
|
type: 'FeatureCollection',
|
|
features: [
|
|
{ type: 'Feature', properties: { iso_a2: 'DE' }, geometry: { type: 'Point', coordinates: [10, 51] } },
|
|
{ type: 'Feature', properties: { iso_a2: 'FR' }, geometry: { type: 'Point', coordinates: [2, 47] } },
|
|
],
|
|
}),
|
|
{ status: 200, headers: { 'Content-Type': 'application/json' } },
|
|
);
|
|
}
|
|
return new Response('{}', { status: 200, headers: { 'Content-Type': 'application/json' } });
|
|
});
|
|
|
|
nestApp = await buildApp();
|
|
app = nestApp.getHttpAdapter().getInstance();
|
|
}, 60_000);
|
|
|
|
beforeEach(async () => {
|
|
await resetDatabase(orm());
|
|
await resetRateLimits(nestApp);
|
|
});
|
|
|
|
afterAll(async () => {
|
|
vi.unstubAllGlobals();
|
|
await nestApp.close();
|
|
});
|
|
|
|
describe('Atlas stats', () => {
|
|
it('ATLAS-001 — GET /api/atlas/stats returns stats object', async () => {
|
|
const { user } = await makeUser(orm());
|
|
|
|
const res = await request(app).get('/api/addons/atlas/stats').set('Cookie', authCookie(user.id));
|
|
expect(res.status).toBe(200);
|
|
expect(res.body).toHaveProperty('countries');
|
|
expect(res.body).toHaveProperty('stats');
|
|
});
|
|
|
|
it('ATLAS-014 — a future trip is returned as planned and excluded from totalCountries (#1048)', async () => {
|
|
const { user } = await makeUser(orm());
|
|
// Offsets from today rather than literal dates, so this cannot expire.
|
|
const iso = (days: number) => new Date(Date.now() + days * 86_400_000).toISOString().slice(0, 10);
|
|
const past = await makeTrip(orm(), user.id, {
|
|
title: 'Rome, last month',
|
|
start_date: iso(-40),
|
|
end_date: iso(-30),
|
|
});
|
|
const future = await makeTrip(orm(), user.id, {
|
|
title: 'Tokyo, next month',
|
|
start_date: iso(30),
|
|
end_date: iso(40),
|
|
});
|
|
// No coordinates and no category: the country has to come from the address.
|
|
const unplaced = { lat: null, lng: null, category: null };
|
|
await makePlace(orm(), past.id, { ...unplaced, name: 'Colosseum', address: 'Piazza del Colosseo, Rome, Italy' });
|
|
await makePlace(orm(), future.id, { ...unplaced, name: 'Senso-ji', address: 'Asakusa, Tokyo, Japan' });
|
|
|
|
const res = await request(app).get('/api/addons/atlas/stats').set('Cookie', authCookie(user.id));
|
|
|
|
expect(res.status).toBe(200);
|
|
const countries = res.body.countries as { code: string; status: string }[];
|
|
expect(countries.find((c) => c.code === 'IT')?.status).toBe('visited');
|
|
expect(countries.find((c) => c.code === 'JP')?.status).toBe('planned');
|
|
expect(res.body.stats.totalCountries).toBe(1);
|
|
expect(res.body.stats.totalCountriesPlanned).toBe(1);
|
|
// The whole point: the map gets more countries than the passport counter shows.
|
|
expect(countries.length).toBeGreaterThan(res.body.stats.totalCountries);
|
|
});
|
|
|
|
it('ATLAS-002 — GET /api/atlas/country/:code returns places in country', async () => {
|
|
const { user } = await makeUser(orm());
|
|
|
|
const res = await request(app).get('/api/addons/atlas/country/FR').set('Cookie', authCookie(user.id));
|
|
expect(res.status).toBe(200);
|
|
expect(Array.isArray(res.body.places)).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('Mark/unmark country', () => {
|
|
it('ATLAS-003 — POST /country/:code/mark marks country as visited', async () => {
|
|
const { user } = await makeUser(orm());
|
|
|
|
const res = await request(app).post('/api/addons/atlas/country/DE/mark').set('Cookie', authCookie(user.id));
|
|
expect(res.status).toBe(200);
|
|
expect(res.body.success).toBe(true);
|
|
|
|
// Verify it appears in visited countries
|
|
const stats = await request(app).get('/api/addons/atlas/stats').set('Cookie', authCookie(user.id));
|
|
const codes = (stats.body.countries as any[]).map((c: any) => c.code);
|
|
expect(codes).toContain('DE');
|
|
});
|
|
|
|
it('ATLAS-004 — DELETE /country/:code/mark unmarks country', async () => {
|
|
const { user } = await makeUser(orm());
|
|
|
|
await request(app).post('/api/addons/atlas/country/IT/mark').set('Cookie', authCookie(user.id));
|
|
|
|
const res = await request(app).delete('/api/addons/atlas/country/IT/mark').set('Cookie', authCookie(user.id));
|
|
expect(res.status).toBe(200);
|
|
expect(res.body.success).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe('Bucket list', () => {
|
|
it('ATLAS-005 — POST /bucket-list creates a bucket list item', async () => {
|
|
const { user } = await makeUser(orm());
|
|
|
|
const res = await request(app)
|
|
.post('/api/addons/atlas/bucket-list')
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ name: 'Machu Picchu', country_code: 'PE', lat: -13.1631, lng: -72.545 });
|
|
expect(res.status).toBe(201);
|
|
expect(res.body.item.name).toBe('Machu Picchu');
|
|
});
|
|
|
|
it('ATLAS-005 — POST without name returns 400', async () => {
|
|
const { user } = await makeUser(orm());
|
|
|
|
const res = await request(app)
|
|
.post('/api/addons/atlas/bucket-list')
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ country_code: 'JP' });
|
|
expect(res.status).toBe(400);
|
|
});
|
|
|
|
it('ATLAS-005 — POST the same item twice returns 409 and keeps one row (#1898)', async () => {
|
|
const { user } = await makeUser(orm());
|
|
const body = { name: 'Japan', country_code: 'JP' };
|
|
|
|
const first = await request(app)
|
|
.post('/api/addons/atlas/bucket-list')
|
|
.set('Cookie', authCookie(user.id))
|
|
.send(body);
|
|
expect(first.status).toBe(201);
|
|
|
|
const second = await request(app)
|
|
.post('/api/addons/atlas/bucket-list')
|
|
.set('Cookie', authCookie(user.id))
|
|
.send(body);
|
|
expect(second.status).toBe(409);
|
|
expect(second.body).toEqual({ error: 'Already on your bucket list' });
|
|
|
|
const list = await request(app).get('/api/addons/atlas/bucket-list').set('Cookie', authCookie(user.id));
|
|
expect(list.body.items).toHaveLength(1);
|
|
});
|
|
|
|
it('ATLAS-005 — POST the same item for another target date is allowed (#1898)', async () => {
|
|
const { user } = await makeUser(orm());
|
|
|
|
const undated = await request(app)
|
|
.post('/api/addons/atlas/bucket-list')
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ name: 'Japan', country_code: 'JP', target_date: null });
|
|
expect(undated.status).toBe(201);
|
|
|
|
const dated = await request(app)
|
|
.post('/api/addons/atlas/bucket-list')
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ name: 'Japan', country_code: 'JP', target_date: '2027-05' });
|
|
expect(dated.status).toBe(201);
|
|
|
|
const list = await request(app).get('/api/addons/atlas/bucket-list').set('Cookie', authCookie(user.id));
|
|
expect(list.body.items).toHaveLength(2);
|
|
});
|
|
|
|
it('ATLAS-006 — GET /bucket-list returns items', async () => {
|
|
const { user } = await makeUser(orm());
|
|
|
|
await request(app)
|
|
.post('/api/addons/atlas/bucket-list')
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ name: 'Santorini', country_code: 'GR' });
|
|
|
|
const res = await request(app).get('/api/addons/atlas/bucket-list').set('Cookie', authCookie(user.id));
|
|
expect(res.status).toBe(200);
|
|
expect(res.body.items).toHaveLength(1);
|
|
});
|
|
|
|
it('ATLAS-007 — PUT /bucket-list/:id updates item', async () => {
|
|
const { user } = await makeUser(orm());
|
|
|
|
const create = await request(app)
|
|
.post('/api/addons/atlas/bucket-list')
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ name: 'Old Name' });
|
|
const id = create.body.item.id;
|
|
|
|
const res = await request(app)
|
|
.put(`/api/addons/atlas/bucket-list/${id}`)
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ name: 'New Name', notes: 'Updated' });
|
|
expect(res.status).toBe(200);
|
|
expect(res.body.item.name).toBe('New Name');
|
|
});
|
|
|
|
it('ATLAS-007 — PUT onto an existing wish returns 409 and leaves the row alone (#1898)', async () => {
|
|
const { user } = await makeUser(orm());
|
|
await request(app)
|
|
.post('/api/addons/atlas/bucket-list')
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ name: 'Japan', country_code: 'JP', target_date: '2027-05' });
|
|
const second = await request(app)
|
|
.post('/api/addons/atlas/bucket-list')
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ name: 'Japan', country_code: 'JP', target_date: '2028-09' });
|
|
|
|
const res = await request(app)
|
|
.put(`/api/addons/atlas/bucket-list/${second.body.item.id}`)
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ target_date: '2027-05' });
|
|
expect(res.status).toBe(409);
|
|
expect(res.body).toEqual({ error: 'Already on your bucket list' });
|
|
|
|
const list = await request(app).get('/api/addons/atlas/bucket-list').set('Cookie', authCookie(user.id));
|
|
expect(list.body.items.map((i: { target_date: string }) => i.target_date).sort()).toEqual(['2027-05', '2028-09']);
|
|
});
|
|
|
|
it('ATLAS-008 — DELETE /bucket-list/:id removes item', async () => {
|
|
const { user } = await makeUser(orm());
|
|
|
|
const create = await request(app)
|
|
.post('/api/addons/atlas/bucket-list')
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ name: 'Tokyo' });
|
|
const id = create.body.item.id;
|
|
|
|
const del = await request(app).delete(`/api/addons/atlas/bucket-list/${id}`).set('Cookie', authCookie(user.id));
|
|
expect(del.status).toBe(200);
|
|
expect(del.body.success).toBe(true);
|
|
|
|
const list = await request(app).get('/api/addons/atlas/bucket-list').set('Cookie', authCookie(user.id));
|
|
expect(list.body.items).toHaveLength(0);
|
|
});
|
|
|
|
it('ATLAS-008 — DELETE non-existent item returns 404', async () => {
|
|
const { user } = await makeUser(orm());
|
|
|
|
const res = await request(app).delete('/api/addons/atlas/bucket-list/99999').set('Cookie', authCookie(user.id));
|
|
expect(res.status).toBe(404);
|
|
});
|
|
});
|
|
|
|
describe('Mark/unmark region', () => {
|
|
it('ATLAS-009 — POST /region/:code/mark marks a region as visited', async () => {
|
|
const { user } = await makeUser(orm());
|
|
|
|
const res = await request(app)
|
|
.post('/api/addons/atlas/region/DE-NW/mark')
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ name: 'Nordrhein-Westfalen', country_code: 'DE' });
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(res.body.success).toBe(true);
|
|
});
|
|
|
|
it('ATLAS-009 — POST /region/:code/mark without name returns 400', async () => {
|
|
const { user } = await makeUser(orm());
|
|
|
|
const res = await request(app)
|
|
.post('/api/addons/atlas/region/DE-NW/mark')
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ country_code: 'DE' });
|
|
|
|
expect(res.status).toBe(400);
|
|
});
|
|
|
|
it('ATLAS-009 — POST /region/:code/mark without country_code returns 400', async () => {
|
|
const { user } = await makeUser(orm());
|
|
|
|
const res = await request(app)
|
|
.post('/api/addons/atlas/region/DE-NW/mark')
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ name: 'Nordrhein-Westfalen' });
|
|
|
|
expect(res.status).toBe(400);
|
|
});
|
|
|
|
it('ATLAS-009 — marking a region also auto-marks the parent country', async () => {
|
|
const { user } = await makeUser(orm());
|
|
|
|
await request(app)
|
|
.post('/api/addons/atlas/region/DE-NW/mark')
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ name: 'Nordrhein-Westfalen', country_code: 'DE' });
|
|
|
|
const stats = await request(app).get('/api/addons/atlas/stats').set('Cookie', authCookie(user.id));
|
|
|
|
const codes = (stats.body.countries as any[]).map((c: any) => c.code);
|
|
expect(codes).toContain('DE');
|
|
});
|
|
|
|
it('ATLAS-009 — marking the same region twice is idempotent', async () => {
|
|
const { user } = await makeUser(orm());
|
|
|
|
await request(app)
|
|
.post('/api/addons/atlas/region/DE-NW/mark')
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ name: 'Nordrhein-Westfalen', country_code: 'DE' });
|
|
|
|
const res = await request(app)
|
|
.post('/api/addons/atlas/region/DE-NW/mark')
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ name: 'Nordrhein-Westfalen', country_code: 'DE' });
|
|
|
|
expect(res.status).toBe(200);
|
|
});
|
|
|
|
it('ATLAS-010 — GET /regions returns marked regions grouped by country', async () => {
|
|
const { user } = await makeUser(orm());
|
|
|
|
await request(app)
|
|
.post('/api/addons/atlas/region/DE-NW/mark')
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ name: 'Nordrhein-Westfalen', country_code: 'DE' });
|
|
|
|
await request(app)
|
|
.post('/api/addons/atlas/region/DE-BY/mark')
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ name: 'Bayern', country_code: 'DE' });
|
|
|
|
const res = await request(app).get('/api/addons/atlas/regions').set('Cookie', authCookie(user.id));
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(res.body).toHaveProperty('regions');
|
|
const deRegions = res.body.regions['DE'] as any[];
|
|
expect(deRegions).toBeDefined();
|
|
const codes = deRegions.map((r: any) => r.code);
|
|
expect(codes).toContain('DE-NW');
|
|
expect(codes).toContain('DE-BY');
|
|
});
|
|
|
|
it('ATLAS-011 — DELETE /region/:code/mark unmarks a region', async () => {
|
|
const { user } = await makeUser(orm());
|
|
|
|
await request(app)
|
|
.post('/api/addons/atlas/region/DE-NW/mark')
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ name: 'Nordrhein-Westfalen', country_code: 'DE' });
|
|
|
|
const del = await request(app).delete('/api/addons/atlas/region/DE-NW/mark').set('Cookie', authCookie(user.id));
|
|
|
|
expect(del.status).toBe(200);
|
|
expect(del.body.success).toBe(true);
|
|
|
|
const res = await request(app).get('/api/addons/atlas/regions').set('Cookie', authCookie(user.id));
|
|
|
|
const deRegions = res.body.regions['DE'] as any[] | undefined;
|
|
const codes = (deRegions || []).map((r: any) => r.code);
|
|
expect(codes).not.toContain('DE-NW');
|
|
});
|
|
|
|
it('ATLAS-011 — unmark last region in country also unmarks the parent country', async () => {
|
|
const { user } = await makeUser(orm());
|
|
|
|
await request(app)
|
|
.post('/api/addons/atlas/region/DE-NW/mark')
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ name: 'Nordrhein-Westfalen', country_code: 'DE' });
|
|
|
|
await request(app).delete('/api/addons/atlas/region/DE-NW/mark').set('Cookie', authCookie(user.id));
|
|
|
|
const stats = await request(app).get('/api/addons/atlas/stats').set('Cookie', authCookie(user.id));
|
|
|
|
const codes = (stats.body.countries as any[]).map((c: any) => c.code);
|
|
expect(codes).not.toContain('DE');
|
|
});
|
|
|
|
it('ATLAS-011 — unmark one region keeps country when another region remains', async () => {
|
|
const { user } = await makeUser(orm());
|
|
|
|
await request(app)
|
|
.post('/api/addons/atlas/region/DE-NW/mark')
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ name: 'Nordrhein-Westfalen', country_code: 'DE' });
|
|
|
|
await request(app)
|
|
.post('/api/addons/atlas/region/DE-BY/mark')
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ name: 'Bayern', country_code: 'DE' });
|
|
|
|
await request(app).delete('/api/addons/atlas/region/DE-NW/mark').set('Cookie', authCookie(user.id));
|
|
|
|
const stats = await request(app).get('/api/addons/atlas/stats').set('Cookie', authCookie(user.id));
|
|
|
|
const codes = (stats.body.countries as any[]).map((c: any) => c.code);
|
|
expect(codes).toContain('DE');
|
|
});
|
|
|
|
it('ATLAS-011: unmark last region keeps a country the user marked visited itself (#2597)', async () => {
|
|
const { user } = await makeUser(orm());
|
|
const cookie = authCookie(user.id);
|
|
|
|
await request(app).post('/api/addons/atlas/country/NO/mark').set('Cookie', cookie);
|
|
await request(app)
|
|
.post('/api/addons/atlas/region/NO-03/mark')
|
|
.set('Cookie', cookie)
|
|
.send({ name: 'Oslo', country_code: 'NO' });
|
|
await request(app).delete('/api/addons/atlas/region/NO-03/mark').set('Cookie', cookie);
|
|
|
|
const stats = await request(app).get('/api/addons/atlas/stats').set('Cookie', cookie);
|
|
expect((stats.body.countries as { code: string }[]).map((c) => c.code)).toContain('NO');
|
|
const country = await request(app).get('/api/addons/atlas/country/NO').set('Cookie', cookie);
|
|
expect(country.body).toMatchObject({ manually_marked: true, marked_source: 'manual' });
|
|
const regions = await request(app).get('/api/addons/atlas/regions').set('Cookie', cookie);
|
|
expect(regions.body.regions['NO']).toBeUndefined();
|
|
});
|
|
|
|
it('ATLAS-011: a country first reached through a region stays once it is marked itself (#2597)', async () => {
|
|
const { user } = await makeUser(orm());
|
|
const cookie = authCookie(user.id);
|
|
|
|
await request(app)
|
|
.post('/api/addons/atlas/region/NO-03/mark')
|
|
.set('Cookie', cookie)
|
|
.send({ name: 'Oslo', country_code: 'NO' });
|
|
const before = await request(app).get('/api/addons/atlas/country/NO').set('Cookie', cookie);
|
|
expect(before.body).toMatchObject({ manually_marked: true, marked_source: 'manual' });
|
|
|
|
await request(app).post('/api/addons/atlas/country/NO/mark').set('Cookie', cookie);
|
|
await request(app).delete('/api/addons/atlas/region/NO-03/mark').set('Cookie', cookie);
|
|
|
|
const stats = await request(app).get('/api/addons/atlas/stats').set('Cookie', cookie);
|
|
expect((stats.body.countries as { code: string }[]).map((c) => c.code)).toContain('NO');
|
|
});
|
|
|
|
it('ATLAS-011 — regions are isolated between users', async () => {
|
|
const { user: user1 } = await makeUser(orm());
|
|
const { user: user2 } = await makeUser(orm());
|
|
|
|
await request(app)
|
|
.post('/api/addons/atlas/region/DE-NW/mark')
|
|
.set('Cookie', authCookie(user1.id))
|
|
.send({ name: 'Nordrhein-Westfalen', country_code: 'DE' });
|
|
|
|
const res = await request(app).get('/api/addons/atlas/regions').set('Cookie', authCookie(user2.id));
|
|
|
|
expect(res.status).toBe(200);
|
|
const deRegions = res.body.regions['DE'] as any[] | undefined;
|
|
expect(deRegions).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
describe('Regions geo', () => {
|
|
it('ATLAS-012 — GET /regions/geo without countries param returns empty FeatureCollection', async () => {
|
|
const { user } = await makeUser(orm());
|
|
|
|
const res = await request(app).get('/api/addons/atlas/regions/geo').set('Cookie', authCookie(user.id));
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(res.body).toEqual({ type: 'FeatureCollection', features: [] });
|
|
});
|
|
|
|
it('ATLAS-013 — GET /regions/geo?countries=DE,FR returns FeatureCollection', async () => {
|
|
const { user } = await makeUser(orm());
|
|
|
|
const res = await request(app)
|
|
.get('/api/addons/atlas/regions/geo?countries=DE,FR')
|
|
.set('Cookie', authCookie(user.id));
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(res.body).toHaveProperty('type', 'FeatureCollection');
|
|
expect(
|
|
new Set((res.body.features as { properties: { iso_a2: string } }[]).map((f) => f.properties.iso_a2)),
|
|
).toEqual(new Set(['DE', 'FR']));
|
|
});
|
|
|
|
it('ATLAS-016 — GET /regions/geo/:code serves that country gzipped, cached for a day', async () => {
|
|
const { user } = await makeUser(orm());
|
|
|
|
const res = await request(app)
|
|
.get('/api/addons/atlas/regions/geo/no')
|
|
.set('Accept-Encoding', 'gzip')
|
|
.set('Cookie', authCookie(user.id));
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(res.headers['content-encoding']).toBe('gzip');
|
|
expect(res.headers['cache-control']).toBe('public, max-age=86400');
|
|
expect(res.body.type).toBe('FeatureCollection');
|
|
expect(res.body.features.length).toBeGreaterThan(0);
|
|
expect((res.body.features as { properties: { iso_a2: string } }[]).every((f) => f.properties.iso_a2 === 'NO')).toBe(
|
|
true,
|
|
);
|
|
});
|
|
|
|
it('ATLAS-017 — GET /regions/geo/:code answers a country without regions with an empty FeatureCollection', async () => {
|
|
const { user } = await makeUser(orm());
|
|
|
|
const res = await request(app).get('/api/addons/atlas/regions/geo/ZZ').set('Cookie', authCookie(user.id));
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(res.body).toEqual({ type: 'FeatureCollection', features: [] });
|
|
});
|
|
|
|
it('ATLAS-018 — GET /regions/geo/:code refuses a code that is not two letters with a 400', async () => {
|
|
const { user } = await makeUser(orm());
|
|
|
|
const codes = ['NOR', '..%2Fadmin0'];
|
|
const answers = await Promise.all(
|
|
codes.map((code) => request(app).get(`/api/addons/atlas/regions/geo/${code}`).set('Cookie', authCookie(user.id))),
|
|
);
|
|
for (const [i, res] of answers.entries()) {
|
|
expect(res.status, codes[i]).toBe(400);
|
|
expect(res.body.error, codes[i]).toMatch(/^code: /);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('A place that moves takes its Atlas country with it (#2527)', () => {
|
|
// The region cache is filled by a background task that GET /regions only starts,
|
|
// so wait for the row the way the next Atlas load would find it.
|
|
async function readRegion(placeId: number): Promise<{ country_code: string; region_code: string } | undefined> {
|
|
const row = await findRow(orm(), PlaceRegions, { place: placeId });
|
|
return row ? { country_code: row.country_code, region_code: row.region_code } : undefined;
|
|
}
|
|
|
|
async function regionRowOf(placeId: number): Promise<{ country_code: string; region_code: string } | undefined> {
|
|
for (let i = 0; i < 100; i++) {
|
|
const row = await readRegion(placeId);
|
|
if (row) return row;
|
|
await new Promise((resolve) => setTimeout(resolve, 20));
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
async function atlasCountries(userId: number): Promise<string[]> {
|
|
const res = await request(app).get('/api/addons/atlas/stats').set('Cookie', authCookie(userId));
|
|
expect(res.status).toBe(200);
|
|
return (res.body.countries as { code: string }[]).map((c) => c.code);
|
|
}
|
|
|
|
it('ATLAS-015: correcting a place from France to Germany moves it on the Atlas', async () => {
|
|
const { user } = await makeUser(orm());
|
|
const trip = await makeTrip(orm(), user.id, {
|
|
title: 'Wrongly imported',
|
|
start_date: '2025-05-01',
|
|
end_date: '2025-05-05',
|
|
});
|
|
const place = await makePlace(orm(), trip.id, {
|
|
name: 'Hotel',
|
|
lat: 48.8566,
|
|
lng: 2.3522,
|
|
address: 'Rue de Rivoli, Paris, France',
|
|
category: null,
|
|
});
|
|
|
|
// The place is seen on the Atlas once, which caches France for it.
|
|
await request(app).get('/api/addons/atlas/regions').set('Cookie', authCookie(user.id));
|
|
expect((await regionRowOf(place.id))?.country_code).toBe('FR');
|
|
expect(await atlasCountries(user.id)).toEqual(['FR']);
|
|
|
|
// The user fixes the location in the trip.
|
|
const put = await request(app)
|
|
.put(`/api/trips/${trip.id}/places/${place.id}`)
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ lat: 52.5163, lng: 13.3777, address: 'Pariser Platz, Berlin, Germany' });
|
|
expect(put.status).toBe(200);
|
|
|
|
expect(await atlasCountries(user.id)).toEqual(['DE']);
|
|
|
|
// And the regions follow on the next load, with nothing left in France.
|
|
await request(app).get('/api/addons/atlas/regions').set('Cookie', authCookie(user.id));
|
|
expect((await regionRowOf(place.id))?.country_code).toBe('DE');
|
|
const regions = await request(app).get('/api/addons/atlas/regions').set('Cookie', authCookie(user.id));
|
|
expect(Object.keys(regions.body.regions)).toEqual(['DE']);
|
|
expect(await atlasCountries(user.id)).toEqual(['DE']);
|
|
});
|
|
|
|
it('ATLAS-015: an edit that leaves the location alone keeps the cached country', async () => {
|
|
const { user } = await makeUser(orm());
|
|
const trip = await makeTrip(orm(), user.id, { title: 'Paris', start_date: '2025-05-01', end_date: '2025-05-05' });
|
|
const place = await makePlace(orm(), trip.id, {
|
|
name: 'Louvre',
|
|
lat: 48.8606,
|
|
lng: 2.3376,
|
|
address: 'Rue de Rivoli, Paris, France',
|
|
category: null,
|
|
});
|
|
await request(app).get('/api/addons/atlas/regions').set('Cookie', authCookie(user.id));
|
|
const cached = await regionRowOf(place.id);
|
|
expect(cached?.country_code).toBe('FR');
|
|
|
|
// The place editor sends the whole form back, location included, for a notes edit.
|
|
const put = await request(app)
|
|
.put(`/api/trips/${trip.id}/places/${place.id}`)
|
|
.set('Cookie', authCookie(user.id))
|
|
.send({ notes: 'Closed on Tuesdays', lat: 48.8606, lng: 2.3376, address: 'Rue de Rivoli, Paris, France' });
|
|
expect(put.status).toBe(200);
|
|
|
|
expect(await readRegion(place.id)).toEqual(cached);
|
|
});
|
|
});
|