@tolgee/core 5.0.0-rc.9be0f0e.0 → 5.0.0

package/src/__test/cache.test.ts

@@ -0,0 +1,190 @@
+/* eslint-disable no-console */
+import { TolgeeCore, TolgeeInstance } from '../TolgeeCore';
+import { TolgeePlugin, TreeTranslationsData } from '../types';
+import { resolvablePromise } from './testTools';
+
+const waitForInitialLoad = (tolgee: TolgeeInstance) =>
+  new Promise<void>((resolve) => {
+    const { unsubscribe } = tolgee.on('initialLoad', () => {
+      unsubscribe();
+      resolve();
+    });
+  });
+
+const DevToolsPlugin =
+  (postfix = ''): TolgeePlugin =>
+  (tolgee, tools) => {
+    tolgee.updateOptions({ apiKey: 'test', apiUrl: 'test' });
+    tools.setDevBackend({
+      getRecord({ language, namespace }) {
+        return Promise.resolve({
+          test: { sub: `${language}.${namespace || 'default'}${postfix}` },
+        });
+      },
+    });
+    return tolgee;
+  };
+
+const DevToolsThrow = (): TolgeePlugin => (tolgee, tools) => {
+  tolgee.updateOptions({ apiKey: 'test', apiUrl: 'test' });
+  tools.setDevBackend({
+    getRecord() {
+      return Promise.reject();
+    },
+  });
+  return tolgee;
+};
+
+describe('cache', () => {
+  let tolgee: TolgeeInstance;
+
+  beforeEach(async () => {
+    tolgee = TolgeeCore().init({
+      language: 'en',
+      staticData: {
+        en: { test: { sub: 'subtestEn' } },
+        cs: { 'test.sub': 'subtestCs' },
+      },
+    });
+  });
+
+  afterEach(() => {
+    tolgee.stop();
+  });
+
+  it('stores initial data correctly', async () => {
+    expect(tolgee.t('test.sub')).toEqual('subtestEn');
+    await tolgee.changeLanguage('cs');
+    expect(tolgee.t('test.sub')).toEqual('subtestCs');
+  });
+
+  it('ignores empty values', async () => {
+    tolgee.addStaticData({
+      en: { sub: { test: 'Test', null: null, undefined: undefined } },
+    });
+    expect(tolgee.t('sub.test')).toEqual('Test');
+    expect(tolgee.t('sub.null')).toEqual('sub.null');
+    expect(tolgee.t('sub.undefined')).toEqual('sub.undefined');
+  });
+
+  it('returns correct data when in dev mode', async () => {
+    expect(tolgee.t('test.sub')).toEqual('subtestEn');
+    tolgee.addPlugin(DevToolsPlugin());
+    await tolgee.run();
+    expect(tolgee.t('test.sub')).toEqual('en.default');
+    const changeLangPromise = tolgee.changeLanguage('cs');
+    expect(tolgee.t('test.sub')).toEqual('en.default');
+    await changeLangPromise;
+    expect(tolgee.t('test.sub')).toEqual('cs.default');
+  });
+
+  it('invalidates the cache when switching to dev', async () => {
+    await tolgee.run();
+    expect(tolgee.t('test.sub')).toEqual('subtestEn');
+    tolgee.addPlugin(DevToolsPlugin());
+    expect(tolgee.t('test.sub')).toEqual('subtestEn');
+
+    await new Promise<void>((resolve) => {
+      const { unsubscribe } = tolgee.on('initialLoad', async () => {
+        expect(tolgee.t('test.sub')).toEqual('en.default');
+        unsubscribe();
+        resolve();
+      });
+    });
+  });
+
+  it('works with switching to different dev backend', async () => {
+    tolgee.addPlugin(DevToolsPlugin());
+    await tolgee.run();
+    expect(tolgee.t('test.sub')).toEqual('en.default');
+    tolgee.addPlugin(DevToolsPlugin('.new'));
+    expect(tolgee.t('test.sub')).toEqual('en.default');
+
+    await waitForInitialLoad(tolgee);
+    expect(tolgee.t('test.sub')).toEqual('en.default.new');
+  });
+
+  it('keeps data when dev backend throws', async () => {
+    console.warn = jest.fn();
+    const keyUpdateHandler = jest.fn();
+    tolgee.on('update', keyUpdateHandler);
+    await tolgee.run();
+    expect(keyUpdateHandler).toBeCalledTimes(1);
+    expect(tolgee.t('test.sub')).toEqual('subtestEn');
+    tolgee.addPlugin(DevToolsThrow());
+    await waitForInitialLoad(tolgee);
+    expect(keyUpdateHandler).toBeCalledTimes(2);
+    expect(tolgee.t('test.sub')).toEqual('subtestEn');
+    expect(console.warn).toBeCalledTimes(1);
+  });
+
+  it('updates initial data correctly', async () => {
+    await tolgee.run();
+    expect(tolgee.t('test.sub')).toEqual('subtestEn');
+    tolgee.addStaticData({ en: { test: { sub: 'newSubtestEn' } } });
+    expect(tolgee.t('test.sub')).toEqual('newSubtestEn');
+  });
+
+  it('ignores new initial data when already in dev mode', async () => {
+    tolgee.addPlugin(DevToolsPlugin());
+    await tolgee.run();
+    expect(tolgee.t('test.sub')).toEqual('en.default');
+    tolgee.addStaticData({ en: { test: { sub: 'newSubtestEn' } } });
+    expect(tolgee.t('test.sub')).toEqual('en.default');
+  });
+
+  it('gets all records', async () => {
+    await tolgee.run();
+    expect(tolgee.getAllRecords().length).toEqual(2);
+  });
+
+  it('fetching works with namespaces', async () => {
+    tolgee.addPlugin(DevToolsPlugin());
+    const runPromise = tolgee.run();
+    expect(tolgee.isFetching()).toBeTruthy();
+    await runPromise;
+    expect(tolgee.t('test.sub', { ns: 'common' })).toEqual('test.sub');
+    const nsPromise = tolgee.addActiveNs('common');
+    expect(tolgee.isFetching()).toBeTruthy();
+    expect(tolgee.isFetching('common')).toBeTruthy();
+    expect(tolgee.isFetching('nonexistant')).toBeFalsy();
+    await nsPromise;
+    expect(tolgee.t('test.sub', { ns: 'common' })).toEqual('en.common');
+    expect(tolgee.isFetching()).toBeFalsy();
+  });
+
+  it('works with namespaces containing colon', async () => {
+    const [promiseEn, resolveEn] = resolvablePromise<TreeTranslationsData>();
+    tolgee.updateOptions({
+      language: 'en',
+      staticData: {
+        'en:common:test': () => promiseEn,
+      },
+    });
+    await tolgee.run();
+    expect(tolgee.t('test.sub', { ns: 'common:test' })).toEqual('test.sub');
+    const nsPromise = tolgee.addActiveNs('common:test');
+    expect(tolgee.isLoading('common:test')).toBeTruthy();
+    resolveEn({ test: { sub: 'Test' } });
+    await nsPromise;
+    expect(tolgee.t('test.sub', { ns: 'common:test' })).toEqual('Test');
+  });
+
+  it("pending requests won't rewrite cache when reinitialized", async () => {
+    const [promiseEn, resolveEn] = resolvablePromise<TreeTranslationsData>();
+    tolgee = TolgeeCore().init({
+      language: 'en',
+      staticData: {
+        en: () => promiseEn,
+      },
+    });
+    tolgee.run();
+    await Promise.resolve();
+    tolgee.addPlugin(DevToolsPlugin());
+    await waitForInitialLoad(tolgee);
+    expect(tolgee.t('test.sub')).toEqual('en.default');
+    resolveEn({ test: { sub: 'Invalid' } });
+    await Promise.resolve();
+    expect(tolgee.t('test.sub')).toEqual('en.default');
+  });
+});

