etincidunt 1.0.0

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

@@ -0,0 +1,296 @@
+import { request, ErrorTypes } from "../src/index";
+import * as fetchMock from "fetch-mock";
+import {
+  SharingRestInfo,
+  SharingRestInfoHTML
+} from "./mocks/sharing-rest-info";
+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);
+      });
+  });
+
+  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");
+      }).toThrowError(
+        "`arcgis-rest-request` requires global variables for `fetch`, `Promise` and `FormData` to be present in the global scope. You are missing `fetch`, `Promise`, `FormData`. We recommend installing the `isomorphic-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);
+        });
+    });
+  });
+});

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

@@ -0,0 +1,167 @@
+import { ArcGISAuthError, IRetryAuthError, ErrorTypes } from "../../src/index";
+import { ArcGISOnlineAuthError, ArcGISOnlineError } from "./../mocks/errors";
+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();
+      });
+    });
+  });
+});

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

@@ -0,0 +1,40 @@
+import { ArcGISRequestError } from "../../src/index";
+import { ArcGISOnlineError } from "./../mocks/errors";
+
+describe("ArcGISRequestError", () => {
+  it("should be an instanceof Error", () => {
+    expect(new ArcGISRequestError() instanceof Error).toBe(true);
+  });
+
+  it("should expose basic error properties", () => {
+    const error = new ArcGISRequestError(
+      ArcGISOnlineError.error.message,
+      ArcGISOnlineError.error.code,
+      ArcGISOnlineError,
+      "https://example.com",
+      {
+        params: {
+          f: "json"
+        },
+        httpMethod: "POST"
+      }
+    );
+
+    expect(error.name).toBe("ArcGISRequestError");
+    expect(error.message).toBe("400: 'type' and 'title' property required.");
+    expect(error.code).toBe(400);
+    expect(error.originalMessage).toBe("'type' and 'title' property required.");
+    expect(error.response).toEqual(ArcGISOnlineError);
+    expect(error.url).toBe("https://example.com");
+    expect(error.options.params).toEqual({ f: "json" });
+    expect(error.options.httpMethod).toEqual("POST");
+  });
+
+  it("should still format without a message, code or response", () => {
+    const error = new ArcGISRequestError();
+    expect(error.message).toBe("UNKNOWN_ERROR");
+    expect(error.code).toEqual("UNKNOWN_ERROR_CODE");
+    expect(error.originalMessage).toBe("UNKNOWN_ERROR");
+    expect(error.response).toEqual(undefined);
+  });
+});

package/packages/arcgis-rest-request/test/utils/check-for-errors.test.ts

@@ -0,0 +1,101 @@
+import {
+  checkForErrors,
+  warn,
+  ArcGISRequestError,
+  ArcGISAuthError
+} from "../../src/index";
+import { SharingRestInfo } from "./../mocks/sharing-rest-info";
+import {
+  ArcGISOnlineError,
+  BillingError,
+  TaskErrorWithJSON,
+  TaskError,
+  ArcGISOnlineErrorNoMessageCode,
+  ArcGISOnlineErrorNoCode,
+  ArcGISServerTokenRequired,
+  ArcGISOnlineAuthError
+} from "./../mocks/errors";
+
+describe("checkForErrors", () => {
+  it("should pass if an error is not found", () => {
+    expect(checkForErrors(SharingRestInfo)).toBe(SharingRestInfo);
+  });
+
+  it("should throw an ArcGISRequestError for an error from the ArcGIS REST API", () => {
+    expect(() => {
+      checkForErrors(ArcGISOnlineError);
+    }).toThrowError(
+      ArcGISRequestError,
+      "400: 'type' and 'title' property required."
+    );
+  });
+
+  it("should throw an ArcGISOnlineAuthError for an error from the ArcGIS REST API", () => {
+    expect(() => {
+      checkForErrors(ArcGISOnlineAuthError);
+    }).toThrowError(ArcGISAuthError, "498: Invalid token.");
+  });
+
+  it("should throw an ArcGISRequestError for an error from the ArcGIS REST API that has no messageCode", () => {
+    expect(() => {
+      checkForErrors(ArcGISOnlineErrorNoMessageCode);
+    }).toThrowError(
+      ArcGISRequestError,
+      "403: You do not have permissions to access this resource or perform this operation."
+    );
+  });
+
+  it("should throw an ArcGISRequestError for an error from the ArcGIS REST API that has no code", () => {
+    expect(() => {
+      checkForErrors(ArcGISOnlineErrorNoCode);
+    }).toThrowError(
+      ArcGISRequestError,
+      "You do not have permissions to access this resource or perform this operation."
+    );
+  });
+
+  it("should throw an ArcGISRequestError for an error from the ArcGIS Online Billing Backend", () => {
+    expect(() => {
+      checkForErrors(BillingError);
+    }).toThrowError(ArcGISRequestError, "500: Error getting subscription info");
+  });
+
+  it("should throw an ArcGISRequestError for an error when checking long running tasks in ArcGIS REST API", () => {
+    expect(() => {
+      checkForErrors(TaskErrorWithJSON);
+    }).toThrowError(
+      ArcGISRequestError,
+      "400: Index was outside the bounds of the array."
+    );
+  });
+
+  it("should throw an ArcGISRequestError for an error when checking long running tasks in ArcGIS REST API without a JSON statusMessage", () => {
+    expect(() => {
+      checkForErrors(TaskError);
+    }).toThrowError(ArcGISRequestError, "failed");
+  });
+
+  it("should throw an ArcGISAuthError instead of ArcGISRequestError for messageCode=GWM_0003", () => {
+    expect(() => {
+      checkForErrors(ArcGISServerTokenRequired);
+    }).toThrowError(ArcGISAuthError, "GWM_0003: Token Required");
+  });
+});
+
+describe("warn", () => {
+  it("should bubble up deprecation warnings", () => {
+    console.warn = jasmine.createSpy("warning");
+    warn("Danger Will Robinson!");
+    expect(console.warn).toHaveBeenCalledWith("Danger Will Robinson!");
+  });
+});
+
+describe("warn", () => {
+  it("should carry on gracefully when no console is available", () => {
+    const realConsoleWarn = console.warn;
+    console.warn = undefined;
+    warn("Danger Will Robinson!");
+    expect(console.warn).toBe(undefined);
+    console.warn = realConsoleWarn;
+  });
+});