@tolgee/core 4.9.2 → 4.9.3-rc.d287ae9.0

package/src/__test/client.test.ts

@@ -0,0 +1,48 @@
+import { Tolgee } from '../index';
+
+describe('using tolgee as client', () => {
+  it('fetch data without running', async () => {
+    const promiseEnTest = jest.fn(() => Promise.resolve({ test: 'Test' }));
+    const promiseEnCommon = jest.fn(() =>
+      Promise.resolve({ cancel: 'Cancel' })
+    );
+    const promiseEsTest = jest.fn(() => Promise.resolve({ test: 'Testa' }));
+    const promiseEsCommon = jest.fn(() =>
+      Promise.resolve({ cancel: 'Cancellar' })
+    );
+
+    const tolgee = Tolgee({
+      language: 'en',
+      ns: ['common'],
+      staticData: {
+        'en:common': promiseEnCommon,
+        'en:test': promiseEnTest,
+        'es:common': promiseEsCommon,
+        'es:test': promiseEsTest,
+      },
+    });
+
+    const enTest = await tolgee.loadRecord({
+      language: 'en',
+      namespace: 'test',
+    });
+    expect(promiseEnTest).toBeCalledTimes(1);
+    expect(promiseEnCommon).not.toBeCalled();
+    expect(enTest).toEqual(new Map([['test', 'Test']]));
+
+    const enCommon = await tolgee.loadRecord({
+      language: 'en',
+      namespace: 'common',
+    });
+    expect(promiseEnCommon).toBeCalledTimes(1);
+    expect(enCommon).toEqual(new Map([['cancel', 'Cancel']]));
+
+    const esTest = await tolgee.loadRecord({
+      language: 'es',
+      namespace: 'test',
+    });
+    expect(promiseEsTest).toBeCalledTimes(1);
+    expect(promiseEsCommon).not.toBeCalled();
+    expect(esTest).toEqual(new Map([['test', 'Testa']]));
+  });
+});

package/src/__test/events.test.ts

@@ -0,0 +1,33 @@
+import { Tolgee } from '../index';
+
+describe('events', () => {
+  it('emits language change event', async () => {
+    const tolgee = Tolgee({ language: 'en' });
+    const handler = jest.fn((lang) => {});
+    tolgee.on('language', handler);
+    await tolgee.changeLanguage('es');
+    expect(handler).toHaveBeenCalledWith({ value: 'es' });
+  });
+
+  it('correctly emits translation change listeners', async () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: {
+        en: { hello: 'World', language: 'English' },
+        es: { hello: 'Mundo', language: 'Spanish' },
+      },
+    });
+    const helloHandler = jest.fn((data) => {});
+    const languageHandler = jest.fn((data) => {});
+
+    tolgee.onKeyUpdate(helloHandler).subscribeKey({ key: 'hello' });
+    tolgee.onKeyUpdate(languageHandler).subscribeKey({ key: 'language' });
+
+    tolgee.changeTranslation({ language: 'es' }, 'hello', 'Světe');
+    tolgee.changeLanguage('es');
+
+    await Promise.resolve();
+    expect(helloHandler).toHaveBeenCalledTimes(1);
+    expect(languageHandler).toHaveBeenCalledTimes(1);
+  });
+});

package/src/__test/initialization.test.ts

