@openedx/frontend-base 1.0.0-alpha.4 → 1.0.0-alpha.41

package/runtime/jest.config.js

@@ -1,32 +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',
-  },
-  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);
-  }
-}

package/runtime/logging/NewRelicLoggingService.test.js

@@ -1,214 +0,0 @@
-import NewRelicLoggingService, { MAX_ERROR_LENGTH } from './NewRelicLoggingService';
-
-global.newrelic = {
-  addPageAction: jest.fn(),
-  noticeError: jest.fn(),
-  setCustomAttribute: jest.fn(),
-};
-
-let service = null;
-const configWithIgnoredErrors = {
-  config: {
-    ignoredErrorRegex: /^Ignore this error|very minor/,
-  },
-};
-const configWithNullIgnoredErrors = {
-  config: {
-    ignoredErrorRegex: null,
-  },
-};
-const configWithEmptyIgnoredErrors = {
-  config: {
-    ignoredErrorRegex: '',
-  },
-};
-const configWithWhitespaceIgnoredErrors = {
-  config: {
-    ignoredErrorRegex: '     ',
-  },
-};
-const configWithMissingIgnoredErrors = {
-  config: {},
-};
-
-describe('NewRelicLoggingService', () => {
-  beforeEach(() => {
-    service = new NewRelicLoggingService(configWithIgnoredErrors);
-  });
-
-  describe('logInfo', () => {
-    beforeEach(() => {
-      global.newrelic.addPageAction.mockReset();
-    });
-
-    it('calls New Relic client to log message if the client is available', () => {
-      const message = 'Test log';
-      service.logInfo(message);
-      expect(global.newrelic.addPageAction).toHaveBeenCalledWith('INFO', { message });
-    });
-
-    it('handles plain string message properly with custom attributes', () => {
-      const message = 'Test log';
-      const attrs = { a: 1, b: 'red', c: 3 };
-      service.logInfo(message, attrs);
-      expect(global.newrelic.addPageAction).toHaveBeenCalledWith('INFO', {
-        message, ...attrs,
-      });
-    });
-
-    it('handles plain string message properly with no custom attributes', () => {
-      const message = 'Test log';
-      service.logInfo(message);
-      expect(global.newrelic.addPageAction).toHaveBeenCalledWith('INFO', {
-        message,
-      });
-    });
-
-    it('handles error object properly with custom attributes', () => {
-      const message = 'Test log';
-      const attrs = { a: 1, b: 'red', c: 3 };
-      const err = { message, customAttributes: attrs };
-      service.logInfo(err);
-      expect(global.newrelic.addPageAction).toHaveBeenCalledWith('INFO', {
-        message, ...attrs,
-      });
-    });
-
-    it('handles error object properly with no custom attributes', () => {
-      const message = 'Test log';
-      const err = { message };
-      service.logInfo(err);
-      expect(global.newrelic.addPageAction).toHaveBeenCalledWith('INFO', {
-        message,
-      });
-    });
-
-    it('handles error object properly with custom attributes in object and param', () => {
-      const message = 'Test log';
-      const attrsObj = { a: 1, b: 'red', c: 3 };
-      const attrsParam = { x: 99, y: 'blue', z: 987 };
-      const err = { message, customAttributes: attrsObj };
-      service.logInfo(err, attrsParam);
-      expect(global.newrelic.addPageAction).toHaveBeenCalledWith('INFO', {
-        message, ...attrsObj, ...attrsParam,
-      });
-    });
-  });
-
-  describe('logError', () => {
-    beforeEach(() => {
-      global.newrelic.noticeError.mockReset();
-    });
-
-    it('calls New Relic client to log error if the client is available', () => {
-      const error = new Error('Failed!');
-      service.logError(error);
-      expect(global.newrelic.noticeError).toHaveBeenCalledWith(error, undefined);
-    });
-
-    it('calls New Relic client to log error if the client is available', () => {
-      const error = new Error('Failed!');
-      service.logError(error);
-      expect(global.newrelic.noticeError).toHaveBeenCalledWith(error, undefined);
-    });
-
-    it('calls New Relic client to log error and merges in customAttributes from the error', () => {
-      const error = new Error('Failed!');
-      error.customAttributes = {
-        boo: 'yah',
-        foo: 'gah',
-      };
-      service.logError(error, { foo: 'wins', bar: 'baz' });
-      expect(global.newrelic.noticeError).toHaveBeenCalledWith(error, { boo: 'yah', foo: 'wins', bar: 'baz' });
-    });
-
-    it('calls New Relic client with truncated error string', () => {
-      const error = new Array(MAX_ERROR_LENGTH + 500 + 1).join('0');
-      const expectedError = new Array(MAX_ERROR_LENGTH + 1).join('0');
-      service.logError(error);
-      expect(global.newrelic.noticeError).toHaveBeenCalledWith(expectedError, undefined);
-    });
-
-    it('calls New Relic client with truncated error', () => {
-      const error = {
-        message: new Array(MAX_ERROR_LENGTH + 500 + 1).join('0'),
-      };
-      const expectedError = {
-        message: new Array(MAX_ERROR_LENGTH + 1).join('0'),
-      };
-      service.logError(error);
-      expect(global.newrelic.noticeError).toHaveBeenCalledWith(expectedError, undefined);
-    });
-  });
-
-  describe('setCustomAttribute', () => {
-    beforeEach(() => {
-      global.newrelic.setCustomAttribute.mockReset();
-    });
-
-    it('calls New Relic client with name and value', () => {
-      service.setCustomAttribute('foo', 'bar');
-      expect(global.newrelic.setCustomAttribute).toHaveBeenCalledWith('foo', 'bar');
-    });
-  });
-
-  describe('ignoredErrors', () => {
-    beforeEach(() => {
-      global.newrelic.addPageAction.mockReset();
-      global.newrelic.noticeError.mockReset();
-    });
-
-    it('calls New Relic client as error objects but ignored and sent as page action', () => {
-      const error1 = new Error('Ignore this error!');
-      error1.customAttributes = {
-        hi: 'hello',
-      };
-      service.logError(error1);
-      expect(global.newrelic.addPageAction).toHaveBeenCalledWith('IGNORED_ERROR', {
-        message: error1.message, ...error1.customAttributes,
-      });
-
-      const error2 = new Error('very minor');
-      service.logError(error2);
-      expect(global.newrelic.addPageAction).toHaveBeenCalledWith('IGNORED_ERROR', {
-        message: error2.message,
-      });
-    });
-
-    it('calls New Relic client as error string but ignored and sent as page action', () => {
-      const error = 'Ignore this error!';
-      service.logError(error);
-      expect(global.newrelic.addPageAction).toHaveBeenCalledWith('IGNORED_ERROR', {
-        message: error,
-      });
-    });
-
-    it('calls New Relic client as error object but with null ignored error config', () => {
-      service = new NewRelicLoggingService(configWithNullIgnoredErrors);
-      const error = new Error('Ignore this error!');
-      service.logError(error);
-      expect(global.newrelic.noticeError).toHaveBeenCalledWith(error, undefined);
-    });
-
-    it('calls New Relic client as error object but with empty ignored error config', () => {
-      service = new NewRelicLoggingService(configWithEmptyIgnoredErrors);
-      const error = new Error('Ignore this error!');
-      service.logError(error);
-      expect(global.newrelic.noticeError).toHaveBeenCalledWith(error, undefined);
-    });
-
-    it('calls New Relic client as error object but with whitespace-only ignored error config', () => {
-      service = new NewRelicLoggingService(configWithWhitespaceIgnoredErrors);
-      const error = new Error('Ignore this error!');
-      service.logError(error);
-      expect(global.newrelic.noticeError).toHaveBeenCalledWith(error, undefined);
-    });
-
-    it('calls New Relic client as error object but with missing ignored error config', () => {
-      service = new NewRelicLoggingService(configWithMissingIgnoredErrors);
-      const error = new Error('Ignore this error!');
-      service.logError(error);
-      expect(global.newrelic.noticeError).toHaveBeenCalledWith(error, undefined);
-    });
-  });
-});

