kempo-testing-framework 1.2.4 → 1.3.3

package/tests/src-browserTestServer.node-test.js

@@ -1,47 +1,47 @@
-import http from 'http';
-import { startServer, stopServer } from '../src/browserTestServer.js';
-
-const get = (port, path) => new Promise((resolve, reject) => {
-  const req = http.request({ hostname: 'localhost', port, path, method: 'GET' }, (res) => {
-    let data = '';
-    res.on('data', chunk => { data += chunk.toString(); });
-    res.on('end', () => resolve({ status: res.statusCode, body: data }));
-  });
-  req.on('error', reject);
-  req.end();
-});
-
-export default {
-  'serves index html at /': async ({ pass, fail, log }) => {
-    const port = 3101;
-    try {
-      const url = await startServer(port);
-      const { status, body } = await get(port, '/');
-    log(`GET / -> ${status}`);
-    if (status === 200 && /<title>Test<\/title>/.test(body)) pass('Browser test server served index.html');
-    else fail(`Bad response from /: status=${status} body=${body?.slice(0,80)}`);
-    } catch (e) {
-      fail(e.stack || String(e));
-    } finally {
-      await stopServer();
-    }
-  },
-  'serves test runner script and static files, 404s missing': async ({ pass, fail, log }) => {
-    const port = 3101;
-    try {
-      await startServer(port);
-      const a = await get(port, '/runTests.js');
-      const b = await get(port, '/tests/counter.browser-test.js');
-      const c = await get(port, '/does-not-exist.js');
-    log(`Statuses: /runTests.js=${a.status} /tests/counter.browser-test.js=${b.status} /does-not-exist.js=${c.status}`);
-      const ok = a.status === 200 && /export default|const wait/.test(a.body)
-        && b.status === 200 && /Counter component/.test(b.body)
-        && c.status === 404;
-    ok ? pass('Static and test files served; missing files 404 as expected') : fail(`Unexpected statuses: a=${a.status}, b=${b.status}, c=${c.status}`);
-    } catch (e) {
-      fail(e.stack || String(e));
-    } finally {
-      await stopServer();
-    }
-  }
-};
+import http from 'http';
+import { startServer, stopServer } from '../src/browserTestServer.js';
+
+const get = (port, path) => new Promise((resolve, reject) => {
+  const req = http.request({ hostname: 'localhost', port, path, method: 'GET' }, (res) => {
+    let data = '';
+    res.on('data', chunk => { data += chunk.toString(); });
+    res.on('end', () => resolve({ status: res.statusCode, body: data }));
+  });
+  req.on('error', reject);
+  req.end();
+});
+
+export default {
+  'serves index html at /': async ({ pass, fail, log }) => {
+    const port = 3101;
+    try {
+      const url = await startServer(port);
+      const { status, body } = await get(port, '/');
+    log(`GET / -> ${status}`);
+    if (status === 200 && /<title>Test<\/title>/.test(body)) pass('Browser test server served index.html');
+    else fail(`Bad response from /: status=${status} body=${body?.slice(0,80)}`);
+    } catch (e) {
+      fail(e.stack || String(e));
+    } finally {
+      await stopServer();
+    }
+  },
+  'serves test runner script and static files, 404s missing': async ({ pass, fail, log }) => {
+    const port = 3101;
+    try {
+      await startServer(port);
+      const a = await get(port, '/runTests.js');
+      const b = await get(port, '/tests/counter.browser-test.js');
+      const c = await get(port, '/does-not-exist.js');
+    log(`Statuses: /runTests.js=${a.status} /tests/counter.browser-test.js=${b.status} /does-not-exist.js=${c.status}`);
+      const ok = a.status === 200 && /export default|const wait/.test(a.body)
+        && b.status === 200 && /Counter component/.test(b.body)
+        && c.status === 404;
+    ok ? pass('Static and test files served; missing files 404 as expected') : fail(`Unexpected statuses: a=${a.status}, b=${b.status}, c=${c.status}`);
+    } catch (e) {
+      fail(e.stack || String(e));
+    } finally {
+      await stopServer();
+    }
+  }
+};

package/tests/src-cli.node-test.js

