167 lines
12 KiB
JavaScript
167 lines
12 KiB
JavaScript
import test from 'node:test'
|
|
import assert from 'node:assert/strict'
|
|
import { mkdtemp, readFile, writeFile, readdir, stat } from 'node:fs/promises'
|
|
import { tmpdir } from 'node:os'
|
|
import path from 'node:path'
|
|
import { FileConfigStore, atomicWriteJson } from '../server/config/file-config-store.js'
|
|
import { normalizeConfig } from '../server/config/schema.js'
|
|
import { ClientRegistry } from '../server/clients/client-registry.js'
|
|
import { safeProxyPath, proxyHeaders } from '../server/proxy/service.js'
|
|
import { createSimAdminClient } from '../server/core.js'
|
|
import { collectInstanceStatus } from '../server/status/service.js'
|
|
import { buildApp } from '../server/app.js'
|
|
import { RequestCoordinator } from '../public/state/request-coordinator.js'
|
|
import { createApiClient } from '../public/infrastructure/api-client.js'
|
|
import { createViewRouter } from '../public/router/view-router.js'
|
|
|
|
const projectRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..')
|
|
|
|
async function files(instances = []) {
|
|
const dir = await mkdtemp(path.join(tmpdir(), 'msa-blockers-'))
|
|
const configPath = path.join(dir, 'config.json')
|
|
const examplePath = path.join(dir, 'example.json')
|
|
await writeFile(examplePath, JSON.stringify({ server: { port: 8788 }, instances }))
|
|
return { dir, configPath, examplePath }
|
|
}
|
|
|
|
function client(instance, request) {
|
|
return { instance, request, jar: { clear() {} }, fetchJson: async () => ({ ok: true, status: 200, latencyMs: 1, data: {} }), ensureAuthenticated: async () => ({ authenticated: true }) }
|
|
}
|
|
|
|
test('proxy path rejects normalization and repeated-decoding structure changes', () => {
|
|
assert.equal(safeProxyPath('api/a%20b'), '/api/a%20b')
|
|
for (const input of ['%252e%252e/x', 'api/%252f/x', 'api/%255c/x', 'api/a%2525252fetc', 'api/%2525252e%2525252e/x', 'api/%2525253fx', 'api\\x', '//evil/x', '%2f%2fevil/x', 'api/%3fadmin', 'api/%253fadmin', 'api/%23x', 'api/%2523x', 'api/%2e%2e/x']) {
|
|
assert.throws(() => safeProxyPath(input), /invalid proxy path/, input)
|
|
}
|
|
assert.equal(proxyHeaders({ 'accept-encoding': 'gzip', accept: 'json' }).has('accept-encoding'), false)
|
|
})
|
|
|
|
test('FileConfigStore preserves constructor env across transactions and serializes real writes', async () => {
|
|
const { configPath, examplePath } = await files()
|
|
const store = await FileConfigStore.open({ configPath, examplePath, env: { HOST: 'localhost', PORT: '4321' } })
|
|
await Promise.all([
|
|
store.add({ id: 'a', url: 'http://192.0.2.21' }),
|
|
store.add({ id: 'b', url: 'http://192.0.2.22' }),
|
|
])
|
|
assert.equal(store.snapshot.server.host, 'localhost')
|
|
assert.equal(store.snapshot.server.port, 4321)
|
|
assert.deepEqual(JSON.parse(await readFile(configPath, 'utf8')).instances.map(x => x.id), ['a', 'b'])
|
|
})
|
|
|
|
test('atomicWriteJson replaces content, leaves no temp and creates POSIX 0600', async () => {
|
|
const { dir, configPath } = await files()
|
|
await writeFile(configPath, 'old', { mode: 0o644 })
|
|
await atomicWriteJson(configPath, { ok: true })
|
|
assert.deepEqual(JSON.parse(await readFile(configPath, 'utf8')), { ok: true })
|
|
assert.deepEqual((await readdir(dir)).filter(x => x.endsWith('.tmp')), [])
|
|
if (process.platform !== 'win32') assert.equal((await stat(configPath)).mode & 0o777, 0o600)
|
|
})
|
|
|
|
test('schema rejects invalid port and auth mode', () => {
|
|
for (const port of [0, 65536, 1.5, 'wat']) assert.throws(() => normalizeConfig({ server: { port }, instances: [] }, {}), /port/)
|
|
assert.throws(() => normalizeConfig({ instances: [{ id: 'x', url: 'http://192.0.2.27', auth: { mode: 'token' } }] }, {}), /auth.mode/)
|
|
})
|
|
|
|
test('registry reconcile builds next map before publishing and closes staged clients on create failure', () => {
|
|
const old = { id: 'old', url: 'http://192.0.2.24', auth: { mode: 'none', password: '' } }
|
|
let stagedClosed = false
|
|
const registry = new ClientRegistry({ createClient: item => {
|
|
if (item.id === 'bad') throw new Error('boom')
|
|
return { instance: item, close() { if (item.id === 'staged') stagedClosed = true } }
|
|
} }).reconcile([old])
|
|
assert.throws(() => registry.reconcile([{ id: 'staged', url: 'http://192.0.2.26' }, { id: 'bad', url: 'http://192.0.2.23' }]), /boom/)
|
|
assert.equal(stagedClosed, true)
|
|
assert.equal(registry.get('old').instance.id, 'old')
|
|
assert.equal(registry.get('bad'), undefined)
|
|
})
|
|
|
|
test('temporary login credential is ephemeral, saved flag comes from store, logout clears it', async t => {
|
|
const { configPath, examplePath } = await files([{ id: 'one', url: 'http://192.0.2.25' }])
|
|
const store = await FileConfigStore.open({ configPath, examplePath })
|
|
let credential
|
|
let cleared = false
|
|
const fake = { instance: structuredClone(store.snapshot.instances[0]), jar: { clear() {} }, ensureAuthenticated: async options => { credential = options?.credential; return { authenticated: true } }, clearEphemeralSecret: () => { cleared = true }, fetchJson: async () => ({ ok: true }) }
|
|
const registry = new ClientRegistry({ createClient: () => fake }).reconcile(store.snapshot.instances)
|
|
const app = await buildApp({ configStore: store, clientRegistry: registry, staticFiles: false }); t.after(() => app.close())
|
|
const login = await app.inject({ method: 'POST', url: '/api/instances/one/login', payload: { password: 'temporary' } })
|
|
assert.equal(credential, 'temporary')
|
|
assert.equal(fake.instance.auth.password, '')
|
|
assert.equal(login.json().hasSavedPassword, false)
|
|
await app.inject({ method: 'POST', url: '/api/instances/one/logout' })
|
|
assert.equal(cleared, true)
|
|
})
|
|
|
|
test('failed temporary login credential is not retained for later automatic attempts', async () => {
|
|
const instance = { id: 'x', url: 'http://192.0.2.27', auth: { mode: 'none', password: '' } }
|
|
const bodies = []
|
|
const c = createSimAdminClient(instance, { fetchImpl: async (url, options = {}) => {
|
|
const pathname = new URL(url).pathname
|
|
if (pathname === '/api/auth/status') return new Response(JSON.stringify({ configured: true, authenticated: false, settings: { password_protection_enabled: true } }), { status: 200 })
|
|
bodies.push(options.body)
|
|
return new Response('{}', { status: 401 })
|
|
} })
|
|
const failed = await c.ensureAuthenticated({ credential: 'wrong' })
|
|
assert.equal(failed.authenticated, false)
|
|
const later = await c.ensureAuthenticated()
|
|
assert.equal(later.loginAttempted, false)
|
|
assert.equal(later.reason, 'password_required')
|
|
assert.deepEqual(bodies, ['{"password":"wrong"}'])
|
|
})
|
|
|
|
test('proxy body/header contract handles JSON text buffer, gzip metadata and stable 415', async t => {
|
|
const { configPath, examplePath } = await files([{ id: 'one', url: 'http://192.0.2.25/base' }])
|
|
const store = await FileConfigStore.open({ configPath, examplePath })
|
|
const calls = []
|
|
const registry = new ClientRegistry({ createClient: instance => client(instance, async (url, options) => {
|
|
calls.push({ url: String(url), options })
|
|
return new Response('decoded', { status: 503, headers: { 'content-encoding': 'gzip', 'content-length': '999', 'x-upstream': 'yes' } })
|
|
}) }).reconcile(store.snapshot.instances)
|
|
const testPolicy = { authorize: () => ({ allowed: true, dangerous: false }) }
|
|
const app = await buildApp({ configStore: store, clientRegistry: registry, staticFiles: false, proxyPolicy: testPolicy }); t.after(() => app.close())
|
|
const json = await app.inject({ method: 'POST', url: '/api/proxy/one/api/x?q=1', headers: { 'content-type': 'application/json', 'accept-encoding': 'gzip' }, payload: { x: 1 } })
|
|
assert.equal(json.statusCode, 503); assert.equal(calls[0].options.body, '{"x":1}'); assert.equal(new URL(calls[0].url).pathname, '/api/x'); assert.equal(new URL(calls[0].url).search, '?q=1')
|
|
assert.equal(calls[0].options.headers.has('accept-encoding'), false); assert.equal(json.headers['content-encoding'], undefined); assert.equal(json.headers['content-length'], '7')
|
|
await app.inject({ method: 'POST', url: '/api/proxy/one/api/x', headers: { 'content-type': 'text/plain' }, payload: 'hello' }); assert.equal(calls[1].options.body, 'hello')
|
|
await app.inject({ method: 'POST', url: '/api/proxy/one/api/x', headers: { 'content-type': 'application/octet-stream' }, payload: Buffer.from('bin') }); assert.ok(Buffer.isBuffer(calls[2].options.body))
|
|
const empty = await app.inject({ method: 'POST', url: '/api/proxy/one/api/logout' }); assert.equal(empty.statusCode, 503); assert.equal(calls[3].options.body, undefined)
|
|
const unsupported = await app.inject({ method: 'POST', url: '/api/proxy/one/api/x', headers: { 'content-type': 'multipart/form-data; boundary=x' }, payload: '--x--' }); assert.equal(unsupported.statusCode, 415); assert.deepEqual(unsupported.json(), { error: 'unsupported proxy content type' })
|
|
})
|
|
|
|
test('committed config survives reconcile failure and readiness degrades then retry recovers', async t => {
|
|
const { configPath, examplePath } = await files()
|
|
const store = await FileConfigStore.open({ configPath, examplePath })
|
|
let fail = true
|
|
const registry = new ClientRegistry({ createClient: instance => { if (fail) throw new Error('factory'); return client(instance, async () => new Response('{}')) } })
|
|
const app = await buildApp({ configStore: store, clientRegistry: registry, staticFiles: false, reconcileRetryMs: 10 }); t.after(() => app.close())
|
|
const created = await app.inject({ method: 'POST', url: '/api/instances', payload: { id: 'x', url: 'http://192.0.2.27' } })
|
|
assert.equal(created.statusCode, 200); assert.equal(created.json().reconcilePending, true); assert.equal((await app.inject('/api/ready')).json().ready, false)
|
|
fail = false
|
|
await new Promise(resolve => setTimeout(resolve, 30))
|
|
assert.equal((await app.inject('/api/ready')).json().ready, true); assert.ok(registry.get('x'))
|
|
})
|
|
|
|
test('status supports registration_status and health 404 with successful business endpoint', async () => {
|
|
const values = new Map([['/api/health', { ok: false, status: 404, latencyMs: 2, data: null }], ['/api/auth/status', { ok: false, status: 404, data: null }], ['/api/device', { ok: true, status: 200, data: { model: 'X' } }], ['/api/network', { ok: true, status: 200, data: { registration_status: 'registered' } }]])
|
|
const instance = { id: 'x', name: 'x', url: 'http://192.0.2.27', auth: { mode: 'none', password: '' } }
|
|
const c = createSimAdminClient(instance, { fetchImpl: async url => { const v = values.get(new URL(url).pathname) || { ok: false, status: 404, data: null }; return new Response(JSON.stringify(v.data), { status: v.status }) } })
|
|
const status = await collectInstanceStatus(c)
|
|
assert.equal(status.reachable, true); assert.notEqual(status.authenticated, false); assert.equal(status.summary.network.registration, 'registered')
|
|
})
|
|
|
|
test('bootstrap copies immutable listen options before handing them to Fastify', async () => {
|
|
const source = await readFile(path.join(projectRoot, 'server/index.js'), 'utf8')
|
|
assert.match(source, /app\.listen\(\{\s*\.\.\.configStore\.snapshot\.server\s*\}\)/)
|
|
assert.doesNotMatch(source, /app\.listen\(configStore\.snapshot\.server\)/)
|
|
})
|
|
|
|
test('coordinator structures rejection and stale errors; api client/router modules are usable', async () => {
|
|
const coordinator = new RequestCoordinator(); let rejectOld
|
|
const old = coordinator.run('login', 'a', () => new Promise((_, reject) => { rejectOld = reject }))
|
|
assert.deepEqual(await coordinator.run('login', 'b', async () => 'ok'), { accepted: true, ownerId: 'b', value: 'ok' })
|
|
rejectOld(new Error('old')); const stale = await old
|
|
assert.equal(stale.accepted, false); assert.equal(stale.ownerId, 'a'); assert.match(stale.error.message, /old/)
|
|
const api = createApiClient({ fetchImpl: async () => new Response('{"ok":true}') }); assert.deepEqual(await api.config(), { ok: true })
|
|
const classes = () => ({ active: false, toggle(_name, value) { this.active = value } }); const control = { dataset: { view: 'home' }, classList: classes() }; const panel = { id: 'homeView', classList: classes() }
|
|
createViewRouter({ controls: () => [control], panels: () => [panel], storage: null })('home'); assert.equal(control.classList.active, true); assert.equal(panel.classList.active, true)
|
|
})
|