package/runtime/logging/types.ts

@@ -1,4 +0,0 @@
-export interface LoggingService {
-  logError: (errorStringOrObject: string | Error, customAttributes: any) => void,
-  logInfo: (infoStringOrErrorObject: string | Error, customAttributes: any) => void,
-}

package/runtime/react/AuthenticatedPageRoute.test.jsx

@@ -1,135 +0,0 @@
-/* eslint-disable react/jsx-no-constructed-context-values */
-import { render } from '@testing-library/react';
-import { MemoryRouter, Route, Routes } from 'react-router-dom';
-import { sendPageEvent } from '../analytics';
-import { getAuthenticatedUser, getLoginRedirectUrl } from '../auth';
-import { getSiteConfig } from '../config';
-import SiteContext from './SiteContext';
-import AuthenticatedPageRoute from './AuthenticatedPageRoute';
-
-jest.mock('../subscriptions');
-jest.mock('../analytics');
-jest.mock('../auth');
-
-describe('AuthenticatedPageRoute', () => {
-  const { location } = global;
-
-  beforeEach(() => {
-    delete global.location;
-    global.location = {
-      assign: jest.fn(),
-    };
-    sendPageEvent.mockReset();
-    getLoginRedirectUrl.mockReset();
-    getAuthenticatedUser.mockReset();
-  });
-
-  afterEach(() => {
-    global.location = location;
-  });
-
-  it('should redirect to login if not authenticated', () => {
-    getAuthenticatedUser.mockReturnValue(null);
-    getLoginRedirectUrl.mockReturnValue('http://localhost/login?next=http%3A%2F%2Flocalhost%2Fauthenticated');
-    const component = (
-      <SiteContext.Provider
-        value={{
-          authenticatedUser: getAuthenticatedUser(),
-          siteConfig: getSiteConfig(),
-        }}
-      >
-        <MemoryRouter initialEntries={['/authenticated']}>
-          <Routes>
-            <Route path="/" element={() => <p>Anonymous</p>} />
-            <Route path="/authenticated" element={<AuthenticatedPageRoute><p>Authenticated</p></AuthenticatedPageRoute>} />
-          </Routes>
-        </MemoryRouter>
-      </SiteContext.Provider>
-    );
-    global.location.href = 'http://localhost/authenticated';
-    render(component);
-    expect(getLoginRedirectUrl).toHaveBeenCalledWith('http://localhost/authenticated');
-    expect(sendPageEvent).not.toHaveBeenCalled();
-    expect(global.location.assign).toHaveBeenCalledWith('http://localhost/login?next=http%3A%2F%2Flocalhost%2Fauthenticated');
-  });
-
-  it('should redirect to custom redirect URL if not authenticated', () => {
-    getAuthenticatedUser.mockReturnValue(null);
-    getLoginRedirectUrl.mockReturnValue('http://localhost/login?next=http%3A%2F%2Flocalhost%2Fauthenticated');
-    const authenticatedElement = (
-      <AuthenticatedPageRoute redirectUrl="http://localhost/elsewhere">
-        <p>Authenticated</p>
-      </AuthenticatedPageRoute>
-    );
-    const component = (
-      <SiteContext.Provider
-        value={{
-          authenticatedUser: getAuthenticatedUser(),
-          siteConfig: getSiteConfig(),
-        }}
-      >
-        <MemoryRouter initialEntries={['/authenticated']}>
-          <Routes>
-            <Route path="/" component={() => <p>Anonymous</p>} />
-            <Route path="/authenticated" element={authenticatedElement} />
-          </Routes>
-        </MemoryRouter>
-      </SiteContext.Provider>
-    );
-    render(component);
-    expect(getLoginRedirectUrl).not.toHaveBeenCalled();
-    expect(sendPageEvent).not.toHaveBeenCalled();
-    expect(global.location.assign).toHaveBeenCalledWith('http://localhost/elsewhere');
-  });
-
-  it('should not call login if not the current route', () => {
-    getAuthenticatedUser.mockReturnValue(null);
-    getLoginRedirectUrl.mockReturnValue('http://localhost/login?next=http%3A%2F%2Flocalhost%2Fauthenticated');
-    const component = (
-      <SiteContext.Provider
-        value={{
-          authenticatedUser: getAuthenticatedUser(),
-          siteConfig: getSiteConfig(),
-        }}
-      >
-        <MemoryRouter>
-          <Routes>
-            <Route path="/" element={<p>Anonymous</p>} />
-            <Route path="/authenticated" element={<AuthenticatedPageRoute><p>Authenticated</p></AuthenticatedPageRoute>} />
-          </Routes>
-        </MemoryRouter>
-      </SiteContext.Provider>
-    );
-    const wrapper = render(component);
-
-    expect(getLoginRedirectUrl).not.toHaveBeenCalled();
-    expect(global.location.assign).not.toHaveBeenCalled();
-    expect(sendPageEvent).not.toHaveBeenCalled();
-    const element = wrapper.container.querySelector('p');
-    expect(element.textContent).toEqual('Anonymous'); // This is just a sanity check on our setup.
-  });
-
-  it('should render authenticated route if authenticated', () => {
-    const component = (
-      <SiteContext.Provider
-        value={{
-          authenticatedUser: { userId: 12345, username: 'edx' },
-          siteConfig: getSiteConfig(),
-        }}
-      >
-        <MemoryRouter initialEntries={['/authenticated']}>
-          <Routes>
-            <Route path="/" element={<p>Anonymous</p>} />
-            <Route path="/authenticated" element={<AuthenticatedPageRoute><p>Authenticated</p></AuthenticatedPageRoute>} />
-          </Routes>
-        </MemoryRouter>
-      </SiteContext.Provider>
-    );
-    const wrapper = render(component);
-    expect(getLoginRedirectUrl).not.toHaveBeenCalled();
-    expect(global.location.assign).not.toHaveBeenCalled();
-    expect(sendPageEvent).toHaveBeenCalled();
-    const element = wrapper.container.querySelector('p');
-    expect(element.textContent).toEqual('Authenticated');
-  });
-});

