kempo-testing-framework 1.1.0

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

@@ -0,0 +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));
+    }
+  }
+};

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

@@ -0,0 +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));
+    }
+  }
+};

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

@@ -0,0 +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 = 1000;
+      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 +2000ms (pre+post). Allow slack for env variance.
+    log(`Timing — headless=${t1}ms, headful=${t2}ms, delta=${t2 - t1}ms`);
+    if (t2 - t1 >= 1500) 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

@@ -0,0 +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));
+    }
+  }
+};

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

@@ -0,0 +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));
+    }
+  }
+};

package/tests/test-framework.browser-test.js

@@ -0,0 +1,65 @@
+// Browser tests for TestFramework component
+
+const nextTick = () => new Promise(r => setTimeout(r));
+
+export const beforeEach = async () => {
+  document.body.innerHTML = '';
+  try { localStorage.removeItem('ktf_settings'); } catch {}
+};
+
+export default {
+  'TestFramework queues and deduplicates tasks, updates statuses': async ({ pass, fail }) => {
+    try {
+      await import('/gui/components/settingsStore.js');
+      await import('/gui/components/Collapsible.js');
+      await import('/gui/components/Logs.js');
+      await import('/gui/components/Icon.js');
+      await import('/gui/components/Test.js');
+      await import('/gui/components/TestSuite.js');
+      await import('/gui/components/TestFramework.js');
+
+      const fw = document.createElement('ktf-test-framework');
+      const suite = document.createElement('ktf-test-suite');
+      suite.file = 'tests/example.node-test.js';
+      suite.testNames = ['X','Y'];
+      document.body.appendChild(fw);
+      fw.appendChild(suite);
+      await nextTick(); await nextTick();
+
+      const [t1, t2] = suite.querySelectorAll('ktf-test');
+
+      // Stub fetch to simulate run responses quickly
+      const originalFetch = window.fetch;
+      window.fetch = async (url) => {
+        // Return a minimal results payload depending on testNames query
+        const u = new URL(String(url), window.location.origin);
+        const testNames = u.searchParams.get('testNames');
+        if (testNames) {
+          const name = testNames;
+          return { ok: true, json: async () => ({ results: { tests: { [name]: { passed: true, logs: [{ message: `PASS ${name}`, type: 'pass', level: 2 }] } }, beforeAllLogs: [], afterAllLogs: [] } }) };
+        }
+        // Suite run: both tests pass
+        return { ok: true, json: async () => ({ results: { tests: { X: { passed: true, logs: [] }, Y: { passed: true, logs: [] } }, beforeAllLogs: [], afterAllLogs: [] } }) };
+      };
+
+  // Enqueue duplicate test; ensure dedupe keeps one queued (status leaves 'notran')
+      fw.enqueueTest({ file: suite.file, name: 'X', el: t1 });
+      fw.enqueueTest({ file: suite.file, name: 'X', el: t1 });
+  await nextTick();
+  const queuedOnce = t1.status !== 'notran';
+
+  // Run individual test via queue processing; wait until it passes
+  for (let i=0;i<20 && t1.status !== 'pass'; i++){ await nextTick(); }
+  const xPassed = t1.status === 'pass';
+
+      // Enqueue suite; children should go queued then pass
+  fw.enqueueSuite({ file: suite.file, testNames: ['X','Y'], el: suite });
+  for (let i=0;i<30 && !(suite.status === 'pass' && t2.status === 'pass'); i++){ await nextTick(); }
+  const suiteOk = suite.status === 'pass' && t2.status === 'pass';
+
+      window.fetch = originalFetch;
+      if (queuedOnce && xPassed && suiteOk) pass('TestFramework deduped queue and updated statuses');
+      else fail('TestFramework queue or status updates failed');
+    } catch (e) { fail(e.stack || String(e)); }
+  }
+};

package/tests/test-summary.browser-test.js

