@openedx/frontend-base 1.0.0-alpha.9 → 1.0.0

package/runtime/initialize.test.js

@@ -1,356 +0,0 @@
-import {
-  SITE_ANALYTICS_INITIALIZED,
-  SITE_AUTH_INITIALIZED,
-  SITE_CONFIG_INITIALIZED,
-  SITE_I18N_INITIALIZED,
-  SITE_INIT_ERROR,
-  SITE_LOGGING_INITIALIZED,
-  SITE_PUBSUB_INITIALIZED,
-  SITE_READY,
-} from './constants';
-import { initialize } from './initialize';
-
-import { configureAnalytics, SegmentAnalyticsService } from './analytics';
-import {
-  AxiosJwtAuthService,
-  configureAuth,
-  ensureAuthenticatedUser,
-  fetchAuthenticatedUser,
-  getAuthenticatedHttpClient,
-  getAuthenticatedUser,
-  hydrateAuthenticatedUser,
-} from './auth';
-import configureCache from './auth/LocalForageCache';
-import { getSiteConfig, mergeSiteConfig } from './config';
-import { configureI18n } from './i18n';
-import {
-  configureLogging,
-  getLoggingService,
-  logError,
-  NewRelicLoggingService,
-} from './logging';
-import { clearAllSubscriptions, subscribe } from './subscriptions';
-
-jest.mock('./logging');
-jest.mock('./auth');
-jest.mock('./analytics');
-jest.mock('./i18n');
-jest.mock('./auth/LocalForageCache');
-
-let config = null;
-const newConfig = {
-  common: {
-    siteName: 'Test Case',
-    accessTokenCookieName: 'edx-jwt-cookie-header-payload',
-    csrfTokenApiPath: '/csrf/api/v1/token',
-    languagePreferenceCookieName: 'openedx-language-preference',
-    lmsBaseUrl: 'http://test.example.com:18000',
-    loginUrl: 'http://test.example.com:18000/login',
-    logoutUrl: 'http://test.example.com:18000/logout',
-    refreshAccessTokenApiPath: '/login_refresh',
-    segmentKey: '',
-    userInfoCookieName: 'edx-user-info',
-    ignoredErrorRegex: '',
-  },
-  auth: {
-    INFO_EMAIL: 'openedx@example.com',
-    ACTIVATION_EMAIL_SUPPORT_LINK: 'http//support.test.com',
-  },
-  learning: {
-    LEGACY_THEME_NAME: 'example',
-    DISCUSSIONS_MFE_BASE_URL: 'http://test.example.com:2002',
-  },
-};
-
-describe('initialize', () => {
-  beforeEach(() => {
-    config = getSiteConfig();
-    fetchAuthenticatedUser.mockReset();
-    ensureAuthenticatedUser.mockReset();
-    hydrateAuthenticatedUser.mockReset();
-    logError.mockReset();
-    clearAllSubscriptions();
-  });
-
-  it('should call default handlers in the absence of overrides', async () => {
-    const expectedEvents = [
-      SITE_PUBSUB_INITIALIZED,
-      SITE_CONFIG_INITIALIZED,
-      SITE_LOGGING_INITIALIZED,
-      SITE_AUTH_INITIALIZED,
-      SITE_ANALYTICS_INITIALIZED,
-      SITE_I18N_INITIALIZED,
-      SITE_READY,
-    ];
-
-    function checkDispatchedDone(eventName) {
-      const index = expectedEvents.indexOf(eventName);
-      if (index > -1) {
-        expectedEvents.splice(index, 1);
-      } else {
-        throw new Error(`Unexpected event dispatched! ${eventName}`);
-      }
-    }
-
-    subscribe(SITE_PUBSUB_INITIALIZED, checkDispatchedDone);
-    subscribe(SITE_CONFIG_INITIALIZED, checkDispatchedDone);
-    subscribe(SITE_LOGGING_INITIALIZED, checkDispatchedDone);
-    subscribe(SITE_AUTH_INITIALIZED, checkDispatchedDone);
-    subscribe(SITE_ANALYTICS_INITIALIZED, checkDispatchedDone);
-    subscribe(SITE_I18N_INITIALIZED, checkDispatchedDone);
-    subscribe(SITE_READY, checkDispatchedDone);
-
-    const messages = { i_am: 'a message' };
-    await initialize({ messages });
-
-    expect(configureLogging).toHaveBeenCalledWith(NewRelicLoggingService, { config });
-    expect(configureAuth).toHaveBeenCalledWith(AxiosJwtAuthService, {
-      loggingService: getLoggingService(),
-      config,
-      middleware: [],
-    });
-    expect(configureAnalytics).toHaveBeenCalledWith(SegmentAnalyticsService, {
-      config,
-      loggingService: getLoggingService(),
-      httpClient: getAuthenticatedHttpClient(),
-    });
-    expect(configureI18n).toHaveBeenCalledWith({
-      messages,
-    });
-    expect(fetchAuthenticatedUser).toHaveBeenCalled();
-    expect(ensureAuthenticatedUser).not.toHaveBeenCalled();
-    expect(hydrateAuthenticatedUser).not.toHaveBeenCalled();
-    expect(logError).not.toHaveBeenCalled();
-  });
-
-  it('should call ensureAuthenticatedUser', async () => {
-    const messages = { i_am: 'a message' };
-    await initialize({ messages, requireAuthenticatedUser: true });
-
-    expect(fetchAuthenticatedUser).not.toHaveBeenCalled();
-    expect(ensureAuthenticatedUser).toHaveBeenCalled();
-    expect(hydrateAuthenticatedUser).not.toHaveBeenCalled();
-    expect(logError).not.toHaveBeenCalled();
-  });
-
-  it('should call hydrateAuthenticatedUser if option is set and authenticated', async () => {
-    getAuthenticatedUser.mockReturnValue({ userId: 'abc123', username: 'Barry' });
-
-    const messages = { i_am: 'a message' };
-    await initialize({ messages, hydrateAuthenticatedUser: true });
-
-    expect(fetchAuthenticatedUser).toHaveBeenCalled();
-    expect(ensureAuthenticatedUser).not.toHaveBeenCalled();
-    expect(hydrateAuthenticatedUser).toHaveBeenCalled();
-    expect(logError).not.toHaveBeenCalled();
-  });
-
-  it('should not call hydrateAuthenticatedUser if option is set but anonymous', async () => {
-    getAuthenticatedUser.mockReturnValue(null);
-
-    const messages = { i_am: 'a message' };
-    await initialize({ messages, hydrateAuthenticatedUser: true });
-
-    expect(fetchAuthenticatedUser).toHaveBeenCalled();
-    expect(ensureAuthenticatedUser).not.toHaveBeenCalled();
-    expect(hydrateAuthenticatedUser).not.toHaveBeenCalled();
-    expect(logError).not.toHaveBeenCalled();
-  });
-
-  it('should call override handlers if they exist', async () => {
-    const overrideHandlers = {
-      pubSub: jest.fn(),
-      config: jest.fn(),
-      logging: jest.fn(),
-      auth: jest.fn(),
-      analytics: jest.fn(),
-      i18n: jest.fn(),
-      ready: jest.fn(),
-      initError: jest.fn(),
-    };
-
-    await initialize({
-      messages: null,
-      handlers: overrideHandlers,
-    });
-
-    expect(overrideHandlers.pubSub).toHaveBeenCalled();
-    expect(overrideHandlers.config).toHaveBeenCalled();
-    expect(overrideHandlers.logging).toHaveBeenCalled();
-    expect(overrideHandlers.auth).toHaveBeenCalled();
-    expect(overrideHandlers.analytics).toHaveBeenCalled();
-    expect(overrideHandlers.i18n).toHaveBeenCalled();
-    expect(overrideHandlers.ready).toHaveBeenCalled();
-    expect(overrideHandlers.initError).not.toHaveBeenCalled();
-    expect(fetchAuthenticatedUser).not.toHaveBeenCalled();
-    expect(ensureAuthenticatedUser).not.toHaveBeenCalled();
-    expect(hydrateAuthenticatedUser).not.toHaveBeenCalled();
-    expect(logError).not.toHaveBeenCalled();
-  });
-
-  it('should call the default initError handler if something throws', async () => {
-    const overrideHandlers = {
-      pubSub: jest.fn(() => {
-        throw new Error('uhoh!');
-      }),
-      config: jest.fn(),
-      logging: jest.fn(),
-      auth: jest.fn(),
-      analytics: jest.fn(),
-      i18n: jest.fn(),
-      ready: jest.fn(),
-    };
-
-    function errorHandler(eventName, data) {
-      expect(eventName).toEqual(SITE_INIT_ERROR);
-      expect(data).toEqual(new Error('uhoh!'));
-    }
-
-    subscribe(SITE_INIT_ERROR, errorHandler);
-
-    await initialize({
-      messages: null,
-      handlers: overrideHandlers,
-    });
-
-    expect(overrideHandlers.pubSub).toHaveBeenCalled();
-    expect(overrideHandlers.config).not.toHaveBeenCalled();
-    expect(overrideHandlers.logging).not.toHaveBeenCalled();
-    expect(overrideHandlers.auth).not.toHaveBeenCalled();
-    expect(overrideHandlers.analytics).not.toHaveBeenCalled();
-    expect(overrideHandlers.i18n).not.toHaveBeenCalled();
-    expect(overrideHandlers.ready).not.toHaveBeenCalled();
-    expect(logError).toHaveBeenCalledWith(new Error('uhoh!'));
-  });
-
-  it('should call the override initError handler if something throws', async () => {
-    const overrideHandlers = {
-      pubSub: jest.fn(() => {
-        throw new Error('uhoh!');
-      }),
-      config: jest.fn(),
-      logging: jest.fn(),
-      auth: jest.fn(),
-      analytics: jest.fn(),
-      i18n: jest.fn(),
-      ready: jest.fn(),
-      initError: jest.fn(),
-    };
-
-    function errorHandler(eventName, data) {
-      expect(eventName).toEqual(SITE_INIT_ERROR);
-      expect(data).toEqual(new Error('uhoh!'));
-    }
-
-    subscribe(SITE_INIT_ERROR, errorHandler);
-
-    await initialize({
-      messages: null,
-      handlers: overrideHandlers,
-    });
-
-    expect(overrideHandlers.pubSub).toHaveBeenCalled();
-    expect(overrideHandlers.config).not.toHaveBeenCalled();
-    expect(overrideHandlers.logging).not.toHaveBeenCalled();
-    expect(overrideHandlers.auth).not.toHaveBeenCalled();
-    expect(overrideHandlers.analytics).not.toHaveBeenCalled();
-    expect(overrideHandlers.i18n).not.toHaveBeenCalled();
-    expect(overrideHandlers.ready).not.toHaveBeenCalled();
-    expect(overrideHandlers.initError).toHaveBeenCalledWith(new Error('uhoh!'));
-  });
-
-  it('should initialize the app with runtime configuration', async () => {
-    configureCache.mockReturnValueOnce(Promise.resolve({
-      get: (url) => {
-        const params = new URL(url).search;
-        const mfe = new URLSearchParams(params).get('mfe');
-        return ({ data: { ...newConfig.common, ...newConfig[mfe] } });
-      },
-    }));
-
-    const messages = { i_am: 'a message' };
-    await initialize({
-      messages,
-      handlers: {
-        config: () => {
-          mergeSiteConfig({
-            mfeConfigApiUrl: 'http://localhost:18000/api/mfe/v1/config',
-            siteId: 'auth',
-          });
-        }
-      }
-    });
-
-    expect(configureCache).toHaveBeenCalled();
-    expect(configureLogging).toHaveBeenCalledWith(NewRelicLoggingService, { config });
-    expect(configureAuth).toHaveBeenCalledWith(AxiosJwtAuthService, {
-      loggingService: getLoggingService(),
-      config,
-      middleware: [],
-    });
-    expect(configureAnalytics).toHaveBeenCalledWith(SegmentAnalyticsService, {
-      config,
-      loggingService: getLoggingService(),
-      httpClient: getAuthenticatedHttpClient(),
-    });
-    expect(configureI18n).toHaveBeenCalledWith({
-      messages,
-    });
-
-    expect(fetchAuthenticatedUser).toHaveBeenCalled();
-    expect(ensureAuthenticatedUser).not.toHaveBeenCalled();
-    expect(hydrateAuthenticatedUser).not.toHaveBeenCalled();
-    expect(logError).not.toHaveBeenCalled();
-    expect(getSiteConfig().siteName).toBe(newConfig.common.siteName);
-    expect(getSiteConfig().INFO_EMAIL).toBe(newConfig.auth.INFO_EMAIL);
-    expect(Object.values(getSiteConfig()).includes(newConfig.learning.DISCUSSIONS_MFE_BASE_URL)).toBeFalsy();
-  });
-
-  describe('with mocked console.error', () => {
-    beforeEach(() => {
-      console.error = jest.fn();
-    });
-
-    afterAll(() => {
-      console.error.mockRestore();
-    });
-
-    it('should initialize the app with the build config when runtime configuration fails', async () => {
-      configureCache.mockRejectedValueOnce(new Error('Api fails'));
-
-      const messages = { i_am: 'a message' };
-      await initialize({
-        messages,
-        handlers: {
-          config: () => {
-            mergeSiteConfig({
-              mfeConfigApiUrl: 'http://localhost:18000/api/mfe/v1/config',
-              siteId: 'auth',
-            });
-          }
-        }
-      });
-
-      expect(configureCache).toHaveBeenCalled();
-      expect(console.error).toHaveBeenCalledWith('Error with config API', 'Api fails');
-      expect(configureLogging).toHaveBeenCalledWith(NewRelicLoggingService, { config });
-      expect(configureAuth).toHaveBeenCalledWith(AxiosJwtAuthService, {
-        loggingService: getLoggingService(),
-        config,
-        middleware: [],
-      });
-      expect(configureAnalytics).toHaveBeenCalledWith(SegmentAnalyticsService, {
-        config,
-        loggingService: getLoggingService(),
-        httpClient: getAuthenticatedHttpClient(),
-      });
-      expect(configureI18n).toHaveBeenCalledWith({
-        messages,
-      });
-      expect(fetchAuthenticatedUser).toHaveBeenCalled();
-      expect(ensureAuthenticatedUser).not.toHaveBeenCalled();
-      expect(hydrateAuthenticatedUser).not.toHaveBeenCalled();
-      expect(logError).not.toHaveBeenCalled();
-    });
-  });
-});

