@nutin/cli 1.3.0 → 2.0.0

package/templates/{features/testinNutin/testin-nutin/core/src → base/tools/testin-nutin/core}/globals/jsdom-setup.js.hbs

@@ -1,8 +1,11 @@
 import fs from 'fs';
 import path from 'path';
 import { JSDOM } from 'jsdom';
-import config from '#root/testin-nutin.config.js';
+import { print } from '../../../utils/index.js';
+import config from '#root/nutin.config.js';
+
 let currentDom = null;
+const nativeGlobalKeys = new Set(Object.getOwnPropertyNames(global));
 
 export function setupJsdom(htmlPath = 'dist/src/index.html') {
   const html = fs.readFileSync(path.resolve(process.cwd(), htmlPath), 'utf8');
@@ -12,7 +15,7 @@ export function setupJsdom(htmlPath = 'dist/src/index.html') {
     resources,
     freezeGlobals,
     pretendToBeVisual,
-  } = config.jsdomOptions;
+  } = config.testinNutin.jsdomOptions;
 
   const dom = new JSDOM(html, {
     url: 'http://localhost',
@@ -26,9 +29,11 @@ export function setupJsdom(htmlPath = 'dist/src/index.html') {
   global.window = dom.window;
   global.document = dom.window.document;
 
-  // DOM globals
+  // DOM globals — re-synced every call so classes like HTMLInputElement always
+  // match the current jsdom realm, not whichever realm happened to run first.
+  // Real Node globals (console, setTimeout, fetch, Event, ...) are left untouched.
   Object.getOwnPropertyNames(dom.window)
-    .filter(prop => !(prop in global))
+    .filter(prop => !nativeGlobalKeys.has(prop))
     .forEach(prop => {
       global[prop] = dom.window[prop];
   });
@@ -41,7 +46,13 @@ export function setupJsdom(htmlPath = 'dist/src/index.html') {
     removeEventListener: () => {},
   });
 
-  window.scrollTo ??= () => {};
+  // jsdom already ships a real (but "not implemented") scrollTo, so ??= never
+  // fires here — always override it with a working no-op.
+  window.scrollTo = () => {};
+
+  // jsdom doesn't implement Element.prototype.scrollIntoView at all (no layout
+  // engine to compute a real scroll position), so any code calling it throws.
+  window.Element.prototype.scrollIntoView ??= function () {};
 
   window.requestAnimationFrame ??= (cb) => setTimeout(cb, 0);
   window.cancelAnimationFrame ??= (id) => clearTimeout(id);
@@ -72,7 +83,9 @@ export function teardownJsdom() {
   if (currentDom) {
     try {
       currentDom.window.close();
-    } catch {}
+    } catch (err) {
+      print.grayError(`[jsdom] window.close() failed: ${err.message}`);
+    }
   }
 
   currentDom = null;

package/templates/{features/testinNutin/testin-nutin/core/src → base/tools/testin-nutin/core}/globals/register-test-globals.js.hbs

@@ -1,8 +1,11 @@
-import { print, addTest } from '../../index.js';
-import config from '#root/testin-nutin.config.js';
+import { print, addTest } from '../index.js';
 import { setupJsdom, teardownJsdom, resetDom, flushPromises } from './jsdom-setup.js';
+import { silenceConsole } from './silence-console.js';
 import './assertion-lib.js';
 import './spyon.js';
+import './clock.js';
+
+const verboseEnabled = process.argv.includes('--verbose');
 
 export function registerTestGlobals() {
   let currentSuite = '';
@@ -16,7 +19,7 @@ export function registerTestGlobals() {
       afterEach: null,
       afterAll: null
     };
-    if (config.verbose) print.boldSuccess('📂 ' + name);
+    if (verboseEnabled) print.boldSuccess('📂 ' + name);
     fn();
   };
 
@@ -31,6 +34,9 @@ export function registerTestGlobals() {
       afterAll: currentSuiteHooks.afterAll
     });
   };