@@ -0,0 +1,78 @@
+// Browser tests for TestSummary component
+
+const nextTick = () => new Promise(r => setTimeout(r));
+
+export const beforeEach = async () => {
+  document.body.innerHTML = '';
+  try { localStorage.removeItem('ktf_settings'); } catch {}
+};
+
+export default {
+  'TestSummary initializes counts from child suites and tests': async ({ pass, fail }) => {
+    try {
+      await import('/gui/components/settingsStore.js');
+      await import('/gui/components/Collapsible.js');
+      await import('/gui/components/Logs.js');
+      await import('/gui/components/Icon.js');
+      await import('/gui/components/Test.js');
+      await import('/gui/components/TestSuite.js');
+      await import('/gui/components/TestSummary.js');
+      await import('/gui/components/TestFramework.js');
+
+      const fw = document.createElement('ktf-test-framework');
+      const summary = document.createElement('ktf-test-summary');
+      const suite = document.createElement('ktf-test-suite');
+      suite.file = 'tests/example.node-test.js';
+      suite.testNames = ['A','B'];
+      fw.appendChild(summary);
+      fw.appendChild(suite);
+      document.body.appendChild(fw);
+      await nextTick(); await nextTick();
+
+      const text = summary.shadowRoot.textContent.replace(/\s+/g,' ');
+      const filesTotal = /Files[\s\S]*Total:\s*1/.test(text);
+      const testsTotal = /Tests[\s\S]*Total:\s*2/.test(text);
+      if (filesTotal && testsTotal) pass('TestSummary counted files and tests on init'); else fail(`Counts missing:\n${text}`);
+    } catch (e) { fail(e.stack || String(e)); }
+  },
+
+  'TestSummary updates status, counts, and queue length': async ({ pass, fail }) => {
+    try {
+      await import('/gui/components/settingsStore.js');
+      await import('/gui/components/Collapsible.js');
+      await import('/gui/components/Logs.js');
+      await import('/gui/components/Icon.js');
+      await import('/gui/components/Test.js');
+      await import('/gui/components/TestSuite.js');
+      await import('/gui/components/TestSummary.js');
+      await import('/gui/components/TestFramework.js');
+
+      const fw = document.createElement('ktf-test-framework');
+      const summary = document.createElement('ktf-test-summary');
+      const suite = document.createElement('ktf-test-suite');
+      suite.file = 'tests/example.node-test.js';
+      suite.testNames = ['A','B'];
+      fw.appendChild(summary);
+      fw.appendChild(suite);
+      document.body.appendChild(fw);
+      await nextTick(); await nextTick();
+
+      // Simulate queue updates
+      fw.dispatchEvent(new CustomEvent('ktf:queue-updated', { detail: { length: 2 } }));
+      await nextTick();
+      const queueShown = summary.shadowRoot.textContent.includes('Queue: 2');
+
+      // Simulate status changes on tests to drive summary
+      const [t1, t2] = suite.querySelectorAll('ktf-test');
+      t1.status = 'running';
+      await nextTick();
+      const running = summary.getAttribute('status') === 'running' || summary.status === 'running';
+      t1.status = 'pass'; t2.status = 'pass';
+      await nextTick(); await nextTick();
+      const passOk = summary.getAttribute('status') === 'pass' || summary.status === 'pass';
+
+      if (queueShown && running && passOk) pass('TestSummary reflected queue and status transitions');
+      else fail('TestSummary did not update as expected');
+    } catch (e) { fail(e.stack || String(e)); }
+  }
+};

package/tests/test.browser-test.js

@@ -0,0 +1,56 @@
+// Browser tests for Test component
+
+const nextTick = () => new Promise(r => setTimeout(r));
+
+export const beforeEach = async () => {
+  document.body.innerHTML = '';
+  try { localStorage.removeItem('ktf_settings'); } catch {}
+};
+
+export default {
+  'Test renders and shows play icon before run': async ({ pass, fail }) => {
+    try {
+      await import('/gui/components/settingsStore.js');
+      await import('/gui/components/Collapsible.js');
+      await import('/gui/components/Logs.js');
+      await import('/gui/components/Icon.js');
+      await import('/gui/components/Test.js');
+
+      const t = document.createElement('ktf-test');
+      t.name = 'Sample Test';
+      t.file = 'tests/example.node-test.js';
+      document.body.appendChild(t);
+      await nextTick();
+
+    const hasPlay = !!t.shadowRoot.querySelector('div[slot="actions"] ktf-icon[name="play"]');
+    if (hasPlay) pass('Test component renders with initial play icon'); else fail('Missing play icon on Test component');
+    } catch (e) { fail(e.stack || String(e)); }
+  },
+
+  'Test status updates through running/pass/fail': async ({ pass, fail }) => {
+    try {
+      await import('/gui/components/settingsStore.js');
+      await import('/gui/components/Collapsible.js');
+      await import('/gui/components/Logs.js');
+      await import('/gui/components/Icon.js');
+      await import('/gui/components/Test.js');
+
+      const t = document.createElement('ktf-test');
+      t.name = 'Sample Test';
+      t.file = 'tests/example.node-test.js';
+      document.body.appendChild(t);
+      await nextTick();
+
+      t.status = 'running';
+      await nextTick();
+      const running = t.getAttribute('status') === 'running' || t.status === 'running';
+      t.status = 'pass';
+      await nextTick();
+      const passOk = t.getAttribute('status') === 'pass' || t.status === 'pass';
+      t.status = 'fail';
+      await nextTick();
+      const failOk = t.getAttribute('status') === 'fail' || t.status === 'fail';
+  if (running && passOk && failOk) pass('Test component reflected status transitions running→pass→fail'); else fail('Status transitions failed to reflect on Test');
+    } catch (e) { fail(e.stack || String(e)); }
+  }
+};

