@nutin/cli 1.3.1 → 2.0.0

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; };

package/templates/base/tools/testin-nutin/mocks/create-mock-method.test.js.hbs

@@ -0,0 +1,64 @@
+import { createMockMethod } from './create-mock-method.js';
+
+describe('createMockMethod', () => {
+  it('records every call', () => {
+    const fn = createMockMethod();
+    fn(1, 2);
+    fn('a');
+
+    expect(fn.calls).toEqual([[1, 2], ['a']]);
+  });
+
+  it('returns undefined by default', () => {
+    const fn = createMockMethod();
+    expect(fn()).toBe(undefined);
+  });
+
+  it('mockReturnValue makes every call return a fixed value', () => {
+    const fn = createMockMethod();
+    fn.mockReturnValue(42);
+
+    expect(fn()).toBe(42);
+    expect(fn('ignored arg')).toBe(42);
+  });
+
+  it('mockImplementation delegates to the given function', () => {
+    const fn = createMockMethod();
+    fn.mockImplementation((a, b) => a + b);
+
+    expect(fn(2, 3)).toBe(5);
+  });
+
+  it('mockReset clears recorded calls and configured behavior', () => {
+    const fn = createMockMethod();
+    fn.mockReturnValue(42);
+    fn(1);
+
+    fn.mockReset();
+
+    expect(fn.calls).toEqual([]);
+    expect(fn()).toBe(undefined);
+  });
+
+  it('falls back to the given default implementation', () => {
+    const fn = createMockMethod((a, b) => a + b);
+
+    expect(fn(2, 3)).toBe(5);
+  });
+
+  it('mockImplementation overrides the default implementation', () => {
+    const fn = createMockMethod(() => 'default');
+    fn.mockImplementation(() => 'overridden');
+
+    expect(fn()).toBe('overridden');
+  });
+
+  it('mockReset restores the default implementation', () => {
+    const fn = createMockMethod(() => 'default');
+    fn.mockImplementation(() => 'overridden');
+
+    fn.mockReset();
+
+    expect(fn()).toBe('default');
+  });
+});

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

