@akemona-org/strapi-plugin-i18n 3.7.0

package/services/__tests__/entity-service-decorator.test.js

@@ -0,0 +1,280 @@
+'use strict';
+
+jest.mock('../localizations', () => {
+  return {
+    syncLocalizations: jest.fn(async () => {}),
+    syncNonLocalizedAttributes: jest.fn(async () => {}),
+  };
+});
+
+const { decorator } = require('../entity-service-decorator');
+const { syncLocalizations, syncNonLocalizedAttributes } = require('../localizations');
+const locales = require('../locales');
+const contentTypes = require('../content-types');
+
+const model = {
+  pluginOptions: {
+    i18n: {
+      localized: true,
+    },
+  },
+};
+
+const nonLocalizedModel = {
+  pluginOptions: {
+    i18n: {
+      localized: false,
+    },
+  },
+};
+
+const models = {
+  'test-model': model,
+  'non-localized-model': nonLocalizedModel,
+};
+
+describe('Entity service decorator', () => {
+  beforeAll(() => {
+    global.strapi = {
+      plugins: {
+        i18n: {
+          services: {
+            locales,
+            'content-types': contentTypes,
+          },
+        },
+      },
+      query() {
+        return {
+          create() {},
+          update() {},
+        };
+      },
+      db: {
+        getModel(uid) {
+          return models[uid || 'test-model'];
+        },
+      },
+      store: () => ({ get: () => 'en' }),
+    };
+  });
+
+  beforeEach(() => {
+    syncLocalizations.mockClear();
+    syncNonLocalizedAttributes.mockClear();
+  });
+
+  describe('wrapOptions', () => {
+    test('Calls original wrapOptions', async () => {
+      const defaultService = {
+        wrapOptions: jest.fn(() => Promise.resolve('li')),
+      };
+
+      const service = decorator(defaultService);
+
+      const input = { populate: ['test'] };
+      await service.wrapOptions(input, { model: 'test-model' });
+
+      expect(defaultService.wrapOptions).toHaveBeenCalledWith(input, { model: 'test-model' });
+    });
+
+    test('Does not wrap options if model is not localized', async () => {
+      const defaultService = {
+        wrapOptions: jest.fn(opts => Promise.resolve(opts)),
+      };
+      const service = decorator(defaultService);
+
+      const input = { populate: ['test'] };
+      const output = await service.wrapOptions(input, { model: 'non-localized-model' });
+
+      expect(output).toStrictEqual(input);
+    });
+
+    test('does not change non params options', async () => {
+      const defaultService = {
+        wrapOptions: jest.fn(opts => Promise.resolve(opts)),
+      };
+      const service = decorator(defaultService);
+
+      const input = { populate: ['test'] };
+      const output = await service.wrapOptions(input, { model: 'test-model' });
+
+      expect(output.populate).toStrictEqual(input.populate);
+    });
+
+    test('Adds locale param', async () => {
+      const defaultService = {
+        wrapOptions: jest.fn(opts => Promise.resolve(opts)),
+      };
+      const service = decorator(defaultService);
+
+      const input = { populate: ['test'] };
+      const output = await service.wrapOptions(input, { model: 'test-model' });
+
+      expect(output).toMatchObject({ params: { locale: 'en' } });
+    });
+
+    const testData = [
+      ['findOne', { id: 1 }],
+      ['update', { id: 1 }],
+      ['delete', { id: 1 }],
+      ['delete', { id_in: [1] }],
+      ['findOne', { _where: { id: 1 } }],
+      ['update', { _where: { id: 1 } }],
+      ['delete', { _where: { id: 1 } }],
+      ['delete', { _where: { id_in: [1] } }],
+      ['findOne', { _where: [{ id: 1 }] }],
+      ['update', { _where: [{ id: 1 }] }],
+      ['delete', { _where: [{ id: 1 }] }],
+      ['delete', { _where: [{ id_in: [1] }] }],
+    ];
+
+    test.each(testData)(
+      "Doesn't add locale param when the params contain id or id_in - %s",
+      async (action, params) => {
+        const defaultService = {
+          wrapOptions: jest.fn(opts => Promise.resolve(opts)),
+        };
+        const service = decorator(defaultService);
+
+        const input = Object.assign({ populate: ['test'], params });
+        const output = await service.wrapOptions(input, { model: 'test-model', action });
+
+        expect(output).toEqual({ populate: ['test'], params });
+      }
+    );
+
+    test('Replaces _locale param', async () => {
+      const defaultService = {
+        wrapOptions: jest.fn(opts => Promise.resolve(opts)),
+      };
+      const service = decorator(defaultService);
+
+      const input = {
+        params: {
+          _locale: 'fr',
+        },
+        populate: ['test'],
+      };
+      const output = await service.wrapOptions(input, { model: 'test-model' });
+
+      expect(output).toMatchObject({ params: { locale: 'fr' } });
+    });
+  });
+
+  describe('create', () => {
+    test('Calls original create', async () => {
+      const entry = {
+        id: 1,
+      };
+
+      const defaultService = {
+        create: jest.fn(() => Promise.resolve(entry)),
+      };
+
+      const service = decorator(defaultService);
+
+      const input = { data: { title: 'title ' } };
+      await service.create(input, { model: 'test-model' });
+
+      expect(defaultService.create).toHaveBeenCalledWith(input, { model: 'test-model' });
+    });
+
+    test('Calls syncLocalizations if model is localized', async () => {
+      const entry = {
+        id: 1,
+        localizations: [{ id: 2 }],
+      };
+
+      const defaultService = {
+        create: jest.fn(() => Promise.resolve(entry)),
+      };
+
+      const service = decorator(defaultService);
+
+      const input = { data: { title: 'title ' } };
+      await service.create(input, { model: 'test-model' });
+
+      expect(defaultService.create).toHaveBeenCalledWith(input, { model: 'test-model' });
+      expect(syncLocalizations).toHaveBeenCalledWith(entry, { model });
+    });
+
+    test('Skip processing if model is not localized', async () => {
+      const entry = {
+        id: 1,
+        localizations: [{ id: 2 }],
+      };
+
+      const defaultService = {
+        create: jest.fn(() => Promise.resolve(entry)),
+      };
+
+      const service = decorator(defaultService);
+
+      const input = { data: { title: 'title ' } };
+      const output = await service.create(input, { model: 'non-localized-model' });
+
+      expect(defaultService.create).toHaveBeenCalledWith(input, { model: 'non-localized-model' });
+      expect(syncLocalizations).not.toHaveBeenCalled();
+      expect(output).toStrictEqual(entry);
+    });
+  });
+
+  describe('update', () => {
+    test('Calls original update', async () => {
+      const entry = {
+        id: 1,
+      };
+
+      const defaultService = {
+        update: jest.fn(() => Promise.resolve(entry)),
+      };
+
+      const service = decorator(defaultService);
+
+      const input = { params: { id: 1 }, data: { title: 'title ' } };
+      await service.update(input, { model: 'test-model' });
+
+      expect(defaultService.update).toHaveBeenCalledWith(input, { model: 'test-model' });
+    });
+
+    test('Calls syncNonLocalizedAttributes if model is localized', async () => {
+      const entry = {
+        id: 1,
+        localizations: [{ id: 2 }],
+      };
+
+      const defaultService = {
+        update: jest.fn(() => Promise.resolve(entry)),
+      };
+
+      const service = decorator(defaultService);
+
+      const input = { params: { id: 1 }, data: { title: 'title ' } };
+      const output = await service.update(input, { model: 'test-model' });
+
+      expect(defaultService.update).toHaveBeenCalledWith(input, { model: 'test-model' });
+      expect(syncNonLocalizedAttributes).toHaveBeenCalledWith(entry, { model });
+      expect(output).toStrictEqual(entry);
+    });
+
+    test('Skip processing if model is not localized', async () => {
+      const entry = {
+        id: 1,
+        localizations: [{ id: 2 }],
+      };
+
+      const defaultService = {
+        update: jest.fn(() => Promise.resolve(entry)),
+      };
+
+      const service = decorator(defaultService);
+
+      const input = { params: { id: 1 }, data: { title: 'title ' } };
+      await service.update(input, { model: 'non-localized-model' });
+
+      expect(defaultService.update).toHaveBeenCalledWith(input, { model: 'non-localized-model' });
+      expect(syncNonLocalizedAttributes).not.toHaveBeenCalled();
+    });
+  });
+});

