mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
The satellites layer now sorts every object into Stations, Imaging, Telecom, Starlink, Probes or Debris, each with a chip and a live count on the layer row. Stations and Imaging show by default; the Starlink chip is the former DENSE catalog switch. Hidden classes keep their points, so a toggle needs no reload, and they leave the detection overlay and the voice position lists. A class comes, strongest evidence first, from CelesTrak SATCAT (object type and status, served by a new /api/celestrak-satcat/<group> proxy route and cached for a day), the bundled UCS Satellite Database pack (operator, owner country and purpose), name patterns for later launches, and the CelesTrak group. The core catalog also reads the resource, weather, planet, sar and science groups. Payloads with no evidence of life launched 20 or more years ago are filed as debris. The UCS pack, its build script and its data credit are added.
200 lines
9.3 KiB
JavaScript
200 lines
9.3 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { readFileSync } from 'node:fs';
|
|
import path from 'node:path';
|
|
import { providerCooldownMs } from '../server/providers/space/cooldown.js';
|
|
import { parseTerrainPoints } from './data/terrainHeightsProxy.js';
|
|
import { readResponseTextCapped, coalesceProxyRequest } from './sources/httpBody.js';
|
|
import { makeRateLimiter, clientKey } from '../server/providers/common/rate-limit.js';
|
|
|
|
const source = ['local.js', 'common/http.js', 'aircraft/enrichment.js', 'terrain.js', 'space/celestrak.js', 'space/launch-library.js', '../../src/data/spaceProviderRequests.js']
|
|
.map(file => readFileSync(new URL(`../server/providers/${file}`, import.meta.url), 'utf8'))
|
|
.join('\n');
|
|
const detail = 'fixture-secret-token /internal/example <html>';
|
|
|
|
// Execute the production middleware with isolated upstreams and cache storage.
|
|
// Top-level function closing braces start in column zero in this module.
|
|
function extract(name) {
|
|
const start = source.search(new RegExp(`(?:export )?(?:async )?function ${name}\\(`));
|
|
assert.ok(start >= 0, `${name} must exist`);
|
|
const end = source.indexOf('\n}', start);
|
|
return source.slice(start, end + 2).replace(/^export /, '');
|
|
}
|
|
|
|
function fixture(name, overrides = {}, preview = false) {
|
|
const logs = [];
|
|
const deps = {
|
|
readResponseTextCapped, coalesceProxyRequest, providerCooldownMs,
|
|
// The rate-limited proxies reach for these; give them the real ones so a
|
|
// fixture request is throttled exactly as production would be.
|
|
makeRateLimiter, clientKey,
|
|
// terrain.js gates cross-site requests first; fixture requests carry no
|
|
// browser headers, so admit them like a loopback tool.
|
|
admitSameSiteKeyless: () => false,
|
|
path, process: { cwd: () => '/fixture', env: {} },
|
|
fsp: {
|
|
readFile: async () => { throw new Error('cache absent'); },
|
|
stat: async () => { throw new Error('cache absent'); },
|
|
mkdir: async () => {}, writeFile: async () => {},
|
|
},
|
|
fetch: async () => { throw new Error(detail); },
|
|
console: { warn: (...args) => logs.push(args.join(' ')), error: (...args) => logs.push(args.join(' ')) },
|
|
setInterval: () => ({ unref() {} }),
|
|
LL2_CACHE_TTL_MS: 15 * 60_000,
|
|
parseTerrainPoints: () => [[1, 2]],
|
|
resolveTerrainHeightRequest: async () => { throw new Error(detail); },
|
|
...overrides,
|
|
};
|
|
const helpers = ['launchLibraryRequestHeaders', 'celestrakTleUrl', 'celestrakSatcatUrl', 'launchLibraryRecentUrl'].map(extract).join('\n');
|
|
const plugin = new Function(...Object.keys(deps), `${helpers}\n${extract(name)}\nreturn ${name}();`)(...Object.values(deps));
|
|
let middleware;
|
|
// A plugin with several routes (CelesTrak: TLEs, then SATCAT) is tested on its first.
|
|
plugin[preview ? 'configurePreviewServer' : 'configureServer']({ middlewares: { use(_route, handler) { middleware ??= handler; } } });
|
|
return {
|
|
logs,
|
|
async request(url = '/', method = 'GET') {
|
|
const response = { headersSent: false, writeHead(status, headers) { Object.assign(this, { status, headers, headersSent: true }); }, end(body) { this.body = body; } };
|
|
await middleware({ url, method }, response);
|
|
assert.doesNotMatch(response.body, /fixture-secret-token|internal\/example|<html>/);
|
|
assert.doesNotMatch(logs.join('\n'), /fixture-secret-token|internal\/example|<html>/);
|
|
return response;
|
|
},
|
|
};
|
|
}
|
|
|
|
for (const status of [401, 429, 500]) {
|
|
for (const preview of [false, true]) {
|
|
test(`Launch Library ${status} stays generic in ${preview ? 'preview' : 'development'}`, async () => {
|
|
const app = fixture('rocketLaunchesProxy', { fetch: async () => new Response(detail.repeat(1000), { status }) }, preview);
|
|
const res = await app.request();
|
|
assert.equal(res.status, status);
|
|
assert.deepEqual(JSON.parse(res.body), { error: 'Launch Library 2 unavailable' });
|
|
assert.equal(res.headers['Cache-Control'], 'no-store');
|
|
assert.equal(res.headers['X-GEV-Cache'], 'NONE');
|
|
assert.equal(app.logs.length, 1);
|
|
assert.match(app.logs[0], new RegExp(`HTTP ${status}`));
|
|
assert.ok(app.logs[0].length < 100);
|
|
});
|
|
}
|
|
}
|
|
|
|
for (const [label, fetch] of [
|
|
['network error', async () => { throw new Error(detail); }],
|
|
['malformed JSON', async () => new Response(detail)],
|
|
['invalid feed', async () => new Response('{}')],
|
|
['oversized response', async () => new Response(detail, { headers: { 'content-length': String(13 * 1024 * 1024) } })],
|
|
]) {
|
|
test(`Launch Library ${label} returns 502`, async () => {
|
|
const res = await fixture('rocketLaunchesProxy', { fetch }).request();
|
|
assert.equal(res.status, 502);
|
|
assert.deepEqual(JSON.parse(res.body), { error: 'Launch Library 2 unavailable' });
|
|
});
|
|
}
|
|
|
|
test('Launch Library retains single-flight, fresh cache, stale fallback, and method guard', async () => {
|
|
let now = Date.now();
|
|
let calls = 0;
|
|
let release;
|
|
const gate = new Promise(resolve => { release = resolve; });
|
|
class Clock extends Date { static now() { return now; } }
|
|
const app = fixture('rocketLaunchesProxy', {
|
|
Date: Clock,
|
|
fetch: async () => { calls += 1; await gate; if (calls > 1) throw new Error(detail); return new Response('{"results":[]}'); },
|
|
});
|
|
assert.equal((await app.request('/', 'POST')).status, 405);
|
|
const first = app.request();
|
|
const second = app.request();
|
|
release();
|
|
const pair = await Promise.all([first, second]);
|
|
assert.deepEqual(pair.map(res => res.headers['X-GEV-Cache']).sort(), ['INFLIGHT', 'MISS']);
|
|
assert.equal(calls, 1);
|
|
assert.equal((await app.request()).headers['X-GEV-Cache'], 'HIT');
|
|
now += 16 * 60_000;
|
|
const stale = await app.request();
|
|
assert.equal(stale.status, 200);
|
|
assert.equal(stale.body, '{"results":[]}');
|
|
assert.equal(stale.headers['X-GEV-Cache'], 'STALE-ERROR');
|
|
assert.equal(calls, 2);
|
|
});
|
|
|
|
test('CelesTrak unexpected failures hide details', async () => {
|
|
const app = fixture('celestrakProxy', { Date: { now() { throw new Error(detail); } } });
|
|
const res = await app.request('/stations');
|
|
assert.equal(res.status, 500);
|
|
assert.equal(res.body, 'celestrak proxy error');
|
|
assert.equal(res.headers['x-tle-cache'], 'ERROR');
|
|
});
|
|
|
|
test('CelesTrak retains invalid-group and unavailable responses', async () => {
|
|
const app = fixture('celestrakProxy');
|
|
assert.equal((await app.request('/../')).status, 400);
|
|
const res = await app.request('/stations');
|
|
assert.equal(res.status, 502);
|
|
assert.equal(res.headers['x-tle-cache'], 'NONE');
|
|
});
|
|
|
|
test('CelesTrak retains fresh and stale TLE caches', async () => {
|
|
let now = Date.now();
|
|
let calls = 0;
|
|
const app = fixture('celestrakProxy', {
|
|
Date: class extends Date { static now() { return now; } },
|
|
fetch: async () => { if (++calls > 1) throw new Error(detail); return new Response('1 valid-fixture-TLE'); },
|
|
});
|
|
assert.equal((await app.request('/stations')).headers['x-tle-cache'], 'MISS');
|
|
assert.equal((await app.request('/stations')).headers['x-tle-cache'], 'HIT');
|
|
now += 7 * 3600_000;
|
|
const stale = await app.request('/stations');
|
|
assert.equal(stale.status, 200);
|
|
assert.equal(stale.body, '1 valid-fixture-TLE');
|
|
assert.equal(stale.headers['x-tle-cache'], 'STALE-ERROR');
|
|
});
|
|
|
|
test('terrain unexpected failures hide details', async () => {
|
|
const res = await fixture('terrainHeightsProxy').request('/?points=1,2');
|
|
assert.equal(res.status, 500);
|
|
assert.deepEqual(JSON.parse(res.body), { error: 'terrain heights proxy error' });
|
|
});
|
|
|
|
test('terrain validation and resolver outcomes remain intact', async () => {
|
|
const invalid = await fixture('terrainHeightsProxy', { parseTerrainPoints: () => null }).request();
|
|
assert.equal(invalid.status, 400);
|
|
const body = { results: [{ height: 12 }] };
|
|
const app = fixture('terrainHeightsProxy', { resolveTerrainHeightRequest: async () => ({ status: 200, body, upstreamError: new Error(detail) }) });
|
|
const res = await app.request('/?points=1,2');
|
|
assert.equal(res.status, 200);
|
|
assert.deepEqual(JSON.parse(res.body), body);
|
|
assert.equal(app.logs.length, 1);
|
|
});
|
|
|
|
test('ADSBDB unexpected failures hide details', async () => {
|
|
const badUrl = { toString() { throw new Error(detail); } };
|
|
const res = await fixture('adsbdbProxy').request(badUrl);
|
|
assert.equal(res.status, 500);
|
|
assert.deepEqual(JSON.parse(res.body), { error: 'adsbdb proxy error' });
|
|
});
|
|
|
|
test('ADSBDB retains validation and missing-aircraft semantics', async () => {
|
|
const app = fixture('adsbdbProxy');
|
|
assert.equal((await app.request('/route/!')).status, 400);
|
|
assert.equal((await app.request('/type/nope')).status, 400);
|
|
assert.equal((await app.request('/unknown')).status, 404);
|
|
const absent = await app.request('/type/abcdef');
|
|
assert.equal(absent.status, 200);
|
|
assert.deepEqual(JSON.parse(absent.body), { found: false });
|
|
});
|
|
|
|
for (const preview of [false, true]) {
|
|
test(`terrain server rejects out-of-range points before upstream resolution in ${preview ? 'preview' : 'development'}`, async () => {
|
|
let calls = 0;
|
|
const app = fixture('terrainHeightsProxy', { parseTerrainPoints,
|
|
resolveTerrainHeightRequest: async () => { calls++; return { status: 200, body: { results: [] } }; },
|
|
}, preview);
|
|
for (const points of ['181,0', '-181,0', '0,91', '0,-91', '1,2;0,91']) {
|
|
assert.equal((await app.request('/?points=' + encodeURIComponent(points))).status, 400);
|
|
}
|
|
assert.equal(calls, 0);
|
|
assert.equal((await app.request('/?points=-180,-90;180,90')).status, 200);
|
|
assert.equal(calls, 1);
|
|
});
|
|
}
|