@nutin/cli 2.1.1 → 3.0.0

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

@@ -20,7 +20,6 @@ export function addTest(test) {
 
 export async function runQueuedTests() {
   printStart();
-  const startTime = performance.now();
   const testAmount = testQueue.length;
   const results = [];
   let previousSuiteKey = null;
@@ -70,10 +69,10 @@ export async function runQueuedTests() {
 
       previousSuiteKey = suiteKey(test);
       previousSuite = test.suiteName;
-      previousSuiteAfterAll = test.afterAll;
-      if (test.beforeAll) {
+      previousSuiteAfterAll = test.hooks?.afterAll;
+      if (test.hooks?.beforeAll) {
         try {
-          await test.beforeAll();
+          await test.hooks.beforeAll();
         } catch (err) {
           failed++;
           results.push({
@@ -99,7 +98,7 @@ export async function runQueuedTests() {
 
     let testError = null;
     try {
-      if (test.beforeEach) await test.beforeEach();
+      if (test.hooks?.beforeEach) await test.hooks.beforeEach();
       await test.testFn();
     } catch (err) {
       testError = err;
@@ -107,7 +106,7 @@ export async function runQueuedTests() {
 
     let afterEachError = null;
     try {
-      if (test.afterEach) await test.afterEach();
+      if (test.hooks?.afterEach) await test.hooks.afterEach();
     } catch (err) {
       afterEachError = err;
     }
@@ -145,8 +144,9 @@ export async function runQueuedTests() {
     teardownJsdom();
   }
 
-  const endTime = performance.now();
-  elapsedTime = (endTime - startTime);
+  // Since the process started (performance's time origin): Node startup, discovery and
+  // the test files' imports count too, not only running the queued tests.
+  elapsedTime = performance.now();
   printResults(results);
   printSummary(todo, passed, failed, elapsedTime);
 

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

@@ -1,45 +1,47 @@
 import { createMockMethod } from './create-mock-method.js';
 
+// Mirrors EventBus's public API (subscribe/once/emit/off): every method is a trackable
+// mock whose default implementation really dispatches, so subscribed callbacks run.
 export class MockEventBus {
   constructor() {
     this.handlers = {};
 
-    this.subscribe = createMockMethod();
-    this.emit = (...args) => {
-      this.emit.calls.push(args);
-      const [event, data] = args;
-      const callbacks = this.handlers[event];
-      if (callbacks) {
-        callbacks.forEach(cb => cb(data));
-      }
-    };
-    this.emit.calls = [];
-    this.emit.mockReset = () => { this.emit.calls = []; };
-
-    this.off = (event, callback) => {
-      this.off.calls.push([event, callback]);
-      if (!this.handlers[event]) return;
-      this.handlers[event] = this.handlers[event].filter(cb => cb !== callback);
-    };
-    this.off.calls = [];
-    this.off.mockReset = () => { this.off.calls = []; };
-
-    this.on = createMockMethod((event, callback) => {
-      if (!this.handlers[event]) this.handlers[event] = [];
-      this.handlers[event].push(callback);
+    this.subscribe = createMockMethod((event, callback) => this._addHandler(event, callback, false));
+    this.once = createMockMethod((event, callback) => this._addHandler(event, callback, true));
+
+    this.emit = createMockMethod((event, data) => {
+      const entries = this.handlers[event];
+      if (!entries) return;
+      entries.slice().forEach((entry) => {
+        if (entry.once) this._removeHandler(event, entry.callback);
+        entry.callback(data);
+      });
+    });
+
+    this.off = createMockMethod((event, callback) => {
+      if (callback) this._removeHandler(event, callback);
+      else delete this.handlers[event];
     });
 
     this.onDestroy = createMockMethod();
     this.reset = this.reset.bind(this);
   }
 
+  _addHandler(event, callback, once) {
+    (this.handlers[event] ??= []).push({ callback, once });
+  }
+
+  _removeHandler(event, callback) {
+    if (!this.handlers[event]) return;
+    this.handlers[event] = this.handlers[event].filter((entry) => entry.callback !== callback);
+  }
+
   reset() {
     this.subscribe.mockReset();
+    this.once.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

@@ -1,10 +1,10 @@
 import { MockEventBus } from './mock-event-bus.js';
 
 describe('MockEventBus', () => {
-  it('on() + emit() dispatches the event data to the registered handler', () => {
+  it('subscribe() + emit() dispatches the event data to the subscribed callback', () => {
     const bus = new MockEventBus();
     let received;
-    bus.on('greet', (data) => { received = data; });
+    bus.subscribe('greet', (data) => { received = data; });
 
     bus.emit('greet', 'hello');
 
@@ -12,53 +12,61 @@ describe('MockEventBus', () => {
     expect(bus.emit.calls).toEqual([['greet', 'hello']]);
   });
 
-  it('on() is a trackable mock', () => {
+  it('subscribe() is a trackable mock', () => {
     const bus = new MockEventBus();
     const handler = () => {};
-    bus.on('greet', handler);
+    bus.subscribe('greet', handler);
 
-    expect(bus.on).toHaveBeenCalled();
-    expect(bus.on).toHaveBeenCalledWith('greet', handler);
+    expect(bus.subscribe).toHaveBeenCalledWith('greet', handler);
   });
 
-  it('off() removes a previously registered handler', () => {
+  it('once() callbacks run for the first emit only', () => {
     const bus = new MockEventBus();
     let callCount = 0;
-    const handler = () => { callCount++; };
-    bus.on('greet', handler);
-    bus.off('greet', handler);
+    bus.once('greet', () => { callCount++; });
 
-    bus.emit('greet', 'hello');
+    bus.emit('greet');
+    bus.emit('greet');
 
-    expect(callCount).toBe(0);
+    expect(callCount).toBe(1);
   });
 
-  it('subscribe() is a bare mock and does not actually register a handler', () => {
+  it('off(event, callback) removes that callback only', () => {
     const bus = new MockEventBus();
-    let called = false;
-    const handler = () => { called = true; };
+    let removed = 0;
+    let kept = 0;
+    const handler = () => { removed++; };
     bus.subscribe('greet', handler);
+    bus.subscribe('greet', () => { kept++; });
+    bus.off('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);
+    expect(removed).toBe(0);
+    expect(kept).toBe(1);
+  });
+
+  it('off(event) removes every callback for that event', () => {
+    const bus = new MockEventBus();
+    let callCount = 0;
+    bus.subscribe('greet', () => { callCount++; });
+    bus.off('greet');
+
+    bus.emit('greet');
+
+    expect(callCount).toBe(0);
   });
 
   it('reset() clears handlers and call logs', () => {
     const bus = new MockEventBus();
     let callCount = 0;
-    bus.on('greet', () => { callCount++; });
+    bus.subscribe('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.js.hbs

@@ -1,22 +1,19 @@
 import { createMockMethod } from './create-mock-method.js';
 
+const METHODS = ['get', 'post', 'put', 'patch', 'delete', 'addRequestInterceptor', 'addResponseInterceptor', 'onDestroy'];
+
+// Mirrors HttpClient's public API; every method is a bare mock (configure responses
+// with e.g. `client.get.mockReturnValue(Promise.resolve(data))`).
 export class MockHttpClient {
   constructor() {
-    this._defineHttpMethods();
-    this.onDestroy = createMockMethod();
-    this.reset = this.reset.bind(this);
-  }
-
-  _defineHttpMethods() {
-    const methods = ['get', 'post', 'put', 'patch', 'delete'];
-    for (const method of methods) {
+    for (const method of METHODS) {
       this[method] = createMockMethod();
     }
+    this.reset = this.reset.bind(this);
   }
 
   reset() {
-    const methods = ['get', 'post', 'put', 'patch', 'delete', 'onDestroy'];
-    for (const method of methods) {
+    for (const method of METHODS) {
       this[method].mockReset();
     }
   }

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

@@ -11,16 +11,28 @@ describe('MockHttpClient', () => {
     expect(client.put.calls).toEqual([]);
   });
 
+  it('exposes the interceptor registration methods as mocks', () => {
+    const client = new MockHttpClient();
+    const interceptor = () => {};
+    client.addRequestInterceptor(interceptor);
+    client.addResponseInterceptor(interceptor);
+
+    expect(client.addRequestInterceptor).toHaveBeenCalledWith(interceptor);
+    expect(client.addResponseInterceptor).toHaveBeenCalledWith(interceptor);
+  });
+
   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.addRequestInterceptor(() => {});
 
     client.reset();
 
     expect(client.get.calls).toEqual([]);
     expect(client.delete.calls).toEqual([]);
+    expect(client.addRequestInterceptor.calls).toEqual([]);
     expect(client.get()).toBe(undefined);
   });
 });

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

@@ -1,5 +1,7 @@
 import { createMockMethod } from './create-mock-method.js';
 
+// Mirrors I18n's public API with in-memory translations (seed them with
+// setTranslations()/setDefaultTranslations()); no fetch, no localStorage.
 export class MockI18n {
   constructor(defaultLang = 'en', supportedLangs = ['en']) {
     this._DEFAULT_LANGUAGE = defaultLang;
@@ -7,39 +9,41 @@ export class MockI18n {
     this._translations = {};
     this._defaultTranslations = {};
     this._currentLanguage = defaultLang;
+    this._languageListeners = [];
 
     this.loadTranslations = createMockMethod(async (lang) => {
       this._currentLanguage = lang;
     });
 
-    this.translate = createMockMethod((key, params) => {
-      const value = this._translations[key] || this._defaultTranslations[key] || key;
-      if (!params) return value;
-      return Object.entries(params).reduce(
-        (acc, [k, v]) => acc.replace(`{${k}}`, v),
-        value
-      );
+    this.setCurrentLanguage = createMockMethod(async (lang) => {
+      await this.loadTranslations(lang);
+      this._languageListeners.forEach((callback) => callback({ lang }));
     });
 
-    this.initTranslations = createMockMethod(async () => {
-      const lang = this._LANGUAGES.includes('browser') ? 'browser' : this._DEFAULT_LANGUAGE;
-      await this.loadTranslations(lang);
+    // Returns the unsubscribe function, like I18n.onLanguageChange.
+    this.onLanguageChange = createMockMethod((callback) => {
+      this._languageListeners.push(callback);
+      return () => {
+        this._languageListeners = this._languageListeners.filter((listener) => listener !== callback);
+      };
     });
 
-    this.resetTranslations = createMockMethod(() => {
-      this._translations = {};
-      this._defaultTranslations = {};
-      this._currentLanguage = this._DEFAULT_LANGUAGE;
+    // Same lookup as I18n.translate: nested dot keys, default-language fallback,
+    // then the given textContent, then the key itself.
+    this.translate = createMockMethod((key, textContent) => {
+      return this._lookup(key) || textContent || key;
     });
 
-    this.getBrowserLanguage = createMockMethod(() => 'en');
+    this.getTranslationObject = createMockMethod((key) => this._lookup(key) || null);
 
-    this.loadDefaultTranslations = createMockMethod(async () => {
-      this._defaultTranslations = { 'fallback.key': 'Fallback Value' };
+    this.initTranslations = createMockMethod(async () => {
+      await this.loadTranslations(this._DEFAULT_LANGUAGE);
     });
 
-    this.getNestedValue = createMockMethod((obj, keys) => {
-      return keys.reduce((acc, key) => acc?.[key], obj);
+    this.resetTranslations = createMockMethod(() => {
+      this._translations = {};
+      this._defaultTranslations = {};
+      this._currentLanguage = this._DEFAULT_LANGUAGE;
     });
 
     this.onDestroy = createMockMethod(() => {
@@ -51,6 +55,26 @@ export class MockI18n {
     return this._currentLanguage;
   }
 
+  get defaultLanguage() {
+    return this._DEFAULT_LANGUAGE;
+  }
+
+  get languages() {
+    return this._LANGUAGES;
+  }
+
+  get localStorageKey() {
+    return 'nutin-fav-lang';
+  }
+
+  _lookup(key) {
+    const keys = key.split('.');
+    const read = (obj) => keys.reduce((acc, k) => acc?.[k], obj);
+    let value = read(this._translations);
+    if (!value && this._currentLanguage !== this._DEFAULT_LANGUAGE) value = read(this._defaultTranslations);
+    return value;
+  }
+
   setTranslations(translations) {
     this._translations = translations;
   }
@@ -61,16 +85,17 @@ export class MockI18n {
 
   reset() {
     this.loadTranslations.mockReset();
+    this.setCurrentLanguage.mockReset();
+    this.onLanguageChange.mockReset();
     this.translate.mockReset();
+    this.getTranslationObject.mockReset();
     this.initTranslations.mockReset();
     this.resetTranslations.mockReset();
-    this.getBrowserLanguage.mockReset();
-    this.loadDefaultTranslations.mockReset();
-    this.getNestedValue.mockReset();
     this.onDestroy.mockReset();
 
     this._translations = {};
     this._defaultTranslations = {};
     this._currentLanguage = this._DEFAULT_LANGUAGE;
+    this._languageListeners = [];
   }
 }

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

@@ -1,57 +1,78 @@
 import { MockI18n } from './mock-i18n.js';
 
 describe('MockI18n', () => {
-  it('exposes the constructor defaults via currentLanguage', () => {
+  it('exposes the constructor defaults via the language getters', () => {
     const i18n = new MockI18n('fr', ['en', 'fr']);
+
     expect(i18n.currentLanguage).toBe('fr');
+    expect(i18n.defaultLanguage).toBe('fr');
+    expect(i18n.languages).toEqual(['en', 'fr']);
   });
 
-  it('translate/getBrowserLanguage run their built-in default implementation without needing .mockImplementation', () => {
+  it('translate() falls back to textContent, then to the key itself', () => {
     const i18n = new MockI18n();
 
-    // No translations set — translate() falls back to returning the key itself.
+    expect(i18n.translate('some.key', 'Fallback text')).toBe('Fallback text');
     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']);
+  it('translate() resolves nested dot keys from setTranslations()', () => {
+    const i18n = new MockI18n();
+    i18n.setTranslations({ home: { title: 'Home' } });
 
+    expect(i18n.translate('home.title')).toBe('Home');
+  });
+
+  it('translate() falls back to the default-language translations off the default language', async () => {
+    const i18n = new MockI18n('en', ['en', 'fr']);
+    i18n.setDefaultTranslations({ greeting: 'Hello' });
     await i18n.loadTranslations('fr');
-    expect(i18n.currentLanguage).toBe('fr');
+
+    expect(i18n.translate('greeting')).toBe('Hello');
   });
 
-  it('translate is still trackable as a mock alongside its default implementation', () => {
+  it('getTranslationObject() returns the nested value, or null', () => {
     const i18n = new MockI18n();
-    i18n.translate('some.key');
+    i18n.setTranslations({ nav: { home: 'Home', about: 'About' } });
 
-    expect(i18n.translate).toHaveBeenCalledWith('some.key');
+    expect(i18n.getTranslationObject('nav')).toEqual({ home: 'Home', about: 'About' });
+    expect(i18n.getTranslationObject('missing')).toBe(null);
   });
 
-  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);
-    });
+  it('setCurrentLanguage() updates currentLanguage and notifies onLanguageChange() callbacks', async () => {
+    const i18n = new MockI18n('en', ['en', 'fr']);
+    let payload;
+    i18n.onLanguageChange((data) => { payload = data; });
 
-    expect(i18n.translate('greeting', { name: 'Ada' })).toBe('Hello Ada');
+    await i18n.setCurrentLanguage('fr');
+
+    expect(i18n.currentLanguage).toBe('fr');
+    expect(payload).toEqual({ lang: 'fr' });
+    expect(i18n.setCurrentLanguage).toHaveBeenCalledWith('fr');
+  });
+
+  it('onLanguageChange() returns a function that stops further notifications', async () => {
+    const i18n = new MockI18n('en', ['en', 'fr']);
+    let calls = 0;
+    const unsubscribe = i18n.onLanguageChange(() => { calls++; });
+    unsubscribe();
+
+    await i18n.setCurrentLanguage('fr');
+
+    expect(calls).toBe(0);
   });
 
-  it('setTranslations/setDefaultTranslations seed real, readable state', () => {
+  it('translate is still trackable as a mock alongside its default implementation', () => {
     const i18n = new MockI18n();
-    i18n.setTranslations({ a: '1' });
-    i18n.setDefaultTranslations({ b: '2' });
+    i18n.translate('some.key');
 
-    expect(i18n._translations).toEqual({ a: '1' });
-    expect(i18n._defaultTranslations).toEqual({ b: '2' });
+    expect(i18n.translate).toHaveBeenCalledWith('some.key');
   });
 
-  it('reset() restores the constructor default language and clears translations', () => {
-    const i18n = new MockI18n('en');
+  it('reset() restores the constructor default language and clears translations', async () => {
+    const i18n = new MockI18n('en', ['en', 'fr']);
     i18n.setTranslations({ a: '1' });
+    await i18n.setCurrentLanguage('fr');
 
     i18n.reset();
 

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

@@ -1,23 +1,31 @@
 import { createMockMethod } from './create-mock-method.js';
 
+// Mirrors Router's public API. Route params are seeded with setParams() and read back
+// through the real getCurrentParams()/getParam() shapes.
 export class MockRouter {
   constructor(routes = {}) {
     this.routes = routes;
-    this._currentView = null;
+    this._currentParams = {};
 
-    this.navigate = createMockMethod();
-    this.handlePopState = createMockMethod();
-    this.handleNotFound = createMockMethod();
-    this.handleGuards = createMockMethod();
-    this.initializeEventListeners = createMockMethod();
+    this.navigate = createMockMethod(async () => {});
+    this.reload = createMockMethod(async () => {});
+    this.getCurrentParams = createMockMethod(() => ({ ...this._currentParams }));
+    this.getParam = createMockMethod((key) => this._currentParams[key]);
+    this.removeEventListeners = createMockMethod();
+    this.onDestroy = createMockMethod();
+  }
+
+  setParams(params) {
+    this._currentParams = { ...params };
   }
 
   reset() {
     this.navigate.mockReset();
-    this.handlePopState.mockReset();
-    this.handleNotFound.mockReset();
-    this.handleGuards.mockReset();
-    this.initializeEventListeners.mockReset();
-    this._currentView = null;
+    this.reload.mockReset();
+    this.getCurrentParams.mockReset();
+    this.getParam.mockReset();
+    this.removeEventListeners.mockReset();
+    this.onDestroy.mockReset();
+    this._currentParams = {};
   }
 }

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

@@ -8,22 +8,39 @@ describe('MockRouter', () => {
     expect(router.routes).toBe(routes);
   });
 
-  it('navigate/handlePopState/handleNotFound/handleGuards/initializeEventListeners are independent bare mocks', () => {
+  it('navigate/reload are independent trackable mocks', async () => {
     const router = new MockRouter();
-    router.navigate('/about');
+    await router.navigate('/about');
 
     expect(router.navigate.calls).toEqual([['/about']]);
-    expect(router.handlePopState.calls).toEqual([]);
+    expect(router.reload.calls).toEqual([]);
   });
 
-  it('reset() clears every mock method and _currentView', () => {
+  it('getCurrentParams/getParam read the params seeded with setParams()', () => {
     const router = new MockRouter();
-    router.navigate('/about');
-    router._currentView = 'about-view';
+    router.setParams({ id: '42' });
+
+    expect(router.getCurrentParams()).toEqual({ id: '42' });
+    expect(router.getParam('id')).toBe('42');
+    expect(router.getParam('missing')).toBe(undefined);
+  });
+
+  it('getCurrentParams returns a copy', () => {
+    const router = new MockRouter();
+    router.setParams({ id: '42' });
+    router.getCurrentParams().id = 'changed';
+
+    expect(router.getParam('id')).toBe('42');
+  });
+
+  it('reset() clears every mock method and the seeded params', async () => {
+    const router = new MockRouter();
+    await router.navigate('/about');
+    router.setParams({ id: '42' });
 
     router.reset();
 
     expect(router.navigate.calls).toEqual([]);
-    expect(router._currentView).toBe(null);
+    expect(router.getCurrentParams()).toEqual({});
   });
 });

package/templates/base/tools/testin-nutin/runner.js.hbs

@@ -12,7 +12,9 @@ const verboseEnabled = args.includes('--verbose');
 const fileFilters = args.filter(arg => arg !== '--coverage' && arg !== '--verbose');
 
 // Tests import and run the compiled build output (dist/src/)
+{{#unless (eq lang "js")}}
 // and has no sourcemap back to the .ts sources
+{{/unless}}
 const origins = [];
 const coverageDirs = [];
 
@@ -41,10 +43,8 @@ if (fileFilters.length) {
 }
 
 async function loadTestFile(file) {
-  setupJsdom();
   setCurrentTestFile(file);
   await import(file);
-  teardownJsdom();
 }
 
 async function runCoverage(testResults) {
@@ -77,18 +77,27 @@ async function runTests() {
 
   if (coverageEnabled) await startCoverage();
 
+  // One DOM for importing every file (module-level code may use it); each suite
+  // then runs in a fresh one (see runQueuedTests).
+  let loadFailures = 0;
+  setupJsdom();
   for (const file of testFiles) {
     try {
       await loadTestFile(file);
     } catch (error) {
+      loadFailures++;
       print.boldError(`✗ ${file} failed to load:`);
       print.grayError(error.stack);
     }
   }
+  teardownJsdom();
 
   const testResults = await runQueuedTests();
 
-  if (testResults.failed > 0) process.exitCode = 1;
+  if (loadFailures > 0) {
+    print.boldError(`✗ ${loadFailures} test file(s) failed to load — see errors above.\n`);
+  }
+  if (testResults.failed > 0 || loadFailures > 0) process.exitCode = 1;
 
   if (coverageEnabled) await runCoverage(testResults);
 }