@@ -1,32 +1,32 @@
-import { spawn } from 'child_process';
-
-const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
-
-const run = (args, timeoutMs = 10000) => new Promise((resolve) => {
-  const child = spawn(process.execPath, ['index.js', ...args], {
-    cwd: process.cwd(),
-    stdio: ['ignore', 'pipe', 'pipe']
-  });
-  let out = '';
-  const finish = () => { try { child.kill('SIGTERM'); } catch {} resolve(out); };
-  child.stdout.on('data', c => { out += c.toString(); });
-  child.stderr.on('data', c => { out += c.toString(); });
-  child.on('exit', finish);
-  setTimeout(finish, timeoutMs);
-});
-
-export default {
-  'passes delay to browser runner and prints delay logs in verbose': async ({ pass, fail }) => {
-    const out = await run(['-b', '-w', '-l', 'verbose', '-d', '200', 'counter']);
-    const txt = stripAnsi(out);
-    const ok = /Applying pre-test browser delay: 200ms/.test(txt) && /Applying post-test browser delay: 200ms/.test(txt);
-  ok ? pass('CLI printed verbose delay logs for browser run') : fail(`Unexpected CLI output:\n${out}`);
-  },
-  'node-only ignores delay and still runs filtered tests': async ({ pass, fail }) => {
-    const out = await run(['-n', '-l', 'minimal', 'example']);
-    const txt = stripAnsi(out);
-    const hasSummary = /=== Test Summary ===/.test(txt) && /Total Tests:\s*\d+/.test(txt);
-    const noBrowser = !/=== Browser Test Results ===/.test(txt) && !/Running Browser test:/.test(txt);
-  hasSummary && noBrowser ? pass('Node-only run produced summary without browser section') : fail(`Unexpected CLI output:\n${out}`);
-  }
-};
+import { spawn } from 'child_process';
+
+const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
+
+const run = (args, timeoutMs = 10000) => new Promise((resolve) => {
+  const child = spawn(process.execPath, ['index.js', ...args], {
+    cwd: process.cwd(),
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+  let out = '';
+  const finish = () => { try { child.kill('SIGTERM'); } catch {} resolve(out); };
+  child.stdout.on('data', c => { out += c.toString(); });
+  child.stderr.on('data', c => { out += c.toString(); });
+  child.on('exit', finish);
+  setTimeout(finish, timeoutMs);
+});
+
+export default {
+  'passes delay to browser runner and prints delay logs in verbose': async ({ pass, fail }) => {
+    const out = await run(['-b', '-w', '-l', 'verbose', '-d', '200', 'counter']);
+    const txt = stripAnsi(out);
+    const ok = /Applying pre-test browser delay: 200ms/.test(txt) && /Applying post-test browser delay: 200ms/.test(txt);
+  ok ? pass('CLI printed verbose delay logs for browser run') : fail(`Unexpected CLI output:\n${out}`);
+  },
+  'node-only ignores delay and still runs filtered tests': async ({ pass, fail }) => {
+    const out = await run(['-n', '-l', 'minimal', 'example']);
+    const txt = stripAnsi(out);
+    const hasSummary = /=== Test Summary ===/.test(txt) && /Total Tests:\s*\d+/.test(txt);
+    const noBrowser = !/=== Browser Test Results ===/.test(txt) && !/Running Browser test:/.test(txt);
+  hasSummary && noBrowser ? pass('Node-only run produced summary without browser section') : fail(`Unexpected CLI output:\n${out}`);
+  }
+};

package/tests/src-findTests.node-test.js

@@ -1,41 +1,41 @@
-import findTests from '../src/findTests.js';
-
-export default {
-  'finds node and browser test files with no filters': async ({ pass, fail, log }) => {
-    try {
-      const { nodeTests, browserTests } = await findTests('', '', true, true);
-    log(`Found node tests: ${nodeTests.length}, browser tests: ${browserTests.length}`);
-      const hasCounter = browserTests.some(f => f.endsWith('tests/counter.browser-test.js'));
-      const hasExample = nodeTests.some(f => f.endsWith('tests/example.node-test.js'));
-    if (hasCounter && hasExample) pass('Discovered expected canonical files (counter + example)');
-    else fail(`Missing expected files. node: ${JSON.stringify(nodeTests)}, browser: ${JSON.stringify(browserTests)}`);
-    } catch (e) {
-      fail(e.stack || String(e));
-    }
-  },
-  'honors suite filter for file substring': async ({ pass, fail, log }) => {
-    try {
-      const { nodeTests, browserTests } = await findTests('counter', '', true, true);
-    log(`Filtered node tests: ${nodeTests.join(', ')}`);
-    log(`Filtered browser tests: ${browserTests.join(', ')}`);
-      const okNode = nodeTests.every(f => f.includes('counter') === true) || nodeTests.length === 0;
-      const okBrowser = browserTests.every(f => f.includes('counter') === true);
-    okNode && okBrowser ? pass('Suite filter correctly applied to file names') : fail(`Unexpected filtering. node: ${nodeTests}, browser: ${browserTests}`);
-    } catch (e) {
-      fail(e.stack || String(e));
-    }
-  },
-  'respects environment toggles': async ({ pass, fail, log }) => {
-    try {
-      const a = await findTests('', '', false, true); // node only
-      const b = await findTests('', '', true, false); // browser only
-    log(`Node-only counts: node=${a.nodeTests.length}, browser=${a.browserTests.length}`);
-    log(`Browser-only counts: node=${b.nodeTests.length}, browser=${b.browserTests.length}`);
-      const okA = a.browserTests.length === 0 && a.nodeTests.length > 0;
-      const okB = b.nodeTests.length === 0 && b.browserTests.length > 0;
-    okA && okB ? pass('Environment toggles respected (node-only / browser-only)') : fail(`Env mismatch: a=${JSON.stringify(a)}, b=${JSON.stringify(b)}`);
-    } catch (e) {
-      fail(e.stack || String(e));
-    }
-  }
-};
+import findTests from '../src/findTests.js';
+
+export default {
+  'finds node and browser test files with no filters': async ({ pass, fail, log }) => {
+    try {
+      const { nodeTests, browserTests } = await findTests('', '', true, true);
+    log(`Found node tests: ${nodeTests.length}, browser tests: ${browserTests.length}`);
+      const hasCounter = browserTests.some(f => f.endsWith('tests/counter.browser-test.js'));
+      const hasExample = nodeTests.some(f => f.endsWith('tests/example.node-test.js'));
+    if (hasCounter && hasExample) pass('Discovered expected canonical files (counter + example)');
+    else fail(`Missing expected files. node: ${JSON.stringify(nodeTests)}, browser: ${JSON.stringify(browserTests)}`);
+    } catch (e) {
+      fail(e.stack || String(e));
+    }
+  },
+  'honors suite filter for file substring': async ({ pass, fail, log }) => {
+    try {
+      const { nodeTests, browserTests } = await findTests('counter', '', true, true);
+    log(`Filtered node tests: ${nodeTests.join(', ')}`);
+    log(`Filtered browser tests: ${browserTests.join(', ')}`);
+      const okNode = nodeTests.every(f => f.includes('counter') === true) || nodeTests.length === 0;
+      const okBrowser = browserTests.every(f => f.includes('counter') === true);
+    okNode && okBrowser ? pass('Suite filter correctly applied to file names') : fail(`Unexpected filtering. node: ${nodeTests}, browser: ${browserTests}`);
+    } catch (e) {
+      fail(e.stack || String(e));
+    }
+  },
+  'respects environment toggles': async ({ pass, fail, log }) => {
+    try {
+      const a = await findTests('', '', false, true); // node only
+      const b = await findTests('', '', true, false); // browser only
+    log(`Node-only counts: node=${a.nodeTests.length}, browser=${a.browserTests.length}`);
+    log(`Browser-only counts: node=${b.nodeTests.length}, browser=${b.browserTests.length}`);
+      const okA = a.browserTests.length === 0 && a.nodeTests.length > 0;
+      const okB = b.nodeTests.length === 0 && b.browserTests.length > 0;
+    okA && okB ? pass('Environment toggles respected (node-only / browser-only)') : fail(`Env mismatch: a=${JSON.stringify(a)}, b=${JSON.stringify(b)}`);
+    } catch (e) {
+      fail(e.stack || String(e));
+    }
+  }
+};

package/tests/src-logLevels.node-test.js

@@ -1,29 +1,29 @@
-import LOG_LEVELS from '../src/utils/logLevels.js';
-
-export default {
-  'defines expected numeric levels': async ({ pass, fail, log }) => {
-    try {
-      const want = { SILENT: 0, MINIMAL: 1, NORMAL: 2, VERBOSE: 3, DEBUG: 4 };
-    log(`Actual levels: ${JSON.stringify(LOG_LEVELS)}`);
-      const ok = want.SILENT === LOG_LEVELS.SILENT &&
-        want.MINIMAL === LOG_LEVELS.MINIMAL &&
-        want.NORMAL === LOG_LEVELS.NORMAL &&
-        want.VERBOSE === LOG_LEVELS.VERBOSE &&
-        want.DEBUG === LOG_LEVELS.DEBUG;
-    ok ? pass('Log level constants match expected numeric values') : fail(`Unexpected values: ${JSON.stringify(LOG_LEVELS)}`);
-    } catch (e) {
-      fail(e.stack || String(e));
-    }
-  },
-  'level ordering is ascending': async ({ pass, fail, log }) => {
-    try {
-      const arr = [LOG_LEVELS.SILENT, LOG_LEVELS.MINIMAL, LOG_LEVELS.NORMAL, LOG_LEVELS.VERBOSE, LOG_LEVELS.DEBUG];
-      const sorted = [...arr].sort((a,b)=>a-b);
-    log(`Order: ${arr.join(' < ')}`);
-      const ok = JSON.stringify(arr) === JSON.stringify(sorted);
-    ok ? pass('Log levels are in ascending order') : fail(`Not ascending: ${arr}`);
-    } catch (e) {
-      fail(e.stack || String(e));
-    }
-  }
-};
+import LOG_LEVELS from '../src/utils/logLevels.js';
+
+export default {
+  'defines expected numeric levels': async ({ pass, fail, log }) => {
+    try {
+      const want = { SILENT: 0, MINIMAL: 1, NORMAL: 2, VERBOSE: 3, DEBUG: 4 };
+    log(`Actual levels: ${JSON.stringify(LOG_LEVELS)}`);
+      const ok = want.SILENT === LOG_LEVELS.SILENT &&
+        want.MINIMAL === LOG_LEVELS.MINIMAL &&
+        want.NORMAL === LOG_LEVELS.NORMAL &&
+        want.VERBOSE === LOG_LEVELS.VERBOSE &&
+        want.DEBUG === LOG_LEVELS.DEBUG;
+    ok ? pass('Log level constants match expected numeric values') : fail(`Unexpected values: ${JSON.stringify(LOG_LEVELS)}`);
+    } catch (e) {
+      fail(e.stack || String(e));
+    }
+  },
+  'level ordering is ascending': async ({ pass, fail, log }) => {
+    try {
+      const arr = [LOG_LEVELS.SILENT, LOG_LEVELS.MINIMAL, LOG_LEVELS.NORMAL, LOG_LEVELS.VERBOSE, LOG_LEVELS.DEBUG];
+      const sorted = [...arr].sort((a,b)=>a-b);
+    log(`Order: ${arr.join(' < ')}`);
+      const ok = JSON.stringify(arr) === JSON.stringify(sorted);
+    ok ? pass('Log levels are in ascending order') : fail(`Not ascending: ${arr}`);
+    } catch (e) {
+      fail(e.stack || String(e));
+    }
+  }
+};

package/tests/src-runBrowserTests.node-test.js

@@ -1,41 +1,41 @@
-import runBrowserTests from '../src/runBrowserTests.js';
-
-export default {
-  'runs a specific browser test headless and returns results': async ({ pass, fail, log }) => {
-    try {
-      const res = await runBrowserTests({
-        testFile: 'tests/counter.browser-test.js',
-        filter: '',
-        showBrowser: false,
-        port: 3111,
-        logLevel: 2,
-        delayMs: 0
-      });
-      const names = Object.keys(res.tests || {});
-    log(`Ran browser tests: ${names.join(', ')}`);
-    if (names.length >= 3 && res.beforeAllLogs?.length >= 1 && res.afterAllLogs?.length >= 1) pass('Headless run produced tests and lifecycle logs');
-    else fail(`Unexpected browser test results: ${JSON.stringify(res)}`);
-    } catch (e) {
-      fail(e.stack || String(e));
-    }
-  },
-  'applies pre/post delay only when showBrowser is true': async ({ pass, fail, log }) => {
-    try {
-      // Use a single test to avoid between-test delays dominating timings
-      const filter = 'Counter component should be defined';
-      const delay = 500; // Reduced from 1000ms to avoid timeouts
-      const start1 = Date.now();
-      await runBrowserTests({ testFile: 'tests/counter.browser-test.js', filter, showBrowser: false, port: 3112, logLevel: 2, delayMs: delay });
-      const t1 = Date.now() - start1;
-      const start2 = Date.now();
-      await runBrowserTests({ testFile: 'tests/counter.browser-test.js', filter, showBrowser: true, port: 3113, logLevel: 2, delayMs: delay });
-      const t2 = Date.now() - start2;
-      // Headful should incur roughly +1000ms (pre+post). Allow slack for env variance.
-      log(`Timing — headless=${t1}ms, headful=${t2}ms, delta=${t2 - t1}ms`);
-      if (t2 - t1 >= 800) pass('Headful mode applied pre/post delay as expected');
-      else fail(`Timing not increased as expected: headless=${t1}ms headful=${t2}ms`);
-    } catch (e) {
-      fail(e.stack || String(e));
-    }
-  }
-};
+import runBrowserTests from '../src/runBrowserTests.js';
+
+export default {
+  'runs a specific browser test headless and returns results': async ({ pass, fail, log }) => {
+    try {
+      const res = await runBrowserTests({
+        testFile: 'tests/counter.browser-test.js',
+        filter: '',
+        showBrowser: false,
+        port: 3111,
+        logLevel: 2,
+        delayMs: 0
+      });
+      const names = Object.keys(res.tests || {});
+    log(`Ran browser tests: ${names.join(', ')}`);
+    if (names.length >= 3 && res.beforeAllLogs?.length >= 1 && res.afterAllLogs?.length >= 1) pass('Headless run produced tests and lifecycle logs');
+    else fail(`Unexpected browser test results: ${JSON.stringify(res)}`);
+    } catch (e) {
+      fail(e.stack || String(e));
+    }
+  },
+  'applies pre/post delay only when showBrowser is true': async ({ pass, fail, log }) => {
+    try {
+      // Use a single test to avoid between-test delays dominating timings
+      const filter = 'Counter component should be defined';
+      const delay = 500; // Reduced from 1000ms to avoid timeouts
+      const start1 = Date.now();
+      await runBrowserTests({ testFile: 'tests/counter.browser-test.js', filter, showBrowser: false, port: 3112, logLevel: 2, delayMs: delay });
+      const t1 = Date.now() - start1;
+      const start2 = Date.now();
+      await runBrowserTests({ testFile: 'tests/counter.browser-test.js', filter, showBrowser: true, port: 3113, logLevel: 2, delayMs: delay });
+      const t2 = Date.now() - start2;
+      // Headful should incur roughly +1000ms (pre+post). Allow slack for env variance.
+      log(`Timing — headless=${t1}ms, headful=${t2}ms, delta=${t2 - t1}ms`);
+      if (t2 - t1 >= 800) pass('Headful mode applied pre/post delay as expected');
+      else fail(`Timing not increased as expected: headless=${t1}ms headful=${t2}ms`);
+    } catch (e) {
+      fail(e.stack || String(e));
+    }
+  }
+};

package/tests/src-runTestFiles.node-test.js

@@ -1,42 +1,42 @@
-import runTestFiles from '../src/runTestFiles.js';
-
-export default {
-  'discovers and runs node tests only when requested': async ({ pass, fail, log }) => {
-    try {
-      const { nodeResults, browserResults } = await runTestFiles({
-        suiteFilter: 'example',
-        testFilter: '',
-        shouldRunBrowser: false,
-        shouldRunNode: true,
-        showBrowser: false,
-        port: 3000,
-        logLevel: 2
-      });
-    log(`Node files run: ${Object.keys(nodeResults).length}, browser files run: ${Object.keys(browserResults).length}`);
-      const onlyNode = Object.keys(browserResults).length === 0 && Object.keys(nodeResults).length >= 1;
-    onlyNode ? pass('Ran node tests only when requested (browser skipped)') : fail(`Unexpected results: node=${Object.keys(nodeResults)}, browser=${Object.keys(browserResults)}`);
-    } catch (e) {
-      fail(e.stack || String(e));
-    }
-  },
-  'passes filter into node runs': async ({ pass, fail, log }) => {
-    try {
-      const { nodeResults } = await runTestFiles({
-        suiteFilter: 'example',
-        testFilter: 'async',
-        shouldRunBrowser: false,
-        shouldRunNode: true,
-        showBrowser: false,
-        port: 3000,
-        logLevel: 2
-      });
-      const [file, res] = Object.entries(nodeResults)[0];
-    if (!res) return fail('No node results returned');
-      const names = Object.keys(res.tests || {});
-    log(`Filtered test names: ${names.join(', ')}`);
-    names.length === 1 && names[0].toLowerCase().includes('async') ? pass('Per-file test filter applied to node run') : fail(`Unexpected filtered tests: ${names}`);
-    } catch (e) {
-      fail(e.stack || String(e));
-    }
-  }
-};
+import runTestFiles from '../src/runTestFiles.js';
+
+export default {
+  'discovers and runs node tests only when requested': async ({ pass, fail, log }) => {
+    try {
+      const { nodeResults, browserResults } = await runTestFiles({
+        suiteFilter: 'example',
+        testFilter: '',
+        shouldRunBrowser: false,
+        shouldRunNode: true,
+        showBrowser: false,
+        port: 3000,
+        logLevel: 2
+      });
+    log(`Node files run: ${Object.keys(nodeResults).length}, browser files run: ${Object.keys(browserResults).length}`);
+      const onlyNode = Object.keys(browserResults).length === 0 && Object.keys(nodeResults).length >= 1;
+    onlyNode ? pass('Ran node tests only when requested (browser skipped)') : fail(`Unexpected results: node=${Object.keys(nodeResults)}, browser=${Object.keys(browserResults)}`);
+    } catch (e) {
+      fail(e.stack || String(e));
+    }
+  },
+  'passes filter into node runs': async ({ pass, fail, log }) => {
+    try {
+      const { nodeResults } = await runTestFiles({
+        suiteFilter: 'example',
+        testFilter: 'async',
+        shouldRunBrowser: false,
+        shouldRunNode: true,
+        showBrowser: false,
+        port: 3000,
+        logLevel: 2
+      });
+      const [file, res] = Object.entries(nodeResults)[0];
+    if (!res) return fail('No node results returned');
+      const names = Object.keys(res.tests || {});
+    log(`Filtered test names: ${names.join(', ')}`);
+    names.length === 1 && names[0].toLowerCase().includes('async') ? pass('Per-file test filter applied to node run') : fail(`Unexpected filtered tests: ${names}`);
+    } catch (e) {
+      fail(e.stack || String(e));
+    }
+  }
+};

package/tests/src-runTests.node-test.js

@@ -1,56 +1,56 @@
-import runTests from '../src/runTests.js';
-
-const mkSuite = () => ({
-  beforeAll: async (log) => { log('before all'); },
-  beforeEach: async (log) => { log('before each'); },
-  afterEach: async (log) => { log('after each'); },
-  afterAll: async (log) => { log('after all'); },
-  default: {
-    'one passes': async ({ pass, log }) => { log('running one'); pass('ok'); },
-    'two passes': async ({ pass, log }) => { log('running two'); pass('ok'); },
-  }
-});
-
-export default {
-  'runs all tests and records logs': async ({ pass, fail, log }) => {
-    try {
-      const res = await runTests(mkSuite(), false, 0);
-      const names = Object.keys(res.tests);
-    log(`Discovered tests: ${names.join(', ')}`);
-    if (names.length !== 2) return fail(`Expected 2 tests, got ${names.length} [${names.join(', ')}]`);
-      const hasBeforeAll = res.beforeAllLogs.some(l => l.message.includes('before all'));
-      const hasAfterAll = res.afterAllLogs.some(l => l.message.includes('after all'));
-      const eachs = Object.values(res.tests).flatMap(r => r.logs.map(l=>l.message));
-      const hasBefores = eachs.some(m => m.includes('== Before Each =='));
-      const hasAfters = eachs.some(m => m.includes('== After Each =='));
-    log(`Lifecycle logs — beforeAll:${hasBeforeAll} afterAll:${hasAfterAll} beforeEach:${hasBefores} afterEach:${hasAfters}`);
-    if (hasBeforeAll && hasAfterAll && hasBefores && hasAfters) pass('Recorded lifecycle and per-test logs as expected');
-    else fail('Missing expected lifecycle log sections');
-    } catch (e) {
-      fail(e.stack || String(e));
-    }
-  },
-  'applies per-test delay': async ({ pass, fail, log }) => {
-    try {
-      const t0 = Date.now();
-      await runTests(mkSuite(), false, 200);
-      const elapsed = Date.now() - t0;
-    log(`Elapsed with delay: ${elapsed}ms`);
-    if (elapsed >= 200 && elapsed < 800) pass(`Applied per-test delay successfully (~${elapsed}ms >= 200ms)`);
-    else fail(`Unexpected timing with delay=200ms: ${elapsed}ms`);
-    } catch (e) {
-      fail(e.stack || String(e));
-    }
-  },
-  'filters tests by substring': async ({ pass, fail, log }) => {
-    try {
-      const res = await runTests(mkSuite(), 'two', 0);
-      const names = Object.keys(res.tests);
-    log(`Filtered tests: ${names.join(', ')}`);
-    if (names.length === 1 && names[0].includes('two')) pass(`Filtered to expected test: ${names[0]}`);
-    else fail(`Unexpected filtered set: [${names.join(', ')}]`);
-    } catch (e) {
-      fail(e.stack || String(e));
-    }
-  }
-};
+import runTests from '../src/runTests.js';
+
+const mkSuite = () => ({
+  beforeAll: async (log) => { log('before all'); },
+  beforeEach: async (log) => { log('before each'); },
+  afterEach: async (log) => { log('after each'); },
+  afterAll: async (log) => { log('after all'); },
+  default: {
+    'one passes': async ({ pass, log }) => { log('running one'); pass('ok'); },
+    'two passes': async ({ pass, log }) => { log('running two'); pass('ok'); },
+  }
+});
+
+export default {
+  'runs all tests and records logs': async ({ pass, fail, log }) => {
+    try {
+      const res = await runTests(mkSuite(), false, 0);
+      const names = Object.keys(res.tests);
+    log(`Discovered tests: ${names.join(', ')}`);
+    if (names.length !== 2) return fail(`Expected 2 tests, got ${names.length} [${names.join(', ')}]`);
+      const hasBeforeAll = res.beforeAllLogs.some(l => l.message.includes('before all'));
+      const hasAfterAll = res.afterAllLogs.some(l => l.message.includes('after all'));
+      const eachs = Object.values(res.tests).flatMap(r => r.logs.map(l=>l.message));
+      const hasBefores = eachs.some(m => m.includes('== Before Each =='));
+      const hasAfters = eachs.some(m => m.includes('== After Each =='));
+    log(`Lifecycle logs — beforeAll:${hasBeforeAll} afterAll:${hasAfterAll} beforeEach:${hasBefores} afterEach:${hasAfters}`);
+    if (hasBeforeAll && hasAfterAll && hasBefores && hasAfters) pass('Recorded lifecycle and per-test logs as expected');
+    else fail('Missing expected lifecycle log sections');
+    } catch (e) {
+      fail(e.stack || String(e));
+    }
+  },
+  'applies per-test delay': async ({ pass, fail, log }) => {
+    try {
+      const t0 = Date.now();
+      await runTests(mkSuite(), false, 200);
+      const elapsed = Date.now() - t0;
+    log(`Elapsed with delay: ${elapsed}ms`);
+    if (elapsed >= 200 && elapsed < 800) pass(`Applied per-test delay successfully (~${elapsed}ms >= 200ms)`);
+    else fail(`Unexpected timing with delay=200ms: ${elapsed}ms`);
+    } catch (e) {
+      fail(e.stack || String(e));
+    }
+  },
+  'filters tests by substring': async ({ pass, fail, log }) => {
+    try {
+      const res = await runTests(mkSuite(), 'two', 0);
+      const names = Object.keys(res.tests);
+    log(`Filtered tests: ${names.join(', ')}`);
+    if (names.length === 1 && names[0].includes('two')) pass(`Filtered to expected test: ${names[0]}`);
+    else fail(`Unexpected filtered set: [${names.join(', ')}]`);
+    } catch (e) {
+      fail(e.stack || String(e));
+    }
+  }
+};