autnam 1.0.0

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

@@ -0,0 +1,91 @@
+/* Copyright (c) 2018-2020 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import fetchMock from "fetch-mock";
+import { exchangeToken, platformSelf } from "../src/app-tokens.js";
+
+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-request/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.js";
+
+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-request/test/fetchToken.test.ts

@@ -0,0 +1,110 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import fetchMock from "fetch-mock";
+import { fetchToken } from "../src/index.js";
+
+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-request/test/generateToken.test.ts

@@ -0,0 +1,40 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import fetchMock from "fetch-mock";
+import { generateToken } from "../src/index.js";
+import { TOMORROW } from "../../../scripts/test-helpers.js";
+
+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);
+      });
+  });
+});

package/packages/arcgis-rest-request/test/mocks/errors.ts

@@ -0,0 +1,76 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+export const ArcGISOnlineError: any = {
+  error: {
+    code: 400,
+    message: "'type' and 'title' property required.",
+    details: []
+  }
+};
+
+export const ArcGISOnlineAuthError: any = {
+  error: {
+    code: 498,
+    message: "Invalid token.",
+    details: []
+  }
+};
+
+export const ArcGISOnlineErrorNoMessageCode: any = {
+  error: {
+    code: 403,
+    message:
+      "You do not have permissions to access this resource or perform this operation.",
+    details: []
+  }
+};
+
+export const ArcGISOnlineErrorNoCode: any = {
+  error: {
+    message:
+      "You do not have permissions to access this resource or perform this operation.",
+    details: []
+  }
+};
+
+export const ArcGISServerTokenRequired: any = {
+  error: {
+    code: 499,
+    message: "Token Required",
+    messageCode: "GWM_0003",
+    details: ["Token Required"]
+  }
+};
+
+export const BillingError: any = {
+  code: 500,
+  message: "Error getting subscription info",
+  status: "failure",
+  details: null as any
+};
+
+export const BillingErrorWithCode200: any = {
+  code: 200,
+  message: null,
+  status: "failure"
+};
+
+export const TaskErrorWithJSON: any = {
+  status: "failed",
+  statusMessage:
+    '{"code":400,"message":"Index was outside the bounds of the array."}'
+};
+
+export const TaskError: any = {
+  status: "failed",
+  statusMessage: "failed"
+};
+
+export const GenerateTokenError: any = {
+  error: {
+    code: 400,
+    message: "Unable to generate token.",
+    details: ["Invalid username or password."]
+  }
+};

package/packages/arcgis-rest-request/test/mocks/geojson-feature-collection.ts

@@ -0,0 +1,13 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+export const GeoJSONFeatureCollection: any = {
+  type: "FeatureCollection",
+  crs: {
+    type: "name",
+    properties: {
+      name: "EPSG:4326"
+    }
+  },
+  features: []
+};

package/packages/arcgis-rest-request/test/mocks/param-builder.ts

@@ -0,0 +1,7 @@
+import { IParamBuilder } from "../../src/index";
+
+export class MockParamBuilder implements IParamBuilder {
+  public toParam() {
+    return "1=1";
+  }
+}