@@ -0,0 +1,85 @@
+import { Tolgee } from '../index';
+
+describe('initialization behavior', () => {
+  it("change in state before running won't trigger fetch", async () => {
+    const promiseEnTest = jest.fn(() => Promise.resolve({ test: 'Test' }));
+    const promiseEnCommon = jest.fn(() =>
+      Promise.resolve({ cancel: 'Cancel' })
+    );
+    const promiseEsTest = jest.fn(() => Promise.resolve({ test: 'Testa' }));
+    const promiseEsCommon = jest.fn(() =>
+      Promise.resolve({ cancel: 'Cancellar' })
+    );
+
+    const tolgee = Tolgee({
+      language: 'en',
+      ns: ['common'],
+      staticData: {
+        'en:common': promiseEnCommon,
+        'en:test': promiseEnTest,
+        'es:common': promiseEsCommon,
+        'es:test': promiseEsTest,
+      },
+    });
+    const onInitialLoad = jest.fn();
+    const onRunningChange = jest.fn();
+    tolgee.on('initialLoad', onInitialLoad);
+    tolgee.on('running', onRunningChange);
+
+    await tolgee.changeLanguage('es');
+    await tolgee.addActiveNs('test');
+    expect(promiseEsCommon).not.toBeCalled();
+    expect(promiseEnCommon).not.toBeCalled();
+    expect(promiseEsTest).not.toBeCalled();
+    expect(promiseEnTest).not.toBeCalled();
+    expect(tolgee.isLoaded()).toBeFalsy();
+
+    await tolgee.run();
+    expect(promiseEsCommon).toBeCalled();
+    expect(promiseEnCommon).not.toBeCalled();
+    expect(promiseEsTest).toBeCalled();
+    expect(promiseEnTest).not.toBeCalled();
+    expect(tolgee.isLoaded()).toBeTruthy();
+
+    tolgee.stop();
+
+    expect(onInitialLoad).toBeCalledTimes(1);
+    expect(onRunningChange).toBeCalledTimes(2);
+  });
+
+  it("won't start loading when nothing to load", async () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: {
+        en: { test: 'Test' },
+      },
+    });
+    const onFetchingHandler = jest.fn(() => {});
+    const onLoadingHandler = jest.fn(() => {});
+
+    tolgee.on('fetching', onFetchingHandler);
+    tolgee.on('loading', onLoadingHandler);
+
+    const runPromise = tolgee.run();
+    expect(tolgee.isLoading()).toBeFalsy();
+    expect(tolgee.isFetching()).toBeFalsy();
+
+    await runPromise;
+    expect(tolgee.isLoading()).toBeFalsy();
+    expect(tolgee.isFetching()).toBeFalsy();
+    expect(onFetchingHandler).not.toBeCalled();
+    expect(onLoadingHandler).not.toBeCalled();
+  });
+
+  it('emits keyUpdate on initialLoad', async () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: { en: { hello: 'world' } },
+    });
+    const onKeyChange = jest.fn();
+    tolgee.on('keyUpdate', onKeyChange);
+    expect(onKeyChange).toBeCalledTimes(0);
+    await tolgee.run();
+    expect(onKeyChange).toBeCalledTimes(1);
+  });
+});

package/src/__test/jest-setup.ts

@@ -0,0 +1,2 @@
+// In your own jest-setup.js (or any other name)
+import '@testing-library/jest-dom';

package/src/__test/languageDetection.test.ts