+  global.it.todo = (s) => {
+    addTest({ suiteName: currentSuite, testName: s, isTodo: true });
+  };
 
   global.beforeAll = (fn) => {
     currentSuiteHooks.beforeAll = fn;
@@ -49,11 +55,14 @@ export function registerTestGlobals() {
   global.teardownJsdom = teardownJsdom;
   global.resetDom = resetDom;
   global.flushPromises = flushPromises;
+  global.silenceConsole = silenceConsole;
 
   global.$ = (selector) => document.querySelector(selector);
   global.$$ = (selector) => [...document.querySelectorAll(selector)];
 
-  global.click = (el) => el.dispatchEvent(new window.MouseEvent("click", { bubbles: true }));
+  // cancelable: true matches a real browser's native click event, so code
+  // under test that calls preventDefault() actually sees defaultPrevented.
+  global.click = (el) => el.dispatchEvent(new window.MouseEvent("click", { bubbles: true, cancelable: true }));
   global.type = (el, text) => { el.value = text; el.dispatchEvent(new window.InputEvent("input", { bubbles: true })); };
 
 }

package/templates/base/tools/testin-nutin/core/globals/silence-console.js.hbs

@@ -0,0 +1,23 @@
+export function silenceConsole(methodOrMethods, fn) {
+  const methods = Array.isArray(methodOrMethods) ? methodOrMethods : [methodOrMethods];
+  const spies = methods.map((method) => spyOn(console, method).andCallFake(() => {}));
+  const restore = () => spies.forEach((spy) => spy.restore());
+
+  let result;
+  try {
+    result = fn();
+  } catch (err) {
+    restore();
+    throw err;
+  }
+
+  if (result && typeof result.then === 'function') {
+    return result.then(
+      (value) => { restore(); return value; },
+      (err) => { restore(); throw err; }
+    );
+  }
+
+  restore();
+  return result;
+}

package/templates/{features/testinNutin/testin-nutin/core/src → base/tools/testin-nutin/core}/globals/spyon.js.hbs

@@ -47,11 +47,13 @@ global.spyOn = (obj, methodName) => {
     andCallFake(fn) {
       spyFunction._fake = fn;
       spyFunction._hasReturn = false;
+      return handle;
     },
     andReturn(value) {
       spyFunction._returnValue = value;
       spyFunction._hasReturn = true;
       spyFunction._fake = null;
+      return handle;
     }
   };
 

package/templates/base/tools/testin-nutin/core/index.js.hbs

@@ -0,0 +1,9 @@
+export * from './globals/jsdom-setup.js';
+export * from './globals/register-test-globals.js';
+export * from './queue/test-discovery.js';
+export * from './queue/test-queue.js';
+export * from './printer.js';
+export * from './coverage/collect-coverage.js';
+export * from './coverage/compute-coverage.js';
+export * from './coverage/write-uncovered-report.js';
+export * from './coverage/write-summary-report.js';

package/templates/base/tools/testin-nutin/core/printer.js.hbs

@@ -0,0 +1,85 @@
+import { print, chalk } from '../../utils/index.js';
+import config from '#root/nutin.config.js';
+
+export { chalk, print } from '../../utils/index.js';
+
+const verboseEnabled = process.argv.includes('--verbose');
+
+export function printSummary(todo, passed, failed, time) {
+  const totalTime = time.toFixed(2);
+  const total = passed + failed;
+
+  print.boldBlue(`Test Summary`);
+  print.boldInfo(`✓ ${passed} passed`);
+  print.boldError(`✗ ${failed} failed`);
+  print.info(`📖 ${total} total`);
+  print.info(`⌚️ Time: ${totalTime}ms\n`);
+  if (todo > 0) print.boldWarn(`⚠️ To do: ${todo}\n`);
+}
+
+export function printResults(results) {
+  const statusOrder = { passed: 0, todo: 1, failed: 2 };
+  const sortedResults = results.sort((a, b) => statusOrder[a.status] - statusOrder[b.status]);
+
+  sortedResults.forEach(result => {
+    if (result.status === 'passed') {
+      if (verboseEnabled) console.log(`${chalk.green('✓')} ${chalk.cyan(`${result.suiteName}`)} - ${chalk.green(`${result.name}`)}`);
+    } else if (result.status === 'todo') {
+      print.warn(`TODO: ${result.name} in ${toTsPath(result.file)}`);
+    } else {
+      print.error(`✗ ${result.suiteName} - ${result.name}`);
+      print.grayError(result.error);
+    }
+  });
+}
+
+export function printStart() {
+  print.boldHead('\nRunning tests...\n');
+}
+
+export function printCoverageReport(report) {
+  if (!report.length) {
+    print.warn('No app source files were covered.');
+    return { globalLinesPct: 100, globalFunctionsPct: 100, globalBranchesPct: 100 };
+  }
+
+  print.boldBlue('\nCoverage Summary');
+  console.table(
+    report
+      .sort((a, b) => a.file.localeCompare(b.file))
+      .map(r => ({
+        File: toTsPath(r.file),
+        'Lines %': r.linesPct.toFixed(1),
+        'Functions %': r.functionsPct.toFixed(1),
+        'Branches %': r.branchesPct.toFixed(1),
+      }))
+  );
+
+  const totals = report.reduce((acc, r) => ({
+    coveredLines: acc.coveredLines + r.coveredLines,
+    totalLines: acc.totalLines + r.totalLines,
+    coveredBranches: acc.coveredBranches + r.coveredBranches,
+    totalBranches: acc.totalBranches + r.totalBranches,
+    coveredFunctions: acc.coveredFunctions + r.coveredFunctions,
+    totalFunctions: acc.totalFunctions + r.totalFunctions,
+  }), { coveredLines: 0, totalLines: 0, coveredBranches: 0, totalBranches: 0, coveredFunctions: 0, totalFunctions: 0 });
+
+  const globalLinesPct = totals.totalLines ? (totals.coveredLines / totals.totalLines) * 100 : 100;
+  const globalFunctionsPct = totals.totalFunctions ? (totals.coveredFunctions / totals.totalFunctions) * 100 : 100;
+  const globalBranchesPct = totals.totalBranches ? (totals.coveredBranches / totals.totalBranches) * 100 : 100;
+
+  const threshold = config.testinNutin.coverage?.threshold;
+  const thresholdSuffix = typeof threshold === 'number' ? `  (threshold: ${threshold}%)` : '';
+  print.boldInfo(`Global:  ${globalBranchesPct.toFixed(1)}% branches, ${globalFunctionsPct.toFixed(1)}% functions, ${globalLinesPct.toFixed(1)}% lines${thresholdSuffix}\n`);
+
+  return { globalLinesPct, globalFunctionsPct, globalBranchesPct };
+}
+
+export function toTsPath(input) {
+  return input
+    .split('/')
+    .slice(1)
+    .join('/')
+    .replace(/\.js$/, '.ts');
+}
+

package/templates/base/tools/testin-nutin/core/queue/queue.test.js.hbs

@@ -0,0 +1,46 @@
+import Queue from './queue.js';
+
+describe('Queue', () => {
+  it('starts empty', () => {
+    const queue = new Queue();
+    expect(queue.length).toBe(0);
+    expect(queue.deque()).toBe(undefined);
+    expect(queue.peek()).toBe(undefined);
+  });
+
+  it('dequeues items in FIFO order', () => {
+    const queue = new Queue();
+    queue.enqueue('a');
+    queue.enqueue('b');
+    queue.enqueue('c');
+
+    expect(queue.length).toBe(3);
+    expect(queue.deque()).toBe('a');
+    expect(queue.deque()).toBe('b');
+    expect(queue.length).toBe(1);
+    expect(queue.deque()).toBe('c');
+    expect(queue.length).toBe(0);
+  });
+
+  it('peek returns the next item without removing it', () => {
+    const queue = new Queue();
+    queue.enqueue('first');
+    queue.enqueue('second');
+
+    expect(queue.peek()).toBe('first');
+    expect(queue.peek()).toBe('first');
+    expect(queue.length).toBe(2);
+  });
+
+  it('handles a single enqueue/deque cycle and can be reused afterward', () => {
+    const queue = new Queue();
+    queue.enqueue('only');
+    expect(queue.deque()).toBe('only');
+    expect(queue.length).toBe(0);
+    expect(queue.deque()).toBe(undefined);
+
+    queue.enqueue('again');
+    expect(queue.length).toBe(1);
+    expect(queue.deque()).toBe('again');
+  });
+});

package/templates/base/tools/testin-nutin/core/queue/test-discovery.test.js.hbs

@@ -0,0 +1,46 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { getTestFiles } from './test-discovery.js';
+
+// getTestFiles resolves its own `projectRoot` anchor one directory short of the real
+// project root (see tools/testin-nutin/runner.js, which always calls it as
+// `getTestFiles(path.join('..', origin))` to compensate). This test file lives in the
+// same directory as test-discovery.js, so it can recompute that same anchor to build
+// `dir` arguments the same way the real runner does.
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const relativeToCwd = path.relative(process.cwd(), __dirname);
+const levelsUp = relativeToCwd.split(path.sep).length - 1;
+const projectRoot = path.resolve(__dirname, ...Array(levelsUp).fill('..'));
+
+describe('getTestFiles', () => {
+  let tmpDir;
+  let relDir;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nutin-test-discovery-'));
+    relDir = path.relative(projectRoot, tmpDir);
+
+    fs.mkdirSync(path.join(tmpDir, 'nested'), { recursive: true });
+    fs.writeFileSync(path.join(tmpDir, 'a.test.js'), '');
+    fs.writeFileSync(path.join(tmpDir, 'b.js'), '');
+    fs.writeFileSync(path.join(tmpDir, 'nested', 'c.test.js'), '');
+    fs.writeFileSync(path.join(tmpDir, 'nested', 'readme.md'), '');
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('recursively finds only files ending in .test.js', () => {
+    const files = getTestFiles(relDir).sort();
+    expect(files).toEqual(
+      [path.join(tmpDir, 'a.test.js'), path.join(tmpDir, 'nested', 'c.test.js')].sort()
+    );
+  });
+
+  it('returns an empty array for a directory that does not exist', () => {
+    expect(getTestFiles(path.join(relDir, 'does-not-exist'))).toEqual([]);
+  });
+});

package/templates/base/tools/testin-nutin/core/queue/test-queue.js.hbs

@@ -0,0 +1,154 @@
+import path from 'path';
+import Queue from './queue.js';
+import { printStart, printSummary, printResults } from '../index.js';
+import { setupJsdom, teardownJsdom } from '../globals/jsdom-setup.js';
+
+const testQueue = new Queue();
+let todo = 0;
+let passed = 0;
+let failed = 0;
+let elapsedTime;
+let currentTestFile = '';
+
+export function setCurrentTestFile(file) {
+  currentTestFile = file ? path.relative(process.cwd(), file) : '';
+}
+
+export function addTest(test) {
+  testQueue.enqueue({ ...test, file: currentTestFile });
+}
+
+export async function runQueuedTests() {
+  printStart();
+  const startTime = performance.now();
+  const testAmount = testQueue.length;
+  const results = [];
+  let previousSuiteKey = null;
+  let previousSuite = null;
+  let previousSuiteAfterAll = null;
+  let test;
+
+  const runAfterAll = async (suiteName, afterAllFn) => {
+    if (!afterAllFn) return;
+    try {
+      await afterAllFn();
+    } catch (err) {
+      failed++;
+      results.push({
+        suiteName,
+        status: 'failed',
+        name: 'afterAll',
+        error: err.stack
+      });
+    }
+  };
+
+  const suiteKey = (t) => `${t.file}::${t.suiteName}`;
+
+  for (let i = 0; i < testAmount; i++) {
+    test = testQueue.deque();
+
+    if (suiteKey(test) !== previousSuiteKey) {
+      await runAfterAll(previousSuite, previousSuiteAfterAll);
+      if (previousSuiteKey !== null) teardownJsdom();
+
+      try {
+        setupJsdom();
+      } catch (err) {
+        failed++;
+        results.push({
+          suiteName: test.suiteName,
+          status: 'failed',
+          name: 'setupJsdom',
+          error: err.stack
+        });
+        previousSuiteKey = suiteKey(test);
+        previousSuite = test.suiteName;
+        previousSuiteAfterAll = null;
+        continue;
+      }
+
+      previousSuiteKey = suiteKey(test);
+      previousSuite = test.suiteName;
+      previousSuiteAfterAll = test.afterAll;
+      if (test.beforeAll) {
+        try {
+          await test.beforeAll();
+        } catch (err) {
+          failed++;
+          results.push({
+            suiteName: test.suiteName,
+            status: 'failed',
+            name: 'beforeAll',
+            error: err.stack
+          });
+        }
+      }
+    }
+
+    if (test.isTodo) {
+      todo++;
+      results.push({
+        suiteName: test.suiteName,
+        status: 'todo',
+        name: test.testName,
+        file: test.file
+      });
+      continue;
+    }
+
+    let testError = null;
+    try {
+      if (test.beforeEach) await test.beforeEach();
+      await test.testFn();
+    } catch (err) {
+      testError = err;
+    }
+
+    let afterEachError = null;
+    try {
+      if (test.afterEach) await test.afterEach();
+    } catch (err) {
+      afterEachError = err;
+    }
+
+    if (testError) {
+      failed++;
+      results.push({
+        suiteName: test.suiteName,
+        status: 'failed',
+        name: test.testName,
+        error: testError.stack
+      });
+    } else {
+      passed++;
+      results.push({
+        suiteName: test.suiteName,
+        status: 'passed',
+        name: test.testName
+      });
+    }
+
+    if (afterEachError) {
+      failed++;
+      results.push({
+        suiteName: test.suiteName,
+        status: 'failed',
+        name: `${test.testName} (afterEach)`,
+        error: afterEachError.stack
+      });
+    }
+  }
+
+  if (previousSuiteKey !== null) {
+    await runAfterAll(previousSuite, previousSuiteAfterAll);
+    teardownJsdom();
+  }
+
+  const endTime = performance.now();
+  elapsedTime = (endTime - startTime);
+  printResults(results);
+  printSummary(todo, passed, failed, elapsedTime);
+
+  return { todo, passed, failed, elapsedTime };
+}

package/templates/{features/testinNutin → base/tools}/testin-nutin/core/tests/assertions.test.js.hbs

@@ -67,4 +67,31 @@ describe('assertions', () => {
     expect(notErr).not.toThrow();
     expect(notErr).not.toThrow('messsage');
   });
+  it('should support toThrow with an async function that rejects', async () => {
+    const rejects = async () => { throw new Error('async failure'); };
+    const resolves = async () => 'ok';
+    await expect(rejects).toThrow();
+    await expect(rejects).toThrow('async failure');
+    await expect(resolves).not.toThrow();
+  });
+  it('should throw a distinguishable AssertionError on failure', () => {
+    let caught;
+    try {
+      expect(1).toBe(2);
+    } catch (err) {
+      caught = err;
+    }
+    expect(caught).toBeInstanceOf(AssertionError);
+  });
+  it('.not should not swallow an unrelated runtime error from the matcher itself', () => {
+    // `x instanceof undefined` throws a TypeError — a bug in the test, not a
+    // legitimate assertion mismatch, so it must not be reported as a pass.
+    let caught;
+    try {
+      expect({}).not.toBeInstanceOf(undefined);
+    } catch (err) {
+      caught = err;
+    }
+    expect(caught).toBeInstanceOf(TypeError);
+  });
 });