package/runtime/react/CombinedAppProvider.tsx

@@ -1,46 +0,0 @@
-import { ReactNode } from 'react';
-import { App, AppProvider } from '../../types';
-import { getSiteConfig } from '../config';
-
-const combineProviders = (providers: AppProvider[]): AppProvider => {
-  return providers.reduce(
-    (AccumulatedProviders, CurrentProvider) => {
-      // eslint-disable-next-line react/prop-types
-      const CombinedProvider: AppProvider = ({ children }) => (
-        <AccumulatedProviders>
-          <CurrentProvider>{children}</CurrentProvider>
-        </AccumulatedProviders>
-      );
-      return CombinedProvider;
-    },
-    ({ children }) => <>{children}</>,
-  );
-};
-
-interface CombinedAppProviderProps {
-  children: ReactNode,
-}
-
-export default function CombinedAppProvider({ children }: CombinedAppProviderProps) {
-  const { apps } = getSiteConfig();
-
-  let providers: AppProvider[] = [];
-
-  if (apps) {
-    apps.forEach(
-      (app: App) => {
-        if (Array.isArray(app.providers)) {
-          providers = providers.concat(app.providers);
-        }
-      }
-    );
-  }
-
-  const CombinedProviders = combineProviders(providers);
-
-  return (
-    <CombinedProviders>
-      {children}
-    </CombinedProviders>
-  );
-};