package/tests/testfile.browser-test.js

@@ -0,0 +1,60 @@
+// Browser tests for TestSuite component
+
+const nextTick = () => new Promise(r => setTimeout(r));
+
+export const beforeEach = async () => {
+  document.body.innerHTML = '';
+  try { localStorage.removeItem('ktf_settings'); } catch {}
+};
+
+export default {
+  'TestSuite renders children and initial play icon': async ({ pass, fail }) => {
+    try {
+      await import('/gui/components/settingsStore.js');
+      await import('/gui/components/Collapsible.js');
+      await import('/gui/components/Logs.js');
+      await import('/gui/components/Icon.js');
+      await import('/gui/components/Test.js');
+  await import('/gui/components/TestSuite.js');
+
+  const tf = document.createElement('ktf-test-suite');
+      tf.file = 'tests/example.node-test.js';
+      tf.testNames = ['A', 'B'];
+      document.body.appendChild(tf);
+      await nextTick(); await nextTick();
+
+    const hasPlay = !!tf.shadowRoot.querySelector('div[slot="actions"] ktf-icon[name="play"]');
+    if (hasPlay) pass('TestSuite renders children and shows initial play icon'); else fail('Missing play icon on TestSuite');
+    } catch (e) { fail(e.stack || String(e)); }
+  },
+
+  'TestSuite aggregates status from children': async ({ pass, fail }) => {
+    try {
+      await import('/gui/components/settingsStore.js');
+      await import('/gui/components/Collapsible.js');
+      await import('/gui/components/Logs.js');
+      await import('/gui/components/Icon.js');
+      await import('/gui/components/Test.js');
+  await import('/gui/components/TestSuite.js');
+
+  const tf = document.createElement('ktf-test-suite');
+      tf.file = 'tests/example.node-test.js';
+      tf.testNames = ['A', 'B'];
+      document.body.appendChild(tf);
+      await nextTick(); await nextTick();
+
+  const children = tf.querySelectorAll('ktf-test');
+      children[0].status = 'running';
+      await nextTick();
+      const statusRunning = tf.getAttribute('status') === 'running' || tf.status === 'running';
+      children[0].status = 'pass';
+      children[1].status = 'fail';
+      await nextTick();
+      const statusFail = tf.getAttribute('status') === 'fail' || tf.status === 'fail';
+      children[1].status = 'pass';
+      await nextTick();
+      const statusPass = tf.getAttribute('status') === 'pass' || tf.status === 'pass';
+  if (statusRunning && statusFail && statusPass) pass('TestSuite aggregated status from children correctly'); else fail('Status propagation failed on TestSuite');
+    } catch (e) { fail(e.stack || String(e)); }
+  }
+};

package/tests/theme.browser-test.js

@@ -0,0 +1,38 @@
+// Browser tests for Theme component
+
+const nextTick = () => new Promise(r => setTimeout(r));
+
+export const beforeEach = async () => {
+  document.body.innerHTML = '';
+  try { localStorage.removeItem('ktf_settings'); } catch {}
+};
+
+export default {
+  'Theme applies document theme on settings change': async ({ pass, fail }) => {
+    try {
+      await import('/gui/components/settingsStore.js');
+      await import('/gui/components/Theme.js');
+      const el = document.createElement('ktf-theme');
+      document.body.appendChild(el);
+      await nextTick();
+      window.KTF_SETTINGS.set({ theme: 'dark' });
+      await nextTick();
+      const themeAttr = document.documentElement.getAttribute('theme');
+    if (themeAttr === 'dark') pass('Theme component applied document theme to dark'); else fail(`Theme not applied: ${themeAttr}`);
+    } catch (e) { fail(e.stack || String(e)); }
+  },
+
+  'Theme switches back to light': async ({ pass, fail }) => {
+    try {
+      await import('/gui/components/settingsStore.js');
+      await import('/gui/components/Theme.js');
+      const el = document.createElement('ktf-theme');
+      document.body.appendChild(el);
+      await nextTick();
+      window.KTF_SETTINGS.set({ theme: 'light' });
+      await nextTick();
+      const themeAttr = document.documentElement.getAttribute('theme');
+    if (themeAttr === 'light') pass('Theme component applied document theme back to light'); else fail(`Theme not applied: ${themeAttr}`);
+    } catch (e) { fail(e.stack || String(e)); }
+  }
+};