@@ -0,0 +1,129 @@
+import { Tolgee, TolgeePlugin, TolgeeInstance } from '../index';
+
+const DetectionPlugin =
+  (value: any): TolgeePlugin =>
+  (tolgee, tools) => {
+    tools.setLanguageDetector({
+      getLanguage() {
+        return value;
+      },
+    });
+    return tolgee;
+  };
+
+describe('language detection plugin', () => {
+  let tolgee: TolgeeInstance;
+
+  afterEach(() => {
+    tolgee.stop();
+  });
+
+  it('will detect language without loading', async () => {
+    tolgee = Tolgee()
+      .use(DetectionPlugin('en'))
+      .init({
+        defaultLanguage: 'es',
+        staticData: {
+          en: { test: 'Test' },
+        },
+      });
+    const onFetchingHandler = jest.fn(() => {});
+    const onLoadingHandler = jest.fn(() => {});
+
+    tolgee.on('fetching', onFetchingHandler);
+    tolgee.on('loading', onLoadingHandler);
+
+    tolgee.run();
+    expect(tolgee.getLanguage()).toEqual('en');
+    expect(tolgee.isLoading()).toBeFalsy();
+    expect(tolgee.isFetching()).toBeFalsy();
+
+    expect(onFetchingHandler).not.toBeCalled();
+    expect(onLoadingHandler).not.toBeCalled();
+  });
+
+  it('will detect language async', async () => {
+    tolgee = Tolgee()
+      .use(DetectionPlugin(Promise.resolve('en')))
+      .init({
+        defaultLanguage: 'es',
+        staticData: {
+          en: { test: 'Test' },
+        },
+      });
+    const onFetchingHandler = jest.fn(() => {});
+    const onLoadingHandler = jest.fn(() => {});
+
+    tolgee.on('fetching', onFetchingHandler);
+    tolgee.on('loading', onLoadingHandler);
+
+    const runPromise = tolgee.run();
+    expect(tolgee.isLoading()).toBeTruthy();
+    expect(tolgee.isFetching()).toBeTruthy();
+
+    await runPromise;
+    expect(tolgee.isLoading()).toBeFalsy();
+    expect(tolgee.isFetching()).toBeFalsy();
+    expect(onFetchingHandler).toBeCalledTimes(2);
+    expect(onLoadingHandler).toBeCalledTimes(2);
+  });
+
+  it('will fallback correctly', async () => {
+    tolgee = Tolgee()
+      .use(DetectionPlugin(Promise.resolve(undefined)))
+      .init({
+        defaultLanguage: 'es',
+        staticData: {
+          en: { test: 'Test' },
+        },
+      });
+    const runPromise = tolgee.run();
+    expect(tolgee.getLanguage()).toEqual(undefined);
+
+    await runPromise;
+    expect(tolgee.getLanguage()).toEqual('es');
+  });
+
+  it('will return key before language is loaded', async () => {
+    tolgee = Tolgee()
+      .use(DetectionPlugin(Promise.resolve('en')))
+      .init({
+        defaultLanguage: 'es',
+        staticData: {
+          en: { test: 'Test' },
+        },
+      });
+
+    const runPromise = tolgee.run();
+    expect(tolgee.t({ key: 'test' })).toEqual('test');
+
+    await runPromise;
+    expect(tolgee.t({ key: 'test' })).toEqual('Test');
+  });
+
+  it('will throw error when no avaliableLanguages are set', () => {
+    tolgee = Tolgee().use(DetectionPlugin('en')).init({
+      defaultLanguage: 'es',
+    });
+
+    expect(() => tolgee.run()).toThrow();
+  });
+
+  it('will throw error when no defaultLanguage specified', () => {
+    tolgee = Tolgee()
+      .use(DetectionPlugin('en'))
+      .init({
+        staticData: {
+          en: { test: 'Test' },
+        },
+      });
+
+    expect(() => tolgee.run()).toThrow(/'defaultLanguage'/);
+  });
+
+  it('will throw error when no available languages specified', () => {
+    tolgee = Tolgee().use(DetectionPlugin('en')).init({});
+
+    expect(() => tolgee.run()).toThrow(/'availableLanguages'/);
+  });
+});

package/src/__test/languageStorage.test.ts

