culparepellendus 1.0.0

package/packages/arcgis-rest-portal/src/util/search.ts

@@ -0,0 +1,47 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { IRequestOptions } from "@esri/arcgis-rest-request";
+import { IPagingParams, IItem, IGroup, IUser } from "@esri/arcgis-rest-types";
+import { SearchQueryBuilder } from "./SearchQueryBuilder";
+
+export interface ISearchOptions extends IRequestOptions, IPagingParams {
+  q: string | SearchQueryBuilder;
+  sortField?: string;
+  sortOrder?: string;
+  countFields?: string;
+  countSize?: number;
+  filter?: string;
+  categories?: string;
+  categoryFilters?: string;
+  [key: string]: any;
+}
+
+export interface ISearchGroupContentOptions extends ISearchOptions {
+  groupId: string;
+}
+
+/**
+ * Results from an item or group search.
+ */
+export interface ISearchResult<T extends IItem | IGroup | IUser> {
+  query: string; // matches the api's form param
+  total: number;
+  start: number;
+  num: number;
+  nextStart: number;
+  results: T[];
+  nextPage?: () => Promise<ISearchResult<T>>;
+  /**
+   * Aggregations will only be present on item searches when [`fieldCounts`](https://developers.arcgis.com/rest/users-groups-and-items/search.htm#GUID-1C625F8A-4A12-45BB-B537-74C82315759A) are requested.
+   */
+  aggregations?: {
+    counts: Array<{
+      fieldName: string;
+      fieldValues: Array<{
+        value: any;
+        count: number;
+      }>;
+    }>;
+  };
+}

package/packages/arcgis-rest-portal/test/groups/add-users.test.ts