package/runtime/jest.config.js

@@ -1,33 +0,0 @@
-module.exports = {
-  setupFilesAfterEnv: [
-    '<rootDir>/setupTest.js',
-  ],
-  moduleNameMapper: {
-    '\\.svg$': '<rootDir>/__mocks__/svg.js',
-    '\\.(jpg|jpeg|png|gif|eot|otf|webp|ttf|woff|woff2|mp4|webm|wav|mp3|m4a|aac|oga)$': '<rootDir/__mocks__/file.js',
-    '\\.(css|scss)$': require.resolve('identity-obj-proxy'),
-    'site.config': '<rootDir>/site.config.test.tsx',
-    '^@src/(.*)$': '<rootDir>/src/$1',
-  },
-  testEnvironment: 'jsdom',
-  testEnvironmentOptions: {
-    url: 'http://localhost/',
-  },
-  collectCoverageFrom: [
-    '<rootDir>/**/*.{js,jsx,ts,tsx}',
-  ],
-  coveragePathIgnorePatterns: [
-    '<rootDir>/setupTest.js',
-  ],
-  transformIgnorePatterns: [
-    '/node_modules/(?!(@openedx|@edx)/)',
-  ],
-  modulePathIgnorePatterns: [
-    '/dist/',
-  ],
-  testPathIgnorePatterns: [
-    '/site.config.test.tsx',
-    '/node_modules/',
-    '/dist/',
-  ],
-};