package/services/__tests__/iso-locales.test.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const { getIsoLocales } = require('../iso-locales');
+
+describe('ISO locales', () => {
+  test('getIsoLocales', () => {
+    const locales = getIsoLocales();
+
+    expect(locales).toMatchSnapshot();
+  });
+});

package/services/__tests__/locales.test.js

@@ -0,0 +1,237 @@
+'use strict';
+
+const localesService = require('../locales');
+
+const fakeMetricsService = {
+  sendDidInitializeEvent() {},
+  sendDidUpdateI18nLocalesEvent() {},
+};
+
+describe('Locales', () => {
+  describe('setIsDefault', () => {
+    test('Set isDefault to false', async () => {
+      const get = jest.fn(() => Promise.resolve('en'));
+      global.strapi = { store: () => ({ get }) };
+
+      const locale = {
+        code: 'fr',
+        name: 'French',
+      };
+
+      const enrichedLocale = await localesService.setIsDefault(locale);
+      expect(enrichedLocale).toMatchObject({
+        ...locale,
+        isDefault: false,
+      });
+    });
+
+    test('Set isDefault to true', async () => {
+      const get = jest.fn(() => Promise.resolve('en'));
+      global.strapi = { store: () => ({ get }) };
+
+      const locale = {
+        code: 'en',
+        name: 'English',
+      };
+
+      const enrichedLocale = await localesService.setIsDefault(locale);
+      expect(enrichedLocale).toMatchObject({
+        ...locale,
+        isDefault: true,
+      });
+    });
+  });
+
+  describe('getDefaultLocale', () => {
+    test('get default locale', async () => {
+      const get = jest.fn(() => Promise.resolve('en'));
+      global.strapi = { store: () => ({ get }) };
+
+      const defaultLocaleCode = await localesService.getDefaultLocale();
+      expect(defaultLocaleCode).toBe('en');
+    });
+  });
+
+  describe('setDefaultLocale', () => {
+    test('set default locale', async () => {
+      const set = jest.fn(() => Promise.resolve());
+      global.strapi = { store: () => ({ set }) };
+
+      await localesService.setDefaultLocale({ code: 'fr-CA' });
+      expect(set).toHaveBeenCalledWith({ key: 'default_locale', value: 'fr-CA' });
+    });
+  });
+
+  describe('CRUD', () => {
+    test('find', async () => {
+      const locales = [{ name: 'French', code: 'fr' }];
+      const find = jest.fn(() => Promise.resolve(locales));
+      const query = jest.fn(() => ({ find }));
+      global.strapi = { query };
+      const params = { name_contains: 'en' };
+
+      const localesFound = await localesService.find(params);
+      expect(query).toHaveBeenCalledWith('locale', 'i18n');
+      expect(find).toHaveBeenCalledWith(params);
+      expect(localesFound).toMatchObject(locales);
+    });
+
+    test('findById', async () => {
+      const locale = { name: 'French', code: 'fr' };
+      const findOne = jest.fn(() => Promise.resolve(locale));
+      const query = jest.fn(() => ({ findOne }));
+      global.strapi = { query };
+
+      const localeFound = await localesService.findById(1);
+      expect(query).toHaveBeenCalledWith('locale', 'i18n');
+      expect(findOne).toHaveBeenCalledWith({ id: 1 });
+      expect(localeFound).toMatchObject(locale);
+    });
+
+    test('findByCode', async () => {
+      const locale = { name: 'French', code: 'fr' };
+      const findOne = jest.fn(() => Promise.resolve(locale));
+      const query = jest.fn(() => ({ findOne }));
+      global.strapi = { query };
+
+      const localeFound = await localesService.findByCode('fr');
+      expect(query).toHaveBeenCalledWith('locale', 'i18n');
+      expect(findOne).toHaveBeenCalledWith({ code: 'fr' });
+      expect(localeFound).toMatchObject(locale);
+    });
+
+    test('create', async () => {
+      const locale = { name: 'French', code: 'fr' };
+      const create = jest.fn(() => locale);
+      const query = jest.fn(() => ({ create }));
+      global.strapi = {
+        query,
+        plugins: {
+          i18n: {
+            services: { metrics: fakeMetricsService },
+          },
+        },
+      };
+
+      const createdLocale = await localesService.create(locale);
+      expect(query).toHaveBeenCalledWith('locale', 'i18n');
+      expect(create).toHaveBeenCalledWith(locale);
+      expect(createdLocale).toMatchObject(locale);
+    });
+
+    test('update', async () => {
+      const locale = { name: 'French', code: 'fr' };
+      const update = jest.fn(() => locale);
+      const query = jest.fn(() => ({ update }));
+      global.strapi = {
+        query,
+        plugins: {
+          i18n: {
+            services: { metrics: fakeMetricsService },
+          },
+        },
+      };
+
+      const updatedLocale = await localesService.update({ code: 'fr' }, { name: 'French' });
+      expect(query).toHaveBeenCalledWith('locale', 'i18n');
+      expect(update).toHaveBeenCalledWith({ code: 'fr' }, { name: 'French' });
+      expect(updatedLocale).toMatchObject(locale);
+    });
+
+    test('delete', async () => {
+      const locale = { name: 'French', code: 'fr' };
+      const deleteFn = jest.fn(() => locale);
+      const findOne = jest.fn(() => locale);
+      const isLocalizedContentType = jest.fn(() => true);
+      const query = jest.fn(() => ({ delete: deleteFn, findOne }));
+      global.strapi = {
+        query,
+        plugins: {
+          i18n: {
+            services: { metrics: fakeMetricsService, 'content-types': { isLocalizedContentType } },
+          },
+        },
+        contentTypes: { 'application::country.country': {} },
+      };
+
+      const deletedLocale = await localesService.delete({ id: 1 });
+      expect(query).toHaveBeenCalledWith('locale', 'i18n');
+      expect(deleteFn).toHaveBeenCalledWith({ id: 1 });
+      expect(deletedLocale).toMatchObject(locale);
+    });
+
+    test('delete - not found', async () => {
+      const locale = { name: 'French', code: 'fr' };
+      const deleteFn = jest.fn(() => locale);
+      const findOne = jest.fn(() => undefined);
+      const query = jest.fn(() => ({ delete: deleteFn, findOne }));
+      global.strapi = {
+        query,
+        plugins: {
+          i18n: {
+            services: { metrics: fakeMetricsService },
+          },
+        },
+      };
+
+      const deletedLocale = await localesService.delete({ id: 1 });
+      expect(query).toHaveBeenCalledWith('locale', 'i18n');
+      expect(deleteFn).not.toHaveBeenCalled();
+      expect(deletedLocale).toBeUndefined();
+    });
+  });
+
+  describe('initDefaultLocale', () => {
+    test('create default local if none exists', async () => {
+      const count = jest.fn(() => Promise.resolve(0));
+      const create = jest.fn(() => Promise.resolve());
+      const set = jest.fn(() => Promise.resolve());
+
+      global.strapi = {
+        query: () => ({
+          count,
+          create,
+        }),
+        store: () => ({
+          set,
+        }),
+        plugins: {
+          i18n: {
+            services: {
+              metrics: fakeMetricsService,
+            },
+          },
+        },
+      };
+
+      await localesService.initDefaultLocale();
+      expect(count).toHaveBeenCalledWith();
+      expect(create).toHaveBeenCalledWith({
+        name: 'English (en)',
+        code: 'en',
+      });
+      expect(set).toHaveBeenCalledWith({ key: 'default_locale', value: 'en' });
+    });
+
+    test('does not create default local if one already exists', async () => {
+      const count = jest.fn(() => Promise.resolve(1));
+      const create = jest.fn(() => Promise.resolve());
+      const set = jest.fn(() => Promise.resolve());
+
+      global.strapi = {
+        query: () => ({
+          count,
+          create,
+        }),
+        store: () => ({
+          set,
+        }),
+      };
+
+      await localesService.initDefaultLocale();
+      expect(count).toHaveBeenCalledWith();
+      expect(create).not.toHaveBeenCalled();
+      expect(set).not.toHaveBeenCalled();
+    });
+  });
+});