@@ -0,0 +1,239 @@
+/* Copyright (c) 2019 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import {
+  addGroupUsers,
+  IAddGroupUsersOptions,
+} from "../../src/groups/add-users";
+import { UserSession } from "@esri/arcgis-rest-auth";
+import { encodeParam } from "@esri/arcgis-rest-request";
+import { TOMORROW } from "@esri/arcgis-rest-auth/test/utils";
+import * as fetchMock from "fetch-mock";
+
+function createUsernames(start: number, end: number): string[] {
+  const usernames = [];
+
+  for (let i = start; i < end; i++) {
+    usernames.push(`username${i}`);
+  }
+
+  return usernames;
+}
+
+describe("add-users", () => {
+  const MOCK_AUTH = new UserSession({
+    clientId: "clientId",
+    redirectUri: "https://example-app.com/redirect-uri",
+    token: "fake-token",
+    tokenExpires: TOMORROW,
+    refreshToken: "refreshToken",
+    refreshTokenExpires: TOMORROW,
+    refreshTokenTTL: 1440,
+    username: "casey",
+    password: "123456",
+    portal: "https://myorg.maps.arcgis.com/sharing/rest",
+  });
+
+  afterEach(fetchMock.restore);
+
+  it("should send multiple requests for a long user array", (done) => {
+    const requests = [createUsernames(0, 25), createUsernames(25, 35)];
+
+    const responses = [
+      { notAdded: ["username1"] },
+      { notAdded: ["username30"] },
+    ];
+
+    fetchMock.post("*", (url, options) => {
+      expect(url).toEqual(
+        "https://myorg.maps.arcgis.com/sharing/rest/community/groups/group-id/addUsers"
+      );
+      expect(options.method).toBe("POST");
+      expect(options.body).toContain(encodeParam("f", "json"));
+      expect(options.body).toContain(encodeParam("token", "fake-token"));
+      expect(options.body).toContain(
+        encodeParam("users", requests.shift().join(","))
+      );
+
+      return responses.shift();
+    });
+
+    const params = {
+      id: "group-id",
+      users: createUsernames(0, 35),
+      authentication: MOCK_AUTH,
+    };
+
+    addGroupUsers(params)
+      .then((result) => {
+        expect(requests.length).toEqual(0);
+        expect(responses.length).toEqual(0);
+        expect(result.notAdded).toEqual(["username1", "username30"]);
+        expect(result.errors).toBeUndefined();
+        done();
+      })
+      .catch((error) => fail(error));
+  });
+
+  it("should send multiple requests for a long admin array", (done) => {
+    const requests = [createUsernames(0, 25), createUsernames(25, 35)];
+
+    const responses = [
+      { notAdded: ["username1"] },
+      { notAdded: ["username30"] },
+    ];
+
+    fetchMock.post("*", (url, options) => {
+      expect(url).toEqual(
+        "https://myorg.maps.arcgis.com/sharing/rest/community/groups/group-id/addUsers"
+      );
+      expect(options.method).toBe("POST");
+      expect(options.body).toContain(encodeParam("f", "json"));
+      expect(options.body).toContain(encodeParam("token", "fake-token"));
+      expect(options.body).toContain(
+        encodeParam("admins", requests.shift().join(","))
+      );
+
+      return responses.shift();
+    });
+
+    const params = {
+      id: "group-id",
+      admins: createUsernames(0, 35),
+      authentication: MOCK_AUTH,
+    };
+
+    addGroupUsers(params)
+      .then((result) => {
+        expect(requests.length).toEqual(0);
+        expect(responses.length).toEqual(0);
+        expect(result.notAdded).toEqual(["username1", "username30"]);
+        expect(result.errors).toBeUndefined();
+        done();
+      })
+      .catch((error) => fail(error));
+  });
+
+  it("should send separate requests for users and admins", (done) => {
+    const requests = [
+      encodeParam("users", ["username1", "username2"]),
+      encodeParam("admins", ["username3"]),
+    ];
+
+    fetchMock.post("*", (url, options) => {
+      expect(url).toEqual(
+        "https://myorg.maps.arcgis.com/sharing/rest/community/groups/group-id/addUsers"
+      );
+      expect(options.method).toBe("POST");
+      expect(options.body).toContain(encodeParam("f", "json"));
+      expect(options.body).toContain(encodeParam("token", "fake-token"));
+      expect(options.body).toContain(requests.shift());
+
+      return { notAdded: [] };
+    });
+
+    const params = {
+      id: "group-id",
+      users: ["username1", "username2"],
+      admins: ["username3"],
+      authentication: MOCK_AUTH,
+    };
+
+    addGroupUsers(params)
+      .then((result) => {
+        expect(requests.length).toEqual(0);
+        expect(result.notAdded).toEqual([]);
+        expect(result.errors).toBeUndefined();
+        done();
+      })
+      .catch((error) => fail(error));
+  });
+
+  it("should return request failure", (done) => {
+    const responses = [
+      { notAdded: ["username2"] },
+      {
+        error: {
+          code: 400,
+          messageCode: "ORG_3100",
+          message: "error message for add-user request",
+        },
+      },
+      { notAdded: ["username30"] },
+      {
+        error: {
+          code: 400,
+          messageCode: "ORG_3200",
+          message: "error message for add-admin request",
+        },
+      },
+    ];
+
+    fetchMock.post("*", () => responses.shift());
+
+    const params = {
+      id: "group-id",
+      users: createUsernames(0, 30),
+      admins: createUsernames(30, 60),
+      authentication: MOCK_AUTH,
+    };
+
+    addGroupUsers(params)
+      .then((result) => {
+        expect(responses.length).toEqual(0);
+
+        const expectedNotAdded = ["username2", "username30"];
+        expect(result.notAdded).toEqual(expectedNotAdded);
+
+        expect(result.errors.length).toEqual(2);
+
+        const errorA = result.errors[0];
+        expect(errorA.url).toEqual(
+          "https://myorg.maps.arcgis.com/sharing/rest/community/groups/group-id/addUsers"
+        );
+        expect(errorA.code).toEqual("ORG_3100");
+        expect(errorA.originalMessage).toEqual(
+          "error message for add-user request"
+        );
+
+        const errorAOptions: any = errorA.options;
+        expect(errorAOptions.users).toEqual(createUsernames(25, 30));
+        expect(errorAOptions.admins).toBeUndefined();
+
+        const errorB = result.errors[1];
+        expect(errorB.url).toEqual(
+          "https://myorg.maps.arcgis.com/sharing/rest/community/groups/group-id/addUsers"
+        );
+        expect(errorB.code).toEqual("ORG_3200");
+        expect(errorB.originalMessage).toEqual(
+          "error message for add-admin request"
+        );
+
+        const errorBOptions: any = errorB.options;
+        expect(errorBOptions.users).toBeUndefined();
+        expect(errorBOptions.admins).toEqual(createUsernames(55, 60));
+
+        done();
+      })
+      .catch((error) => fail(error));
+  });
+
+  it("should not send any request for zero-length username array", (done) => {
+    const params: IAddGroupUsersOptions = {
+      id: "group-id",
+      users: [],
+      admins: [],
+      authentication: MOCK_AUTH,
+    };
+    fetchMock.post("*", () => 200);
+    addGroupUsers(params)
+      .then((result) => {
+        expect(fetchMock.called()).toEqual(false);
+        expect(result.notAdded).toEqual([]);
+        expect(result.errors).toBeUndefined();
+
+        done();
+      })
+      .catch((error) => fail(error));
+  });
+});

package/packages/arcgis-rest-portal/test/groups/crud.test.ts

@@ -0,0 +1,180 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { createGroup } from "../../src/groups/create";
+import { updateGroup } from "../../src/groups/update";
+import { removeGroup } from "../../src/groups/remove";
+
+import { GroupEditResponse } from "../mocks/groups/responses";
+
+import { encodeParam } from "@esri/arcgis-rest-request";
+import { IGroupAdd } from "@esri/arcgis-rest-types";
+
+import { UserSession } from "@esri/arcgis-rest-auth";
+import { TOMORROW } from "@esri/arcgis-rest-auth/test/utils";
+import * as fetchMock from "fetch-mock";
+
+describe("groups", () => {
+  afterEach(fetchMock.restore);
+
+  describe("authenticted methods", () => {
+    const MOCK_AUTH = new UserSession({
+      clientId: "clientId",
+      redirectUri: "https://example-app.com/redirect-uri",
+      token: "fake-token",
+      tokenExpires: TOMORROW,
+      refreshToken: "refreshToken",
+      refreshTokenExpires: TOMORROW,
+      refreshTokenTTL: 1440,
+      username: "casey",
+      password: "123456",
+      portal: "https://myorg.maps.arcgis.com/sharing/rest"
+    });
+
+    const MOCK_REQOPTS = {
+      authentication: MOCK_AUTH
+    };
+
+    it("should create a group", done => {
+      fetchMock.once("*", GroupEditResponse);
+      const fakeGroup = {
+        title: "fake group",
+        owner: "fakeUser",
+        tags: ["foo", "bar"],
+        description: "my fake group",
+        access: "public"
+      } as IGroupAdd;
+      createGroup({ group: fakeGroup, ...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/community/createGroup"
+          );
+          expect(options.method).toBe("POST");
+          expect(options.body).toContain(encodeParam("f", "json"));
+          expect(options.body).toContain(encodeParam("token", "fake-token"));
+          expect(options.body).toContain(encodeParam("owner", "fakeUser"));
+          // ensure the array props are serialized into strings
+          expect(options.body).toContain(encodeParam("tags", "foo,bar"));
+          expect(options.body).toContain(encodeParam("access", "public"));
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should create a group without an owner or tags", done => {
+      fetchMock.once("*", GroupEditResponse);
+      const fakeGroup = {
+        title: "bone stock fake group",
+        access: "org"
+      } as IGroupAdd;
+      createGroup({ group: fakeGroup, ...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/community/createGroup"
+          );
+          expect(options.method).toBe("POST");
+          expect(options.body).toContain(encodeParam("f", "json"));
+          expect(options.body).toContain(encodeParam("token", "fake-token"));
+          expect(options.body).toContain(
+            encodeParam("title", "bone stock fake group")
+          );
+          expect(options.body).toContain(encodeParam("access", "org"));
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should update a group", done => {
+      fetchMock.once("*", GroupEditResponse);
+      const fakeGroup = {
+        id: "5bc",
+        title: "fake group",
+        owner: "fakeUser",
+        tags: ["foo", "bar"],
+        description: "my fake group"
+      };
+      updateGroup({ group: fakeGroup, ...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/community/groups/5bc/update"
+          );
+          expect(options.method).toBe("POST");
+          expect(options.body).toContain(encodeParam("f", "json"));
+          expect(options.body).toContain(encodeParam("token", "fake-token"));
+          expect(options.body).toContain(encodeParam("owner", "fakeUser"));
+          // ensure the array props are serialized into strings
+          expect(options.body).toContain(encodeParam("tags", "foo,bar"));
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should update a group with a custom param", done => {
+      fetchMock.once("*", GroupEditResponse);
+      const fakeGroup = {
+        id: "5bc",
+        title: "fake group",
+        owner: "fakeUser",
+        tags: ["foo", "bar"],
+        description: "my fake group"
+      };
+      updateGroup({
+        group: fakeGroup,
+        authentication: MOCK_AUTH,
+        params: {
+          clearEmptyFields: true
+        }
+      })
+        .then(response => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://myorg.maps.arcgis.com/sharing/rest/community/groups/5bc/update"
+          );
+          expect(options.method).toBe("POST");
+          expect(options.body).toContain(encodeParam("f", "json"));
+          expect(options.body).toContain(encodeParam("token", "fake-token"));
+          expect(options.body).toContain(encodeParam("owner", "fakeUser"));
+          // ensure the array props are serialized into strings
+          expect(options.body).toContain(encodeParam("tags", "foo,bar"));
+          expect(options.body).toContain(encodeParam("clearEmptyFields", true));
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should remove a group", done => {
+      fetchMock.once("*", GroupEditResponse);
+
+      removeGroup({ id: "5bc", ...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/community/groups/5bc/delete"
+          );
+          expect(options.method).toBe("POST");
+          expect(options.body).toContain(encodeParam("f", "json"));
+          expect(options.body).toContain(encodeParam("token", "fake-token"));
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+  });
+});

package/packages/arcgis-rest-portal/test/groups/get.test.ts

@@ -0,0 +1,176 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import {
+  getGroup,
+  getGroupCategorySchema,
+  getGroupContent,
+  getGroupUsers,
+  searchGroupUsers
+} from "../../src/groups/get";
+
+import {
+  GroupResponse,
+  GroupCategorySchemaResponse,
+  GroupContentResponse,
+  GroupUsersResponse,
+  SearchGroupUsersResponse
+} from "../mocks/groups/responses";
+
+import * as fetchMock from "fetch-mock";
+
+describe("groups", () => {
+  afterEach(fetchMock.restore);
+
+  describe("getGroup", () => {
+    it("should return a group", done => {
+      fetchMock.once("*", GroupResponse);
+      getGroup("3ef")
+        .then(response => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://www.arcgis.com/sharing/rest/community/groups/3ef?f=json"
+          );
+          expect(options.method).toBe("GET");
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+  });
+
+  describe("getGroupCategorySchema", () => {
+    it("should return group's category schema", done => {
+      fetchMock.once("*", GroupCategorySchemaResponse);
+      getGroupCategorySchema("3ef")
+        .then(response => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://www.arcgis.com/sharing/rest/community/groups/3ef/categorySchema?f=json"
+          );
+          expect(options.method).toBe("GET");
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+  });
+
+  describe("getGroupContent", () => {
+    it("should return group content", done => {
+      fetchMock.once("*", GroupContentResponse);
+      getGroupContent("3ef")
+        .then(response => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://www.arcgis.com/sharing/rest/content/groups/3ef?f=json&start=1&num=100"
+          );
+          expect(options.method).toBe("GET");
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should return group content, paged", done => {
+      fetchMock.once("*", GroupContentResponse);
+      getGroupContent("3ef", { paging: { start: 4, num: 7 } })
+        .then(response => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://www.arcgis.com/sharing/rest/content/groups/3ef?f=json&start=4&num=7"
+          );
+          expect(options.method).toBe("GET");
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+  });
+
+  describe("authenticted methods", () => {
+    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 return group users", done => {
+      fetchMock.once("*", GroupUsersResponse);
+
+      getGroupUsers("5bc", 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/community/groups/5bc/users?f=json&token=fake-token"
+          );
+          expect(options.method).toBe("GET");
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    describe("search group users", function() {
+      it("should search group users", done => {
+        fetchMock.once("*", SearchGroupUsersResponse);
+
+        searchGroupUsers("5bc", {
+          name: "jupe",
+          sortField: "fullname",
+          sortOrder: "asc",
+          num: 2,
+          start: 2,
+          joined: [null, 123456],
+          memberType: "member",
+          ...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/community/groups/5bc/userlist?f=json&name=jupe&num=2&start=2&sortField=fullname&sortOrder=asc&joined=%2C123456&memberType=member&token=fake-token"
+            );
+            expect(options.method).toBe("GET");
+            done();
+          })
+          .catch(e => {
+            fail(e);
+          });
+      });
+
+      it("shouldn't require searchOptions", done => {
+        fetchMock.once("*", SearchGroupUsersResponse);
+
+        searchGroupUsers("5bc")
+          .then(_ => {
+            expect(fetchMock.called()).toEqual(true);
+            const [__, options]: [string, RequestInit] = fetchMock.lastCall(
+              "*"
+            );
+            expect(options.method).toBe("GET");
+            done();
+          })
+          .catch(e => {
+            fail(e);
+          });
+      });
+    });
+  });
+});