@nutin/cli 2.1.0 → 3.0.0

package/templates/base/tools/generator/handle-file.test.js.hbs

@@ -1,22 +1,19 @@
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
-import { generateFile, appendToIndex } from './handle-file.js';
+import { generateFile } from './handle-file.js';
 
 describe('handle-file', () => {
   let tmpDir;
-  let originalCwd;
   let exitSpy;
 
   beforeEach(() => {
     tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nutin-handle-file-'));
-    originalCwd = process.cwd();
     exitSpy = spyOn(process, 'exit').andCallFake(() => {});
   });
 
   afterEach(() => {
     exitSpy.restore();
-    process.chdir(originalCwd);
     fs.rmSync(tmpDir, { recursive: true, force: true });
   });
 
@@ -26,7 +23,7 @@ describe('handle-file', () => {
 
     generateFile({ name, targetPath, templateFn: (n) => `content for ${n.kebab}`, suffix: 'component' });
 
-    const filePath = path.join(targetPath, 'widget.component.ts');
+    const filePath = path.join(targetPath, 'widget.component.{{#if (eq lang "js")}}js{{else}}ts{{/if}}');
     expect(fs.existsSync(filePath)).toBeTruthy();
     expect(fs.readFileSync(filePath, 'utf8')).toBe('content for widget');
     expect(exitSpy.callCount).toBe(0);
@@ -36,9 +33,9 @@ describe('handle-file', () => {
     const targetPath = path.join(tmpDir, 'services', 'widget');
     const name = { kebab: 'widget', pascal: 'Widget', camel: 'widget', capitalized: 'Widget' };
 
-    generateFile({ name, targetPath, templateFn: () => 'x', suffix: 'service', extension: 'js' });
+    generateFile({ name, targetPath, templateFn: () => 'x', suffix: 'service', extension: 'scss' });
 
-    expect(fs.existsSync(path.join(targetPath, 'widget.service.js'))).toBeTruthy();
+    expect(fs.existsSync(path.join(targetPath, 'widget.service.scss'))).toBeTruthy();
   });
 
   it('generateFile calls process.exit(1) instead of overwriting an existing file', () => {
@@ -53,20 +50,4 @@ describe('handle-file', () => {
     expect(exitSpy.callCount).toBe(1);
     expect(exitSpy.lastCall).toEqual([1]);
   });
-
-  it('appendToIndex appends an export line to the barrel three segments up from targetPath', () => {
-    process.chdir(tmpDir);
-    const basePath = path.join('src', 'app', 'components');
-    fs.mkdirSync(basePath, { recursive: true });
-    fs.writeFileSync(path.join(basePath, 'index.ts'), "export * from './existing.js';\n");
-
-    const targetPath = path.join('src', 'app', 'components', 'widget');
-    const name = { kebab: 'widget', pascal: 'Widget', camel: 'widget', capitalized: 'Widget' };
-
-    // appendToIndex prints a "index.ts updated" log via console.info
-    silenceConsole('info', () => appendToIndex({ name, targetPath, suffix: 'component' }));
-
-    const indexContent = fs.readFileSync(path.join(basePath, 'index.ts'), 'utf8');
-    expect(indexContent).toBe("export * from './existing.js';\nexport * from './widget/widget.component.js';\n");
-  });
 });

package/templates/base/tools/generator/templates/component/component.template.js.hbs

@@ -4,12 +4,12 @@ export const componentTemplate = (name, targetPath) => {
   const relToCore = getRelToCore(targetPath);
   const htmlTemplate = '__TEMPLATE_PLACEHOLDER__';
 
-  return `import { Component } from '${relToCore}';
+  return `import { Component, html } from '${relToCore}';
 
-const templateFn = () => \`${htmlTemplate}\`;
+const templateFn = () => html\`${htmlTemplate}\`;
 
 export class ${name.pascal}Component extends Component {
-  constructor(mountTarget: HTMLElement) {
+  constructor({{#if (eq lang "js")}}mountTarget{{else}}mountTarget: HTMLElement{{/if}}) {
     super({templateFn, mountTarget});
   }
 }

package/templates/base/tools/generator/templates/component/component.template.test.js.hbs

@@ -8,12 +8,12 @@ describe('componentTemplate', () => {
     // The generator always leaves the html body as a placeholder — the builder
     // swaps in the .html sibling's content at build time.
     expect(componentTemplate(name, targetPath)).toBe(
-      `import { Component } from '../../../core/index.js';
+      `import { Component, html } from '../../../core/index.js';
 
-const templateFn = () => \`__TEMPLATE_PLACEHOLDER__\`;
+const templateFn = () => html\`__TEMPLATE_PLACEHOLDER__\`;
 
 export class WidgetComponent extends Component {
-  constructor(mountTarget: HTMLElement) {
+  constructor({{#if (eq lang "js")}}mountTarget{{else}}mountTarget: HTMLElement{{/if}}) {
     super({templateFn, mountTarget});
   }
 }

package/templates/base/tools/generator/templates/service/service.template.js.hbs

@@ -5,7 +5,7 @@ export const serviceTemplate = (name, targetPath) => {
 
   return `import { Service } from '${relToCore}';
 
-export class ${name.pascal}Service extends Service<${name.pascal}Service> {  
+export class ${name.pascal}Service extends Service{{#unless (eq lang "js")}}<${name.pascal}Service>{{/unless}} {  
   constructor() {
     super();
   }

package/templates/base/tools/generator/templates/service/service.template.test.js.hbs

@@ -8,7 +8,7 @@ describe('serviceTemplate', () => {
     expect(serviceTemplate(name, targetPath)).toBe(
       `import { Service } from '../../../core/index.js';
 
-export class WidgetService extends Service<WidgetService> {  
+export class WidgetService extends Service{{#unless (eq lang "js")}}<WidgetService>{{/unless}} {  
   constructor() {
     super();
   }

package/templates/base/tools/generator/templates/view/view.template.js.hbs

@@ -4,9 +4,9 @@ export const viewTemplate = (name, targetPath) => {
   const relToCore = getRelToCore(targetPath);
   const htmlTemplate = '__TEMPLATE_PLACEHOLDER__';
 
-  return `import { View } from '${relToCore}';
+  return `import { View, html } from '${relToCore}';
 
-const template = \`${htmlTemplate}\`;
+const template = html\`${htmlTemplate}\`;
 
 export class ${name.pascal}View extends View {
   constructor() {

package/templates/base/tools/generator/templates/view/view.template.test.js.hbs

@@ -8,9 +8,9 @@ describe('viewTemplate', () => {
     // The generator always leaves the html body as a placeholder — the builder
     // swaps in the .html sibling's content at build time.
     expect(viewTemplate(name, targetPath)).toBe(
-      `import { View } from '../../../core/index.js';
+      `import { View, html } from '../../../core/index.js';
 
-const template = \`__TEMPLATE_PLACEHOLDER__\`;
+const template = html\`__TEMPLATE_PLACEHOLDER__\`;
 
 export class WidgetView extends View {
   constructor() {

package/templates/base/tools/testin-nutin/core/coverage/write-uncovered-report.js.hbs

@@ -13,7 +13,7 @@ export async function maybeWriteUncoveredReport(report) {
     return;
   }
 
-  if (!config.testinNutin.coverage.reportUncovered) return;
+  if (!config.testinNutin.coverage?.reportUncovered) return;
 
   try {
     fs.mkdirSync(path.dirname(REPORT_PATH), { recursive: true });

package/templates/base/tools/testin-nutin/core/globals/assertion-lib.js.hbs

@@ -101,12 +101,12 @@ global.expect = (actual) => {
       }
     },
     toBeLessThan(expected) {
-      if (actual > expected) {
+      if (!(actual < expected)) {
         throw new AssertionError(`Expected ${actual} to be less than ${expected}`)
       }
     },
     toBeGreaterThan(expected) {
-      if (actual < expected) {
+      if (!(actual > expected)) {
         throw new AssertionError(`Expected ${actual} to be greater than ${expected}`)
       }
     },

package/templates/base/tools/testin-nutin/core/{tests/assertions.test.js.hbs → globals/assertion-lib.test.js.hbs}

@@ -94,4 +94,10 @@ describe('assertions', () => {
     }
     expect(caught).toBeInstanceOf(TypeError);
   });
+  it('toBeLessThan / toBeGreaterThan are strict comparisons', () => {
+    expect(1).toBeLessThan(2);
+    expect(2).toBeGreaterThan(1);
+    expect(2).not.toBeLessThan(2);
+    expect(2).not.toBeGreaterThan(2);
+  });
 });

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

@@ -23,15 +23,14 @@ export function registerTestGlobals() {
     fn();
   };
 
+  // The suite's hooks object is shared by reference (read when the queue runs), so a hook
+  // registered after some it() calls in the same describe() still applies to them.
   global.it = (name, fn) => {
-    addTest({ 
-      suiteName: currentSuite, 
-      testName: name, 
+    addTest({
+      suiteName: currentSuite,
+      testName: name,
       testFn: fn,
-      beforeEach: currentSuiteHooks.beforeEach,
-      beforeAll: currentSuiteHooks.beforeAll,
-      afterEach: currentSuiteHooks.afterEach,
-      afterAll: currentSuiteHooks.afterAll
+      hooks: currentSuiteHooks,
     });
   };
   global.it.todo = (s) => {

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

@@ -26,3 +26,15 @@ describe('globals beforeEach/All and afterEach/All', () => {
     expect(afterEachCount).toEqual(1);
   });
 })
+
+describe('Hooks registered after it()', () => {
+  let beforeEachCount = 0;
+
+  it('still get the beforeEach declared further down', () => {
+    expect(beforeEachCount).toBe(1);
+  });
+
+  beforeEach(() => {
+    beforeEachCount++;
+  });
+});

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

@@ -39,8 +39,9 @@ export function printStart() {
 
 export function printCoverageReport(report) {
   if (!report.length) {
-    print.warn('No app source files were covered.');
-    return { globalLinesPct: 100, globalFunctionsPct: 100, globalBranchesPct: 100 };
+    // 0, not 100: an empty report must not pass a coverage threshold by default.
+    print.warn('No source files were covered.');
+    return { globalLinesPct: 0, globalFunctionsPct: 0, globalBranchesPct: 0 };
   }
 
   print.boldBlue('\nCoverage Summary');
@@ -77,9 +78,14 @@ export function printCoverageReport(report) {
 
 export function toTsPath(input) {
   return input
-    .split('/')
+    .split(/[\\/]/)
     .slice(1)
+{{#if (eq lang "js")}}
+    .join('/');
+{{else}}
     .join('/')
-    .replace(/\.js$/, '.ts');
+    // Test files stay .test.js in TypeScript projects too.
+    .replace(/(?<!\.test)\.js$/, '.ts');
+{{/if}}
 }
 

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 = [];
   }
 }