@@ -0,0 +1,145 @@
+import { Tolgee, TolgeePlugin, TolgeeInstance } from '../index';
+
+describe('language storage plugin', () => {
+  let tolgee: TolgeeInstance;
+  let storedValue: string | undefined;
+  const StoragePlugin =
+    (value: any): TolgeePlugin =>
+    (tolgee, tools) => {
+      tools.setLanguageStorage({
+        getLanguage() {
+          return value;
+        },
+        setLanguage(language: string) {
+          storedValue = language;
+        },
+      });
+      return tolgee;
+    };
+
+  afterEach(() => {
+    tolgee.stop();
+  });
+
+  it('will restore language without loading', async () => {
+    tolgee = Tolgee()
+      .use(StoragePlugin('en'))
+      .init({
+        defaultLanguage: 'es',
+        staticData: {
+          en: { test: 'Test' },
+        },
+      });
+    const onFetchingHandler = jest.fn(() => {});
+    const onLoadingHandler = jest.fn(() => {});
+
+    tolgee.on('fetching', onFetchingHandler);
+    tolgee.on('loading', onLoadingHandler);
+
+    tolgee.run();
+    expect(tolgee.getLanguage()).toEqual('en');
+    expect(tolgee.isLoading()).toBeFalsy();
+    expect(tolgee.isFetching()).toBeFalsy();
+
+    expect(onFetchingHandler).not.toBeCalled();
+    expect(onLoadingHandler).not.toBeCalled();
+  });
+
+  it('will restore language async', async () => {
+    tolgee = Tolgee()
+      .use(StoragePlugin(Promise.resolve('en')))
+      .init({
+        defaultLanguage: 'es',
+        staticData: {
+          en: { test: 'Test' },
+        },
+      });
+    const onFetchingHandler = jest.fn(() => {});
+    const onLoadingHandler = jest.fn(() => {});
+
+    tolgee.on('fetching', onFetchingHandler);
+    tolgee.on('loading', onLoadingHandler);
+
+    const runPromise = tolgee.run();
+    expect(tolgee.isLoading()).toBeTruthy();
+    expect(tolgee.isFetching()).toBeTruthy();
+
+    await runPromise;
+    expect(tolgee.isLoading()).toBeFalsy();
+    expect(tolgee.isFetching()).toBeFalsy();
+    expect(onFetchingHandler).toBeCalledTimes(2);
+    expect(onLoadingHandler).toBeCalledTimes(2);
+  });
+
+  it('will fallback correctly', async () => {
+    tolgee = Tolgee()
+      .use(StoragePlugin(Promise.resolve(undefined)))
+      .init({
+        defaultLanguage: 'es',
+        staticData: {
+          en: { test: 'Test' },
+        },
+      });
+    const runPromise = tolgee.run();
+    expect(tolgee.getLanguage()).toEqual(undefined);
+
+    await runPromise;
+    expect(tolgee.getLanguage()).toEqual('es');
+  });
+
+  it('will return key before language is loaded', async () => {
+    tolgee = Tolgee()
+      .use(StoragePlugin(Promise.resolve('en')))
+      .init({
+        defaultLanguage: 'es',
+        staticData: {
+          en: { test: 'Test' },
+        },
+      });
+
+    const runPromise = tolgee.run();
+    expect(tolgee.t({ key: 'test' })).toEqual('test');
+
+    await runPromise;
+    expect(tolgee.t({ key: 'test' })).toEqual('Test');
+  });
+
+  it('will store language value on language change', async () => {
+    tolgee = Tolgee()
+      .use(StoragePlugin(Promise.resolve('en')))
+      .init({
+        defaultLanguage: 'es',
+        staticData: {
+          en: { test: 'Test' },
+          es: { test: 'Testa' },
+        },
+      });
+
+    tolgee.run();
+
+    await tolgee.changeLanguage('es');
+    expect(storedValue).toEqual('es');
+  });
+
+  it('will ignore invalid values', () => {
+    tolgee = Tolgee()
+      .use(StoragePlugin('eq'))
+      .init({
+        defaultLanguage: 'es',
+        staticData: {
+          en: { test: 'Test' },
+          es: { test: 'Testa' },
+        },
+      });
+    tolgee.run();
+    expect(tolgee.getLanguage()).toEqual('es');
+  });
+
+  it('will return invalid value if no available languages', () => {
+    tolgee = Tolgee().use(StoragePlugin('eq')).init({
+      defaultLanguage: 'es',
+    });
+    tolgee.run();
+    expect(tolgee.getLanguage()).toEqual('eq');
+  });
+});

package/src/__test/languages.test.ts

