autculpa 1.0.0

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

@@ -0,0 +1,55 @@
+import { revokeToken, appendCustomParams } from "../src/index.js";
+import fetchMock from "fetch-mock";
+
+describe("revokeToken", () => {
+  afterEach(() => {
+    fetchMock.restore();
+  });
+
+  it("should revoke a token with a client id", () => {
+    fetchMock.once("*", { success: true });
+    return revokeToken({
+      clientId: "clientId",
+      token: "token"
+    }).then((response) => {
+      const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+
+      expect(response).toEqual({ success: true });
+      expect(url).toBe(
+        "https://www.arcgis.com/sharing/rest/oauth2/revokeToken/"
+      );
+      expect(options.body).toContain("auth_token=token");
+      expect(options.body).toContain("client_id=clientId");
+    });
+  });
+
+  it("should revoke a token with a client id and custom portal", () => {
+    fetchMock.once("*", { success: true });
+
+    return revokeToken({
+      clientId: "clientId",
+      token: "token",
+      portal: "https://myportal.com/sharing/rest/"
+    }).then((response) => {
+      const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+
+      expect(response).toEqual({ success: true });
+      expect(url).toBe("https://myportal.com/sharing/rest/oauth2/revokeToken/");
+      expect(options.body).toContain("auth_token=token");
+      expect(options.body).toContain("client_id=clientId");
+    });
+  });
+
+  it("should throw a ArcGISRequestError when success is false", () => {
+    fetchMock.once("*", { success: false });
+
+    return revokeToken({
+      clientId: "clientId",
+      token: "token",
+      portal: "https://myportal.com/sharing/rest/"
+    }).catch((e) => {
+      expect(e.name).toBe("ArcGISRequestError");
+      expect(e.message).toBe("500: Unable to revoke token");
+    });
+  });
+});

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

