Initial commit

test/api.test.js

@@ -0,0 +1,201 @@
+import assert from 'node:assert/strict'
+import { spawn } from 'node:child_process'
+import { createServer } from 'node:net'
+import path from 'node:path'
+import test from 'node:test'
+import { fileURLToPath } from 'node:url'
+import { startMockWiki } from './mock-wiki.js'
+
+const ROOT = path.dirname(path.dirname(fileURLToPath(import.meta.url)))
+
+function freePort() {
+  return new Promise((resolve, reject) => {
+    const server = createServer()
+    server.once('error', reject)
+    server.listen(0, '127.0.0.1', () => {
+      const { port } = server.address()
+      server.close((error) => (error ? reject(error) : resolve(port)))
+    })
+  })
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+async function startApp({ port, wikiUrl, apiKey = 'test-key', extraEnv = {} }) {
+  const env = {
+    ...process.env,
+    NODE_ENV: 'test',
+    HOST: '127.0.0.1',
+    PORT: String(port),
+    WIKI_URL: wikiUrl || '',
+    WIKI_API_KEY: apiKey,
+    ...extraEnv,
+  }
+  delete env.MAX_PAGES
+  delete env.AUTH_USER
+  delete env.AUTH_PASSWORD
+
+  const child = spawn(process.execPath, ['src/server.js'], {
+    cwd: ROOT,
+    env,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  })
+
+  let output = ''
+  child.stdout.on('data', (chunk) => {
+    output += chunk
+  })
+  child.stderr.on('data', (chunk) => {
+    output += chunk
+  })
+
+  const baseUrl = `http://127.0.0.1:${port}`
+  for (let attempt = 0; attempt < 100; attempt += 1) {
+    if (child.exitCode !== null) break
+    try {
+      const response = await fetch(`${baseUrl}/healthz`)
+      if (response.ok) return { baseUrl, child, output: () => output }
+    } catch {
+      // The server is not listening yet.
+    }
+    await sleep(50)
+  }
+
+  child.kill('SIGKILL')
+  throw new Error(`server did not start:\n${output}`)
+}
+
+async function stopApp(app) {
+  if (!app) return
+  if (app.child.exitCode === null) {
+    await new Promise((resolve) => {
+      app.child.once('exit', resolve)
+      app.child.kill('SIGTERM')
+      setTimeout(() => app.child.kill('SIGKILL'), 5_000).unref()
+    })
+  }
+}
+
+test('serves the wiki page list and keeps the connection details server-side', async () => {
+  const wiki = await startMockWiki()
+  const port = await freePort()
+  const app = await startApp({ port, wikiUrl: wiki.url })
+
+  try {
+    const configResponse = await fetch(`${app.baseUrl}/api/config`)
+    assert.equal(configResponse.status, 200)
+    assert.match(configResponse.headers.get('x-request-id') || '', /^[0-9a-f-]{36}$/)
+    const config = await configResponse.json()
+    assert.equal(config.wikiUrlConfigured, true)
+    assert.equal(config.wikiUrl, wiki.url)
+    assert.equal(config.apiKeyConfigured, true)
+    assert.equal('apiKey' in config, false, 'the API key must never be sent to the browser')
+
+    const pagesResponse = await fetch(`${app.baseUrl}/api/pages`)
+    assert.equal(pagesResponse.status, 200)
+    const pagesPayload = await pagesResponse.json()
+    assert.equal(pagesPayload.baseUrl, wiki.url)
+    assert.equal(pagesPayload.defaultLocale, 'en')
+    assert.equal(pagesPayload.namespacing, true)
+    assert.equal(pagesPayload.pages.length, wiki.pages.length)
+
+    const docs = pagesPayload.pages.find((page) => page.path === 'docs')
+    assert.deepEqual(docs, {
+      path: 'docs',
+      locale: 'en',
+      title: 'Documentation',
+      description: 'Documentation root',
+      isPublished: true,
+    })
+    assert.equal(
+      pagesPayload.pages.find((page) => page.path === 'docs/draft').isPublished,
+      false,
+    )
+
+    const paths = pagesPayload.pages.map((page) => page.path)
+    assert.deepEqual(paths, [...paths].sort((a, b) => a.localeCompare(b, 'en')))
+  } finally {
+    await stopApp(app)
+    await wiki.close()
+  }
+})
+
+test('rejects an export without a starting page and does not require a browser URL', async () => {
+  const wiki = await startMockWiki()
+  const port = await freePort()
+  const app = await startApp({ port, wikiUrl: wiki.url })
+
+  try {
+    const response = await fetch(`${app.baseUrl}/api/exports`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ startPage: '' }),
+    })
+    assert.equal(response.status, 400)
+    const payload = await response.json()
+    assert.equal(payload.error, 'The starting page is required.')
+
+    // A browser-supplied baseUrl/API key must be ignored: the server uses
+    // WIKI_URL and WIKI_API_KEY only. A missing page fails before Chromium
+    // starts, so this test does not need a browser.
+    const accepted = await fetch(`${app.baseUrl}/api/exports`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        baseUrl: 'https://attacker.example',
+        apiKey: 'attacker-key',
+        startPage: 'missing-page',
+        maxPages: 1,
+      }),
+    })
+    assert.equal(accepted.status, 202)
+    const { job } = await accepted.json()
+    assert.equal(job.request.baseUrl, wiki.url)
+    assert.equal('apiKey' in job.request, false)
+    assert.equal('apiKey' in job, false)
+
+    let status = job
+    for (let attempt = 0; attempt < 100 && status.status !== 'error'; attempt += 1) {
+      await sleep(50)
+      status = (await (await fetch(`${app.baseUrl}/api/exports/${job.id}`)).json()).job
+    }
+    assert.equal(status.status, 'error')
+    assert.equal(status.error.code, 'START_PAGE_NOT_FOUND')
+  } finally {
+    await stopApp(app)
+    await wiki.close()
+  }
+})
+
+test('reports missing and invalid WIKI_URL without crashing', async () => {
+  const port = await freePort()
+  const app = await startApp({ port, wikiUrl: '' })
+
+  try {
+    const config = await (await fetch(`${app.baseUrl}/api/config`)).json()
+    assert.equal(config.wikiUrlConfigured, false)
+    assert.equal(config.wikiUrl, null)
+
+    const pagesResponse = await fetch(`${app.baseUrl}/api/pages`)
+    assert.equal(pagesResponse.status, 503)
+    const pagesPayload = await pagesResponse.json()
+    assert.equal(pagesPayload.code, 'WIKI_URL_MISSING')
+  } finally {
+    await stopApp(app)
+  }
+
+  const invalidPort = await freePort()
+  const invalidApp = await startApp({ port: invalidPort, wikiUrl: 'ftp://not-a-wiki' })
+
+  try {
+    const pagesResponse = await fetch(`${invalidApp.baseUrl}/api/pages`)
+    assert.equal(pagesResponse.status, 503)
+    const payload = await pagesResponse.json()
+    assert.equal(payload.code, 'WIKI_URL_MISSING')
+    assert.match(payload.error, /WIKI_URL is invalid/)
+  } finally {
+    await stopApp(invalidApp)
+  }
+})