@openedx/frontend-base 1.0.0-alpha.0 → 1.0.0-alpha.10

package/runtime/auth/interceptors/createRetryInterceptor.test.js

@@ -0,0 +1,23 @@
+import { defaultGetBackoffMilliseconds } from './createRetryInterceptor';
+
+describe('createRetryInterceptor: defaultGetBackoffMilliseconds', () => {
+  it('returns a number between 2000 and 3000 on the first retry', () => {
+    const backoffInMilliseconds = defaultGetBackoffMilliseconds(1);
+    expect(backoffInMilliseconds).toBeGreaterThanOrEqual(2000);
+    expect(backoffInMilliseconds).toBeLessThanOrEqual(3000);
+  });
+  it('returns a number between 4000 and 5000 on the second retry', () => {
+    const backoffInMilliseconds = defaultGetBackoffMilliseconds(2);
+    expect(backoffInMilliseconds).toBeGreaterThanOrEqual(4000);
+    expect(backoffInMilliseconds).toBeLessThanOrEqual(5000);
+  });
+  it('returns a number between 8000 and 9000 on the third retry', () => {
+    const backoffInMilliseconds = defaultGetBackoffMilliseconds(3);
+    expect(backoffInMilliseconds).toBeGreaterThanOrEqual(8000);
+    expect(backoffInMilliseconds).toBeLessThanOrEqual(9000);
+  });
+  it('returns 16000 fourth or later retry', () => {
+    const backoffInMilliseconds = defaultGetBackoffMilliseconds(4);
+    expect(backoffInMilliseconds).toEqual(16000);
+  });
+});

package/runtime/config/getExternalLinkUrl.test.js

@@ -0,0 +1,76 @@
+import { getExternalLinkUrl, setSiteConfig } from '.';
+
+describe('getExternalLinkUrl', () => {
+  afterEach(() => {
+    // Reset config after each test to avoid cross-test pollution
+    setSiteConfig({});
+  });
+
+  it('should return the url passed in when externalLinkUrlOverrides is not set', () => {
+    setSiteConfig({});
+    const url = 'https://foo.example.com';
+    expect(getExternalLinkUrl(url)).toBe(url);
+  });
+
+  it('should return the url passed in when externalLinkUrlOverrides does not have the url mapping', () => {
+    setSiteConfig({
+      externalLinkUrlOverrides: {
+        'https://bar.example.com': 'https://mapped.example.com',
+      },
+    });
+    const url = 'https://foo.example.com';
+    expect(getExternalLinkUrl(url)).toBe(url);
+  });
+
+  it('should return the mapped url when externalLinkUrlOverrides has the url mapping', () => {
+    const url = 'https://foo.example.com';
+    const mappedUrl = 'https://mapped.example.com';
+    setSiteConfig({ externalLinkUrlOverrides: { [url]: mappedUrl } });
+    expect(getExternalLinkUrl(url)).toBe(mappedUrl);
+  });
+
+  it('should handle empty externalLinkUrlOverrides object', () => {
+    setSiteConfig({ externalLinkUrlOverrides: {} });
+    const url = 'https://foo.example.com';
+    expect(getExternalLinkUrl(url)).toBe(url);
+  });
+
+  it('should guard against empty string argument', () => {
+    const fallbackResult = '#';
+    setSiteConfig({ externalLinkUrlOverrides: { foo: 'bar' } });
+    expect(getExternalLinkUrl(undefined)).toBe(fallbackResult);
+  });
+
+  it('should guard against non-string argument', () => {
+    const fallbackResult = '#';
+    setSiteConfig({ externalLinkUrlOverrides: { foo: 'bar' } });
+    expect(getExternalLinkUrl(null)).toBe(fallbackResult);
+    expect(getExternalLinkUrl(42)).toBe(fallbackResult);
+  });
+
+  it('should not throw if externalLinkUrlOverrides is not an object', () => {
+    setSiteConfig({ externalLinkUrlOverrides: null });
+    const url = 'https://foo.example.com';
+    expect(getExternalLinkUrl(url)).toBe(url);
+    setSiteConfig({ externalLinkUrlOverrides: 42 });
+    expect(getExternalLinkUrl(url)).toBe(url);
+  });
+
+  it('should work with multiple mappings', () => {
+    setSiteConfig({
+      externalLinkUrlOverrides: {
+        'https://a.example.com': 'https://mapped-a.example.com',
+        'https://b.example.com': 'https://mapped-b.example.com',
+      },
+    });
+    expect(getExternalLinkUrl('https://a.example.com')).toBe(
+      'https://mapped-a.example.com',
+    );
+    expect(getExternalLinkUrl('https://b.example.com')).toBe(
+      'https://mapped-b.example.com',
+    );
+    expect(getExternalLinkUrl('https://c.example.com')).toBe(
+      'https://c.example.com',
+    );
+  });
+});

