@inrupt/solid-client-authn-browser 1.13.4 → 1.15.0

package/src/Session.ts

@@ -22,14 +22,18 @@
 /**
  * @hidden
  */
-import { EventEmitter } from "events";
 import {
   EVENTS,
   ILoginInputOptions,
   ISessionInfo,
   IStorage,
+  IHasSessionEventListener,
+  ISessionEventListener,
+  buildProxyHandler,
 } from "@inrupt/solid-client-authn-core";
+import { fetch } from "@inrupt/universal-fetch";
 import { v4 } from "uuid";
+import EventEmitter from "events";
 import ClientAuthentication from "./ClientAuthentication";
 import { getClientAuthenticationWithDependencies } from "./dependencies";
 import { KEY_CURRENT_SESSION, KEY_CURRENT_URL } from "./constant";
@@ -116,7 +120,7 @@ export async function silentlyAuthenticate(
         clientSecret: storedSessionInfo.clientAppSecret,
         tokenType: storedSessionInfo.tokenType ?? "DPoP",
       },
-      session
+      session.events
     );
     return true;
   }
@@ -132,12 +136,19 @@ function isLoggedIn(
 /**
  * A {@link Session} object represents a user's session on an application. The session holds state, as it stores information enabling acces to private resources after login for instance.
  */
-export class Session extends EventEmitter {
+export class Session extends EventEmitter implements IHasSessionEventListener {
   /**
    * Information regarding the current session.
    */
   public readonly info: ISessionInfo;
 
+  /**
+   * Session attribute exposing the EventEmitter interface, to listen on session
+   * events such as login, logout, etc.
+   * @since 1.15.0
+   */
+  public readonly events: ISessionEventListener;
+
   private clientAuthentication: ClientAuthentication;
 
   private tokenRequestInProgress = false;
@@ -162,7 +173,17 @@ export class Session extends EventEmitter {
     sessionId: string | undefined = undefined
   ) {
     super();
-
+    // Until Session no longer implements EventEmitter, this.events is just a proxy
+    // to this (with some interface filtering). When we make the breaking change,
+    // this.events will be a regular EventEmitter (implementing ISessionEventEmitter):
+    // this.events = new EventEmitter();
+    this.events = new Proxy(
+      this,
+      buildProxyHandler(
+        Session.prototype,
+        "events only implements ISessionEventListener"
+      )
+    );
     if (sessionOptions.clientAuthentication) {
       this.clientAuthentication = sessionOptions.clientAuthentication;
     } else if (sessionOptions.secureStorage && sessionOptions.insecureStorage) {
@@ -191,13 +212,13 @@ export class Session extends EventEmitter {
     // enable silent refresh. The current session ID specifically stored in 'localStorage'
     // (as opposed to using our storage abstraction layer) because it is only
     // used in a browser-specific mechanism.
-    this.on(EVENTS.LOGIN, () =>
+    this.events.on(EVENTS.LOGIN, () =>
       window.localStorage.setItem(KEY_CURRENT_SESSION, this.info.sessionId)
     );
 
-    this.on(EVENTS.SESSION_EXPIRED, () => this.internalLogout(false));
+    this.events.on(EVENTS.SESSION_EXPIRED, () => this.internalLogout(false));
 
-    this.on(EVENTS.ERROR, () => this.internalLogout(false));
+    this.events.on(EVENTS.ERROR, () => this.internalLogout(false));
   }
 
   /**
@@ -216,7 +237,7 @@ export class Session extends EventEmitter {
         // Defaults the token type to DPoP
         tokenType: options.tokenType ?? "DPoP",
       },
-      this
+      this.events
     );
     // `login` redirects the user away from the app,
     // so unless it throws an error, there is no code that should run afterwards
@@ -250,7 +271,7 @@ export class Session extends EventEmitter {
     await this.clientAuthentication.logout(this.info.sessionId);
     this.info.isLoggedIn = false;
     if (emitSignal) {
-      this.emit(EVENTS.LOGOUT);
+      (this.events as EventEmitter).emit(EVENTS.LOGOUT);
     }
   };
 
@@ -282,7 +303,7 @@ export class Session extends EventEmitter {
     this.tokenRequestInProgress = true;
     const sessionInfo = await this.clientAuthentication.handleIncomingRedirect(
       url,
-      this
+      this.events
     );
     if (isLoggedIn(sessionInfo)) {
       this.setSessionInfo(sessionInfo);
@@ -290,13 +311,13 @@ export class Session extends EventEmitter {
       if (currentUrl === null) {
         // The login event can only be triggered **after** the user has been
         // redirected from the IdP with access and ID tokens.
-        this.emit(EVENTS.LOGIN);
+        (this.events as EventEmitter).emit(EVENTS.LOGIN);
       } else {
         // If an URL is stored in local storage, we are being logged in after a
         // silent authentication, so remove our currently stored URL location
         // to clean up our state now that we are completing the re-login process.
         window.localStorage.removeItem(KEY_CURRENT_URL);
-        this.emit(EVENTS.SESSION_RESTORED, currentUrl);
+        (this.events as EventEmitter).emit(EVENTS.SESSION_RESTORED, currentUrl);
       }
     } else if (options.restorePreviousSession === true) {
       // Silent authentication happens after a refresh, which means there are no
@@ -332,18 +353,20 @@ export class Session extends EventEmitter {
    * The callback is called when {@link handleIncomingRedirect} completes successfully.
    *
    * @param callback The function called when a user completes login.
+   * @deprecated Prefer session.events.on(EVENTS.LOGIN, callback)
    */
   onLogin(callback: () => unknown): void {
-    this.on(EVENTS.LOGIN, callback);
+    this.events.on(EVENTS.LOGIN, callback);
   }
 
   /**
    * Register a callback function to be called when a user logs out:
    *
    * @param callback The function called when a user completes logout.
+   * @deprecated Prefer session.events.on(EVENTS.LOGOUT, callback)
    */
   onLogout(callback: () => unknown): void {
-    this.on(EVENTS.LOGOUT, callback);
+    this.events.on(EVENTS.LOGOUT, callback);
   }
 
   /**
@@ -351,6 +374,7 @@ export class Session extends EventEmitter {
    *
    * @param callback The function called when an error occurs.
    * @since 1.11.0
+   * @deprecated Prefer session.events.on(EVENTS.ERROR, callback)
    */
   onError(
     callback: (
@@ -358,7 +382,7 @@ export class Session extends EventEmitter {
       errorDescription?: string | null
     ) => unknown
   ): void {
-    this.on(EVENTS.ERROR, callback);
+    this.events.on(EVENTS.ERROR, callback);
   }
 
   /**
@@ -368,9 +392,10 @@ export class Session extends EventEmitter {
    * at the time the session was restored.
    *
    * @param callback The function called when a user's already logged-in session is restored, e.g., after a silent authentication is completed after a page refresh.
+   * @deprecated Prefer session.events.on(EVENTS.SESSION_RESTORED, callback)
    */
   onSessionRestore(callback: (currentUrl: string) => unknown): void {
-    this.on(EVENTS.SESSION_RESTORED, callback);
+    this.events.on(EVENTS.SESSION_RESTORED, callback);
   }
 
   /**
@@ -378,9 +403,10 @@ export class Session extends EventEmitter {
    * make authenticated requests, but following a user logout.
    * @param callback The function that runs on session expiration.
    * @since 1.11.0
+   * @deprecated Prefer session.events.on(EVENTS.SESSION_EXPIRED, callback)
    */
   onSessionExpiration(callback: () => unknown): void {
-    this.on(EVENTS.SESSION_EXPIRED, callback);
+    this.events.on(EVENTS.SESSION_EXPIRED, callback);
   }
 
   private setSessionInfo(
@@ -390,7 +416,7 @@ export class Session extends EventEmitter {
     this.info.webId = sessionInfo.webId;
     this.info.sessionId = sessionInfo.sessionId;
     this.info.expirationDate = sessionInfo.expirationDate;
-    this.on(EVENTS.SESSION_EXTENDED, (expiresIn: number) => {
+    this.events.on(EVENTS.SESSION_EXTENDED, (expiresIn: number) => {
       this.info.expirationDate = Date.now() + expiresIn * 1000;
     });
   }

package/src/defaultSession.spec.ts

@@ -19,6 +19,7 @@
 // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //
 
+import { EVENTS } from "@inrupt/solid-client-authn-core";
 import { jest, it, expect } from "@jest/globals";
 import {
   fetch,
@@ -29,33 +30,34 @@ import {
   onLogin,
   onSessionRestore,
   onLogout,
+  events,
 } from "./defaultSession";
-import type * as SessionModuleType from "./Session";
-
-jest.mock("../src/Session.ts");
-
-it("does not instantiate a Session without calling one of its methods", () => {
-  const mockedSession = jest.requireMock(
-    "../src/Session.ts"
-  ) as typeof SessionModuleType;
-
-  expect(mockedSession.Session).not.toHaveBeenCalled();
+import * as SessionModule from "./Session";
+
+it("instantiates the default session lazily", () => {
+  const singletonSession = new SessionModule.Session();
+  const spiedConstructor = jest
+    .spyOn(SessionModule, "Session")
+    .mockImplementation(() => singletonSession);
+  expect(spiedConstructor).not.toHaveBeenCalled();
+  events().on(EVENTS.LOGIN, jest.fn());
+  expect(spiedConstructor).toHaveBeenCalled();
 });
 
 it("re-uses the same Session when calling multiple methods", () => {
-  const mockedSession = jest.requireMock(
-    "../src/Session.ts"
-  ) as typeof SessionModuleType;
+  const singletonSession = new SessionModule.Session();
+  const spiedConstructor = jest
+    .spyOn(SessionModule, "Session")
+    .mockImplementation(() => singletonSession);
 
-  expect(mockedSession.Session).not.toHaveBeenCalled();
+  events().on(EVENTS.LOGIN, jest.fn());
 
-  onLogin(jest.fn());
+  expect(spiedConstructor).toHaveBeenCalledTimes(1);
 
-  expect(mockedSession.Session).toHaveBeenCalledTimes(1);
+  events().on(EVENTS.LOGOUT, jest.fn());
 
-  onLogout(jest.fn());
-
-  expect(mockedSession.Session).toHaveBeenCalledTimes(1);
+  // No new session has been instantiated.
+  expect(spiedConstructor).toHaveBeenCalledTimes(1);
 });
 
 it("all functions pass on their arguments to the default session", () => {
@@ -73,6 +75,7 @@ it("all functions pass on their arguments to the default session", () => {
   const onLoginSpy = jest.spyOn(defaultSession, "onLogin");
   const onLogoutSpy = jest.spyOn(defaultSession, "onLogout");
   const onSessionRestoreSpy = jest.spyOn(defaultSession, "onSessionRestore");
+  const eventsOnSpy = jest.spyOn(defaultSession.events, "on");
 
   expect(fetchSpy).not.toHaveBeenCalled();
   // eslint-disable-next-line @typescript-eslint/no-floating-promises
@@ -94,6 +97,12 @@ it("all functions pass on their arguments to the default session", () => {
   handleIncomingRedirect("https://example.com");
   expect(handleIncomingRedirectSpy).toHaveBeenCalledTimes(1);
 
+  // onLogin will internall call events.on(...), so the following test
+  // must come first.
+  expect(eventsOnSpy).not.toHaveBeenCalled();
+  events().on(EVENTS.LOGIN, jest.fn());
+  expect(eventsOnSpy).toHaveBeenCalledTimes(1);
+
   expect(onLoginSpy).not.toHaveBeenCalled();
   onLogin(jest.fn());
   expect(onLoginSpy).toHaveBeenCalledTimes(1);

package/src/defaultSession.ts

@@ -21,7 +21,7 @@
 
 import { Session } from "./Session";
 
-let defaultSession: Session;
+let defaultSession: Session | undefined;
 
 /**
  * Obtain the {@link Session} used when not explicitly instantiating one yourself.
@@ -97,6 +97,8 @@ export const handleIncomingRedirect: Session["handleIncomingRedirect"] = (
  * @since 1.3.0
  *
  * @param callback The function called when a user completes login.
+ * @deprecated Prefer events.on(EVENTS.LOGIN, callback)
+
  */
 export const onLogin: Session["onLogin"] = (...args) => {
   const session = getDefaultSession();
@@ -108,6 +110,8 @@ export const onLogin: Session["onLogin"] = (...args) => {
  *
  * @param callback The function called when a user completes logout.
  * @since 1.3.0
+ * @deprecated Prefer events.on(EVENTS.LOGOUT, callback)
+
  */
 export const onLogout: Session["onLogout"] = (...args) => {
   const session = getDefaultSession();
@@ -119,8 +123,18 @@ export const onLogout: Session["onLogout"] = (...args) => {
  *
  * @param callback The function called when a session is restored.
  * @since 1.3.0
+ * @deprecated Prefer events.on(EVENTS.SESSION_RESTORED, callback)
  */
 export const onSessionRestore: Session["onSessionRestore"] = (...args) => {
   const session = getDefaultSession();
   return session.onSessionRestore(...args);
 };
+
+/**
+ * {@link SessionEventEmitter} instance to subscribe to events by the default session.
+ *
+ * @since Unreleased
+ */
+export const events = (): Session["events"] => {
+  return getDefaultSession().events;
+};

package/src/index.ts

@@ -34,4 +34,5 @@ export {
   NotImplementedError,
   ConfigurationError,
   InMemoryStorage,
+  EVENTS,
 } from "@inrupt/solid-client-authn-core";

package/src/login/oidc/ClientRegistrar.spec.ts

@@ -24,7 +24,7 @@ import {
   mockStorageUtility,
 } from "@inrupt/solid-client-authn-core/mocks";
 import { jest, it, describe, expect } from "@jest/globals";
-import { Response as NodeResponse } from "cross-fetch";
+import { Response as NodeResponse } from "@inrupt/universal-fetch";
 import ClientRegistrar from "./ClientRegistrar";
 import { IssuerConfigFetcherFetchConfigResponse } from "./__mocks__/IssuerConfigFetcher";
 

package/src/login/oidc/IssuerConfigFetcher.spec.ts

@@ -21,9 +21,20 @@
 
 import { jest, it, describe, expect } from "@jest/globals";
 import { mockStorageUtility } from "@inrupt/solid-client-authn-core";
-import { Response as NodeResponse } from "cross-fetch";
+import { fetch, Response as NodeResponse } from "@inrupt/universal-fetch";
+import * as UniversalFetch from "@inrupt/universal-fetch";
 import IssuerConfigFetcher from "./IssuerConfigFetcher";
 
+jest.mock("@inrupt/universal-fetch", () => {
+  const fetchModule = jest.requireActual(
+    "@inrupt/universal-fetch"
+  ) as typeof UniversalFetch;
+  return {
+    ...fetchModule,
+    fetch: jest.fn<typeof fetch>(),
+  };
+});
+
 /**
  * Test for IssuerConfigFetcher
  */
@@ -41,19 +52,22 @@ describe("IssuerConfigFetcher", () => {
   }
 
   it("should return a config based on the fetched config if none was stored in the storage", async () => {
-    const fetchResponse = new NodeResponse(
-      JSON.stringify({
-        issuer: "https://example.com",
-        // eslint-disable-next-line camelcase
-        claim_types_supported: "oidc",
-        bleepBloop: "Meep Moop",
-      })
-    ) as unknown as Response;
     const configFetcher = getIssuerConfigFetcher({
       storageUtility: mockStorageUtility({}),
     });
-    const mockFetch = (jest.fn() as any).mockResolvedValueOnce(fetchResponse);
-    window.fetch = mockFetch as typeof window.fetch;
+    const { fetch: mockFetch } = jest.requireMock(
+      "@inrupt/universal-fetch"
+    ) as jest.Mocked<typeof UniversalFetch>;
+    mockFetch.mockResolvedValueOnce(
+      new NodeResponse(
+        JSON.stringify({
+          issuer: "https://example.com",
+          // eslint-disable-next-line camelcase
+          claim_types_supported: "oidc",
+          bleepBloop: "Meep Moop",
+        })
+      )
+    );
     const fetchedConfig = await configFetcher.fetchConfig(
       "https://arbitrary.url"
     );
@@ -65,34 +79,34 @@ describe("IssuerConfigFetcher", () => {
   });
 
   it("should throw an error if the fetched config could not be converted to JSON", async () => {
-    const mockFetch = (): Promise<Response> =>
-      Promise.resolve({
-        json: () => {
-          throw new Error("Some error");
-        },
-      } as unknown as Response);
-    window.fetch = mockFetch;
+    const { fetch: mockFetch } = jest.requireMock(
+      "@inrupt/universal-fetch"
+    ) as jest.Mocked<typeof UniversalFetch>;
+    mockFetch.mockResolvedValueOnce(new NodeResponse("Not JSON."));
     const configFetcher = new IssuerConfigFetcher(mockStorageUtility({}));
 
     await expect(configFetcher.fetchConfig("https://some.url")).rejects.toThrow(
-      "[https://some.url] has an invalid configuration: Some error"
+      "[https://some.url] has an invalid configuration:"
     );
   });
 
   it("should return a config including the support for solid-oidc if present in the discovery profile", async () => {
-    const fetchResponse = new NodeResponse(
-      JSON.stringify({
-        issuer: "https://example.com",
-        // eslint-disable-next-line camelcase
-        claim_types_supported: "oidc",
-        scopes_supported: ["openid", "offline_access", "webid"],
-      })
-    ) as unknown as Response;
+    const { fetch: mockFetch } = jest.requireMock(
+      "@inrupt/universal-fetch"
+    ) as jest.Mocked<typeof UniversalFetch>;
+    mockFetch.mockResolvedValueOnce(
+      new NodeResponse(
+        JSON.stringify({
+          issuer: "https://example.com",
+          // eslint-disable-next-line camelcase
+          claim_types_supported: "oidc",
+          scopes_supported: ["openid", "offline_access", "webid"],
+        })
+      )
+    );
     const configFetcher = getIssuerConfigFetcher({
       storageUtility: mockStorageUtility({}),
     });
-    const mockFetch = (jest.fn() as any).mockResolvedValueOnce(fetchResponse);
-    window.fetch = mockFetch as typeof window.fetch;
     const fetchedConfig = await configFetcher.fetchConfig(
       "https://arbitrary.url"
     );
@@ -102,18 +116,21 @@ describe("IssuerConfigFetcher", () => {
   });
 
   it("should return a default value for the supported scopes if not advertized by the OpenID provider", async () => {
-    const fetchResponse = new NodeResponse(
-      JSON.stringify({
-        issuer: "https://example.com",
-        // eslint-disable-next-line camelcase
-        claim_types_supported: "oidc",
-      })
-    ) as unknown as Response;
+    const { fetch: mockFetch } = jest.requireMock(
+      "@inrupt/universal-fetch"
+    ) as jest.Mocked<typeof UniversalFetch>;
+    mockFetch.mockResolvedValueOnce(
+      new NodeResponse(
+        JSON.stringify({
+          issuer: "https://example.com",
+          // eslint-disable-next-line camelcase
+          claim_types_supported: "oidc",
+        })
+      )
+    );
     const configFetcher = getIssuerConfigFetcher({
       storageUtility: mockStorageUtility({}),
     });
-    const mockFetch = (jest.fn() as any).mockResolvedValueOnce(fetchResponse);
-    window.fetch = mockFetch as typeof window.fetch;
     const fetchedConfig = await configFetcher.fetchConfig(
       "https://arbitrary.url"
     );
@@ -122,17 +139,20 @@ describe("IssuerConfigFetcher", () => {
 
   it("should append the .well-known/openid-configuration path at the end of the issuer URL", async () => {
     // The response value is irrelevant to this test.
-    const mockFetch = jest.fn<typeof fetch>().mockImplementation(
+    const { fetch: mockFetch } = jest.requireMock(
+      "@inrupt/universal-fetch"
+    ) as jest.Mocked<typeof UniversalFetch>;
+    mockFetch.mockImplementation(
       async () =>
         new NodeResponse(
           JSON.stringify({
             issuer: "https://example.com",
             // eslint-disable-next-line camelcase
             claim_types_supported: "oidc",
+            scopes_supported: ["openid", "offline_access", "webid"],
           })
         )
     );
-    window.fetch = mockFetch as typeof window.fetch;
     const configFetcher = getIssuerConfigFetcher({
       storageUtility: mockStorageUtility({}),
     });

package/src/login/oidc/IssuerConfigFetcher.ts

@@ -33,6 +33,7 @@ import {
   IStorageUtility,
   ConfigurationError,
 } from "@inrupt/solid-client-authn-core";
+import { fetch } from "@inrupt/universal-fetch";
 
 export const WELL_KNOWN_OPENID_CONFIG = ".well-known/openid-configuration";
 
@@ -165,7 +166,7 @@ export default class IssuerConfigFetcher implements IIssuerConfigFetcher {
       // includes the full issuer path. See https://openid.net/specs/openid-connect-discovery-1_0.html#ProviderConfig.
       issuer.endsWith("/") ? issuer : `${issuer}/`
     ).href;
-    const issuerConfigRequestBody = await window.fetch(openIdConfigUrl);
+    const issuerConfigRequestBody = await fetch(openIdConfigUrl);
     // Check the validity of the fetched config
     try {
       issuerConfig = processConfig(await issuerConfigRequestBody.json());

package/src/login/oidc/incomingRedirectHandler/AuthCodeRedirectHandler.spec.ts

@@ -35,7 +35,8 @@ import type * as SolidClientAuthnCore from "@inrupt/solid-client-authn-core";
 import { jest, it, describe, expect } from "@jest/globals";
 import { CodeExchangeResult, getBearerToken } from "@inrupt/oidc-client-ext";
 import type * as OidcClientExt from "@inrupt/oidc-client-ext";
-import { Response, Headers } from "cross-fetch";
+import { fetch, Response, Headers } from "@inrupt/universal-fetch";
+import * as UniversalFetch from "@inrupt/universal-fetch";
 import { JWK, importJWK } from "jose";
 import { KeyObject } from "crypto";
 import { AuthCodeRedirectHandler } from "./AuthCodeRedirectHandler";
@@ -46,6 +47,16 @@ import {
   mockTokenRefresher,
 } from "../refresh/__mocks__/TokenRefresher";
 
+jest.mock("@inrupt/universal-fetch", () => {
+  const fetchModule = jest.requireActual(
+    "@inrupt/universal-fetch"
+  ) as typeof UniversalFetch;
+  return {
+    ...fetchModule,
+    fetch: jest.fn<typeof fetch>(),
+  };
+});
+
 const mockJwk = (): JWK => {
   return {
     kty: "EC",
@@ -193,8 +204,10 @@ function mockClientRegistrar(client: IClient): IClientRegistrar {
 }
 
 const mockFetch = (response: Response) => {
-  const mockedFetch = jest.fn(global.fetch).mockResolvedValue(response);
-  window.fetch = mockedFetch;
+  const { fetch: mockedFetch } = jest.requireMock(
+    "@inrupt/universal-fetch"
+  ) as jest.Mocked<typeof UniversalFetch>;
+  mockedFetch.mockResolvedValueOnce(response);
   return mockedFetch;
 };
 
@@ -405,7 +418,7 @@ describe("AuthCodeRedirectHandler", () => {
 
     it("returns an authenticated bearer fetch if requested", async () => {
       mockOidcClient();
-      const mockedFetch = jest.mocked<typeof fetch>(window.fetch);
+      const mockedFetch = jest.mocked<typeof fetch>(fetch);
       mockedFetch.mockResolvedValueOnce(
         new Response("", {
           status: 200,
@@ -433,7 +446,7 @@ describe("AuthCodeRedirectHandler", () => {
 
     it("returns an authenticated DPoP fetch if requested", async () => {
       mockOidcClient();
-      const mockedFetch = jest.mocked<typeof fetch>(window.fetch);
+      const mockedFetch = jest.mocked<typeof fetch>(fetch);
       mockedFetch.mockResolvedValueOnce(
         new Response("", {
           status: 200,
@@ -454,13 +467,9 @@ describe("AuthCodeRedirectHandler", () => {
 
     it("saves session information in storage on successful login", async () => {
       mockOidcClient();
-      window.fetch = jest.fn(global.fetch).mockReturnValue(
-        new Promise((resolve) => {
-          resolve(
-            new Response("", {
-              status: 200,
-            })
-          );
+      mockFetch(
+        new Response("", {
+          status: 200,
         })
       );
 
@@ -482,15 +491,11 @@ describe("AuthCodeRedirectHandler", () => {
     it("does not override the previously stored redirect URL", async () => {
       mockOidcClient();
 
-      window.fetch = (jest.fn() as any).mockReturnValue(
-        new Promise((resolve) => {
-          resolve(
-            new Response("", {
-              status: 200,
-            })
-          );
+      mockFetch(
+        new Response("", {
+          status: 200,
         })
-      ) as jest.Mock<typeof fetch>;
+      );
 
       const mockedStorage = mockDefaultStorageUtility();
 
@@ -510,7 +515,7 @@ describe("AuthCodeRedirectHandler", () => {
 
     it("returns the expiration time normalised to the current time", async () => {
       mockOidcClient();
-      window.fetch = jest.fn<typeof fetch>();
+      mockFetch(new Response());
       const MOCK_TIMESTAMP = 10000;
       Date.now = jest
         .fn()
@@ -533,7 +538,7 @@ describe("AuthCodeRedirectHandler", () => {
 
     it("returns null for the expiration time if none was provided", async () => {
       const mockedOidcClient = mockOidcClient();
-      window.fetch = jest.fn<typeof fetch>();
+      mockFetch(new Response());
       mockedOidcClient.getBearerToken = jest
         .fn(getBearerToken)
         .mockResolvedValueOnce({

package/src/login/oidc/incomingRedirectHandler/AuthCodeRedirectHandler.ts

@@ -27,6 +27,8 @@
 // being unauthenticated. This should be looked into when migrating to universal-fetch.
 // import { fetch } from "cross-fetch";
 
+import { fetch } from "@inrupt/universal-fetch";
+
 import {
   buildAuthenticatedFetch,
   IClient,