@@ -0,0 +1,112 @@
+import { Tolgee, TreeTranslationsData } from '../index';
+import { resolvablePromise } from './testTools';
+
+describe('language changes', () => {
+  it('changes language', async () => {
+    const tolgee = Tolgee({ language: 'en' });
+    expect(tolgee.getLanguage()).toEqual('en');
+    await tolgee.changeLanguage('es');
+    expect(tolgee.getLanguage()).toEqual('es');
+  });
+
+  it('returns correct translation', async () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: { en: { hello: 'World' }, es: { hello: 'Mundo' } },
+    });
+    expect(tolgee.t({ key: 'hello' })).toEqual('World');
+    await tolgee.changeLanguage('es');
+    expect(tolgee.t({ key: 'hello' })).toEqual('Mundo');
+    await tolgee.changeLanguage('cs');
+    expect(tolgee.t({ key: 'hello' })).toEqual('hello');
+  });
+
+  it('fetches language data correctly', async () => {
+    const [promiseEn, resolveEn] = resolvablePromise<TreeTranslationsData>();
+    const [promiseEs, resolveEs] = resolvablePromise<TreeTranslationsData>();
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: {
+        en: () => promiseEn,
+        es: () => promiseEs,
+      },
+    });
+    const runPromise = tolgee.run();
+    expect(tolgee.t({ key: 'test' })).toEqual('test');
+    expect(tolgee.getPendingLanguage()).toEqual('en');
+    resolveEn({ test: 'Test' });
+    await runPromise;
+    expect(tolgee.t({ key: 'test' })).toEqual('Test');
+
+    const langChangeEsPromise = tolgee.changeLanguage('es');
+    expect(tolgee.getPendingLanguage()).toEqual('es');
+    resolveEs({ test: 'Testa' });
+    await langChangeEsPromise;
+    expect(tolgee.t({ key: 'test' })).toEqual('Testa');
+  });
+
+  it('fetches fallback', async () => {
+    const [promiseEn, resolveEn] = resolvablePromise<TreeTranslationsData>();
+    const [promiseEs, resolveEs] = resolvablePromise<TreeTranslationsData>();
+    const [promiseEnGb, resolveEnGb] =
+      resolvablePromise<TreeTranslationsData>();
+    const [promiseEnIn, resolveEnIn] =
+      resolvablePromise<TreeTranslationsData>();
+
+    const tolgee = Tolgee({
+      language: 'es',
+      staticData: {
+        en: () => promiseEn,
+        es: () => promiseEs,
+        'en-GB': () => promiseEnGb,
+        'en-IN': () => promiseEnIn,
+      },
+      fallbackLanguage: {
+        es: 'en',
+        'en-GB': 'en',
+        'en-IN': ['en-GB', 'en'],
+      },
+    });
+
+    resolveEn({ color: 'Color', egg: 'Egg' });
+    resolveEs({ color: 'Pintar' });
+    await tolgee.run();
+
+    expect(tolgee.t({ key: 'color' })).toEqual('Pintar');
+    expect(tolgee.t({ key: 'egg' })).toEqual('Egg');
+
+    resolveEnGb({ color: 'Colour', india: 'India' });
+    resolveEnIn({ india: 'Blabla' });
+
+    await tolgee.changeLanguage('en-IN');
+    expect(tolgee.t({ key: 'color' })).toEqual('Colour');
+    expect(tolgee.t({ key: 'egg' })).toEqual('Egg');
+    expect(tolgee.t({ key: 'india' })).toEqual('Blabla');
+
+    await tolgee.changeLanguage('en-GB');
+    expect(tolgee.t({ key: 'color' })).toEqual('Colour');
+    expect(tolgee.t({ key: 'egg' })).toEqual('Egg');
+    expect(tolgee.t({ key: 'india' })).toEqual('India');
+
+    await tolgee.changeLanguage('en');
+    expect(tolgee.t({ key: 'color' })).toEqual('Color');
+    expect(tolgee.t({ key: 'egg' })).toEqual('Egg');
+    expect(tolgee.t({ key: 'india' })).toEqual('india');
+  });
+
+  it('will fallback to default value', () => {
+    const tolgee = Tolgee({
+      defaultLanguage: 'en',
+    });
+
+    expect(tolgee.getLanguage()).toEqual(undefined);
+    tolgee.run();
+    expect(tolgee.getLanguage()).toEqual('en');
+  });
+
+  it('will throw error when no language specified', () => {
+    const tolgee = Tolgee({});
+
+    expect(() => tolgee.run()).toThrow(/'language'/);
+  });
+});

package/src/__test/loading.test.ts

@@ -0,0 +1,39 @@
+import { Tolgee, TreeTranslationsData } from '../index';
+import { resolvablePromise } from './testTools';
+
+describe('loading', () => {
+  it('isLoading & isFetching', async () => {
+    const [promiseEn, resolveEn] = resolvablePromise<TreeTranslationsData>();
+    const [promiseEs, resolveEs] = resolvablePromise<TreeTranslationsData>();
+    const onLoadHandler = jest.fn(() => {});
+    const onFetchingHandler = jest.fn(() => {});
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: {
+        en: () => promiseEn,
+        es: () => promiseEs,
+      },
+    });
+    tolgee.on('initialLoad', onLoadHandler);
+    tolgee.on('fetching', onFetchingHandler);
+
+    const runPromise = tolgee.run();
+    expect(tolgee.isLoading()).toBeTruthy();
+    expect(tolgee.isFetching()).toBeTruthy();
+    resolveEn({});
+    await runPromise;
+    expect(tolgee.isLoading()).toBeFalsy();
+    expect(tolgee.isFetching()).toBeFalsy();
+    expect(onLoadHandler).toBeCalledTimes(1);
+    expect(onFetchingHandler).toBeCalledTimes(2);
+
+    const changeLanguagePromise = tolgee.changeLanguage('es');
+    expect(tolgee.isLoading()).toBeFalsy();
+    expect(tolgee.isFetching()).toBeTruthy();
+    resolveEs({});
+    await changeLanguagePromise;
+    expect(onLoadHandler).toBeCalledTimes(1);
+    expect(onFetchingHandler).toBeCalledTimes(4);
+    expect(tolgee.isFetching()).toBeFalsy();
+  });
+});

