@alecsibilia/luca 14.0.0-alpha.2 → 14.0.0-alpha.21

package/engine/gates/test-runner.ts

@@ -1,8 +1,9 @@
 import { existsSync } from 'node:fs'
 
 import type { TestCase, TestRun } from './gate-schemas'
+import { inTestSlot } from './test-slots'
 
-import { clipOutput, runShell } from '../shell/run-command'
+import { clipOutput, runShell, timedOutLine } from '../shell/run-command'
 
 const decode = (text: string): string =>
     text
@@ -25,7 +26,9 @@ const attribute = ({
 
 /**
  * Reads bun's JUnit report: one `<testsuite file=..>` per file, a nested
- * `<testsuite>` per describe, and a `<testcase>` per test.
+ * `<testsuite>` per describe, and a `<testcase>` per test. Each case keeps
+ * its `time`, in whole milliseconds, and its `assertions` count when the
+ * report has them (#518, #581).
  */
 export const parseJunit = ({ xml }: { xml: string }): TestCase[] => {
     const cases: TestCase[] = []
@@ -46,10 +49,18 @@ export const parseJunit = ({ xml }: { xml: string }): TestCase[] => {
                 continue
             }
             const name = attribute({ attrs, name: 'name' }) ?? ''
+            const seconds = Number(attribute({ attrs, name: 'time' }))
+            const assertions = Number(attribute({ attrs, name: 'assertions' }))
             cases.push({
                 file: attribute({ attrs, name: 'file' }) ?? suites[0] ?? '',
                 full_name: [...suites.slice(1), name].join(' > '),
                 status: 'passed',
+                ...(Number.isFinite(seconds)
+                    ? { duration_ms: Math.round(seconds * 1000) }
+                    : {}),
+                ...(Number.isInteger(assertions) && assertions >= 0
+                    ? { assertions }
+                    : {}),
             })
             open = selfClosing ? -1 : cases.length - 1
         } else if (open >= 0 && !closing) {
@@ -83,6 +94,13 @@ export const testFilesAmong = ({
 
 const NO_TEST_FILES = /0 test files matching|No tests found!/
 
+/**
+ * How to give a test command longer, for the timed-out message. Every test
+ * command says the same, whatever its kind (#542).
+ */
+export const TEST_TIMEOUT_HINT =
+    'To give it longer, raise `test_timeout_ms` in `.luca/config.json`.'
+
 /**
  * Runs the engine config's test command with bun's JUnit reporter, so each
  * test case's outcome is known. The command must be a `bun test` command; the
@@ -90,22 +108,70 @@ const NO_TEST_FILES = /0 test files matching|No tests found!/
  *
  * A repo with no test files counts as a pass: `bun test` exits 1 there, but a
  * baseline with nothing to break is fine.
+ *
+ * One that runs past `timeout_ms` (see `testTimeoutOf`) is stopped, with
+ * everything it started, and fails; its output starts by saying so, and how
+ * to give it longer (#542).
+ *
+ * With `test_concurrency` (#544), it first waits for a test slot (see
+ * `inTestSlot`): the run records that wait as `wait_ms`, and its time limit
+ * starts after it. An `exclusive` run (a lone rerun, #544) waits until no
+ * other test run is going, and holds every slot while it runs.
  */
 export const runTests = async ({
     cwd,
     command,
     test_files,
     report_file,
+    timeout_ms,
+    test_concurrency,
+    exclusive,
 }: {
     cwd: string
     command: string
     /** The worktree's test files, to spot files that produced no results. */
     test_files: string[]
     report_file: string
+    timeout_ms: number
+    /** The config's `test_concurrency`; left out, no cap. */
+    test_concurrency?: number
+    /** Run alone, holding every test slot (#544). Left out, it doesn't. */
+    exclusive?: boolean
+}): Promise<TestRun> =>
+    inTestSlot({
+        test_concurrency,
+        exclusive,
+        work: () =>
+            runTestsInHeldSlot({
+                cwd,
+                command,
+                test_files,
+                report_file,
+                timeout_ms,
+            }),
+    })
+
+/**
+ * `runTests` for a caller that already holds a test slot (see `inTestSlot`):
+ * it runs at once, taking no slot of its own.
+ */
+export const runTestsInHeldSlot = async ({
+    cwd,
+    command,
+    test_files,
+    report_file,
+    timeout_ms,
+}: {
+    cwd: string
+    command: string
+    test_files: string[]
+    report_file: string
+    timeout_ms: number
 }): Promise<TestRun> => {
     const shell = await runShell({
         command: `${command} --reporter=junit --reporter-outfile='${report_file}'`,
         cwd,
+        timeout_ms,
     })
     const output = `${shell.stdout}\n${shell.stderr}`
     const noTestFiles = NO_TEST_FILES.test(output)
@@ -124,10 +190,31 @@ export const runTests = async ({
         files_without_results: test_files.filter(
             (file) => !withResults.has(file)
         ),
-        output: clipOutput({ text: output }),
+        output: `${shell.timed_out ? timedOutLine({ timeout_ms, hint: TEST_TIMEOUT_HINT, survivors: shell.survivors }) : ''}${clipOutput({ text: output })}`,
     }
 }
 
+/** A word quoted for `sh`, whatever it holds. */
+const shellWord = (word: string): string => `'${word.replaceAll("'", `'\\''`)}'`
+
+/**
+ * A bun test command that runs just these test files: the config's command
+ * with each file after it, as a `./` path so bun takes it as a path, not a
+ * name to match. A command that already names a folder runs that too.
+ *
+ * @example
+ * onlyTestFiles({ command: 'bun test', files: ['src/sum.test.ts'] })
+ * // "bun test './src/sum.test.ts'"
+ */
+export const onlyTestFiles = ({
+    command,
+    files,
+}: {
+    command: string
+    files: string[]
+}): string =>
+    [command, ...files.map((file) => shellWord(`./${file}`))].join(' ')
+
 /**
  * The report file for the `index`th of several commands: the first keeps
  * `report_file`, the others get a numbered one beside it.
@@ -155,18 +242,27 @@ export const reportFileFor = ({
  * empty passing run.
  *
  * @example
- * const run = await runBunTests({ cwd, commands: ['bun test'], test_files, report_file })
+ * const run = await runBunTests({ cwd, commands: ['bun test'], test_files, report_file, timeout_ms: testTimeoutOf({ config }) })
  */
 export const runBunTests = async ({
     cwd,
     commands,
     test_files,
     report_file,
+    timeout_ms,
+    test_concurrency,
+    exclusive,
 }: {
     cwd: string
     commands: string[]
     test_files: string[]
     report_file: string
+    /** Each command's time limit (see `runTests`). */
+    timeout_ms: number
+    /** The config's `test_concurrency`: each command takes a test slot. */
+    test_concurrency?: number
+    /** Each command runs alone, holding every test slot (#544). */
+    exclusive?: boolean
 }): Promise<TestRun> => {
     const runs: TestRun[] = []
     for (const [index, command] of commands.entries()) {
@@ -176,9 +272,66 @@ export const runBunTests = async ({
                 command,
                 test_files,
                 report_file: reportFileFor({ report_file, index }),
+                timeout_ms,
+                test_concurrency,
+                exclusive,
             })
         )
     }
+    return joinRuns({ runs, test_files })
+}
+
+/**
+ * A command that runs just these test files with plain `bun test` (#564):
+ * never the config's command plus the files, because Bun's
+ * `--path-ignore-patterns` leaves out even files named on the command line.
+ *
+ * @example
+ * fileTestsCommand({ files: ['src/a.e2e.test.ts'] }) // "bun test './src/a.e2e.test.ts'"
+ */
+export const fileTestsCommand = ({ files }: { files: string[] }): string =>
+    onlyTestFiles({ command: 'bun test', files })
+
+/**
+ * A fast run with a ticket's own-files run (#564) joined on (see
+ * `joinRuns`). An own run that gave no results at all means every file in it
+ * still doesn't load, which the fast run already said: it changes nothing,
+ * so the fast run, its command, and its output stay exactly as they are.
+ * (A fast test file that can't load yet, the usual red state, is such a
+ * file: it is not run twice in the journal.)
+ *
+ * @example
+ * const current = withOwnRun({ fast, own: await runTests({ ... }), test_files })
+ */
+export const withOwnRun = ({
+    fast,
+    own,
+    test_files,
+}: {
+    fast: TestRun
+    own: TestRun
+    test_files: string[]
+}): TestRun =>
+    own.cases.length === 0 ? fast : joinRuns({ runs: [fast, own], test_files })
+
+/**
+ * Several test runs as one: every case, `ok` only when all passed, and a test
+ * file without results only when no run gave it any. One run is itself. No
+ * run (a run of refactor tickets only, which the red check skips) gives an
+ * empty passing run. Used for the baseline and the red check
+ * (`runBunTests`) and for a ticket's own slow test files (#564). Their
+ * waits for a test slot add up to the joined run's `wait_ms` (#544).
+ *
+ * @example
+ * const run = joinRuns({ runs: [fast, own], test_files })
+ */
+export const joinRuns = ({
+    runs,
+    test_files,
+}: {
+    runs: TestRun[]
+    test_files: string[]
+}): TestRun => {
     const [first] = runs
     if (first === undefined) {
         return {
@@ -194,8 +347,11 @@ export const runBunTests = async ({
     if (runs.length === 1) return first
     const cases = runs.flatMap((run) => run.cases)
     const withResults = new Set(cases.map(({ file }) => file))
+    const waits = runs.flatMap(({ wait_ms }) =>
+        wait_ms === undefined ? [] : [wait_ms]
+    )
     return {
-        command: commands.join(' && '),
+        command: runs.map(({ command }) => command).join(' && '),
         ok: runs.every(({ ok }) => ok),
         exit_code: runs.find(({ ok }) => !ok)?.exit_code ?? first.exit_code,
         no_test_files: runs.every(({ no_test_files }) => no_test_files),
@@ -208,5 +364,8 @@ export const runBunTests = async ({
                 .map(({ command, output }) => `$ ${command}\n${output}`)
                 .join('\n\n'),
         }),
+        ...(waits.length === 0
+            ? {}
+            : { wait_ms: waits.reduce((total, wait) => total + wait, 0) }),
     }
 }

package/engine/gates/test-slots.ts

@@ -0,0 +1,48 @@
+import { createSlots, type Slots } from './prepare-slots'
+import { onSlotWait } from './slot-waits'
+
+/**
+ * The engine's test slots (#544): one set for the whole engine process, so
+ * `test_concurrency` caps every test run at once, whichever step runs it.
+ */
+export const TEST_SLOTS: Slots = createSlots()
+
+/**
+ * Runs `work` in a test slot, at most `test_concurrency` at once, and adds
+ * how long it waited for one as `wait_ms`; the work's own time limit and
+ * timing start inside, after the wait. The step's slot-wait listener hears
+ * the wait while it lasts (see `slot-waits.ts`). An `exclusive` take waits for every
+ * test run to end, and holds off new ones until it settles.
+ *
+ * With `test_concurrency` left out there is no cap, but the work still holds
+ * a slot, so an exclusive take waits for it too. Nothing waits then unless an
+ * exclusive take is going, and the result is as `work` gave it (no
+ * `wait_ms`). Work that already holds a slot must not take another: an
+ * exclusive take queued between the two would wait forever.
+ *
+ * @example
+ * const check = await inTestSlot({ test_concurrency: 1, work: () => shellCheck({ ... }) })
+ * check.wait_ms // 0, or how long another test run held the slot
+ */
+export const inTestSlot = async <T extends object>({
+    test_concurrency,
+    work,
+    exclusive = false,
+}: {
+    test_concurrency: number | undefined
+    work: () => Promise<T>
+    exclusive?: boolean
+}): Promise<T & { wait_ms?: number }> => {
+    const asked = performance.now()
+    const limit = test_concurrency ?? Infinity
+    return TEST_SLOTS.run({
+        limit,
+        exclusive,
+        on_wait: onSlotWait({ kind: 'test_slot', limit }),
+        work: async () => {
+            if (test_concurrency === undefined && !exclusive) return work()
+            const wait_ms = Math.round(performance.now() - asked)
+            return { ...(await work()), wait_ms }
+        },
+    })
+}