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

package/runtime/initialize.test.js

@@ -0,0 +1,356 @@
+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/logging/NewRelicLoggingService.test.js

@@ -0,0 +1,214 @@
+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/react/AuthenticatedPageRoute.test.jsx

@@ -0,0 +1,135 @@
+/* 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');
+  });
+});