culparepellendus 1.0.0

package/packages/arcgis-rest-auth/test/app-tokens.test.ts

@@ -0,0 +1,95 @@
+/* Copyright (c) 2018-2020 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import * as fetchMock from "fetch-mock";
+
+import { exchangeToken, platformSelf } from "../src/app-tokens";
+
+describe("app-token functions: ", () => {
+  describe("exchangeToken:", () => {
+    it("makes a request to /oauth2/exchangeToken passing params", () => {
+      const EXCHANGE_TOKEN_URL =
+        "https://www.arcgis.com/sharing/rest/oauth2/exchangeToken";
+      fetchMock.postOnce(EXCHANGE_TOKEN_URL, {
+        token: "APP-TOKEN",
+      });
+      return exchangeToken("FAKE-TOKEN", "CLIENT-ID-ABC123")
+        .then((response) => {
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall(
+            EXCHANGE_TOKEN_URL
+          );
+          expect(url).toEqual(EXCHANGE_TOKEN_URL);
+          expect(options.body).toContain("f=json");
+          expect(options.body).toContain("token=FAKE-TOKEN");
+          expect(options.body).toContain("client_id=CLIENT-ID-ABC123");
+          expect(response).toEqual("APP-TOKEN");
+        })
+        .catch((e) => fail(e));
+    });
+    it("takes a portalUrl", () => {
+      const PORTAL_BASE_URL = "https://my-portal.com/instance/sharing/rest";
+      const PORTAL_EXCHANGE_URL = `${PORTAL_BASE_URL}/oauth2/exchangeToken`;
+      fetchMock.postOnce(PORTAL_EXCHANGE_URL, {
+        valid: true,
+        viewOnlyUserTypeApp: false,
+      });
+      return exchangeToken("FAKE-TOKEN", "CLIENT-ID-ABC123", PORTAL_BASE_URL)
+        .then((response) => {
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall(
+            PORTAL_EXCHANGE_URL
+          );
+          expect(url).toEqual(PORTAL_EXCHANGE_URL);
+        })
+        .catch((e) => fail(e));
+    });
+  });
+
+  describe("platformSelf:", () => {
+    it("makes a request to /oauth2/platformSelf passing params", () => {
+      const PLATFORM_SELF_URL =
+        "https://www.arcgis.com/sharing/rest/oauth2/platformSelf?f=json";
+      fetchMock.postOnce(PLATFORM_SELF_URL, {
+        username: "jsmith",
+        token: "APP-TOKEN",
+      });
+      return platformSelf(
+        "CLIENT-ID-ABC123",
+        "https://hub.arcgis.com/torii-provider-arcgis/redirect.html"
+      )
+        .then((response) => {
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall(
+            PLATFORM_SELF_URL
+          );
+          expect(url).toEqual(PLATFORM_SELF_URL);
+          const headers = options.headers || ({} as any);
+          expect(headers["X-Esri-Auth-Redirect-Uri"]).toBe(
+            "https://hub.arcgis.com/torii-provider-arcgis/redirect.html"
+          );
+          expect(options.credentials).toBe(
+            "include",
+            "fetch should send cookie"
+          );
+          expect(headers["X-Esri-Auth-Client-Id"]).toBe("CLIENT-ID-ABC123");
+          expect(response.token).toEqual("APP-TOKEN");
+          expect(response.username).toEqual("jsmith");
+        })
+        .catch((e) => fail(e));
+    });
+    it("takes a portalUrl", () => {
+      const PORTAL_BASE_URL = "https://my-portal.com/instance/sharing/rest";
+      const PORTAL_PLATFORM_SELF_URL = `${PORTAL_BASE_URL}/oauth2/platformSelf?f=json`;
+      fetchMock.postOnce(PORTAL_PLATFORM_SELF_URL, {
+        username: "jsmith",
+        token: "APP-TOKEN",
+      });
+      return platformSelf("FAKE-TOKEN", "CLIENT-ID-ABC123", PORTAL_BASE_URL)
+        .then((response) => {
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall(
+            PORTAL_PLATFORM_SELF_URL
+          );
+          expect(url).toEqual(PORTAL_PLATFORM_SELF_URL);
+        })
+        .catch((e) => fail(e));
+    });
+  });
+});

package/packages/arcgis-rest-auth/test/federation-utils.test.ts

@@ -0,0 +1,323 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import {
+  isFederated,
+  isOnline,
+  getOnlineEnvironment,
+  normalizeOnlinePortalUrl,
+  canUseOnlineToken
+} from "../src/federation-utils";
+
+describe("federation utils", () => {
+  describe("isOnline()", () => {
+    it("should detect if a url is part of ArcGIS Online or not", () => {
+      // https standard portal URLs
+      expect(isOnline("https://devext.arcgis.com/sharing/rest")).toBe(true);
+      expect(isOnline("https://qaext.arcgis.com/sharing/rest")).toBe(true);
+      expect(isOnline("https://www.arcgis.com/sharing/rest")).toBe(true);
+
+      // https org portal URLs
+      expect(isOnline("https://someorg.mapsdev.arcgis.com/sharing/rest")).toBe(
+        true
+      );
+      expect(isOnline("https://someorg.mapsqa.arcgis.com/sharing/rest")).toBe(
+        true
+      );
+      expect(isOnline("https://someorg.maps.arcgis.com/sharing/rest")).toBe(
+        true
+      );
+
+      // http standard portal URLs
+      expect(isOnline("http://devext.arcgis.com/sharing/rest")).toBe(true);
+      expect(isOnline("http://qaext.arcgis.com/sharing/rest")).toBe(true);
+      expect(isOnline("http://www.arcgis.com/sharing/rest")).toBe(true);
+
+      // http org portal URLs
+      expect(isOnline("http://someorg.mapsdev.arcgis.com/sharing/rest")).toBe(
+        true
+      );
+      expect(isOnline("http://someorg.mapsqa.arcgis.com/sharing/rest")).toBe(
+        true
+      );
+      expect(isOnline("http://someorg.maps.arcgis.com/sharing/rest")).toBe(
+        true
+      );
+
+      // online service URLs
+      expect(
+        isOnline(
+          "https://services1.arcgis.com/Hp6G80Pky0om7QvQ/arcgis/rest/services/PowerPlants/FeatureServer/"
+        )
+      ).toBe(true);
+      expect(
+        isOnline(
+          "https://services8.arcgis.com/Q1W9j3Lr1BaxMiWi/arcgis/rest/info"
+        )
+      ).toBe(true);
+
+      // non online URLs
+      expect(
+        isOnline(
+          "https://mapservices.nps.gov/arcgis/rest/services/LandResourcesDivisionTractAndBoundaryService/MapServer"
+        )
+      ).toBe(false);
+    });
+  });
+
+  describe("getOnlineEnvironment()", () => {
+    it("should fetch the proper ArcGIS Online Environment for a variety of URLs", () => {
+      // https standard portal URLs
+      expect(
+        getOnlineEnvironment("https://devext.arcgis.com/sharing/rest")
+      ).toBe("dev");
+      expect(
+        getOnlineEnvironment("https://qaext.arcgis.com/sharing/rest")
+      ).toBe("qa");
+      expect(getOnlineEnvironment("https://www.arcgis.com/sharing/rest")).toBe(
+        "production"
+      );
+
+      // https org portal URLs
+      expect(
+        getOnlineEnvironment("https://someorg.mapsdev.arcgis.com/sharing/rest")
+      ).toBe("dev");
+      expect(
+        getOnlineEnvironment("https://someorg.mapsqa.arcgis.com/sharing/rest")
+      ).toBe("qa");
+      expect(
+        getOnlineEnvironment("https://someorg.maps.arcgis.com/sharing/rest")
+      ).toBe("production");
+
+      // http standard portal URLs
+      expect(
+        getOnlineEnvironment("http://devext.arcgis.com/sharing/rest")
+      ).toBe("dev");
+      expect(getOnlineEnvironment("http://qaext.arcgis.com/sharing/rest")).toBe(
+        "qa"
+      );
+      expect(getOnlineEnvironment("http://www.arcgis.com/sharing/rest")).toBe(
+        "production"
+      );
+
+      // http org portal URLs
+      expect(
+        getOnlineEnvironment("http://someorg.mapsdev.arcgis.com/sharing/rest")
+      ).toBe("dev");
+      expect(
+        getOnlineEnvironment("http://someorg.mapsqa.arcgis.com/sharing/rest")
+      ).toBe("qa");
+      expect(
+        getOnlineEnvironment("http://someorg.maps.arcgis.com/sharing/rest")
+      ).toBe("production");
+
+      // online service URLs
+      expect(
+        getOnlineEnvironment(
+          "https://services1.arcgis.com/Hp6G80Pky0om7QvQ/arcgis/rest/services/PowerPlants/FeatureServer/"
+        )
+      ).toBe("production");
+
+      expect(
+        getOnlineEnvironment(
+          "https://services8.arcgis.com/Q1W9j3Lr1BaxMiWi/arcgis/rest/info"
+        )
+      ).toBe("production");
+
+      expect(
+        getOnlineEnvironment(
+          "https://basemaps.arcgis.com/arcgis/rest/services/World_Basemap_v2/VectorTileServer"
+        )
+      ).toBe("production");
+
+      expect(
+        getOnlineEnvironment(
+          "https://servicesdev.arcgis.com/kRtcltUX8zQf4sFu/arcgis/rest/services/test/FeatureServer"
+        )
+      ).toBe("dev");
+
+      // non online URLs
+      expect(
+        getOnlineEnvironment(
+          "https://mapservices.nps.gov/arcgis/rest/services/LandResourcesDivisionTractAndBoundaryService/MapServer"
+        )
+      ).toBe(null);
+    });
+  });
+
+  describe("normalizeOnlinePortalUrl()", () => {
+    it("should normalize portal URLs for ArcGIS Online organzation portals", () => {
+      expect(
+        normalizeOnlinePortalUrl("https://devext.arcgis.com/sharing/rest")
+      ).toBe("https://devext.arcgis.com/sharing/rest");
+      expect(
+        normalizeOnlinePortalUrl("https://qaext.arcgis.com/sharing/rest")
+      ).toBe("https://qaext.arcgis.com/sharing/rest");
+      expect(
+        normalizeOnlinePortalUrl("https://www.arcgis.com/sharing/rest")
+      ).toBe("https://www.arcgis.com/sharing/rest");
+
+      // https org portal URLs
+      expect(
+        normalizeOnlinePortalUrl(
+          "https://someorg.mapsdev.arcgis.com/sharing/rest"
+        )
+      ).toBe("https://devext.arcgis.com/sharing/rest");
+      expect(
+        normalizeOnlinePortalUrl(
+          "https://someorg.mapsqa.arcgis.com/sharing/rest"
+        )
+      ).toBe("https://qaext.arcgis.com/sharing/rest");
+      expect(
+        normalizeOnlinePortalUrl("https://someorg.maps.arcgis.com/sharing/rest")
+      ).toBe("https://www.arcgis.com/sharing/rest");
+
+      // non AGOL portals
+      expect(
+        normalizeOnlinePortalUrl("https://mygis.city.gov/sharing/rest")
+      ).toBe("https://mygis.city.gov/sharing/rest");
+    });
+  });
+
+  describe("canUseOnlineToken()", () => {
+    it("should allow using the portal token for requests between online where the domains match", () => {
+      expect(
+        canUseOnlineToken(
+          "https://devext.arcgis.com/sharing/rest",
+          "https://servicesdev.arcgis.com/f8b/arcgis/rest/services/Custom/FeatureServer/0"
+        )
+      ).toBe(true);
+
+      expect(
+        canUseOnlineToken(
+          "https://qaext.arcgis.com/sharing/rest",
+          "https://servicesqa.arcgis.com/f8b/arcgis/rest/services/Custom/FeatureServer/0"
+        )
+      ).toBe(true);
+
+      expect(
+        canUseOnlineToken(
+          "https://www.arcgis.com/sharing/rest",
+          "https://services.arcgis.com/f8b/arcgis/rest/services/Custom/FeatureServer/0"
+        )
+      ).toBe(true);
+    });
+
+    it("should normalize org portals for checking", () => {
+      expect(
+        canUseOnlineToken(
+          "https://myorg.mapsdev.arcgis.com/sharing/rest",
+          "https://servicesdev.arcgis.com/f8b/arcgis/rest/services/Custom/FeatureServer/0"
+        )
+      ).toBe(true);
+
+      expect(
+        canUseOnlineToken(
+          "https://myorg.mapsqa.arcgis.com/sharing/rest",
+          "https://servicesqa.arcgis.com/f8b/arcgis/rest/services/Custom/FeatureServer/0"
+        )
+      ).toBe(true);
+
+      expect(
+        canUseOnlineToken(
+          "https://myorg.maps.arcgis.com/sharing/rest",
+          "https://services.arcgis.com/f8b/arcgis/rest/services/Custom/FeatureServer/0"
+        )
+      ).toBe(true);
+    });
+
+    it("should not allow cross environment token use", () => {
+      expect(
+        canUseOnlineToken(
+          "https://myorg.mapsdev.arcgis.com/sharing/rest",
+          "https://services.arcgis.com/f8b/arcgis/rest/services/Custom/FeatureServer/0"
+        )
+      ).toBe(false);
+
+      expect(
+        canUseOnlineToken(
+          "https://myorg.maps.arcgis.com/sharing/rest",
+          "https://servicesqa.arcgis.com/f8b/arcgis/rest/services/Custom/FeatureServer/0"
+        )
+      ).toBe(false);
+    });
+
+    it("should not allow the online portal token to be sent outside online", () => {
+      expect(
+        canUseOnlineToken(
+          "https://devext.arcgis.com/sharing/rest",
+          "https://random.city.gov/arcgis/rest/services/parcels/FeatureServer"
+        )
+      ).toBe(false);
+
+      expect(
+        canUseOnlineToken(
+          "https://myorg.maps.arcgis.com/sharing/rest",
+          "https://random.city.gov/arcgis/rest/services/parcels/FeatureServer"
+        )
+      ).toBe(false);
+    });
+  });
+
+  describe("isFederated", () => {
+    it("should allow Online ORG URLs to match Online owning systems URL", () => {
+      expect(
+        isFederated(
+          "https://devext.arcgis.com",
+          "https://myorg.mapsdev.arcgis.com/sharing/rest"
+        )
+      ).toBe(true);
+
+      expect(
+        isFederated(
+          "https://qaext.arcgis.com",
+          "https://myorg.mapsqa.arcgis.com/sharing/rest"
+        )
+      ).toBe(true);
+
+      expect(
+        isFederated(
+          "https://www.arcgis.com",
+          "https://myorg.maps.arcgis.com/sharing/rest"
+        )
+      ).toBe(true);
+
+      expect(
+        isFederated(
+          "https://mygig.city.gov",
+          "https://myorg.maps.arcgis.com/sharing/rest"
+        )
+      ).toBe(false);
+    });
+
+    it("should allow https/http mismatches", () => {
+      expect(
+        isFederated(
+          "http://devext.arcgis.com",
+          "https://myorg.mapsdev.arcgis.com/sharing/rest"
+        )
+      ).toBe(true);
+
+      expect(
+        isFederated(
+          "https://qaext.arcgis.com",
+          "http://myorg.mapsqa.arcgis.com/sharing/rest"
+        )
+      ).toBe(true);
+
+      expect(
+        isFederated(
+          "http://devext.arcgis.com",
+          "https://devext.arcgis.com/sharing/rest"
+        )
+      ).toBe(true);
+
+      expect(
+        isFederated(
+          "https://qaext.arcgis.com",
+          "http://www.arcgis.com/sharing/rest"
+        )
+      ).toBe(false);
+    });
+  });
+});

package/packages/arcgis-rest-auth/test/fetchToken.test.ts

@@ -0,0 +1,112 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import * as fetchMock from "fetch-mock";
+import { fetchToken } from "../src/index";
+
+const TOKEN_URL = "https://www.arcgis.com/sharing/rest/oauth2/token";
+
+describe("fetchToken()", () => {
+  afterEach(fetchMock.restore);
+
+  it("should request a token with `client_credentials`, `client_id` and `client_secret`", done => {
+    fetchMock.postOnce(TOKEN_URL, {
+      access_token: "token",
+      expires_in: 1800,
+      ssl: true
+    });
+
+    fetchToken(TOKEN_URL, {
+      params: {
+        client_id: "clientId",
+        client_secret: "clientSecret",
+        grant_type: "client_credentials"
+      }
+    })
+      .then(response => {
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall(
+          TOKEN_URL
+        );
+        expect(url).toEqual(TOKEN_URL);
+        expect(options.body).toContain("f=json");
+        expect(options.body).toContain("client_id=clientId");
+        expect(options.body).toContain("client_secret=clientSecret");
+        expect(options.body).toContain("grant_type=client_credentials");
+        expect(response.token).toEqual("token");
+        expect(response.expires).toBeGreaterThan(Date.now());
+        expect(response.ssl).toEqual(true);
+        done();
+      })
+      .catch(e => {
+        fail(e);
+      });
+  });
+
+  it("should request a token with `authorization_code`, `client_id` and `redirect_uri`", done => {
+    fetchMock.postOnce(TOKEN_URL, {
+      access_token: "token",
+      expires_in: 1800,
+      refresh_token: "refreshToken",
+      username: "Casey",
+      ssl: true
+    });
+
+    fetchToken(TOKEN_URL, {
+      params: {
+        client_id: "clientId",
+        redirect_uri: "https://example-app.com/redirect-uri",
+        code: "authorizationCode",
+        grant_type: "authorization_code"
+      }
+    })
+      .then(response => {
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall(
+          TOKEN_URL
+        );
+        expect(url).toEqual(TOKEN_URL);
+        expect(options.body).toContain("f=json");
+        expect(options.body).toContain("client_id=clientId");
+        expect(options.body).toContain(
+          `redirect_uri=${encodeURIComponent(
+            "https://example-app.com/redirect-uri"
+          )}`
+        );
+        expect(options.body).toContain("grant_type=authorization_code");
+        expect(options.body).toContain("code=authorizationCode");
+        expect(response.token).toEqual("token");
+        expect(response.refreshToken).toEqual("refreshToken");
+        expect(response.username).toEqual("Casey");
+        expect(response.expires).toBeGreaterThan(Date.now());
+        expect(response.ssl).toEqual(true);
+        done();
+      })
+      .catch(e => {
+        fail(e);
+      });
+  });
+
+  it("should return ssl: false when there is no ssl property returned from endpoint response", done => {
+    fetchMock.postOnce(TOKEN_URL, {
+      access_token: "token",
+      expires_in: 1800,
+      refresh_token: "refreshToken",
+      username: "Casey"
+    });
+
+    fetchToken(TOKEN_URL, {
+      params: {
+        client_id: "clientId",
+        redirect_uri: "https://example-app.com/redirect-uri",
+        code: "authorizationCode",
+        grant_type: "authorization_code"
+      }
+    })
+      .then(response => {
+        expect(response.ssl).toEqual(false);
+        done();
+      })
+      .catch(e => {
+        fail(e);
+      });
+  });
+});

package/packages/arcgis-rest-auth/test/generateToken.test.ts

@@ -0,0 +1,102 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import * as fetchMock from "fetch-mock";
+import { generateToken } from "../src/index";
+import { TOMORROW } from "./utils";
+
+const TOKEN_URL = "https://www.arcgis.com/sharing/rest/generateToken";
+
+describe("generateToken()", () => {
+  afterEach(fetchMock.restore);
+
+  it("should generate a token for a username and password", done => {
+    fetchMock.postOnce(TOKEN_URL, {
+      token: "token",
+      expires: TOMORROW.getTime()
+    });
+
+    generateToken(TOKEN_URL, {
+      params: {
+        username: "Casey",
+        password: "Jones"
+      }
+    })
+      .then(response => {
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall(
+          TOKEN_URL
+        );
+        expect(url).toEqual(TOKEN_URL);
+        expect(options.body).toContain("f=json");
+        expect(options.body).toContain("username=Casey");
+        expect(options.body).toContain("password=Jones");
+        expect(response.token).toEqual("token");
+        expect(response.expires).toEqual(TOMORROW.getTime());
+        done();
+      })
+      .catch(e => {
+        fail(e);
+      });
+  });
+});
+
+describe("generateToken() with custom fetch", () => {
+  const oldPromise = Promise;
+  const oldFetch = fetch;
+  const oldFormData = FormData;
+
+  beforeEach(() => {
+    Promise = undefined;
+    FormData = undefined;
+    Function("return this")().fetch = undefined;
+  });
+
+  afterEach(() => {
+    Promise = oldPromise;
+    FormData = oldFormData;
+    Function("return this")().fetch = oldFetch;
+  });
+
+  it("should generate a token for a username and password with custom fetch", done => {
+    Promise = oldPromise;
+    FormData = oldFormData;
+
+    const tokenResponse = {
+      token: "token",
+      expires: TOMORROW.getTime()
+    };
+
+    const MockFetchResponse = {
+      ok: true,
+      json() {
+        return Promise.resolve(tokenResponse);
+      },
+      blob() {
+        return Promise.resolve(new Blob([JSON.stringify(tokenResponse)]));
+      },
+      text() {
+        return Promise.resolve(JSON.stringify(tokenResponse));
+      }
+    };
+
+    const MockFetch = function() {
+      return Promise.resolve(MockFetchResponse);
+    };
+
+    generateToken(TOKEN_URL, {
+      params: {
+        username: "Casey",
+        password: "Jones"
+      },
+      fetch: MockFetch as any
+    })
+      .then(response => {
+        expect(response.token).toEqual(tokenResponse.token);
+        expect(response.expires).toEqual(tokenResponse.expires);
+        done();
+      })
+      .catch(e => {
+        fail(e);
+      });
+  });
+});

package/packages/arcgis-rest-auth/test/utils.ts

@@ -0,0 +1,14 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+export const TOMORROW = (function() {
+  const now = new Date();
+  now.setDate(now.getDate() + 1);
+  return now;
+})();
+
+export const YESTERDAY = (function() {
+  const now = new Date();
+  now.setDate(now.getDate() - 1);
+  return now;
+})();

package/packages/arcgis-rest-auth/test/validate-app-access.test.ts

@@ -0,0 +1,46 @@
+/* Copyright (c) 2018-2020 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+import * as fetchMock from "fetch-mock";
+
+import { validateAppAccess } from "../src/validate-app-access";
+
+const VERIFYAPPACCESS_URL =
+  "https://www.arcgis.com/sharing/rest/oauth2/validateAppAccess";
+
+describe("validateAppAccess: ", () => {
+  it("makes a request to /oauth2/validateAppAccess passing params", () => {
+    fetchMock.postOnce(VERIFYAPPACCESS_URL, {
+      valid: true,
+      viewOnlyUserTypeApp: false,
+    });
+    return validateAppAccess("FAKE-TOKEN", "abc123")
+      .then((response) => {
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall(
+          VERIFYAPPACCESS_URL
+        );
+        expect(url).toEqual(VERIFYAPPACCESS_URL);
+        expect(options.body).toContain("f=json");
+        expect(options.body).toContain("token=FAKE-TOKEN");
+        expect(options.body).toContain("client_id=abc123");
+        expect(response.valid).toEqual(true);
+        expect(response.viewOnlyUserTypeApp).toBe(false);
+      })
+      .catch((e) => fail(e));
+  });
+  it("takes a portalUrl", () => {
+    const PORTAL_BASE_URL = "https://my-portal.com/instance/sharing/rest";
+    const PORTAL_VERIFY_URL = `${PORTAL_BASE_URL}/oauth2/validateAppAccess`;
+    fetchMock.postOnce(PORTAL_VERIFY_URL, {
+      valid: true,
+      viewOnlyUserTypeApp: false,
+    });
+    return validateAppAccess("FAKE-TOKEN", "abc123", PORTAL_BASE_URL)
+      .then((response) => {
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall(
+          PORTAL_VERIFY_URL
+        );
+        expect(url).toEqual(PORTAL_VERIFY_URL);
+      })
+      .catch((e) => fail(e));
+  });
+});