package/src/__test/client.test.ts

@@ -1,4 +1,4 @@
-import { Tolgee } from '../index';
+import { TolgeeCore } from '../index';
 
 describe('using tolgee as client', () => {
   it('fetch data without running', async () => {
@@ -11,7 +11,7 @@ describe('using tolgee as client', () => {
       Promise.resolve({ cancel: 'Cancellar' })
     );
 
-    const tolgee = Tolgee({
+    const tolgee = TolgeeCore().init({
       language: 'en',
       ns: ['common'],
       staticData: {

package/src/__test/events.test.ts

@@ -1,8 +1,8 @@
-import { Tolgee } from '../index';
+import { TolgeeCore } from '../index';
 
 describe('events', () => {
   it('emits language change event', async () => {
-    const tolgee = Tolgee({ language: 'en' });
+    const tolgee = TolgeeCore().init({ language: 'en' });
     const handler = jest.fn((lang) => {});
     tolgee.on('language', handler);
     await tolgee.changeLanguage('es');
@@ -10,18 +10,18 @@ describe('events', () => {
   });
 
   it('correctly emits translation change listeners', async () => {
-    const tolgee = Tolgee({
+    const tolgee = TolgeeCore().init({
       language: 'en',
       staticData: {
         en: { hello: 'World', language: 'English' },
         es: { hello: 'Mundo', language: 'Spanish' },
       },
     });
-    const helloHandler = jest.fn((data) => {});
-    const languageHandler = jest.fn((data) => {});
+    const helloHandler = jest.fn(() => {});
+    const languageHandler = jest.fn(() => {});
 
-    tolgee.onKeyUpdate(helloHandler).subscribeKey({ key: 'hello' });
-    tolgee.onKeyUpdate(languageHandler).subscribeKey({ key: 'language' });
+    tolgee.onNsUpdate(helloHandler);
+    tolgee.onNsUpdate(languageHandler);
 
     tolgee.changeTranslation({ language: 'es' }, 'hello', 'Světe');
     tolgee.changeLanguage('es');
@@ -30,4 +30,29 @@ describe('events', () => {
     expect(helloHandler).toHaveBeenCalledTimes(1);
     expect(languageHandler).toHaveBeenCalledTimes(1);
   });
+
+  it('stop emitting when turned off', async () => {
+    const tolgee = TolgeeCore().init({
+      language: 'en',
+      staticData: {
+        en: { hello: 'World', language: 'English' },
+        es: { hello: 'Mundo', language: 'Spanish' },
+      },
+    });
+    const eventHandler = jest.fn(() => {});
+
+    tolgee.on('language', eventHandler);
+    tolgee.on('pendingLanguage', eventHandler);
+
+    await tolgee.changeLanguage('es');
+    expect(eventHandler).toBeCalledTimes(2);
+
+    tolgee.setEmmiterActive(false);
+    await tolgee.changeLanguage('en');
+    expect(eventHandler).toBeCalledTimes(2);
+
+    tolgee.setEmmiterActive(true);
+    await tolgee.changeLanguage('es');
+    expect(eventHandler).toBeCalledTimes(4);
+  });
 });

package/src/__test/format.simple.test.ts

@@ -0,0 +1,14 @@
+import { FormatSimple } from '../FormatSimple/FormatSimple';
+import { TolgeeCore } from '../TolgeeCore';
+
+describe('format simple', () => {
+  it('works with parameters', () => {
+    const tolgee = TolgeeCore()
+      .use(FormatSimple())
+      .init({
+        language: 'en',
+        staticData: { en: { apples: 'Bob has { num } apples' } },
+      });
+    expect(tolgee.t('apples', { num: 7 })).toEqual('Bob has 7 apples');
+  });
+});

package/src/__test/formatError.test.ts

@@ -0,0 +1,61 @@
+/* eslint-disable no-console */
+import { FormatSimple } from '../FormatSimple/FormatSimple';
+import { TolgeeCore } from '../TolgeeCore';
+
+describe('format error', () => {
+  beforeEach(() => {
+    console.error = jest.fn();
+  });
+
+  it('returns default error', () => {
+    const tolgee = TolgeeCore().use(FormatSimple()).init({ language: 'en' });
+
+    expect(tolgee.t('test', 'missing {param}')).toEqual('invalid');
+    expect(console.error).toBeCalledTimes(1);
+  });
+
+  it('returns specified error message', () => {
+    const tolgee = TolgeeCore()
+      .use(FormatSimple())
+      .init({ language: 'en', onFormatError: 'my error' });
+
+    expect(tolgee.t('test', 'missing {param}')).toEqual('my error');
+    expect(console.error).toBeCalledTimes(1);
+  });
+
+  it('accepts error handler function', () => {
+    const tolgee = TolgeeCore()
+      .use(FormatSimple())
+      .init({
+        language: 'en',
+        onFormatError(error) {
+          return error;
+        },
+      });
+
+    expect(tolgee.t('test', 'missing {param}')).toEqual(
+      'Missing parameter "param" in "missing {param}"'
+    );
+    expect(console.error).toBeCalledTimes(1);
+  });
+
+  it('handler recieves correct information', () => {
+    const tolgee = TolgeeCore()
+      .use(FormatSimple())
+      .init({
+        language: 'en',
+        onFormatError(_, { key, defaultValue, params }) {
+          return JSON.stringify({ key, defaultValue, params });
+        },
+      });
+
+    expect(tolgee.t('test', 'missing {param}', { param2: 'test' })).toEqual(
+      JSON.stringify({
+        key: 'test',
+        defaultValue: 'missing {param}',
+        params: { param2: 'test' },
+      })
+    );
+    expect(console.error).toBeCalledTimes(1);
+  });
+});

package/src/__test/initialization.test.ts

@@ -1,4 +1,4 @@
-import { Tolgee } from '../index';
+import { TolgeeCore } from '../index';
 
 describe('initialization behavior', () => {
   it("change in state before running won't trigger fetch", async () => {
@@ -11,7 +11,7 @@ describe('initialization behavior', () => {
       Promise.resolve({ cancel: 'Cancellar' })
     );
 
-    const tolgee = Tolgee({
+    const tolgee = TolgeeCore().init({
       language: 'en',
       ns: ['common'],
       staticData: {
@@ -48,7 +48,7 @@ describe('initialization behavior', () => {
   });
 
   it("won't start loading when nothing to load", async () => {
-    const tolgee = Tolgee({
+    const tolgee = TolgeeCore().init({
       language: 'en',
       staticData: {
         en: { test: 'Test' },
@@ -70,4 +70,16 @@ describe('initialization behavior', () => {
     expect(onFetchingHandler).not.toBeCalled();
     expect(onLoadingHandler).not.toBeCalled();
   });
+
+  it('emits keyUpdate on initialLoad', async () => {
+    const tolgee = TolgeeCore().init({
+      language: 'en',
+      staticData: { en: { hello: 'world' } },
+    });
+    const onKeyChange = jest.fn();
+    tolgee.on('update', onKeyChange);
+    expect(onKeyChange).toBeCalledTimes(0);
+    await tolgee.run();
+    expect(onKeyChange).toBeCalledTimes(1);
+  });
 });

package/src/__test/languageDetection.test.ts

@@ -1,4 +1,4 @@
-import { Tolgee, TolgeePlugin, TolgeeInstance } from '../index';
+import { TolgeeCore, TolgeePlugin, TolgeeInstance } from '../index';
 
 const DetectionPlugin =
   (value: any): TolgeePlugin =>
@@ -19,7 +19,7 @@ describe('language detection plugin', () => {
   });
 
   it('will detect language without loading', async () => {
-    tolgee = Tolgee()
+    tolgee = TolgeeCore()
       .use(DetectionPlugin('en'))
       .init({
         defaultLanguage: 'es',
@@ -43,7 +43,7 @@ describe('language detection plugin', () => {
   });
 
   it('will detect language async', async () => {
-    tolgee = Tolgee()
+    tolgee = TolgeeCore()
       .use(DetectionPlugin(Promise.resolve('en')))
       .init({
         defaultLanguage: 'es',
@@ -69,7 +69,7 @@ describe('language detection plugin', () => {
   });
 
   it('will fallback correctly', async () => {
-    tolgee = Tolgee()
+    tolgee = TolgeeCore()
       .use(DetectionPlugin(Promise.resolve(undefined)))
       .init({
         defaultLanguage: 'es',
@@ -85,7 +85,7 @@ describe('language detection plugin', () => {
   });
 
   it('will return key before language is loaded', async () => {
-    tolgee = Tolgee()
+    tolgee = TolgeeCore()
       .use(DetectionPlugin(Promise.resolve('en')))
       .init({
         defaultLanguage: 'es',
@@ -102,7 +102,7 @@ describe('language detection plugin', () => {
   });
 
   it('will throw error when no avaliableLanguages are set', () => {
-    tolgee = Tolgee().use(DetectionPlugin('en')).init({
+    tolgee = TolgeeCore().use(DetectionPlugin('en')).init({
       defaultLanguage: 'es',
     });
 
@@ -110,7 +110,7 @@ describe('language detection plugin', () => {
   });
 
   it('will throw error when no defaultLanguage specified', () => {
-    tolgee = Tolgee()
+    tolgee = TolgeeCore()
       .use(DetectionPlugin('en'))
       .init({
         staticData: {
@@ -118,6 +118,12 @@ describe('language detection plugin', () => {
         },
       });
 
-    expect(() => tolgee.run()).toThrow();
+    expect(() => tolgee.run()).toThrow(/'defaultLanguage'/);
+  });
+
+  it('will throw error when no available languages specified', () => {
+    tolgee = TolgeeCore().use(DetectionPlugin('en')).init({});
+
+    expect(() => tolgee.run()).toThrow(/'availableLanguages'/);
   });
 });

package/src/__test/languageStorage.test.ts

@@ -1,4 +1,4 @@
-import { Tolgee, TolgeePlugin, TolgeeInstance } from '../index';
+import { TolgeeCore, TolgeePlugin, TolgeeInstance } from '../index';
 
 describe('language storage plugin', () => {
   let tolgee: TolgeeInstance;
@@ -22,7 +22,7 @@ describe('language storage plugin', () => {
   });
 
   it('will restore language without loading', async () => {
-    tolgee = Tolgee()
+    tolgee = TolgeeCore()
       .use(StoragePlugin('en'))
       .init({
         defaultLanguage: 'es',
@@ -46,7 +46,7 @@ describe('language storage plugin', () => {
   });
 
   it('will restore language async', async () => {
-    tolgee = Tolgee()
+    tolgee = TolgeeCore()
       .use(StoragePlugin(Promise.resolve('en')))
       .init({
         defaultLanguage: 'es',
@@ -72,7 +72,7 @@ describe('language storage plugin', () => {
   });
 
   it('will fallback correctly', async () => {
-    tolgee = Tolgee()
+    tolgee = TolgeeCore()
       .use(StoragePlugin(Promise.resolve(undefined)))
       .init({
         defaultLanguage: 'es',
@@ -88,7 +88,7 @@ describe('language storage plugin', () => {
   });
 
   it('will return key before language is loaded', async () => {
-    tolgee = Tolgee()
+    tolgee = TolgeeCore()
       .use(StoragePlugin(Promise.resolve('en')))
       .init({
         defaultLanguage: 'es',
@@ -105,7 +105,7 @@ describe('language storage plugin', () => {
   });
 
   it('will store language value on language change', async () => {
-    tolgee = Tolgee()
+    tolgee = TolgeeCore()
       .use(StoragePlugin(Promise.resolve('en')))
       .init({
         defaultLanguage: 'es',
@@ -122,7 +122,7 @@ describe('language storage plugin', () => {
   });
 
   it('will ignore invalid values', () => {
-    tolgee = Tolgee()
+    tolgee = TolgeeCore()
       .use(StoragePlugin('eq'))
       .init({
         defaultLanguage: 'es',
@@ -135,11 +135,10 @@ describe('language storage plugin', () => {
     expect(tolgee.getLanguage()).toEqual('es');
   });
 
-  it('will return invalid value if no available languages', () => {
-    tolgee = Tolgee().use(StoragePlugin('eq')).init({
+  it('will throw an error when no available languages are specified', () => {
+    tolgee = TolgeeCore().use(StoragePlugin('eq')).init({
       defaultLanguage: 'es',
     });
-    tolgee.run();
-    expect(tolgee.getLanguage()).toEqual('eq');
+    expect(() => tolgee.run()).toThrowError('availableLanguages');
   });
 });

package/src/__test/languages.test.ts

@@ -1,16 +1,16 @@
-import { Tolgee, TreeTranslationsData } from '../index';
+import { TolgeeCore, TreeTranslationsData } from '../index';
 import { resolvablePromise } from './testTools';
 
 describe('language changes', () => {
   it('changes language', async () => {
-    const tolgee = Tolgee({ language: 'en' });
+    const tolgee = TolgeeCore().init({ language: 'en' });
     expect(tolgee.getLanguage()).toEqual('en');
     await tolgee.changeLanguage('es');
     expect(tolgee.getLanguage()).toEqual('es');
   });
 
   it('returns correct translation', async () => {
-    const tolgee = Tolgee({
+    const tolgee = TolgeeCore().init({
       language: 'en',
       staticData: { en: { hello: 'World' }, es: { hello: 'Mundo' } },
     });
@@ -24,7 +24,7 @@ describe('language changes', () => {
   it('fetches language data correctly', async () => {
     const [promiseEn, resolveEn] = resolvablePromise<TreeTranslationsData>();
     const [promiseEs, resolveEs] = resolvablePromise<TreeTranslationsData>();
-    const tolgee = Tolgee({
+    const tolgee = TolgeeCore().init({
       language: 'en',
       staticData: {
         en: () => promiseEn,
@@ -53,7 +53,7 @@ describe('language changes', () => {
     const [promiseEnIn, resolveEnIn] =
       resolvablePromise<TreeTranslationsData>();
 
-    const tolgee = Tolgee({
+    const tolgee = TolgeeCore().init({
       language: 'es',
       staticData: {
         en: () => promiseEn,
@@ -95,7 +95,7 @@ describe('language changes', () => {
   });
 
   it('will fallback to default value', () => {
-    const tolgee = Tolgee({
+    const tolgee = TolgeeCore().init({
       defaultLanguage: 'en',
     });
 
@@ -103,4 +103,28 @@ describe('language changes', () => {
     tolgee.run();
     expect(tolgee.getLanguage()).toEqual('en');
   });
+
+  it('will throw error when no language specified', () => {
+    const tolgee = TolgeeCore().init({});
+
+    expect(() => tolgee.run()).toThrow(/'language'/);
+  });
+
+  it('loads fallback languages and namespaces', async () => {
+    const loadNs = jest.fn(() => Promise.resolve(undefined as any));
+    const tolgee = TolgeeCore().init({
+      language: 'en',
+      fallbackNs: ['fallback'],
+      staticData: {
+        en: loadNs,
+        'en:fallback': loadNs,
+        cs: loadNs,
+        'cs:fallback': loadNs,
+      },
+    });
+    tolgee.run();
+    expect(loadNs).toBeCalledTimes(2);
+    await tolgee.changeLanguage('cs');
+    expect(loadNs).toBeCalledTimes(4);
+  });
 });

package/src/__test/loading.test.ts

@@ -1,4 +1,4 @@
-import { Tolgee, TreeTranslationsData } from '../index';
+import { TolgeeCore, TreeTranslationsData } from '../index';
 import { resolvablePromise } from './testTools';
 
 describe('loading', () => {
@@ -7,7 +7,7 @@ describe('loading', () => {
     const [promiseEs, resolveEs] = resolvablePromise<TreeTranslationsData>();
     const onLoadHandler = jest.fn(() => {});
     const onFetchingHandler = jest.fn(() => {});
-    const tolgee = Tolgee({
+    const tolgee = TolgeeCore().init({
       language: 'en',
       staticData: {
         en: () => promiseEn,

package/src/__test/{namespacesFallback.test.ts → namespaces.fallback.test.ts}

@@ -1,8 +1,8 @@
-import { Tolgee } from '../Tolgee';
+import { TolgeeCore } from '../TolgeeCore';
 
 describe('namespaces fallback', () => {
   test('works with multiple and default', () => {
-    const tolgee = Tolgee({
+    const tolgee = TolgeeCore().init({
       language: 'en',
       staticData: {
         en: { '0': 'noNamespace' },
@@ -20,7 +20,7 @@ describe('namespaces fallback', () => {
   });
 
   test('works when no fallback specified', () => {
-    const tolgee = Tolgee({
+    const tolgee = TolgeeCore().init({
       language: 'en',
       staticData: {
         en: { '0': 'noNamespace' },
@@ -37,7 +37,7 @@ describe('namespaces fallback', () => {
   });
 
   test('works when data present but no fallback', () => {
-    const tolgee = Tolgee({
+    const tolgee = TolgeeCore().init({
       language: 'en',
       staticData: {
         en: { '0': 'noNamespace' },
@@ -54,11 +54,11 @@ describe('namespaces fallback', () => {
     expect(tolgee.t({ key: '4', orEmpty: true })).toEqual('');
   });
 
-  test('works with override', () => {
-    const tolgee = Tolgee({
+  test('works with default', () => {
+    const tolgee = TolgeeCore().init({
       language: 'en',
       staticData: {
-        en: { '0': 'noNamespace' },
+        en: { '0': 'empty' },
         'en:first': { '1': 'first' },
         'en:second': { '2': 'second' },
       },
@@ -66,8 +66,10 @@ describe('namespaces fallback', () => {
     });
 
     expect(tolgee.t({ key: '1' })).toEqual('1');
+    expect(tolgee.t({ key: '0' })).toEqual('empty');
     expect(tolgee.t({ key: '1', ns: 'first' })).toEqual('first');
     expect(tolgee.t({ key: '0', ns: 'first' })).toEqual('0');
-    expect(tolgee.t({ key: '2', ns: ['first', 'second'] })).toEqual('second');
+    expect(tolgee.t({ key: '2', ns: 'first' })).toEqual('second');
+    expect(tolgee.t({ key: '2', ns: 'second' })).toEqual('second');
   });
 });