183 lines
7.5 KiB
TypeScript
183 lines
7.5 KiB
TypeScript
import { test, expect, login, sceneObjectCount } from './fixtures';
|
|
|
|
/**
|
|
* A launch west of Greenwich must work.
|
|
*
|
|
* The app holds longitudes in [-180, 180] — wrapLongitude produces that, the map
|
|
* reports clicks that way, and the predictor accepts [-180, 360). Django's
|
|
* PredictionRequestSerializer declared launch_longitude with min_value=0, so every
|
|
* western coordinate was refused before it ever reached the predictor. That is
|
|
* Canada, Greenland and Alaska: most of the Arctic launch sites this product is
|
|
* being built for.
|
|
*
|
|
* Nuuk (64.1, -51.7) is the fixture. 308.3 is the same meridian written in the
|
|
* [0, 360) convention, which is the control: if one is refused and the other is
|
|
* accepted, the constraint is about notation, not about the place.
|
|
*/
|
|
|
|
test.beforeEach(async ({ context }) => {
|
|
await login(context);
|
|
});
|
|
|
|
const NUUK = { lat: 64.1, lngSigned: -51.7, lngUnsigned: 308.3 };
|
|
|
|
/** POST straight to Django from the page, so the browser's session and CSRF apply. */
|
|
async function postPrediction(page: import('@playwright/test').Page, lat: number, lng: number) {
|
|
return page.evaluate(
|
|
async ({ lat, lng }) => {
|
|
const cookie = (name: string) =>
|
|
document.cookie
|
|
.split('; ')
|
|
.find((c) => c.startsWith(name + '='))
|
|
?.split('=')[1] ?? '';
|
|
await fetch('/api/csrf/', { credentials: 'include' });
|
|
const res = await fetch('/api/predictions/', {
|
|
method: 'POST',
|
|
credentials: 'include',
|
|
headers: { 'Content-Type': 'application/json', 'X-CSRFToken': cookie('csrftoken') },
|
|
body: JSON.stringify({
|
|
launch_latitude: lat,
|
|
launch_longitude: lng,
|
|
launch_datetime: '2026-08-05T12:00:00Z',
|
|
launch_altitude: 0,
|
|
ascent_rate: 5,
|
|
burst_altitude: 30000,
|
|
descent_rate: 5,
|
|
profile: 'standard_profile',
|
|
}),
|
|
});
|
|
return { status: res.status, body: (await res.text()).slice(0, 300) };
|
|
},
|
|
{ lat, lng },
|
|
);
|
|
}
|
|
|
|
test('the operator can run a prediction west of Greenwich', async ({ page }) => {
|
|
test.setTimeout(150_000);
|
|
|
|
const posted: string[] = [];
|
|
const answered: string[] = [];
|
|
page.on('request', (r) => {
|
|
if (r.url().includes('/predictions/') && r.method() === 'POST') posted.push(r.postData() ?? '');
|
|
});
|
|
page.on('response', async (r) => {
|
|
if (r.url().includes('/predictions/'))
|
|
answered.push(`${r.status()} ${(await r.text().catch(() => '')).slice(0, 200)}`);
|
|
});
|
|
|
|
// A default workspace is created on first visit; nothing is seeded, so the
|
|
// coordinates below come from the input fields the way an operator enters them.
|
|
await page.goto('/predict');
|
|
await page
|
|
.locator('.map-container canvas')
|
|
.first()
|
|
.waitFor({ state: 'attached', timeout: 60_000 });
|
|
|
|
// The coordinate fields live on the Conditions tab; the Scenario tab is open by
|
|
// default, so nothing numeric is mounted until this click.
|
|
await page
|
|
.locator('.panel-container-left')
|
|
.getByRole('button', { name: /Условия|Conditions/ })
|
|
.first()
|
|
.click();
|
|
|
|
// The latitude input is the only number field bounded to +-90; longitude is the
|
|
// number field immediately after it.
|
|
const latInput = page.locator('.panel-container-left input[type="number"][min="-90"]').first();
|
|
await expect(latInput).toBeVisible();
|
|
const lngInput = latInput.locator('xpath=following::input[@type="number"][1]');
|
|
|
|
await latInput.fill(String(NUUK.lat));
|
|
await lngInput.fill(String(NUUK.lngSigned));
|
|
|
|
// What the UI holds after its own normalisation. wrapLongitude keeps west
|
|
// negative rather than folding it to 308.3, which is why the value Django sees
|
|
// is negative.
|
|
expect(Number(await lngInput.inputValue())).toBeCloseTo(NUUK.lngSigned, 6);
|
|
|
|
await page
|
|
.locator('.panel-container-right .workspace-row')
|
|
.first()
|
|
.getByRole('button', { name: /Рассчитать|Run/ })
|
|
.click();
|
|
|
|
await expect.poll(() => answered.length, { timeout: 90_000 }).toBeGreaterThan(0);
|
|
console.log(' POST body :', posted[0]);
|
|
console.log(' response :', answered[0]);
|
|
|
|
// Compared numerically: wrapLongitude's modular arithmetic returns
|
|
// -51.69999999999999, about a nanometre off, which is not worth chasing.
|
|
expect(JSON.parse(posted[0]).launch_longitude).toBeCloseTo(NUUK.lngSigned, 6);
|
|
expect(answered[0]).toMatch(/^2\d\d /);
|
|
// And the trajectory actually renders.
|
|
await expect.poll(() => sceneObjectCount(page, 'ws/'), { timeout: 30_000 }).toBeGreaterThan(0);
|
|
});
|
|
|
|
test('the same point is accepted in either longitude convention', async ({ page }) => {
|
|
test.setTimeout(150_000);
|
|
await page.goto('/predict');
|
|
|
|
const west = await postPrediction(page, NUUK.lat, NUUK.lngSigned);
|
|
const east = await postPrediction(page, NUUK.lat, NUUK.lngUnsigned);
|
|
console.log(` lng=${NUUK.lngSigned} -> ${west.status} ${west.body.slice(0, 120)}`);
|
|
console.log(` lng=${NUUK.lngUnsigned} -> ${east.status} ${east.body.slice(0, 120)}`);
|
|
|
|
// The control: the unsigned form of the same meridian was always accepted.
|
|
expect(east.status).toBeLessThan(300);
|
|
expect(west.status).toBe(east.status);
|
|
});
|
|
|
|
test('the parsed trajectory is folded back to the signed convention', async ({ page }) => {
|
|
test.setTimeout(150_000);
|
|
|
|
// v1 publishes [0, 360) — the convention upstream Tawhiri publishes, which is
|
|
// why v1 exists. The frontend holds [-180, 180], and domain/prediction.ts is
|
|
// the single place that folds: parsePrediction runs normalizeLng over the
|
|
// flight path and over launch/burst/landing. This checks that fold actually
|
|
// happened, since a missed one would put Greenland at 308 E — on the far side
|
|
// of the globe — with no error anywhere.
|
|
await page.goto('/');
|
|
await page.evaluate(() => {
|
|
const ws = {
|
|
id: crypto.randomUUID(), name: 'nuuk', color: '#dc3545', opacity: 1, visible: true,
|
|
flightParameters: {
|
|
ascent_rate: 5, burst_altitude: 30000, dataset: '', descent_rate: 5, format: 'json',
|
|
launch_altitude: 0, launch_latitude: 64.1, launch_longitude: -51.7,
|
|
profile: 'standard_profile', version: 2,
|
|
},
|
|
launchDate: new Date().toISOString().split('T')[0], launchTime: '12:00:00', result: null,
|
|
};
|
|
localStorage.setItem('workspaces', JSON.stringify({ items: [ws], activeId: ws.id }));
|
|
});
|
|
await page.goto('/predict');
|
|
await page.locator('.map-container canvas').first().waitFor({ state: 'attached', timeout: 60_000 });
|
|
await page
|
|
.locator('.panel-container-right .workspace-row')
|
|
.first()
|
|
.getByRole('button', { name: /Рассчитать|Run/ })
|
|
.click();
|
|
await expect.poll(() => sceneObjectCount(page, 'ws/'), { timeout: 90_000, intervals: [1000, 2000, 3000] })
|
|
.toBeGreaterThan(0);
|
|
|
|
// Read the drawn polyline, not the store: what matters is where the trajectory
|
|
// ends up on the globe, and Cesium holds it as earth-centred vectors that have
|
|
// to be read back through Cartographic.
|
|
const geom = await page.evaluate(() => {
|
|
/* eslint-disable @typescript-eslint/no-explicit-any */
|
|
const v: any = (window as any)._lsvMap;
|
|
const C: any = v.camera.positionCartographic.constructor;
|
|
const e = v.entities.values.find((x: any) => String(x.id).includes('ws/') && x.polyline);
|
|
if (!e) return null;
|
|
const ps = e.polyline.positions.getValue(v.clock.currentTime);
|
|
const lngs = ps.map((p: any) => (C.fromCartesian(p).longitude * 180) / Math.PI);
|
|
return { n: ps.length, min: Math.min(...lngs), max: Math.max(...lngs), first: lngs[0] };
|
|
/* eslint-enable @typescript-eslint/no-explicit-any */
|
|
});
|
|
|
|
expect(geom).not.toBeNull();
|
|
console.log(' drawn longitudes:', geom!.min.toFixed(4), '..', geom!.max.toFixed(4), `(${geom!.n} pts)`);
|
|
// Nuuk and its whole flight stay near -51, not near +308 on the far side.
|
|
expect(geom!.max).toBeLessThan(0);
|
|
expect(geom!.min).toBeGreaterThan(-90);
|
|
expect(geom!.first).toBeCloseTo(-51.7, 3);
|
|
});
|