package/runtime/config/index.ts

@@ -124,6 +124,7 @@ let siteConfig: SiteConfig = {
   externalRoutes: [],
   externalLinkUrlOverrides: [],
   mfeConfigApiUrl: null,
+  theme: {},
   accessTokenCookieName: 'edx-jwt-cookie-header-payload',
   csrfTokenApiPath: '/csrf/api/v1/token',
   ignoredErrorRegex: null,
@@ -238,9 +239,7 @@ export function getActiveRouteRoles() {
 const activeWidgetRoles: Record<string, number> = {};
 
 export function addActiveWidgetRole(role: string) {
-  if (activeWidgetRoles[role] === undefined) {
-    activeWidgetRoles[role] = 0;
-  }
+  activeWidgetRoles[role] ??= 0;
   activeWidgetRoles[role] += 1;
   publish(ACTIVE_ROLES_CHANGED);
 }

package/runtime/i18n/lib.test.js

@@ -0,0 +1,230 @@
+import {
+  configureI18n,
+  getCookies,
+  getLocale,
+  getMessages,
+  getPrimaryLanguageSubtag,
+  handleRtl,
+  isRtl,
+  mergeMessages,
+} from './lib';
+
+jest.mock('universal-cookie');
+
+describe('lib', () => {
+  describe('getPrimaryLanguageSubtag', () => {
+    it('should work for primary language subtags', () => {
+      expect(getPrimaryLanguageSubtag('en')).toEqual('en');
+      expect(getPrimaryLanguageSubtag('ars')).toEqual('ars');
+      expect(getPrimaryLanguageSubtag('a')).toEqual('a');
+    });
+
+    it('should work for longer language codes', () => {
+      expect(getPrimaryLanguageSubtag('en-us')).toEqual('en');
+      expect(getPrimaryLanguageSubtag('es-419')).toEqual('es');
+      expect(getPrimaryLanguageSubtag('zh-hans-CN')).toEqual('zh');
+    });
+  });
+
+  describe('getLocale', () => {
+    beforeEach(() => {
+      configureI18n({
+        messages: {
+          'es-419': {},
+          de: {},
+          'en-us': {},
+        },
+      });
+    });
+
+    it('should return a supported locale as supplied', () => {
+      expect(getLocale('es-419')).toEqual('es-419');
+      expect(getLocale('en-us')).toEqual('en-us');
+    });
+
+    it('should return the supported primary language tag of a not-quite-supported locale', () => {
+      expect(getLocale('de-de')).toEqual('de');
+    });
+
+    it('should return en if the locale is not supported at all', () => {
+      expect(getLocale('oh-no')).toEqual('en');
+    });
+
+    it('should look up a locale in the language preference cookie if one was not supplied', () => {
+      getCookies().get = jest.fn(() => 'es-419');
+      expect(getLocale()).toEqual('es-419');
+
+      getCookies().get = jest.fn(() => 'pl');
+      expect(getLocale()).toEqual('en');
+
+      getCookies().get = jest.fn(() => 'de-bah');
+      expect(getLocale()).toEqual('de');
+    });
+    it('should fallback to the browser locale if the cookie does not exist', () => {
+      getCookies().get = jest.fn(() => null);
+      expect(getLocale()).toEqual(global.navigator.language.toLowerCase());
+    });
+  });
+
+  describe('getMessages', () => {
+    beforeEach(() => {
+      configureI18n({
+        messages: {
+          'es-419': { message: 'es-hah' },
+          de: { message: 'de-hah' },
+          'en-us': { message: 'en-us-hah' },
+        },
+      });
+
+      getCookies().get = jest.fn(() => 'es-419'); // Means the cookie will be set to es-419
+    });
+
+    it('should return the messages for the provided locale', () => {
+      expect(getMessages('en-us').message).toEqual('en-us-hah');
+    });
+
+    it('should return the messages for the preferred locale if no argument is passed', () => {
+      expect(getMessages().message).toEqual('es-hah');
+    });
+  });
+
+  describe('isRtl', () => {
+    it('should be true for RTL languages', () => {
+      expect(isRtl('ar')).toBe(true);
+      expect(isRtl('he')).toBe(true);
+      expect(isRtl('fa')).toBe(true);
+      expect(isRtl('fa-ir')).toBe(true);
+      expect(isRtl('ur')).toBe(true);
+    });
+
+    it('should be false for anything else', () => {
+      expect(isRtl('en')).toBe(false);
+      expect(isRtl('blah')).toBe(false);
+      expect(isRtl('es-419')).toBe(false);
+      expect(isRtl('de')).toBe(false);
+      expect(isRtl('ru')).toBe(false);
+    });
+  });
+
+  describe('handleRtl', () => {
+    let setAttribute;
+    beforeEach(() => {
+      setAttribute = jest.fn();
+
+      global.document.getElementsByTagName = jest.fn(() => [
+        {
+          setAttribute,
+        },
+      ]);
+    });
+
+    it('should do the right thing for non-RTL languages', () => {
+      getCookies().get = jest.fn(() => 'es-419');
+      configureI18n({
+        messages: {
+          'es-419': { message: 'es-hah' },
+        },
+      });
+
+      handleRtl();
+      expect(setAttribute).toHaveBeenCalledWith('dir', 'ltr');
+    });
+
+    it('should do the right thing for RTL languages', () => {
+      getCookies().get = jest.fn(() => 'ar');
+      configureI18n({
+        messages: {
+          ar: { message: 'ar-hah' },
+        },
+      });
+
+      handleRtl();
+      expect(setAttribute).toHaveBeenCalledWith('dir', 'rtl');
+    });
+  });
+});
+
+describe('mergeMessages', () => {
+  it('should merge objects', () => {
+    configureI18n({
+      messages: {
+        ar: { message: 'ar-hah' },
+      },
+    });
+    const result = mergeMessages({ en: { foo: 'bar' }, de: { buh: 'baz' }, jp: { gah: 'wut' } });
+    expect(result).toEqual({
+      ar: { message: 'ar-hah' },
+      en: { foo: 'bar' },
+      de: { buh: 'baz' },
+      jp: { gah: 'wut' },
+    });
+  });
+
+  it('should merge objects from an array', () => {
+    configureI18n({
+      messages: {
+        ar: { message: 'ar-hah' },
+      },
+    });
+    const result = mergeMessages([{ foo: 'bar' }, { buh: 'baz' }, { gah: 'wut' }]);
+    expect(result).toEqual({
+      ar: { message: 'ar-hah' },
+      foo: 'bar',
+      buh: 'baz',
+      gah: 'wut',
+    });
+  });
+
+  it('should merge nested objects from an array', () => {
+    configureI18n({
+      messages: {
+        en: { init: 'initial' },
+        es: { init: 'inicial' },
+      },
+    });
+    const messages = [
+      {
+        en: { hello: 'hello' },
+        es: { hello: 'hola' },
+      },
+      {
+        en: { goodbye: 'goodbye' },
+        es: { goodbye: 'adiós' },
+      },
+    ];
+
+    const result = mergeMessages(messages);
+    expect(result).toEqual({
+      en: {
+        init: 'initial',
+        hello: 'hello',
+        goodbye: 'goodbye',
+      },
+      es: {
+        init: 'inicial',
+        hello: 'hola',
+        goodbye: 'adiós',
+      },
+    });
+  });
+
+  it('should return an empty object if no messages', () => {
+    configureI18n({
+      messages: {},
+    });
+    expect(mergeMessages(undefined)).toEqual({});
+    expect(mergeMessages(null)).toEqual({});
+    expect(mergeMessages([])).toEqual({});
+    expect(mergeMessages({})).toEqual({});
+  });
+
+  it('should return the original object if no messages', () => {
+    configureI18n({
+      messages: { en: { hello: 'world ' } },
+    });
+    expect(mergeMessages(undefined)).toEqual({ en: { hello: 'world ' } });
+    expect(mergeMessages(null)).toEqual({ en: { hello: 'world ' } });
+    expect(mergeMessages([])).toEqual({ en: { hello: 'world ' } });
+    expect(mergeMessages({})).toEqual({ en: { hello: 'world ' } });
+  });
+});

package/runtime/index.ts

@@ -110,6 +110,11 @@ export {
   useAppConfig
 } from './react';
 
+export {
+  getUrlByRouteRole,
+  isRoleRouteObject
+} from './routing';
+
 export {
   clearAllSubscriptions,
   publish,

package/runtime/initialize.async.function.config.test.js

@@ -0,0 +1,43 @@
+import {
+  ensureAuthenticatedUser,
+  fetchAuthenticatedUser,
+  hydrateAuthenticatedUser,
+} from './auth';
+import { getSiteConfig } from './config';
+import { initialize } from './initialize';
+import {
+  logError,
+} from './logging';
+import { clearAllSubscriptions } from './subscriptions';
+
+jest.mock('./logging');
+jest.mock('./auth');
+jest.mock('./analytics');
+jest.mock('./i18n');
+jest.mock('./auth/LocalForageCache');
+jest.mock('site.config', () => async () => new Promise((resolve) => {
+  resolve({
+    JS_FILE_VAR: 'JS_FILE_VAR_VALUE_ASYNC_FUNCTION',
+  });
+}));
+
+let config = null;
+
+describe('initialize with async function js file config', () => {
+  beforeEach(() => {
+    jest.resetModules();
+    config = getSiteConfig();
+    fetchAuthenticatedUser.mockReset();
+    ensureAuthenticatedUser.mockReset();
+    hydrateAuthenticatedUser.mockReset();
+    logError.mockReset();
+    clearAllSubscriptions();
+  });
+
+  it('should initialize the app with async function javascript file configuration', async () => {
+    const messages = { i_am: 'a message' };
+    await initialize({ messages });
+
+    expect(config.JS_FILE_VAR).toEqual('JS_FILE_VAR_VALUE_ASYNC_FUNCTION');
+  });
+});

package/runtime/initialize.const.config.test.js

@@ -0,0 +1,41 @@
+import {
+  ensureAuthenticatedUser,
+  fetchAuthenticatedUser,
+  hydrateAuthenticatedUser,
+} from './auth';
+import { getSiteConfig } from './config';
+import { initialize } from './initialize';
+import {
+  logError,
+} from './logging';
+import { clearAllSubscriptions } from './subscriptions';
+
+jest.mock('./logging');
+jest.mock('./auth');
+jest.mock('./analytics');
+jest.mock('./i18n');
+jest.mock('./auth/LocalForageCache');
+jest.mock('site.config', () => ({
+  JS_FILE_VAR: 'JS_FILE_VAR_VALUE_CONSTANT',
+}));
+
+let config = null;
+
+describe('initialize with constant js file config', () => {
+  beforeEach(() => {
+    jest.resetModules();
+    config = getSiteConfig();
+    fetchAuthenticatedUser.mockReset();
+    ensureAuthenticatedUser.mockReset();
+    hydrateAuthenticatedUser.mockReset();
+    logError.mockReset();
+    clearAllSubscriptions();
+  });
+
+  it('should initialize the app with javascript file configuration', async () => {
+    const messages = { i_am: 'a message' };
+    await initialize({ messages });
+
+    expect(config.JS_FILE_VAR).toEqual('JS_FILE_VAR_VALUE_CONSTANT');
+  });
+});

package/runtime/initialize.function.config.test.js

@@ -0,0 +1,41 @@
+import {
+  ensureAuthenticatedUser,
+  fetchAuthenticatedUser,
+  hydrateAuthenticatedUser,
+} from './auth';
+import { getSiteConfig } from './config';
+import { initialize } from './initialize';
+import {
+  logError,
+} from './logging';
+import { clearAllSubscriptions } from './subscriptions';
+
+jest.mock('./logging');
+jest.mock('./auth');
+jest.mock('./analytics');
+jest.mock('./i18n');
+jest.mock('./auth/LocalForageCache');
+jest.mock('site.config', () => () => ({
+  JS_FILE_VAR: 'JS_FILE_VAR_VALUE_FUNCTION',
+}));
+
+let config = null;
+
+describe('initialize with function js file config', () => {
+  beforeEach(() => {
+    jest.resetModules();
+    config = getSiteConfig();
+    fetchAuthenticatedUser.mockReset();
+    ensureAuthenticatedUser.mockReset();
+    hydrateAuthenticatedUser.mockReset();
+    logError.mockReset();
+    clearAllSubscriptions();
+  });
+
+  it('should initialize the app with javascript file configuration', async () => {
+    const messages = { i_am: 'a message' };
+    await initialize({ messages });
+
+    expect(config.JS_FILE_VAR).toEqual('JS_FILE_VAR_VALUE_FUNCTION');
+  });
+});