culparepellendus 1.0.0

package/packages/arcgis-rest-portal/test/users/search.test.ts

@@ -0,0 +1,42 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { searchUsers } from "../../src/users/search-users";
+import { UserSearchResponse } from "../mocks/users/user-search";
+
+import * as fetchMock from "fetch-mock";
+
+describe("users", () => {
+  afterEach(fetchMock.restore);
+
+  describe("searchUsers", () => {
+    const MOCK_AUTH = {
+      getToken() {
+        return Promise.resolve("fake-token");
+      },
+      portal: "https://myorg.maps.arcgis.com/sharing/rest"
+    };
+
+    it("should make a simple, authenticated user search request", done => {
+      fetchMock.once("*", UserSearchResponse);
+
+      searchUsers({
+        q: "role:org_user OR role:org_publisher",
+        num: 100,
+        authentication: MOCK_AUTH
+      })
+        .then(response => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://myorg.maps.arcgis.com/sharing/rest/portals/self/users/search?f=json&q=role%3Aorg_user%20OR%20role%3Aorg_publisher&num=100&token=fake-token"
+          );
+          expect(options.method).toBe("GET");
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+  });
+});

package/packages/arcgis-rest-portal/test/users/update.test.ts

@@ -0,0 +1,151 @@
+/* Copyright (c) 2018-2019 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { updateUser, IUpdateUserResponse } from "../../src/users/update";
+import { encodeParam } from "@esri/arcgis-rest-request";
+import { UserSession } from "@esri/arcgis-rest-auth";
+import * as fetchMock from "fetch-mock";
+
+const TOMORROW = (function() {
+  const now = new Date();
+  now.setDate(now.getDate() + 1);
+  return now;
+})();
+
+describe("updateUser", () => {
+  afterEach(fetchMock.restore);
+
+  const session = new UserSession({
+    username: "c@sey",
+    password: "123456",
+    token: "fake-token",
+    tokenExpires: TOMORROW,
+    portal: "https://myorg.maps.arcgis.com/sharing/rest"
+  });
+
+  it("should make an authenticated request to update the same user profile.", done => {
+    fetchMock.once("*", {
+      success: true,
+      username: "c@sey"
+    } as IUpdateUserResponse);
+
+    updateUser({
+      authentication: session,
+      user: { description: "destroyer of worlds" }
+    })
+      .then(() => {
+        expect(fetchMock.called()).toEqual(true);
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          "https://myorg.maps.arcgis.com/sharing/rest/community/users/c%40sey/update"
+        );
+        expect(options.method).toBe("POST");
+        expect(options.body).toContain("f=json");
+        expect(options.body).toContain("token=fake-token");
+        expect(options.body).toContain(
+          encodeParam("description", "destroyer of worlds")
+        );
+        done();
+      })
+      .catch(e => {
+        fail(e);
+      });
+  });
+
+  it("should make an authenticated request to update the same user profile and mixin custom params.", done => {
+    fetchMock.once("*", {
+      success: true,
+      username: "c@sey"
+    } as IUpdateUserResponse);
+
+    updateUser({
+      authentication: session,
+      user: { description: "destroyer of worlds" },
+      params: { foo: "bar" }
+    })
+      .then(() => {
+        expect(fetchMock.called()).toEqual(true);
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          "https://myorg.maps.arcgis.com/sharing/rest/community/users/c%40sey/update"
+        );
+        expect(options.method).toBe("POST");
+        expect(options.body).toContain("f=json");
+        expect(options.body).toContain("token=fake-token");
+        expect(options.body).toContain("foo=bar");
+        expect(options.body).toContain(
+          encodeParam("description", "destroyer of worlds")
+        );
+        done();
+      })
+      .catch(e => {
+        fail(e);
+      });
+  });
+
+  it("should make an org administrator authenticated request to update a different user.", done => {
+    fetchMock.once("*", {
+      success: true,
+      username: "jsmith"
+    } as IUpdateUserResponse);
+
+    updateUser({
+      authentication: session,
+      user: { username: "jsmith", description: "something different" }
+    })
+      .then(() => {
+        expect(fetchMock.called()).toEqual(true);
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          "https://myorg.maps.arcgis.com/sharing/rest/community/users/jsmith/update"
+        );
+        expect(options.method).toBe("POST");
+        expect(options.body).toContain("f=json");
+        expect(options.body).toContain("token=fake-token");
+        expect(options.body).toContain(
+          encodeParam("description", "something different")
+        );
+        done();
+      })
+      .catch(e => {
+        fail(e);
+      });
+  });
+
+  it("should throw an error when the authenticated user doesnt have permission to update the user profile in question.", done => {
+    fetchMock.once("*", {
+      error: {
+        code: 403,
+        messageCode: "GWM_0003",
+        message:
+          "You do not have permissions to access this resource or perform this operation.",
+        details: []
+      }
+    });
+
+    updateUser({
+      authentication: session,
+      user: { username: "fake", description: "real" }
+    })
+      .then(() => {
+        fail();
+      })
+      .catch(e => {
+        expect(fetchMock.called()).toEqual(true);
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          "https://myorg.maps.arcgis.com/sharing/rest/community/users/fake/update"
+        );
+        expect(options.method).toBe("POST");
+        expect(options.body).toContain("f=json");
+        expect(options.body).toContain("token=fake-token");
+        expect(options.body).toContain(encodeParam("description", "real"));
+        expect(e.name).toBe("ArcGISAuthError");
+        expect(e.code).toBe("GWM_0003");
+        expect(e.originalMessage).toBe(
+          "You do not have permissions to access this resource or perform this operation."
+        );
+        done();
+      });
+  });
+});

package/packages/arcgis-rest-portal/test/util/SearchQueryBuilder.test.ts

@@ -0,0 +1,345 @@
+/* Copyright (c) 2019 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { SearchQueryBuilder } from "../../src/util/SearchQueryBuilder";
+
+describe("SearchQueryBuilder", () => {
+  const originalWarn = console.warn;
+
+  beforeAll(function() {
+    console.warn = jasmine.createSpy().and.callFake(() => {
+      return;
+    });
+  });
+
+  afterAll(function() {
+    console.warn = originalWarn;
+  });
+
+  it("should return an empty string when called with no other functions", () => {
+    const query = new SearchQueryBuilder().toParam();
+    expect(query).toEqual("");
+  });
+
+  it("should format a simple search query", () => {
+    const query = new SearchQueryBuilder().match("test").toParam();
+    expect(query).toEqual("test");
+  });
+
+  it("should format a simple search query in a field", () => {
+    const query = new SearchQueryBuilder()
+      .match("test")
+      .in("tags")
+      .toParam();
+    expect(query).toEqual("tags:test");
+  });
+
+  it("should warp multi word search terms in quotes", () => {
+    const query = new SearchQueryBuilder().match("foo bar").toParam();
+    expect(query).toEqual(`"foo bar"`);
+  });
+
+  it("should wrap multi word search terms with colons in quotes", () => {
+    const query = new SearchQueryBuilder().match("foo:bar").toParam();
+    expect(query).toEqual(`"foo:bar"`);
+  });
+
+  it("should accept .in() without a parameter", () => {
+    const query = new SearchQueryBuilder()
+      .match("test")
+      .in()
+      .toParam();
+    expect(query).toEqual(`test`);
+  });
+
+  it("should accept `*` as a value for .in()", () => {
+    const query = new SearchQueryBuilder()
+      .match("test")
+      .in("*")
+      .toParam();
+    expect(query).toEqual(`test`);
+  });
+
+  it("should chain calls with .and()", () => {
+    const query = new SearchQueryBuilder()
+      .match("bar")
+      .and()
+      .match("foo")
+      .in("tags")
+      .toParam();
+
+    expect(query).toEqual("bar AND tags:foo");
+  });
+
+  it("should format a simple range", () => {
+    const query = new SearchQueryBuilder()
+      .from("a")
+      .to("z")
+      .in("title")
+      .toParam();
+    expect(query).toEqual("title:[a TO z]");
+  });
+
+  it("should format a simple group", () => {
+    const query = new SearchQueryBuilder()
+      .startGroup()
+      .from("a")
+      .to("z")
+      .in("title")
+      .endGroup()
+      .toParam();
+    expect(query).toEqual("(title:[a TO z])");
+  });
+
+  it("should format a more complex group", () => {
+    const query = new SearchQueryBuilder()
+      .startGroup()
+      .match("California")
+      .or()
+      .match("recent")
+      .endGroup()
+      .and()
+      .match("fires")
+      .toParam();
+    expect(query).toEqual("(California OR recent) AND fires");
+  });
+
+  it("should boost the previous search", () => {
+    const query = new SearchQueryBuilder()
+      .match("test")
+      .boost(5)
+      .toParam();
+    expect(query).toEqual("test^5");
+  });
+
+  it("should convert dates into timestamps", () => {
+    const date1 = new Date("January 1 2019");
+    const date2 = new Date("January 7 2019");
+    const expectedDate1 = date1.getTime();
+    const expectedDate2 = date2.getTime();
+
+    const query = new SearchQueryBuilder()
+      .from(date1)
+      .to(date2)
+      .in("created")
+      .and()
+      .match("test")
+      .in("tags")
+      .toParam();
+
+    expect(query).toEqual(
+      `created:[${expectedDate1} TO ${expectedDate2}] AND tags:test`
+    );
+  });
+
+  it("should format a complex group properly", () => {
+    const query = new SearchQueryBuilder()
+      .match("fred")
+      .in("owner")
+      .and()
+      .startGroup()
+      .match("Web Mapping Application")
+      .in("type")
+      .or()
+      .match("Mobile Application")
+      .in("type")
+      .or()
+      .match("Application")
+      .in("type")
+      .endGroup()
+      .and()
+      .match("test")
+      .in("*")
+      .toParam();
+
+    expect(query).toEqual(
+      `owner:fred AND (type:"Web Mapping Application" OR type:"Mobile Application" OR type:Application) AND test`
+    );
+  });
+
+  it("should allow .not to be called without a preceding search value", () => {
+    const query = new SearchQueryBuilder()
+      .not()
+      .match("public")
+      .in("access")
+      .not()
+      .match("code attachment")
+      .in("type")
+      .toParam();
+
+    expect(query).toEqual(`NOT access:public NOT type:"code attachment"`);
+  });
+
+  it("should clone searches for modification", () => {
+    const myAppsQuery = new SearchQueryBuilder()
+      .match("fred")
+      .in("owner")
+      .and()
+      .startGroup()
+      .match("Web Mapping Application")
+      .in("type")
+      .or()
+      .match("Mobile Application")
+      .in("type")
+      .or()
+      .match("Application")
+      .in("type")
+      .endGroup();
+
+    const myTestAppsQuery = myAppsQuery
+      .clone()
+      .and()
+      .match("test")
+      .in("*");
+
+    expect(myAppsQuery.toParam()).toEqual(
+      `owner:fred AND (type:"Web Mapping Application" OR type:"Mobile Application" OR type:Application)`
+    );
+
+    expect(myTestAppsQuery.toParam()).toEqual(
+      `owner:fred AND (type:"Web Mapping Application" OR type:"Mobile Application" OR type:Application) AND test`
+    );
+  });
+
+  it("should not allow trailing modifiers, and warn user", () => {
+    const query = new SearchQueryBuilder()
+      .match("test")
+      .not()
+      .toParam();
+
+    expect(console.warn).toHaveBeenCalled();
+    expect(query).toEqual("test");
+  });
+
+  it("should not allow chains of logic modifiers, and warn user", () => {
+    const query = new SearchQueryBuilder()
+      .and()
+      .or()
+      .or()
+      .toParam();
+
+    expect(console.warn).toHaveBeenCalled();
+    expect(query).toEqual("");
+  });
+
+  it("should not allow chains of logic modifiers after a .match, and warn user", () => {
+    const query = new SearchQueryBuilder()
+      .match("test")
+      .not()
+      .and()
+      .toParam();
+
+    expect(console.warn).toHaveBeenCalled();
+    expect(query).toEqual("test");
+  });
+
+  it("should close groups on toParam(), and warn user", () => {
+    const query = new SearchQueryBuilder()
+      .startGroup()
+      .match("test")
+      .toParam();
+
+    expect(console.warn).toHaveBeenCalled();
+    expect(query).toEqual("(test)");
+  });
+
+  it("should close groups automatically on clone(), and warn user", () => {
+    const query = new SearchQueryBuilder()
+      .startGroup()
+      .match("test")
+      .clone()
+      .toParam();
+
+    expect(console.warn).toHaveBeenCalled();
+    expect(query).toEqual("(test)");
+  });
+
+  it("should close more then 1 group, and warn user", () => {
+    const query = new SearchQueryBuilder()
+      .startGroup()
+      .match("foo")
+      .startGroup()
+      .match("bar")
+      .toParam();
+
+    expect(console.warn).toHaveBeenCalled();
+    expect(query).toEqual("(foo (bar))");
+  });
+
+  it("should not allow .in() without valid term or range and warn user", () => {
+    const query = new SearchQueryBuilder()
+      .in("tags")
+      .in("title")
+      .toParam();
+
+    expect(console.warn).toHaveBeenCalled();
+    expect(query).toEqual("");
+  });
+
+  it("should not allow .in() with only .from() and warn user", () => {
+    const query = new SearchQueryBuilder()
+      .from("a")
+      .in("title")
+      .toParam();
+
+    expect(console.warn).toHaveBeenCalled();
+    expect(query).toEqual("");
+  });
+
+  it("should not allow .in() with only .to() and warn user", () => {
+    const query = new SearchQueryBuilder()
+      .to("a")
+      .in("title")
+      .toParam();
+
+    expect(console.warn).toHaveBeenCalled();
+    expect(query).toEqual("");
+  });
+
+  it("should not allow .to() after a .match() and warn user", () => {
+    const query = new SearchQueryBuilder()
+      .match("test")
+      .to("a")
+      .toParam();
+
+    expect(console.warn).toHaveBeenCalled();
+    expect(query).toEqual("test");
+  });
+
+  it("should not allow .to() after a .match() and warn user", () => {
+    const query = new SearchQueryBuilder()
+      .match("test")
+      .from("a")
+      .toParam();
+
+    expect(console.warn).toHaveBeenCalled();
+    expect(query).toEqual("test");
+  });
+
+  it("should not allow .endGroup() without .startGroup()", () => {
+    const query = new SearchQueryBuilder()
+      .match("a")
+      .in("title")
+      .endGroup()
+      .toParam();
+
+    expect(console.warn).toHaveBeenCalled();
+    expect(query).toEqual("title:a");
+  });
+
+  it("should not allow .match().from().in(), and warn user", () => {
+    const query = new SearchQueryBuilder()
+      .match("test")
+      .from("a")
+      .in("title")
+      .toParam();
+
+    expect(console.warn).toHaveBeenCalled();
+    expect(query).toEqual("title:test");
+  });
+
+  it("should produce an empty string when no methods are called", () => {
+    const query = new SearchQueryBuilder().toParam();
+    expect(query).toEqual("");
+  });
+});

package/packages/arcgis-rest-portal/test/util/array.test.ts

@@ -0,0 +1,30 @@
+/* Copyright (c) 2019 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { chunk } from "../../src/util/array";
+
+describe("array.chunk", () => {
+  it("should chunk a long array", () => {
+    const input = [1, 2, 3, 4];
+    const result = chunk(input, 3);
+    expect(result).toEqual([[1, 2, 3], [4]]);
+  });
+
+  it("should chunk an array with the length proportional to the chunk size", () => {
+    const input = [1, 2, 3, 4];
+    const result = chunk(input, 2);
+    expect(result).toEqual([[1, 2], [3, 4]]);
+  });
+
+  it("should not chunk a short array", () => {
+    const input = [1, 2, 3, 4];
+    const result = chunk(input, 5);
+    expect(result).toEqual([[1, 2, 3, 4]]);
+  });
+
+  it("should not chunk a zero-length array", () => {
+    const input: number[] = [];
+    const result = chunk(input, 5);
+    expect(result).toEqual([]);
+  });
+});

package/packages/arcgis-rest-portal/test/util/get-portal-settings.test.ts

@@ -0,0 +1,68 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { getPortalSettings } from "../../src/util/get-portal-settings";
+
+import { PortalResponse } from "./../mocks/portal/response";
+
+import * as fetchMock from "fetch-mock";
+
+describe("portal", () => {
+  let paramsSpy: jasmine.Spy;
+
+  beforeEach(() => {
+    paramsSpy = spyOn(FormData.prototype, "append").and.callThrough();
+  });
+
+  afterAll(() => {
+    paramsSpy.calls.reset();
+  });
+
+  afterEach(fetchMock.restore);
+
+  describe("getPortalSettings", () => {
+    // setup an authmgr to use in all these tests
+    const MOCK_AUTH = {
+      getToken() {
+        return Promise.resolve("fake-token");
+      },
+      portal: "https://myorg.maps.arcgis.com/sharing/rest"
+    };
+    const MOCK_REQOPTS = {
+      authentication: MOCK_AUTH
+    };
+
+    it("should get the portal settings by id", done => {
+      fetchMock.once("*", PortalResponse);
+      getPortalSettings("5BZFaKe", MOCK_REQOPTS)
+        .then(response => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://myorg.maps.arcgis.com/sharing/rest/portals/5BZFaKe/settings?f=json&token=fake-token"
+          );
+          expect(options.method).toBe("GET");
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+    it("should get the portal self settings if no id", done => {
+      fetchMock.once("*", PortalResponse);
+      getPortalSettings(null, MOCK_REQOPTS)
+        .then(response => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://myorg.maps.arcgis.com/sharing/rest/portals/self/settings?f=json&token=fake-token"
+          );
+          expect(options.method).toBe("GET");
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+  });
+});

package/packages/arcgis-rest-portal/test/util/get-portal-url.test.ts

@@ -0,0 +1,37 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { getPortalUrl } from "../../src/util/get-portal-url";
+
+describe("getPortalUrl", () => {
+  it("should default to arcgis.com", () => {
+    const url = getPortalUrl();
+    expect(url).toEqual("https://www.arcgis.com/sharing/rest");
+  });
+  it("should use the portal from authorization if passed", () => {
+    const requestOptions = {
+      authentication: {
+        portal: "https://foo.com/arcgis/sharing/rest",
+        getToken() {
+          return Promise.resolve("fake");
+        }
+      }
+    };
+    const url = getPortalUrl(requestOptions);
+    expect(url).toEqual("https://foo.com/arcgis/sharing/rest");
+  });
+
+  it("should use the portal in the requestOptions if passed", () => {
+    const requestOptions = {
+      authentication: {
+        portal: "https://foo.com/arcgis/sharing/rest",
+        getToken() {
+          return Promise.resolve("fake");
+        }
+      },
+      portal: "https://bar.com/arcgis/sharing/rest"
+    };
+    const url = getPortalUrl(requestOptions);
+    expect(url).toEqual("https://bar.com/arcgis/sharing/rest");
+  });
+});