package/templates/base/tools/testin-nutin/core/tests/clock.test.js.hbs

@@ -0,0 +1,118 @@
+describe('clock (fake timers)', () => {
+  afterEach(() => {
+    useRealTimers();
+  });
+
+  it('should fake setTimeout and fire it on advanceTimersByTime', () => {
+    useFakeTimers();
+    let called = false;
+    setTimeout(() => { called = true; }, 1000);
+
+    expect(called).toBeFalsy();
+    advanceTimersByTime(999);
+    expect(called).toBeFalsy();
+    advanceTimersByTime(1);
+    expect(called).toBeTruthy();
+  });
+
+  it('should fire multiple timers in deadline order', () => {
+    useFakeTimers();
+    const order = [];
+    setTimeout(() => order.push('b'), 200);
+    setTimeout(() => order.push('a'), 100);
+    setTimeout(() => order.push('c'), 300);
+
+    advanceTimersByTime(300);
+    expect(order).toEqual(['a', 'b', 'c']);
+  });
+
+  it('should fire setInterval repeatedly on a single advance', () => {
+    useFakeTimers();
+    let count = 0;
+    const id = setInterval(() => { count++; }, 10);
+
+    advanceTimersByTime(105);
+    expect(count).toEqual(10);
+    clearInterval(id);
+  });
+
+  it('should chase timers scheduled from within a firing timer via runAllTimers', () => {
+    useFakeTimers();
+    const order = [];
+    setTimeout(() => {
+      order.push('first');
+      setTimeout(() => order.push('nested'), 10);
+    }, 10);
+
+    runAllTimers();
+    expect(order).toEqual(['first', 'nested']);
+    expect(getTimerCount()).toEqual(0);
+  });
+
+  it('should bail out of an infinite setInterval loop in runAllTimers', () => {
+    useFakeTimers();
+    setInterval(() => {}, 0);
+    const throwing = () => runAllTimers();
+
+    expect(throwing).toThrow();
+  });
+
+  it('should only fire snapshot-pending timers with runOnlyPendingTimers', () => {
+    useFakeTimers();
+    let outer = 0;
+    let inner = 0;
+    setTimeout(() => {
+      outer++;
+      setTimeout(() => { inner++; }, 0);
+    }, 0);
+
+    runOnlyPendingTimers();
+    expect(outer).toEqual(1);
+    expect(inner).toEqual(0);
+  });
+
+  it('should clear all pending timers without firing them', () => {
+    useFakeTimers();
+    let called = false;
+    setTimeout(() => { called = true; }, 10);
+
+    expect(getTimerCount()).toEqual(1);
+    clearAllTimers();
+    expect(getTimerCount()).toEqual(0);
+    advanceTimersByTime(1000);
+    expect(called).toBeFalsy();
+  });
+
+  it('should reflect fake time in Date.now() and new Date()', () => {
+    useFakeTimers();
+    setSystemTime(1000000);
+
+    expect(Date.now()).toEqual(1000000);
+    expect(new Date().getTime()).toEqual(1000000);
+    advanceTimersByTime(500);
+    expect(Date.now()).toEqual(1000500);
+  });
+
+  it('should still construct explicit Date args normally under fake time', () => {
+    useFakeTimers();
+    setSystemTime(1000000);
+    const explicit = new Date(2020, 0, 1);
+
+    expect(explicit.getFullYear()).toEqual(2020);
+  });
+
+  it('should restore real timers after useRealTimers()', async () => {
+    useFakeTimers();
+    useRealTimers();
+
+    await new Promise(resolve => {
+      setTimeout(resolve, 5);
+    });
+    expect(true).toBeTruthy();
+  });
+
+  it('should throw a clear error when used without useFakeTimers()', () => {
+    const throwing = () => advanceTimersByTime(100);
+    expect(throwing).toThrow('useFakeTimers');
+  });
+});