@@ -24,10 +24,10 @@ export class MockEventBus {
     this.off.calls = [];
     this.off.mockReset = () => { this.off.calls = []; };
 
-    this.on = (event, callback) => {
+    this.on = createMockMethod((event, callback) => {
       if (!this.handlers[event]) this.handlers[event] = [];
       this.handlers[event].push(callback);
-    };
+    });
 
     this.onDestroy = createMockMethod();
     this.reset = this.reset.bind(this);
@@ -37,6 +37,7 @@ export class MockEventBus {
     this.subscribe.mockReset();
     this.emit.mockReset();
     this.off.mockReset();
+    this.on.mockReset();
     this.onDestroy.mockReset();
     this.handlers = {};
   }

package/templates/base/tools/testin-nutin/mocks/mock-event-bus.test.js.hbs

@@ -0,0 +1,66 @@
+import { MockEventBus } from './mock-event-bus.js';
+
+describe('MockEventBus', () => {
+  it('on() + emit() dispatches the event data to the registered handler', () => {
+    const bus = new MockEventBus();
+    let received;
+    bus.on('greet', (data) => { received = data; });
+
+    bus.emit('greet', 'hello');
+
+    expect(received).toBe('hello');
+    expect(bus.emit.calls).toEqual([['greet', 'hello']]);
+  });
+
+  it('on() is a trackable mock', () => {
+    const bus = new MockEventBus();
+    const handler = () => {};
+    bus.on('greet', handler);
+
+    expect(bus.on).toHaveBeenCalled();
+    expect(bus.on).toHaveBeenCalledWith('greet', handler);
+  });
+
+  it('off() removes a previously registered handler', () => {
+    const bus = new MockEventBus();
+    let callCount = 0;
+    const handler = () => { callCount++; };
+    bus.on('greet', handler);
+    bus.off('greet', handler);
+
+    bus.emit('greet', 'hello');
+
+    expect(callCount).toBe(0);
+  });
+
+  it('subscribe() is a bare mock and does not actually register a handler', () => {
+    const bus = new MockEventBus();
+    let called = false;
+    const handler = () => { called = true; };
+    bus.subscribe('greet', handler);
+
+    bus.emit('greet', 'hello');
+
+    expect(called).toBeFalsy();
+    expect(bus.subscribe.calls.length).toBe(1);
+    expect(bus.subscribe.calls[0][0]).toBe('greet');
+    expect(bus.subscribe.calls[0][1]).toBe(handler);
+  });
+
+  it('reset() clears handlers and call logs', () => {
+    const bus = new MockEventBus();
+    let callCount = 0;
+    bus.on('greet', () => { callCount++; });
+    bus.emit('greet', 'x');
+    bus.subscribe('greet', () => {});
+
+    bus.reset();
+
+    expect(bus.emit.calls).toEqual([]);
+    expect(bus.subscribe.calls).toEqual([]);
+    expect(bus.on.calls).toEqual([]);
+
+    bus.emit('greet', 'y');
+    expect(callCount).toBe(1); // only the pre-reset emit reached the handler
+  });
+});

package/templates/base/tools/testin-nutin/mocks/mock-http-client.test.js.hbs

@@ -0,0 +1,26 @@
+import { MockHttpClient } from './mock-http-client.js';
+
+describe('MockHttpClient', () => {
+  it('exposes get/post/put/patch/delete as independent bare mocks', () => {
+    const client = new MockHttpClient();
+    client.get.mockReturnValue('get-result');
+    client.post('/widgets', { name: 'a' });
+
+    expect(client.get()).toBe('get-result');
+    expect(client.post.calls).toEqual([['/widgets', { name: 'a' }]]);
+    expect(client.put.calls).toEqual([]);
+  });
+
+  it('reset() clears calls and configured return values on every method', () => {
+    const client = new MockHttpClient();
+    client.get.mockReturnValue('cached');
+    client.get();
+    client.delete('/widgets/1');
+
+    client.reset();
+
+    expect(client.get.calls).toEqual([]);
+    expect(client.delete.calls).toEqual([]);
+    expect(client.get()).toBe(undefined);
+  });
+});

package/templates/base/tools/testin-nutin/mocks/mock-i18n.test.js.hbs

@@ -0,0 +1,61 @@
+import { MockI18n } from './mock-i18n.js';
+
+describe('MockI18n', () => {
+  it('exposes the constructor defaults via currentLanguage', () => {
+    const i18n = new MockI18n('fr', ['en', 'fr']);
+    expect(i18n.currentLanguage).toBe('fr');
+  });
+
+  it('translate/getBrowserLanguage run their built-in default implementation without needing .mockImplementation', () => {
+    const i18n = new MockI18n();
+
+    // No translations set — translate() falls back to returning the key itself.
+    expect(i18n.translate('some.key')).toBe('some.key');
+    expect(i18n.getBrowserLanguage()).toBe('en');
+  });
+
+  it('loadTranslations/initTranslations run their default implementation and update currentLanguage', async () => {
+    const i18n = new MockI18n('en', ['en', 'fr']);
+
+    await i18n.loadTranslations('fr');
+    expect(i18n.currentLanguage).toBe('fr');
+  });
+
+  it('translate is still trackable as a mock alongside its default implementation', () => {
+    const i18n = new MockI18n();
+    i18n.translate('some.key');
+
+    expect(i18n.translate).toHaveBeenCalledWith('some.key');
+  });
+
+  it('translate can be given real interpolation behavior via .mockImplementation', () => {
+    const i18n = new MockI18n();
+    i18n.setTranslations({ greeting: 'Hello {name}' });
+    i18n.translate.mockImplementation((key, params) => {
+      const value = i18n._translations[key] || key;
+      if (!params) return value;
+      return Object.entries(params).reduce((acc, [k, v]) => acc.replace(`{${k}}`, v), value);
+    });
+
+    expect(i18n.translate('greeting', { name: 'Ada' })).toBe('Hello Ada');
+  });
+
+  it('setTranslations/setDefaultTranslations seed real, readable state', () => {
+    const i18n = new MockI18n();
+    i18n.setTranslations({ a: '1' });
+    i18n.setDefaultTranslations({ b: '2' });
+
+    expect(i18n._translations).toEqual({ a: '1' });
+    expect(i18n._defaultTranslations).toEqual({ b: '2' });
+  });
+
+  it('reset() restores the constructor default language and clears translations', () => {
+    const i18n = new MockI18n('en');
+    i18n.setTranslations({ a: '1' });
+
+    i18n.reset();
+
+    expect(i18n._translations).toEqual({});
+    expect(i18n.currentLanguage).toBe('en');
+  });
+});

package/templates/base/tools/testin-nutin/mocks/mock-router.test.js.hbs

@@ -0,0 +1,29 @@
+import { MockRouter } from './mock-router.js';
+
+describe('MockRouter', () => {
+  it('stores the routes passed to the constructor', () => {
+    const routes = { '/home': {} };
+    const router = new MockRouter(routes);
+
+    expect(router.routes).toBe(routes);
+  });
+
+  it('navigate/handlePopState/handleNotFound/handleGuards/initializeEventListeners are independent bare mocks', () => {
+    const router = new MockRouter();
+    router.navigate('/about');
+
+    expect(router.navigate.calls).toEqual([['/about']]);
+    expect(router.handlePopState.calls).toEqual([]);
+  });
+
+  it('reset() clears every mock method and _currentView', () => {
+    const router = new MockRouter();
+    router.navigate('/about');
+    router._currentView = 'about-view';
+
+    router.reset();
+
+    expect(router.navigate.calls).toEqual([]);
+    expect(router._currentView).toBe(null);
+  });
+});