aspernaturalias 1.0.0

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

@@ -0,0 +1,496 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { request, ErrorTypes, setDefaultRequestOptions } from "../src/index";
+import * as fetchMock from "fetch-mock";
+import {
+  SharingRestInfo,
+  SharingRestInfoHTML
+} from "./mocks/sharing-rest-info";
+import { MockParamBuilder } from "./mocks/param-builder";
+import { ArcGISOnlineError } from "./mocks/errors";
+import { WebMapAsText, WebMapAsJSON } from "./mocks/webmap";
+import { GeoJSONFeatureCollection } from "./mocks/geojson-feature-collection";
+
+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 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 allow you to use custom implementations of `fetch`", done => {
+    const MockFetchResponse = {
+      ok: true,
+      json() {
+        return Promise.resolve(SharingRestInfo);
+      },
+      blob() {
+        return Promise.resolve(new Blob([JSON.stringify(SharingRestInfo)]));
+      },
+      text() {
+        return Promise.resolve(JSON.stringify(SharingRestInfo));
+      }
+    };
+
+    const MockFetch = function() {
+      return Promise.resolve(MockFetchResponse);
+    };
+
+    request("https://www.arcgis.com/sharing/rest/info", {
+      fetch: MockFetch as any
+    })
+      .then(response => {
+        expect(response).toEqual(SharingRestInfo);
+        done();
+      })
+      .catch(e => {
+        fail(e);
+      });
+  });
+
+  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);
+        });
+    });
+  });
+
+  describe("should throw errors when required dependencies are missing", () => {
+    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 throw for missing dependencies", () => {
+      expect(() => {
+        request("https://www.arcgis.com/sharing/rest/info").catch();
+      }).toThrowError(
+        "`arcgis-rest-request` requires a `fetch` implementation and global variables for `Promise` and `FormData` to be present in the global scope. You are missing `fetch`, `Promise`, `FormData`. We recommend installing the `node-fetch`, `es6-promise`, `isomorphic-form-data` modules at the root of your application to add these to the global scope. See https://bit.ly/2KNwWaJ for more info."
+      );
+    });
+
+    it("should not throw if fetch is not present but a custom fetch is defined", done => {
+      Promise = oldPromise;
+      FormData = oldFormData;
+
+      const MockFetchResponse = {
+        ok: true,
+        json() {
+          return Promise.resolve(SharingRestInfo);
+        },
+        blob() {
+          return Promise.resolve(new Blob([JSON.stringify(SharingRestInfo)]));
+        },
+        text() {
+          return Promise.resolve(JSON.stringify(SharingRestInfo));
+        }
+      };
+
+      const MockFetch = function() {
+        return Promise.resolve(MockFetchResponse);
+      };
+
+      request("https://www.arcgis.com/sharing/rest/info", {
+        fetch: MockFetch as any
+      })
+        .then(response => {
+          expect(response).toEqual(SharingRestInfo);
+          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);
+        });
+    });
+  }
+});

package/packages/arcgis-rest-request/test/utils/ArcGISAuthError.test.ts