package/templates/base/tools/testin-nutin/core/tests/globals-each-all.test.js.hbs

@@ -0,0 +1,28 @@
+describe('globals beforeEach/All and afterEach/All', () => {
+  let beforeEachCount = 0;
+  let beforeAllCount = 0;
+  let afterEachCount = 0;
+
+  beforeAll(() => {
+    beforeAllCount++;
+  });
+  beforeEach(() => {
+    beforeEachCount++;
+  });
+  afterEach(() => {
+    afterEachCount++;
+  });
+  afterAll(() => {
+    // console.debug('afterAll called.');
+  });
+  it('should be called once for all and once for each', () => {
+    expect(beforeAllCount).toEqual(1);
+    expect(beforeEachCount).toEqual(1);
+    expect(afterEachCount).toEqual(0);
+  });
+  it('should be called once for all and twice for each', () => {
+    expect(beforeAllCount).toEqual(1);
+    expect(beforeEachCount).toEqual(2);
+    expect(afterEachCount).toEqual(1);
+  });
+})

package/templates/{features/testinNutin → base/tools}/testin-nutin/mocks/create-mock-method.js.hbs

@@ -1,9 +1,10 @@
-export function createMockMethod() {
+export function createMockMethod(defaultImpl) {
   const calls = [];
   const fn = (...args) => {
     calls.push(args);
     if (fn.__mockReturn !== undefined) return fn.__mockReturn;
     if (fn.__mockReturnFn) return fn.__mockReturnFn(...args);
+    if (defaultImpl) return defaultImpl(...args);
   };
   fn.calls = calls;
   fn.mockReturnValue = (value) => { fn.__mockReturn = value; };