package/src/__test/namespaces.test.ts

@@ -0,0 +1,99 @@
+import { Tolgee } from '../index';
+
+const tolgeeWithNamespaces = () => {
+  const promiseEnTest = jest.fn(() => Promise.resolve({ test: 'Test' }));
+  const promiseEnCommon = jest.fn(() => Promise.resolve({ cancel: 'Cancel' }));
+  const promiseEsTest = jest.fn(() => Promise.resolve({ test: 'Testa' }));
+  const promiseEsCommon = jest.fn(() =>
+    Promise.resolve({ cancel: 'Cancellar' })
+  );
+
+  return Tolgee({
+    language: 'en',
+    ns: ['common'],
+    staticData: {
+      'en:common': promiseEnCommon,
+      'en:test': promiseEnTest,
+      'es:common': promiseEsCommon,
+      'es:test': promiseEsTest,
+    },
+  });
+};
+
+describe('language changes', () => {
+  it('returns correct translation from namespace', () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: {
+        en: { hello: 'World' },
+        'en:common': { test: 'Test' },
+      },
+    });
+    expect(tolgee.t({ key: 'hello' })).toEqual('World');
+    expect(tolgee.t({ key: 'test' })).toEqual('test');
+    expect(tolgee.t({ key: 'test', ns: 'common' })).toEqual('Test');
+  });
+
+  it('uses defaultNs', async () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      defaultNs: 'common',
+      staticData: {
+        'en:common': { test: 'Test' },
+        'es:common': { test: 'Testa' },
+      },
+    });
+    await tolgee.run();
+
+    expect(tolgee.t({ key: 'test' })).toEqual('Test');
+    await tolgee.changeLanguage('es');
+    expect(tolgee.t({ key: 'test' })).toEqual('Testa');
+  });
+
+  it('active namespaces', async () => {
+    const tolgee = tolgeeWithNamespaces();
+    await tolgee.run();
+
+    expect(tolgee.t({ key: 'cancel', ns: 'common' })).toEqual('Cancel');
+    expect(tolgee.t({ key: 'test', ns: 'test' })).toEqual('test');
+
+    await tolgee.changeLanguage('es');
+
+    expect(tolgee.t({ key: 'cancel', ns: 'common' })).toEqual('Cancellar');
+    expect(tolgee.t({ key: 'test', ns: 'test' })).toEqual('test');
+
+    await tolgee.changeLanguage('en');
+    await tolgee.addActiveNs('test');
+
+    expect(tolgee.t({ key: 'cancel', ns: 'common' })).toEqual('Cancel');
+    expect(tolgee.t({ key: 'test', ns: 'test' })).toEqual('Test');
+
+    await tolgee.changeLanguage('es');
+
+    expect(tolgee.t({ key: 'cancel', ns: 'common' })).toEqual('Cancellar');
+    expect(tolgee.t({ key: 'test', ns: 'test' })).toEqual('Testa');
+  });
+
+  it('removing active namespaces', async () => {
+    const tolgee = tolgeeWithNamespaces();
+    await tolgee.run();
+    const handler = jest.fn();
+    tolgee.on('cache', handler);
+
+    expect(tolgee.t({ key: 'cancel', ns: 'common' })).toEqual('Cancel');
+    expect(tolgee.t({ key: 'test', ns: 'test' })).toEqual('test');
+
+    await tolgee.addActiveNs('test');
+    expect(handler).toBeCalledTimes(1);
+
+    expect(tolgee.t({ key: 'cancel', ns: 'common' })).toEqual('Cancel');
+    expect(tolgee.t({ key: 'test', ns: 'test' })).toEqual('Test');
+
+    tolgee.removeActiveNs('test');
+    await tolgee.changeLanguage('es');
+    expect(handler).toBeCalledTimes(2);
+
+    expect(tolgee.t({ key: 'cancel', ns: 'common' })).toEqual('Cancellar');
+    expect(tolgee.t({ key: 'test', ns: 'test' })).toEqual('test');
+  });
+});