package/services/__tests__/localizations.test.js

@@ -0,0 +1,187 @@
+'use strict';
+
+const {
+  assignDefaultLocale,
+  syncLocalizations,
+  syncNonLocalizedAttributes,
+} = require('../localizations');
+
+const locales = require('../locales');
+const contentTypes = require('../content-types');
+
+const model = {
+  uid: 'test-model',
+  pluginOptions: {
+    i18n: {
+      localized: true,
+    },
+  },
+  attributes: {
+    title: {
+      type: 'string',
+      pluginOptions: {
+        i18n: {
+          localized: true,
+        },
+      },
+    },
+    stars: {
+      type: 'integer',
+    },
+  },
+};
+
+const allLocalizedModel = {
+  uid: 'test-model',
+  pluginOptions: {
+    i18n: {
+      localized: true,
+    },
+  },
+  attributes: {
+    title: {
+      type: 'string',
+      pluginOptions: {
+        i18n: {
+          localized: true,
+        },
+      },
+    },
+    stars: {
+      type: 'integer',
+      pluginOptions: {
+        i18n: {
+          localized: true,
+        },
+      },
+    },
+  },
+};
+
+const setGlobalStrapi = () => {
+  global.strapi = {
+    plugins: {
+      i18n: {
+        services: {
+          locales,
+          'content-types': contentTypes,
+        },
+      },
+    },
+  };
+};
+
+describe('localizations service', () => {
+  describe('assignDefaultLocale', () => {
+    test('Does not change the input if locale is already defined', async () => {
+      setGlobalStrapi();
+      const input = { locale: 'myLocale' };
+      await assignDefaultLocale(input);
+
+      expect(input).toStrictEqual({ locale: 'myLocale' });
+    });
+
+    test('Use default locale to set the locale on the input data', async () => {
+      setGlobalStrapi();
+
+      const getDefaultLocaleMock = jest.fn(() => 'defaultLocale');
+
+      global.strapi.plugins.i18n.services.locales.getDefaultLocale = getDefaultLocaleMock;
+
+      const input = {};
+      await assignDefaultLocale(input);
+
+      expect(input).toStrictEqual({ locale: 'defaultLocale' });
+      expect(getDefaultLocaleMock).toHaveBeenCalled();
+    });
+  });
+
+  describe('syncLocalizations', () => {
+    test('Updates every other localizations with correct ids', async () => {
+      setGlobalStrapi();
+
+      const update = jest.fn();
+      global.strapi.query = () => {
+        return { update };
+      };
+
+      const localizations = [{ id: 2 }, { id: 3 }];
+      const entry = { id: 1, locale: 'test', localizations };
+
+      await syncLocalizations(entry, { model });
+
+      expect(update).toHaveBeenCalledTimes(localizations.length);
+      expect(update).toHaveBeenNthCalledWith(1, { id: 2 }, { localizations: [1, 3] });
+      expect(update).toHaveBeenNthCalledWith(2, { id: 3 }, { localizations: [1, 2] });
+    });
+  });
+
+  describe('syncNonLocalizedAttributes', () => {
+    test('Does nothing if no localizations set', async () => {
+      setGlobalStrapi();
+
+      const update = jest.fn();
+      global.strapi.query = () => {
+        return { update };
+      };
+
+      const entry = { id: 1, locale: 'test' };
+
+      await syncNonLocalizedAttributes(entry, { model });
+
+      expect(update).not.toHaveBeenCalled();
+    });
+
+    test('Does not update the current locale', async () => {
+      setGlobalStrapi();
+
+      const update = jest.fn();
+      global.strapi.query = () => {
+        return { update };
+      };
+
+      const entry = { id: 1, locale: 'test', localizations: [] };
+
+      await syncNonLocalizedAttributes(entry, { model });
+
+      expect(update).not.toHaveBeenCalled();
+    });
+
+    test('Does not update if all the fields are localized', async () => {
+      setGlobalStrapi();
+
+      const update = jest.fn();
+      global.strapi.query = () => {
+        return { update };
+      };
+
+      const entry = { id: 1, locale: 'test', localizations: [] };
+
+      await syncNonLocalizedAttributes(entry, { model: allLocalizedModel });
+
+      expect(update).not.toHaveBeenCalled();
+    });
+
+    test('Updates locales with non localized fields only', async () => {
+      setGlobalStrapi();
+
+      const update = jest.fn();
+      global.strapi.query = () => {
+        return { update };
+      };
+
+      const entry = {
+        id: 1,
+        locale: 'test',
+        title: 'Localized',
+        stars: 1,
+        localizations: [{ id: 2, locale: 'fr' }],
+      };
+
+      await syncNonLocalizedAttributes(entry, { model });
+
+      expect(update).toHaveBeenCalledTimes(1);
+      expect(update).toHaveBeenCalledWith({ id: 2 }, { stars: 1 });
+    });
+  });
+});