@@ -0,0 +1,196 @@
+/* Copyright (c) 2018-2019 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import {
+  ArcGISAuthError,
+  IRetryAuthError,
+  ErrorTypes,
+} from "../../src/index.js";
+import {
+  ArcGISOnlineAuthError,
+  ArcGISOnlineError,
+  GenerateTokenError,
+} from "./../mocks/errors.js";
+import { request } from "../../src/request.js";
+import 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();
+      });
+    });
+  });
+});

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

@@ -0,0 +1,51 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { ArcGISRequestError } from "../../src/index.js";
+import { ArcGISOnlineError } from "./../mocks/errors.js";
+
+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);
+  });
+
+  it("should still format with a null or empty string message or code", () => {
+    const error = new ArcGISRequestError(null, "");
+    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,111 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import {
+  checkForErrors,
+  warn,
+  ArcGISRequestError,
+  ArcGISAuthError,
+} from "../../src/index.js";
+import { SharingRestInfo } from "./../mocks/sharing-rest-info.js";
+import {
+  ArcGISOnlineError,
+  BillingError,
+  TaskErrorWithJSON,
+  TaskError,
+  ArcGISOnlineErrorNoMessageCode,
+  ArcGISOnlineErrorNoCode,
+  ArcGISServerTokenRequired,
+  ArcGISOnlineAuthError,
+  BillingErrorWithCode200,
+} from "./../mocks/errors.js";
+
+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 from the ArcGIS Online Billing Backend with a failure status", () => {
+    expect(() => {
+      checkForErrors(BillingErrorWithCode200);
+    }).toThrowError(ArcGISRequestError, "UNKNOWN_ERROR");
+  });
+
+  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;
+  });
+});

package/packages/arcgis-rest-request/test/utils/clean-url.test.ts

@@ -0,0 +1,50 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { cleanUrl } from "../../src/utils/clean-url.js";
+
+const validUrl =
+  "https://server.com/arcgis/rest/services/Custom Space/MapServer";
+
+describe("cleanUrl", () => {
+  it("should not mangle a valid url", () => {
+    expect(
+      cleanUrl(
+        "https://server.com/arcgis/rest/services/Custom Space/MapServer/"
+      )
+    ).toEqual(validUrl);
+  });
+
+  it("should add a trailing slash", () => {
+    expect(
+      cleanUrl("https://server.com/arcgis/rest/services/Custom Space/MapServer")
+    ).toEqual(validUrl);
+  });
+
+  it("should remove leading whitespace", () => {
+    expect(
+      cleanUrl(
+        "  https://server.com/arcgis/rest/services/Custom Space/MapServer/"
+      )
+    ).toEqual(validUrl);
+  });
+
+  it("should remove trailing whitespace", () => {
+    expect(
+      cleanUrl(
+        "https://server.com/arcgis/rest/services/Custom Space/MapServer/   "
+      )
+    ).toEqual(validUrl);
+  });
+
+  it("should do it all at once", () => {
+    expect(
+      cleanUrl(
+        "  https://server.com/arcgis/rest/services/Custom Space/MapServer       "
+      )
+    ).toEqual(validUrl);
+  });
+  it("should not throw on a null string", () => {
+    expect(cleanUrl(null)).toEqual(null);
+  });
+});

package/packages/arcgis-rest-request/test/utils/encode-form-data.test.ts

@@ -0,0 +1,146 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { encodeFormData } from "../../src/utils/encode-form-data.js";
+import {
+  requiresFormData,
+  processParams,
+} from "../../src/utils/process-params.js";
+import { createReadStream } from "fs";
+import { FormData } from "formdata-node";
+export function attachmentFile(): any {
+  if (typeof File !== "undefined" && File) {
+    return new File(["foo"], "foo.txt", { type: "text/plain" });
+  } else {
+    return createReadStream(
+      "./packages/arcgis-rest-feature-service/test/mocks/foo.txt"
+    );
+  }
+}
+
+describe("encodeFormData", () => {
+  it("should encode in form data for multipart file requests", () => {
+    const binaryObj = attachmentFile();
+
+    const formData = encodeFormData({ binary: binaryObj });
+    expect(formData instanceof FormData).toBeTruthy();
+
+    const data = formData as FormData;
+    // console.log(data.get("binary"));
+
+    // if (data.get) {
+    //   // expect(data.get("binary") instanceof File).toBeTruthy();
+    //   expect((data.get("binary") as unknown as File).name).toBe("foo.txt");
+    // }
+  });
+
+  it("should encode in form data for multipart blob requests", () => {
+    const binaryObj =
+      typeof Blob !== "undefined"
+        ? new Blob([], {
+            type: "text/plain",
+          })
+        : Buffer.from("");
+
+    const formData = encodeFormData({ binary: binaryObj });
+    expect(formData instanceof FormData).toBeTruthy();
+
+    const data = formData as FormData;
+
+    // if (data.get) {
+    //   // expect(data.get("binary") instanceof File).toBeTruthy();
+    //   expect((data.get("binary") as unknown as File).name).toBe("binary");
+    // }
+  });
+
+  it("should encode as query string for basic types", () => {
+    const dateValue = 1471417200000;
+
+    // null, undefined, function are excluded. If you want to send an empty key you need to send an empty string "".
+    // See https://github.com/Esri/arcgis-rest-js/issues/18
+    const params = {
+      myArray1: new Array(8),
+      myArray2: [1, 2, 4, 16],
+      myArray3: [{ a: 1, b: 2 }, { c: "abc" }],
+      myDate: new Date(dateValue),
+      myFunction: () => {
+        return 3.1415;
+      },
+      myBoolean: true,
+      myString: "Hello, world!",
+      myEmptyString: "",
+      myNumber: 380,
+    };
+
+    expect(requiresFormData(params)).toBeFalsy();
+
+    const formData = processParams(params);
+    expect(typeof formData).toBe("object");
+    expect(formData.myArray1).toBe(",,,,,,,");
+    expect(formData.myArray2).toBe("1,2,4,16");
+    expect(formData.myArray3).toBe('[{"a":1,"b":2},{"c":"abc"}]');
+    expect(formData.myDate).toBe(dateValue);
+    expect(formData.myBoolean).toBeTruthy();
+    expect(formData.myString).toBe("Hello, world!");
+    expect(formData.myEmptyString).toBe("");
+    expect(formData.myNumber).toBe(380);
+
+    const encodedFormData = encodeFormData(params);
+    expect(typeof encodedFormData).toBe("string");
+    expect(encodedFormData).toBe(
+      "myArray1=%2C%2C%2C%2C%2C%2C%2C&" +
+        "myArray2=1%2C2%2C4%2C16&" +
+        "myArray3=%5B%7B%22a%22%3A1%2C%22b%22%3A2%7D%2C%7B%22c%22%3A%22abc%22%7D%5D&" +
+        "myDate=1471417200000&" +
+        "myBoolean=true&" +
+        "myString=Hello%2C%20world!&" +
+        "myEmptyString=&" +
+        "myNumber=380"
+    );
+  });
+
+  it("should switch to form data if any item is not a basic type", () => {
+    const dateValue = 1471417200000;
+    const file = attachmentFile();
+    if (!file.name) {
+      // The file's name is used for adding files to a form, so supply a name when we're in a testing
+      // environment that doesn't support File (attachmentFile creates a File with the name "foo.txt"
+      // if File is supported and a file stream otherwise)
+      file.name = "foo.txt";
+    }
+
+    // null, undefined, function are excluded. If you want to send an empty key you need to send an empty string "".
+    // See https://github.com/Esri/arcgis-rest-js/issues/18
+    const params = {
+      myArray1: new Array(8),
+      myArray2: [1, 2, 4, 16],
+      myArray3: [{ a: 1, b: 2 }, { c: "abc" }],
+      myDate: new Date(dateValue),
+      myFunction: () => {
+        return 3.1415;
+      },
+      myBoolean: true,
+      myString: "Hello, world!",
+      myEmptyString: "",
+      myNumber: 380,
+      file,
+    };
+
+    expect(requiresFormData(params)).toBeTruthy();
+
+    const formData = processParams(params);
+    expect(typeof formData).toBe("object");
+    expect(formData.myArray1).toBe(",,,,,,,");
+    expect(formData.myArray2).toBe("1,2,4,16");
+    expect(formData.myArray3).toBe('[{"a":1,"b":2},{"c":"abc"}]');
+    expect(formData.myDate).toBe(dateValue);
+    expect(formData.myBoolean).toBeTruthy();
+    expect(formData.myString).toBe("Hello, world!");
+    expect(formData.myEmptyString).toBe("");
+    expect(formData.myNumber).toBe(380);
+    expect(typeof formData.file).toBe("object");
+
+    const encodedFormData = encodeFormData(params);
+    expect(encodedFormData instanceof FormData).toBeTruthy();
+  });
+});

package/packages/arcgis-rest-request/test/utils/encode-query-string.test.ts

@@ -0,0 +1,22 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { encodeParam } from "../../src/utils/encode-query-string.js";
+
+describe("encodeQueryString", () => {
+  it("should encode simple value", () => {
+    expect(encodeParam("key", "value")).toEqual("key=value");
+  });
+
+  it("should encode array", () => {
+    expect(encodeParam("key", ["value1", "value2"])).toEqual(
+      "key=value1%2Cvalue2"
+    );
+  });
+
+  it("should encode array of arrays", () => {
+    expect(encodeParam("key", [["value1a", "value1b"], ["value2"]])).toEqual(
+      "key=value1a%2Cvalue1b&key=value2"
+    );
+  });
+});