package/runtime/logging/MockLoggingService.js

@@ -1,31 +0,0 @@
-/**
- * The MockLoggingService implements both logInfo and logError as jest mock functions via
- * jest.fn().  It has no other functionality.
- *
- * @implements {LoggingService}
- * @memberof module:Logging
- */
-class MockLoggingService {
-  /**
-   * Implemented as a jest.fn()
-   *
-   * @memberof MockLoggingService
-   */
-  logInfo = jest.fn();
-
-  /**
-   * Implemented as a jest.fn()
-   *
-   * @memberof MockLoggingService
-   */
-  logError = jest.fn();
-
-  /**
-   * Implemented as a jest.fn()
-   *
-   * @memberof MockLoggingService
-   */
-  setCustomAttribute = jest.fn();
-}
-
-export default MockLoggingService;

package/runtime/logging/NewRelicLoggingService.js

@@ -1,184 +0,0 @@
-import { EnvironmentTypes } from '../../types';
-import { getSiteConfig } from '../config';
-
-/**
- * NewRelic will not log an error if it is too long.
- *
- * @ignore
- */
-export const MAX_ERROR_LENGTH = 4000;
-
-function fixErrorLength(error) {
-  if (error.message && error.message.length > MAX_ERROR_LENGTH) {
-    const processedError = Object.create(error);
-    processedError.message = processedError.message.substring(0, MAX_ERROR_LENGTH);
-    return processedError;
-  }
-  if (typeof error === 'string' && error.length > MAX_ERROR_LENGTH) {
-    return error.substring(0, MAX_ERROR_LENGTH);
-  }
-  return error;
-}
-
-/* Constants used as New Relic page action names. */
-const pageActionNameInfo = 'INFO';
-const pageActionNameIgnoredError = 'IGNORED_ERROR';
-
-function sendPageAction(actionName, message, customAttributes) {
-  if (getSiteConfig().environment === EnvironmentTypes.DEVELOPMENT) {
-    console.log(actionName, message, customAttributes);
-  }
-  if (window && typeof window.newrelic !== 'undefined') {
-    // https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/addpageaction/
-    window.newrelic.addPageAction(actionName, { message, ...customAttributes });
-  }
-}
-
-function sendError(error, customAttributes) {
-  if (getSiteConfig().environment === EnvironmentTypes.DEVELOPMENT) {
-    console.error(error, customAttributes);
-  }
-  if (window && typeof window.newrelic !== 'undefined') {
-    // https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/noticeerror/
-    window.newrelic.noticeError(fixErrorLength(error), customAttributes);
-  }
-}
-
-function setCustomAttribute(name, value) {
-  if (getSiteConfig().environment === EnvironmentTypes.DEVELOPMENT) {
-    console.log(name, value);
-  }
-  if (window && typeof window.newrelic !== 'undefined') {
-    // https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/setcustomattribute/
-    window.newrelic.setCustomAttribute(name, value);
-  }
-}
-
-/**
- * The NewRelicLoggingService is a concrete implementation of the logging service interface that
- * sends messages to NewRelic that can be seen in NewRelic Browser and NewRelic Insights. When in
- * development mode, all messages will instead be sent to the console.
- *
- * When you use `logError`, your errors will be checked to see if they're ignored *or* not.
- * Not-ignored errors will appear under "JS errors" for your Browser application.
- *
- * ```
- * SELECT * from JavaScriptError WHERE errorStatus is not null SINCE 10 days ago
- * ```
- *
- * Ignored errors will appear in New Relic Insights as page actions, which can be queried:
- *
- * ```
- * SELECT * from PageAction WHERE actionName = 'IGNORED_ERROR' SINCE 1 hour ago
- * ```
- *
- * When using `logInfo`, these only appear in New Relic Insights when querying for page actions as
- * follows:
- *
- * ```
- * SELECT * from PageAction WHERE actionName = 'INFO' SINCE 1 hour ago
- * ```
- *
- * You can also add your own custom metrics as an additional argument, or see the code to find
- * other standard custom attributes. By default, userId is added (via setCustomAttribute) for logged
- * in users via the auth service (AuthAxiosJwtService).
- *
- * Requires the NewRelic Browser JavaScript snippet.
- *
- * @implements {LoggingService}
- * @memberof module:Logging
- */
-export default class NewRelicLoggingService {
-  constructor(options) {
-    const config = options ? options.config : undefined;
-    /*
-        String which is an explicit error message regex. If an error message matches the regex, the error
-        is considered an *ignored* error and submitted to New Relic as a page action - not an error.
-
-        Ignored error regexes are configured per frontend application (MFE).
-
-        The regex for all ignored errors are represented in the .env files as a single string. If you need to
-        ignore multiple errors, use the standard `|` regex syntax.
-
-        For example, here's a .env line which ignores two specific errors:
-
-        ignoredErrorRegex='^\\[frontend-auth\\] Unimportant Error|Specific non-critical error #[\\d]+'
-
-        This example would ignore errors with the following messages:
-
-        [frontend-app-generic] - Specific non-critical error #45678 happened.
-        [frontend-app-generic] - Specific non-critical error #93475 happened.
-        [frontend-auth] Unimportant Error: Browser strangeness occurred.
-
-        To test your regex additions, use a JS CLI environment (such as node) and run code like this:
-
-        x = new RegExp('^\\[frontend-auth\\] Unimportant Error|Specific non-critical error #[\\d]+');
-        '[frontend-app-generic] - Specific non-critical error #45678 happened.'.match(x);
-        '[frontend-auth] Unimportant Error: Browser strangeness occurred.'.match(x);
-        'This error should not match anything!'.match(x);
-
-        For edx.org, add new error message regexes in edx-internal YAML as needed.
-    */
-    this.ignoredErrorRegexes = config ? config.ignoredErrorRegex : undefined;
-  }
-
-  /**
-   *
-   *
-   * @param {*} infoStringOrErrorObject
-   * @param {*} [customAttributes={}]
-   * @memberof NewRelicLoggingService
-   */
-  logInfo(infoStringOrErrorObject, customAttributes = {}) {
-    let message = infoStringOrErrorObject;
-    let customAttrs = customAttributes;
-    if (typeof infoStringOrErrorObject === 'object' && 'message' in infoStringOrErrorObject) {
-      /* Caller has passed in an error object to be logged as a page action. */
-      /* Extract the attributes and the message. */
-      const infoCustomAttributes = infoStringOrErrorObject.customAttributes || {};
-      customAttrs = { ...infoCustomAttributes, ...customAttributes };
-      message = infoStringOrErrorObject.message;
-    }
-    sendPageAction(pageActionNameInfo, message, customAttrs);
-  }
-
-  /**
-   *
-   *
-   * @param {*} errorStringOrObject
-   * @param {*} [customAttributes={}]
-   * @memberof NewRelicLoggingService
-   */
-  logError(errorStringOrObject, customAttributes = {}) {
-    const errorCustomAttributes = errorStringOrObject.customAttributes || {};
-    let allCustomAttributes = { ...errorCustomAttributes, ...customAttributes };
-    if (Object.keys(allCustomAttributes).length === 0) {
-      // noticeError expects undefined if there are no custom attributes.
-      allCustomAttributes = undefined;
-    }
-
-    /*
-        Separate the errors into ignored errors and other errors.
-        Ignored errors are logged via adding a page action.
-        Other errors are logged via noticeError and count as "JS Errors" for the application.
-    */
-    const errorMessage = errorStringOrObject.message || (typeof errorStringOrObject === 'string' ? errorStringOrObject : '');
-    if (this.ignoredErrorRegexes && errorMessage.match(this.ignoredErrorRegexes)) {
-      /* ignored error */
-      sendPageAction(pageActionNameIgnoredError, errorMessage, allCustomAttributes);
-    } else {
-      /*  error! */
-      sendError(errorStringOrObject, allCustomAttributes);
-    }
-  }
-
-  /**
-   * Sets a custom attribute that will be included with all subsequent log messages.
-   *
-   * @param {string} name
-   * @param {string|number|null} value
-   */
-  setCustomAttribute(name, value) {
-    setCustomAttribute(name, value);
-  }
-}