npm - autculpa - Versions diffs - 1.0.0 - Mend

autculpa 1.0.0

Files changed (489) hide show

package/packages/arcgis-rest-request/test/mocks/sharing-rest-info.ts ADDED Viewed

@@ -0,0 +1,41 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+export const SharingRestInfo = {
+  owningSystemUrl: "http://www.arcgis.com",
+  authInfo: {
+    tokenServicesUrl: "https://www.arcgis.com/sharing/rest/generateToken",
+    isTokenBasedSecurity: true
+  }
+};
+export const SharingRestInfoHTML = `<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
+<html>
+<head>
+<title>ArcGIS Portal Directory</title>
+<link href="/sharing/rest/files/gw.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<br/>
+<div class="gwDiv">
+<table class="navTable" width="100%"><tr><td class="breadcrumbs">ArcGIS Portal Directory</td></tr></table>
+<tr valign="top">
+<br/><br/>
+<b>
+<a href="http://resources.arcgis.com/en/help/arcgis-rest-api/" >API Reference</a>
+</b>
+</tr>
+</table>
+</div>
+</body>
+</html>`;

package/packages/arcgis-rest-request/test/mocks/webmap.ts ADDED Viewed

@@ -0,0 +1,41 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+export const WebMapAsText =
+  '{"operationalLayers":[{"id":"Alternative_Fueling_Stations_3694","layerType":"ArcGISFeatureLayer","url":"http://services.arcgis.com/rOo16HdIMeOBI4Mb/arcgis/rest/services/Alternative_Fueling_Stations/FeatureServer/0","visibility":true,"opacity":1,"title":"Alternative Fueling Stations","itemId":"44612e6217d34f40b1ce2a48f367e90a","layerDefinition":{"minScale":2896791,"maxScale":0}}],"baseMap":{"baseMapLayers":[{"id":"VectorTile_4047","type":"VectorTileLayer","layerType":"VectorTileLayer","title":"Dark Gray Canvas","styleUrl":"http://www.arcgis.com/sharing/rest/content/items/5ad3948260a147a993ef4865e3fad476/resources/styles/root.json","itemId":"5ad3948260a147a993ef4865e3fad476","visibility":true,"opacity":1}],"title":"Basemap"},"spatialReference":{"wkid":102100,"latestWkid":3857},"authoringApp":"WebMapViewer","authoringAppVersion":"5.1","version":"2.8"}';
+export const WebMapAsJSON = {
+  operationalLayers: [
+    {
+      id: "Alternative_Fueling_Stations_3694",
+      layerType: "ArcGISFeatureLayer",
+      url:
+        "http://services.arcgis.com/rOo16HdIMeOBI4Mb/arcgis/rest/services/Alternative_Fueling_Stations/FeatureServer/0",
+      visibility: true,
+      opacity: 1,
+      title: "Alternative Fueling Stations",
+      itemId: "44612e6217d34f40b1ce2a48f367e90a",
+      layerDefinition: { minScale: 2896791, maxScale: 0 }
+    }
+  ],
+  baseMap: {
+    baseMapLayers: [
+      {
+        id: "VectorTile_4047",
+        type: "VectorTileLayer",
+        layerType: "VectorTileLayer",
+        title: "Dark Gray Canvas",
+        styleUrl:
+          "http://www.arcgis.com/sharing/rest/content/items/5ad3948260a147a993ef4865e3fad476/resources/styles/root.json",
+        itemId: "5ad3948260a147a993ef4865e3fad476",
+        visibility: true,
+        opacity: 1
+      }
+    ],
+    title: "Basemap"
+  },
+  spatialReference: { wkid: 102100, latestWkid: 3857 },
+  authoringApp: "WebMapViewer",
+  authoringAppVersion: "5.1",
+  version: "2.8"
+};

package/packages/arcgis-rest-request/test/request.test.ts ADDED Viewed