@@ -0,0 +1,191 @@
+/* Copyright (c) 2018-2019 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { ArcGISAuthError, IRetryAuthError, ErrorTypes } from "../../src/index";
+import {
+  ArcGISOnlineAuthError,
+  ArcGISOnlineError,
+  GenerateTokenError
+} from "./../mocks/errors";
+import { request } from "../../src/request";
+import * as fetchMock from "fetch-mock";
+
+describe("ArcGISRequestError", () => {
+  afterEach(fetchMock.restore);
+
+  it("should be an instanceof Error", () => {
+    expect(new ArcGISAuthError() instanceof Error).toBe(true);
+  });
+
+  it("should expose basic error properties", () => {
+    const error = new ArcGISAuthError(
+      ArcGISOnlineAuthError.error.message,
+      ArcGISOnlineAuthError.error.code,
+      ArcGISOnlineAuthError
+    );
+
+    expect(error.name).toBe("ArcGISAuthError");
+    expect(error.message).toBe("498: Invalid token.");
+    expect(error.code).toBe(498);
+    expect(error.originalMessage).toBe("Invalid token.");
+    expect(error.response).toEqual(ArcGISOnlineAuthError);
+  });
+
+  it("should still format without a message, code or response", () => {
+    const error = new ArcGISAuthError();
+    expect(error.message).toBe("AUTHENTICATION_ERROR");
+    expect(error.code).toEqual("AUTHENTICATION_ERROR_CODE");
+    expect(error.originalMessage).toBe("AUTHENTICATION_ERROR");
+    expect(error.response).toEqual(undefined);
+  });
+
+  describe("retry", () => {
+    const MockAuth: {
+      portal: string;
+      getToken: any;
+      retryHandler: IRetryAuthError;
+    } = {
+      portal: "https://www.arcgis.com/sharing/rest",
+      getToken() {
+        return Promise.resolve("token");
+      },
+      retryHandler(url, options) {
+        return Promise.resolve(MockAuth);
+      }
+    };
+
+    it("should allow retrying a request with a new or updated session", done => {
+      const error = new ArcGISAuthError(
+        "Invalid token.",
+        498,
+        ArcGISAuthError,
+        "http://www.arcgis.com/sharing/rest/content/users/caseyjones/addItem",
+        {
+          httpMethod: "POST",
+          params: {
+            title: "Test Map",
+            tags: "foo",
+            type: "Web Map",
+            f: "json"
+          }
+        }
+      );
+
+      fetchMock.once("*", {
+        success: true,
+        id: "abc",
+        folder: null
+      });
+
+      const retryHandlerSpy = spyOn(MockAuth, "retryHandler").and.callThrough();
+
+      error
+        .retry(MockAuth.retryHandler, 1)
+        .then((response: any) => {
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "http://www.arcgis.com/sharing/rest/content/users/caseyjones/addItem"
+          );
+          expect(options.method).toEqual("POST");
+          expect(retryHandlerSpy).toHaveBeenCalledTimes(1);
+          expect(options.body).toContain("token=token");
+          expect(options.body).toContain("tags=foo");
+          expect(options.body).toContain("f=json");
+          expect(response.success).toBe(true);
+          expect(response.id).toBe("abc");
+          expect(response.folder).toBe(null);
+          done();
+        })
+        .catch((e: any) => {
+          fail(e);
+        });
+    });
+
+    it("should retry a request with a new or updated session up to the limit", done => {
+      const error = new ArcGISAuthError(
+        "Invalid token.",
+        498,
+        ArcGISAuthError,
+        "http://www.arcgis.com/sharing/rest/content/users/caseyjones/addItem",
+        {
+          httpMethod: "POST",
+          params: {
+            title: "Test Map",
+            tags: "foo",
+            type: "Web Map",
+            f: "json"
+          }
+        }
+      );
+
+      fetchMock.post("*", ArcGISOnlineAuthError);
+
+      const retryHandlerSpy = spyOn(MockAuth, "retryHandler").and.callThrough();
+
+      error.retry(MockAuth.retryHandler).catch((e: any) => {
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          "http://www.arcgis.com/sharing/rest/content/users/caseyjones/addItem"
+        );
+        expect(options.method).toEqual("POST");
+        expect(retryHandlerSpy).toHaveBeenCalledTimes(3);
+        expect(options.body).toContain("token=token");
+        expect(options.body).toContain("tags=foo");
+        expect(options.body).toContain("f=json");
+        expect(e.name).toBe(ErrorTypes.ArcGISAuthError);
+        expect(e.message).toBe("498: Invalid token.");
+        done();
+      });
+    });
+
+    it("should throw an error if retrying throws a non-auth error", done => {
+      const requestUrl =
+        "http://www.arcgis.com/sharing/rest/content/users/caseyjones/addItem";
+      const error = new ArcGISAuthError(
+        "Invalid token.",
+        498,
+        ArcGISAuthError,
+        requestUrl,
+        {
+          httpMethod: "POST",
+          params: {
+            type: "Web Map",
+            f: "json"
+          }
+        }
+      );
+
+      fetchMock.post("*", ArcGISOnlineError);
+
+      const retryHandlerSpy = spyOn(MockAuth, "retryHandler").and.callThrough();
+
+      error.retry(MockAuth.retryHandler).catch((e: any) => {
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(requestUrl);
+        expect(options.method).toEqual("POST");
+        expect(retryHandlerSpy).toHaveBeenCalledTimes(1);
+        expect(options.body).toContain("token=token");
+        expect(options.body).toContain("f=json");
+        expect(e.name).toBe(ErrorTypes.ArcGISRequestError);
+        expect(e.message).toBe("400: 'type' and 'title' property required.");
+        done();
+      });
+    });
+
+    it("should throw an authentication error for invalid credentials", done => {
+      fetchMock.post("*", GenerateTokenError);
+
+      request("https://www.arcgis.com/sharing/rest/generateToken", {
+        params: {
+          username: "correct",
+          password: "incorrect",
+          expiration: 10260,
+          referer: "localhost"
+        }
+      }).catch(err => {
+        expect(err.name).toBe(ErrorTypes.ArcGISAuthError);
+        done();
+      });
+    });
+  });
+});