Upstream/test/client-api.test.js
jvanvik 249818a7aa Stage 3-5 server (military, expansion, social), web client for stages 1-2, ops/deploy
Built: units/research/training, movements (scan, raid, attack, takeover, reinforce, settle, transport), deterministic
combat resolved in the event queue, reports, power/offline units, founding + conquest + incumbent sites; alliances,
roles, diplomacy (24h pact cancel via events), messages, rankings; vanilla-JS phone-first client (auth, POP, map,
alerts, settings, en/nb); systemd units, backup timer, DEPLOY.md, tools/admin.js.
Tested: npm test 96/96 (fake clock, in-memory db, a few real-HTTP tests); client checked with headless Chromium
screenshots only. NOT done: marketplace/transport trade, client screens for military/social, WebSocket push,
bots/balance, e2e suite. All unit stats and costs are unbalanced first guesses.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Q2MJaQ5LXAHzGnTDgceT14
2026-10-11 18:32:36 +02:00

186 lines
9.2 KiB
JavaScript

'use strict';
const test = require('node:test');
const assert = require('node:assert');
const { createApi, ApiError } = require('../public/js/api.js');
// A scripted fetch: each call takes the next response (or throws when given an Error).
function harness(script, extra) {
const calls = [];
const sleeps = [];
let t = 1000;
const store = new Map();
const api = createApi(Object.assign({
fetch: async (url, init) => {
calls.push({ url, init });
const step = script.shift();
if (step instanceof Error) throw step;
t += step.rtt || 0;
return {
ok: step.status >= 200 && step.status < 300, status: step.status,
headers: { get: (k) => (step.headers || {})[k] || null },
json: async () => step.body,
};
},
now: () => t, sleep: async (ms) => { sleeps.push(ms); t += ms; }, jitter: () => 0.5,
storage: { getItem: (k) => (store.has(k) ? store.get(k) : null), setItem: (k, v) => store.set(k, v), removeItem: (k) => store.delete(k) },
randomHex: (() => { let n = 0; return () => 'abcdef' + String(++n).padStart(6, '0'); })(),
}, extra));
return { api, calls, sleeps, store, tick: (ms) => { t += ms; } };
}
const ok = (body, more) => Object.assign({ status: 200, body: Object.assign({ serverTime: 5000 }, body) }, more);
const err = (status, code, more) => Object.assign({ status, body: { serverTime: 5000, error: { code, message: code, details: {} } } }, more);
test('bearer token, JSON body and Idempotency-Key on authenticated POST', async () => {
const h = harness([ok({ a: 1 })]);
h.api.setToken('tok');
assert.strictEqual(h.store.get('upstream.token'), 'tok');
await h.api.post('/towns/1/build', { key: 'f1' });
const { url, init } = h.calls[0];
assert.strictEqual(url, 'api/v1/towns/1/build');
assert.strictEqual(init.headers.Authorization, 'Bearer tok');
assert.strictEqual(init.headers['Content-Type'], 'application/json');
assert.ok(h.api.isValidKey(init.headers['Idempotency-Key']));
assert.strictEqual(init.body, '{"key":"f1"}');
});
test('login POST carries no token and no idempotency key; GET carries no key', async () => {
const h = harness([ok({}), ok({})]);
await h.api.post('/auth/login', { username: 'a', password: 'b' }, { auth: false });
assert.strictEqual(h.calls[0].init.headers['Idempotency-Key'], undefined);
assert.strictEqual(h.calls[0].init.headers.Authorization, undefined);
h.api.setToken('t');
await h.api.get('/me');
assert.strictEqual(h.calls[1].init.headers['Idempotency-Key'], undefined);
});
test('query string is encoded and skips undefined values', async () => {
const h = harness([ok({})]);
await h.api.get('/map', { x: -3, y: 4, r: 20, worldId: undefined });
assert.strictEqual(h.calls[0].url, 'api/v1/map?x=-3&y=4&r=20');
});
test('error envelope becomes ApiError with code, status and details', async () => {
const h = harness([{ status: 409, body: { serverTime: 1, error: { code: 'not_enough_resources', message: 'no', details: { key: 'f1' } } } }]);
h.api.setToken('t');
await assert.rejects(() => h.api.post('/towns/1/build', { key: 'f1' }), (e) => e instanceof ApiError && e.code === 'not_enough_resources' && e.status === 409 && e.details.key === 'f1');
});
test('401 clears the token and emits unauthorized', async () => {
const h = harness([err(401, 'unauthorized')]);
h.api.setToken('t');
let fired = 0;
h.api.on('unauthorized', () => fired++);
await assert.rejects(() => h.api.get('/me'), (e) => e.code === 'unauthorized');
assert.strictEqual(fired, 1);
assert.strictEqual(h.api.hasToken(), false);
assert.strictEqual(h.store.has('upstream.token'), false);
});
test('network errors on GET retry with growing backoff, then succeed', async () => {
const h = harness([new TypeError('fail'), new TypeError('fail'), ok({ fine: true })]);
const events = [];
h.api.on('offline', () => events.push('offline')); h.api.on('online', () => events.push('online'));
const r = await h.api.get('/me');
assert.strictEqual(r.fine, true);
assert.deepStrictEqual(h.sleeps, [400, 800]);
assert.deepStrictEqual(events, ['offline', 'online']);
});
test('network errors give up as network_error after the retry budget', async () => {
const h = harness([new TypeError('x'), new TypeError('x'), new TypeError('x')], { maxRetries: 2 });
await assert.rejects(() => h.api.get('/me'), (e) => e.code === 'network_error' && e.status === 0);
assert.strictEqual(h.calls.length, 3);
});
test('unkeyed POST (login) is NOT retried on a network error', async () => {
const h = harness([new TypeError('x'), ok({})]);
await assert.rejects(() => h.api.post('/auth/signup', { username: 'a' }, { auth: false }), (e) => e.code === 'network_error');
assert.strictEqual(h.calls.length, 1);
});
test('429 honours Retry-After (seconds) and is retried even for unkeyed POSTs', async () => {
const h = harness([err(429, 'rate_limited', { headers: { 'Retry-After': '3' } }), ok({ done: 1 })]);
const r = await h.api.post('/auth/login', {}, { auth: false });
assert.strictEqual(r.done, 1);
assert.deepStrictEqual(h.sleeps, [3000]);
});
test('a Retry-After beyond the cap is handed to the caller instead of blocking', async () => {
const h = harness([err(429, 'rate_limited', { headers: { 'Retry-After': '120' } })]);
await assert.rejects(() => h.api.get('/me'), (e) => e.code === 'rate_limited' && e.retryAfter === 120);
assert.deepStrictEqual(h.sleeps, []);
});
test('retries of one call reuse its Idempotency-Key; the next call gets a new one', async () => {
const h = harness([new TypeError('x'), ok({}), ok({})]);
h.api.setToken('t');
await h.api.post('/towns/1/build', { key: 'f1' });
await h.api.post('/towns/1/build', { key: 'f1' });
const keys = h.calls.map((c) => c.init.headers['Idempotency-Key']);
assert.strictEqual(keys[0], keys[1]);
assert.notStrictEqual(keys[1], keys[2]);
});
test('an intent keeps its key across failed attempts until the server answers', async () => {
const h = harness([new TypeError('x'), new TypeError('x'), new TypeError('x'), err(409, 'not_enough_resources'), ok({})], { maxRetries: 0 });
h.api.setToken('t');
for (let i = 0; i < 3; i++) await assert.rejects(() => h.api.post('/towns/1/build', { key: 'f1' }, { intent: 'build:1:f1' }), (e) => e.code === 'network_error');
assert.deepStrictEqual(h.api.pendingIntents(), ['build:1:f1']);
await assert.rejects(() => h.api.post('/towns/1/build', { key: 'f1' }, { intent: 'build:1:f1' }), (e) => e.code === 'not_enough_resources');
assert.deepStrictEqual(h.api.pendingIntents(), []); // definite answer: the intent is over
await h.api.post('/towns/1/build', { key: 'f1' }, { intent: 'build:1:f1' });
const keys = h.calls.map((c) => c.init.headers['Idempotency-Key']);
assert.strictEqual(new Set(keys.slice(0, 4)).size, 1);
assert.notStrictEqual(keys[4], keys[3]);
});
test('request_in_progress is retried after a short delay', async () => {
const h = harness([err(409, 'request_in_progress'), ok({ x: 1 })]);
h.api.setToken('t');
const r = await h.api.post('/towns/1/build', { key: 'f1' });
assert.strictEqual(r.x, 1);
assert.strictEqual(h.sleeps.length, 1);
});
test('503 on GET is retried, on unkeyed POST is not', async () => {
const a = harness([err(503, 'internal_error'), ok({ y: 1 })]);
assert.strictEqual((await a.api.get('/me')).y, 1);
const b = harness([err(503, 'internal_error'), ok({})]);
await assert.rejects(() => b.api.post('/auth/login', {}, { auth: false }), (e) => e.status === 503);
assert.strictEqual(b.calls.length, 1);
});
test('server clock offset comes from the lowest-latency sample; replayed responses are ignored', async () => {
// t0=1000, rtt 400, serverTime 5000 -> offset 5000 - 1200 = 3800
const h = harness([ok({}, { rtt: 400 }), ok({ serverTime: 99999 }, { rtt: 100 }), ok({ serverTime: 1 }, { rtt: 900 }), ok({ serverTime: 99999 }, { rtt: 1, headers: { 'Idempotent-Replay': 'true' } })]);
await h.api.get('/me');
assert.strictEqual(h.api.serverOffset(), 3800);
await h.api.get('/me'); // better rtt (100): adopted. t0 was 1400 -> mid 1450 -> offset 99999-1450
assert.strictEqual(h.api.serverOffset(), 99999 - 1450);
const before = h.api.serverOffset();
await h.api.get('/me'); // worse rtt: kept
assert.strictEqual(h.api.serverOffset(), before);
await h.api.get('/me'); // replay: ignored
assert.strictEqual(h.api.serverOffset(), before);
});
test('push events can be emitted and unsubscribed; a throwing listener does not break others', () => {
const h = harness([]);
const got = [];
const off = h.api.on('push', (m) => got.push(m));
h.api.on('push', () => { throw new Error('boom'); });
h.api.on('push', (m) => got.push('2:' + m.type));
h.api.emit('push', { type: 'town', id: 1 });
off();
h.api.emit('push', { type: 'x' });
assert.deepStrictEqual(got, [{ type: 'town', id: 1 }, '2:town', '2:x']);
});
test('storage failures fall back to memory', () => {
const api = createApi({ fetch: async () => { throw new Error('unused'); }, storage: { getItem() { throw new Error('denied'); }, setItem() { throw new Error('denied'); }, removeItem() { throw new Error('denied'); } } });
api.setToken('abc');
assert.strictEqual(api.getToken(), 'abc');
api.clearToken();
assert.strictEqual(api.getToken(), null);
});