@@ -0,0 +1,563 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+import {
+  request,
+  ErrorTypes,
+  setDefaultRequestOptions,
+  IRequestOptions
+} from "../src/index.js";
+import fetchMock from "fetch-mock";
+import {
+  SharingRestInfo,
+  SharingRestInfoHTML
+} from "./mocks/sharing-rest-info.js";
+import { MockParamBuilder } from "./mocks/param-builder.js";
+import { ArcGISOnlineError } from "./mocks/errors.js";
+import { WebMapAsText, WebMapAsJSON } from "./mocks/webmap.js";
+import { GeoJSONFeatureCollection } from "./mocks/geojson-feature-collection.js";
+describe("request()", () => {
+  afterEach(() => {
+    fetchMock.restore();
+  });
+  it("should make a basic POST request", (done) => {
+    fetchMock.once("*", SharingRestInfo);
+    request("https://www.arcgis.com/sharing/rest/info")
+      .then((response) => {
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual("https://www.arcgis.com/sharing/rest/info");
+        expect(options.method).toBe("POST");
+        expect(response).toEqual(SharingRestInfo);
+        expect(options.body).toContain("f=json");
+        done();
+      })
+      .catch((e) => {
+        fail(e);
+      });
+  });
+  it("should make a basic GET request", (done) => {
+    fetchMock.once("*", SharingRestInfo);
+    request("https://www.arcgis.com/sharing/rest/info", {
+      httpMethod: "GET"
+    })
+      .then((response) => {
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual("https://www.arcgis.com/sharing/rest/info?f=json");
+        expect(options.method).toBe("GET");
+        expect(response).toEqual(SharingRestInfo);
+        done();
+      })
+      .catch((e) => {
+        fail(e);
+      });
+  });
+  it("should make a basic GET request for text", (done) => {
+    fetchMock.once("*", WebMapAsText);
+    request(
+      "https://www.arcgis.com/sharing/rest/content/items/43a8e51789044d9480a20089a84129ad/data",
+      {
+        httpMethod: "GET",
+        params: { f: "text" }
+      }
+    )
+      .then((response) => {
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          "https://www.arcgis.com/sharing/rest/content/items/43a8e51789044d9480a20089a84129ad/data?f=text"
+        );
+        expect(options.method).toBe("GET");
+        expect(response).toEqual(WebMapAsText);
+        done();
+      })
+      .catch((e) => {
+        fail(e);
+      });
+  });
+  it("should make a basic GET request for html", (done) => {
+    fetchMock.once("*", SharingRestInfoHTML);
+    request("https://www.arcgis.com/sharing/rest/info", {
+      httpMethod: "GET",
+      params: { f: "html" }
+    })
+      .then((response) => {
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual("https://www.arcgis.com/sharing/rest/info?f=html");
+        expect(options.method).toBe("GET");
+        expect(response).toEqual(SharingRestInfoHTML);
+        done();
+      })
+      .catch((e) => {
+        fail(e);
+      });
+  });
+  it("should make a basic GET request for geojson", (done) => {
+    fetchMock.once("*", GeoJSONFeatureCollection);
+    request(
+      "https://services1.arcgis.com/ORG/arcgis/rest/services/FEATURE_SERVICE/FeatureServer/0/query",
+      {
+        httpMethod: "GET",
+        params: { where: "1=1", f: "geojson" }
+      }
+    )
+      .then((response) => {
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          "https://services1.arcgis.com/ORG/arcgis/rest/services/FEATURE_SERVICE/FeatureServer/0/query?f=geojson&where=1%3D1"
+        );
+        expect(options.method).toBe("GET");
+        expect(response).toEqual(GeoJSONFeatureCollection);
+        done();
+      })
+      .catch((e) => {
+        fail(e);
+      });
+  });
+  it("should switch from GET to POST when url is longer than specified", (done) => {
+    fetchMock.once("*", SharingRestInfo);
+    const restInfoUrl = "https://www.arcgis.com/sharing/rest/info";
+    request(restInfoUrl, {
+      httpMethod: "GET",
+      // typically consumers would base maxUrlLength on browser/server limits
+      // but for testing, we use an artificially low limit
+      // like this one that assumes no parameters will be added
+      maxUrlLength: restInfoUrl.length
+    })
+      .then((response) => {
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual("https://www.arcgis.com/sharing/rest/info");
+        expect(options.method).toBe("POST");
+        expect(options.body).toContain("f=json");
+        expect(response).toEqual(SharingRestInfo);
+        done();
+      })
+      .catch((e) => {
+        fail(e);
+      });
+  });
+  it("should use the `authentication` option to authenticate a request", (done) => {
+    fetchMock.once("*", WebMapAsText);
+    const MOCK_AUTH = {
+      portal: "https://www.arcgis.com/sharing/rest",
+      getToken() {
+        return Promise.resolve("token");
+      }
+    };
+    request(
+      "https://www.arcgis.com/sharing/rest/content/items/43a8e51789044d9480a20089a84129ad/data",
+      {
+        authentication: MOCK_AUTH
+      }
+    )
+      .then((response) => {
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          "https://www.arcgis.com/sharing/rest/content/items/43a8e51789044d9480a20089a84129ad/data"
+        );
+        expect(options.body).toContain("token=token");
+        expect(response).toEqual(WebMapAsJSON);
+        done();
+      })
+      .catch((e) => {
+        fail(e);
+      });
+  });
+  it("should hide token in POST body in browser environments otherwise it should hide token in `X-ESRI_AUTHORIZATION` header in Node", (done) => {
+    fetchMock.once("*", SharingRestInfo);
+    const MOCK_AUTH = {
+      portal: "https://www.arcgis.com/sharing/rest",
+      getToken() {
+        return Promise.resolve("token");
+      }
+    };
+    request("https://www.arcgis.com/sharing/rest/info", {
+      authentication: MOCK_AUTH,
+      httpMethod: "GET",
+      hideToken: true
+    })
+      .then((response) => {
+        // Test Node path with Jasmine in Node
+        if (typeof window === "undefined") {
+          const [url, options] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://www.arcgis.com/sharing/rest/info?f=json"
+          );
+          expect(options.method).toBe("GET");
+          expect(response).toEqual(SharingRestInfo);
+          expect((options.headers as any)["X-Esri-Authorization"]).toBe(
+            "Bearer token"
+          );
+        } else {
+          // Test browser path when run in browser with Karma
+          const [url, options] = fetchMock.lastCall("*");
+          expect(url).toEqual("https://www.arcgis.com/sharing/rest/info");
+          expect(options.method).toBe("POST");
+          expect(options.body).toContain("f=json");
+          expect(options.body).toContain("token=token");
+          expect((options.headers as any)["X-Esri-Authorization"]).toBe(
+            undefined
+          );
+          expect(response).toEqual(SharingRestInfo);
+        }
+        done();
+      })
+      .catch((e) => {
+        fail(e);
+      });
+  });
+  it("it should set credential to include for platformSelf call w header", () => {
+    const PLATFORM_SELF_URL =
+      "https://www.arcgis.com/sharing/rest/oauth2/platformSelf?f=json";
+    fetchMock.postOnce(PLATFORM_SELF_URL, {
+      username: "jsmith",
+      token: "APP-TOKEN"
+    });
+    const ro = {
+      method: "POST",
+      headers: {
+        "X-Esri-Auth-Client-Id": "CLIENT-ID-ABC123",
+        "X-Esri-Auth-Redirect-Uri":
+          "https://hub.arcgis.com/torii-provider-arcgis/redirect.html"
+      },
+      // Note: request has logic to include the cookie
+      // for platformSelf calls w/ the X-Esri-Auth-Client-Id header
+      params: {
+        f: "json"
+      }
+    } as IRequestOptions;
+    return request(PLATFORM_SELF_URL, ro).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");
+    });
+  });
+  it("should switch from GET to POST when url is longer than specified and replace token in header with token in POST body", (done) => {
+    fetchMock.once("*", SharingRestInfo);
+    const restInfoUrl = "https://www.arcgis.com/sharing/rest/info";
+    const MOCK_AUTH = {
+      portal: "https://www.arcgis.com/sharing/rest",
+      getToken() {
+        return Promise.resolve("token");
+      }
+    };
+    request(restInfoUrl, {
+      authentication: MOCK_AUTH,
+      httpMethod: "GET",
+      hideToken: true,
+      // typically consumers would base maxUrlLength on browser/server limits
+      // but for testing, we use an artificially low limit
+      // like this one that assumes no parameters will be added
+      maxUrlLength: restInfoUrl.length
+    })
+      .then((response) => {
+        const [url, options] = fetchMock.lastCall("*");
+        expect(url).toEqual("https://www.arcgis.com/sharing/rest/info");
+        expect(options.method).toBe("POST");
+        expect(options.body).toContain("f=json");
+        expect(options.body).toContain("token=token");
+        expect((options.headers as any)["X-Esri-Authorization"]).toBe(
+          undefined
+        );
+        expect(response).toEqual(SharingRestInfo);
+        done();
+      })
+      .catch((e) => {
+        fail(e);
+      });
+  });
+  it("should re-throw HTTP errors (404, 500, etc)", (done) => {
+    fetchMock.once("*", 404);
+    request(
+      "https://www.arcgis.com/sharing/rest/content/items/43a8e51789044d9480a20089a84129ad/data"
+    ).catch((error) => {
+      expect(error.name).toBe(ErrorTypes.ArcGISRequestError);
+      expect(error.message).toBe("HTTP 404: Not Found");
+      expect(error instanceof Error).toBeTruthy();
+      expect(error.url).toBe(
+        "https://www.arcgis.com/sharing/rest/content/items/43a8e51789044d9480a20089a84129ad/data"
+      );
+      expect(error.options.params).toEqual({ f: "json" });
+      expect(error.options.httpMethod).toEqual("POST");
+      // expect(typeof error.options.fetch).toEqual("function");
+      // expect(error.options.fetch.length).toEqual(2);
+      done();
+    });
+  });
+  it("should throw errors with information about the request", (done) => {
+    fetchMock.once("*", ArcGISOnlineError);
+    request(
+      "https://www.arcgis.com/sharing/rest/content/items/43a8e51789044d9480a20089a84129ad/data"
+    ).catch((error) => {
+      expect(error.name).toBe(ErrorTypes.ArcGISRequestError);
+      expect(error.message).toBe("400: 'type' and 'title' property required.");
+      expect(error instanceof Error).toBeTruthy();
+      expect(error.url).toBe(
+        "https://www.arcgis.com/sharing/rest/content/items/43a8e51789044d9480a20089a84129ad/data"
+      );
+      expect(error.options.params).toEqual({ f: "json" });
+      expect(error.options.httpMethod).toEqual("POST");
+      // expect(typeof error.options.fetch).toEqual("function");
+      // expect(error.options.fetch.length).toEqual(2);
+      done();
+    });
+  });
+  it("should return a raw response if requested", (done) => {
+    fetchMock.once("*", GeoJSONFeatureCollection);
+    request(
+      "https://services1.arcgis.com/ORG/arcgis/rest/services/FEATURE_SERVICE/FeatureServer/0/query",
+      {
+        httpMethod: "GET",
+        params: { where: "1=1", f: "geojson" },
+        rawResponse: true
+      }
+    )
+      .then((response) => {
+        expect(response.status).toBe(200);
+        expect(response.ok).toBe(true);
+        expect(response.body.Readable).not.toBe(null);
+        response.json().then((raw: any) => {
+          expect(raw).toEqual(GeoJSONFeatureCollection);
+          done();
+        });
+        // this used to work with isomorphic-fetch
+        // expect(response instanceof Response).toBe(true);
+      })
+      .catch((e) => {
+        fail(e);
+      });
+  });
+  it("should allow setting defaults for all requests", (done) => {
+    fetchMock.once("*", SharingRestInfo);
+    setDefaultRequestOptions({
+      headers: {
+        "Test-Header": "Test"
+      }
+    });
+    request("https://www.arcgis.com/sharing/rest/info")
+      .then((response) => {
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual("https://www.arcgis.com/sharing/rest/info");
+        expect(options.method).toBe("POST");
+        expect(response).toEqual(SharingRestInfo);
+        expect(options.body).toContain("f=json");
+        expect((options.headers as any)["Test-Header"]).toBe("Test");
+        done();
+      })
+      .catch((e) => {
+        fail(e);
+      });
+    // since calling request is sync we can delete this right away
+    setDefaultRequestOptions({
+      httpMethod: "POST",
+      params: {
+        f: "json"
+      }
+      // fetch,
+    });
+  });
+  it("should warn users when attempting to set default auth", () => {
+    const oldWarn = console.warn;
+    console.warn = jasmine.createSpy().and.callFake(() => {
+      return;
+    });
+    const MOCK_AUTH = {
+      portal: "https://www.arcgis.com/sharing/rest",
+      getToken() {
+        return Promise.resolve("token");
+      }
+    };
+    setDefaultRequestOptions({
+      authentication: MOCK_AUTH
+    });
+    setDefaultRequestOptions(
+      {
+        authentication: MOCK_AUTH
+      },
+      true
+    );
+    expect(console.warn).toHaveBeenCalledTimes(1);
+    // since calling request is  sync we can delete this right away
+    setDefaultRequestOptions({
+      httpMethod: "POST",
+      params: {
+        f: "json"
+      }
+    });
+    console.warn = oldWarn;
+  });
+  describe("should impliment the IParamBuilder and IParamsBuilder interfaces builder", () => {
+    it("should encode a param that impliments IParamBuilder", (done) => {
+      fetchMock.once("*", GeoJSONFeatureCollection);
+      const builder = new MockParamBuilder();
+      request(
+        "https://services1.arcgis.com/ORG/arcgis/rest/services/FEATURE_SERVICE/FeatureServer/0/query",
+        {
+          params: { where: builder, f: "geojson" }
+        }
+      )
+        .then((response) => {
+          const options: RequestInit = fetchMock.lastCall("*")[1];
+          expect(options.body).toContain(`where=${encodeURIComponent("1=1")}`);
+          expect(response).toEqual(GeoJSONFeatureCollection);
+          done();
+        })
+        .catch((e) => {
+          fail(e);
+        });
+    });
+  });
+  if (typeof window === "undefined") {
+    it("should tack on a generic referer header - in Node.js only", (done) => {
+      fetchMock.once("*", WebMapAsJSON);
+      request("https://www.arcgis.com/sharing/rest/content/items/43a/data")
+        .then(() => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://www.arcgis.com/sharing/rest/content/items/43a/data"
+          );
+          expect(options.method).toBe("POST");
+          expect(options.headers).toEqual({
+            referer: "@esri/arcgis-rest-js",
+            "Content-Type": "application/x-www-form-urlencoded"
+          });
+          done();
+        })
+        .catch((e) => {
+          fail(e);
+        });
+    });
+    it("should use referer header from request options - in Node.js only", (done) => {
+      fetchMock.once("*", WebMapAsJSON);
+      request("https://www.arcgis.com/sharing/rest/content/items/43a/data", {
+        headers: { referer: "test/referer" }
+      })
+        .then(() => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://www.arcgis.com/sharing/rest/content/items/43a/data"
+          );
+          expect(options.method).toBe("POST");
+          expect(options.headers).toEqual({
+            referer: "test/referer",
+            "Content-Type": "application/x-www-form-urlencoded"
+          });
+          done();
+        })
+        .catch((e) => {
+          fail(e);
+        });
+    });
+    it("if no referer header is provided, but other headers are passed, a default should still be set - in Node.js only", (done) => {
+      fetchMock.once("*", WebMapAsJSON);
+      request("https://www.arcgis.com/sharing/rest/content/items/43a/data", {
+        headers: { foo: "bar" }
+      })
+        .then(() => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://www.arcgis.com/sharing/rest/content/items/43a/data"
+          );
+          expect(options.method).toBe("POST");
+          expect(options.headers).toEqual({
+            "Content-Type": "application/x-www-form-urlencoded",
+            referer: "@esri/arcgis-rest-js",
+            foo: "bar"
+          });
+          done();
+        })
+        .catch((e) => {
+          fail(e);
+        });
+    });
+  }
+  it("should use a string passed to authentication option as the token", () => {
+    const oldWarn = console.warn;
+    console.warn = jasmine.createSpy().and.callFake(() => {
+      return;
+    });
+    fetchMock.post("*", {
+      username: "jsmith"
+    });
+    return request("https://www.arcgis.com/sharing/rest/portals/self", {
+      authentication: "token"
+    })
+      .then(() => {
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual("https://www.arcgis.com/sharing/rest/portals/self");
+        expect(console.warn).toHaveBeenCalledTimes(1);
+        expect(options.body).toContain("f=json");
+        expect(options.body).toContain("token=token");
+      })
+      .catch((e) => {
+        fail(e);
+      })
+      .finally(() => {
+        console.warn = oldWarn;
+      });
+  });
+});