sintfacilis 1.0.0

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

@@ -0,0 +1,146 @@
+/* Copyright (c) 2019 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import {
+  inviteGroupUsers,
+  IInviteGroupUsersOptions,
+} from "../../src/groups/invite-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("invite-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 = [{ success: true }, { success: false }];
+
+    fetchMock.post("*", (url, options) => {
+      expect(url).toEqual(
+        "https://myorg.maps.arcgis.com/sharing/rest/community/groups/group-id/invite"
+      );
+      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("role", "group_member"));
+      expect(options.body).toContain(encodeParam("expiration", 1440));
+      expect(options.body).toContain(
+        encodeParam("users", requests.shift().join(","))
+      );
+
+      return responses.shift();
+    });
+
+    const params: IInviteGroupUsersOptions = {
+      id: "group-id",
+      users: createUsernames(0, 35),
+      role: "group_member",
+      expiration: 1440,
+      authentication: MOCK_AUTH,
+    };
+
+    inviteGroupUsers(params)
+      .then((result) => {
+        expect(requests.length).toEqual(0);
+        expect(responses.length).toEqual(0);
+        expect(result.success).toEqual(false);
+        expect(result.errors).toBeUndefined();
+        done();
+      })
+      .catch((error) => fail(error));
+  });
+
+  it("should return request failure", (done) => {
+    const responses = [
+      { success: true },
+      {
+        error: {
+          code: 400,
+          messageCode: "ORG_3100",
+          message: "error message for add-user request",
+        },
+      },
+    ];
+
+    fetchMock.post("*", (url, options) => {
+      return responses.shift();
+    });
+
+    const params: IInviteGroupUsersOptions = {
+      id: "group-id",
+      users: createUsernames(0, 30),
+      role: "group_member",
+      expiration: 1440,
+      authentication: MOCK_AUTH,
+    };
+
+    inviteGroupUsers(params)
+      .then((result) => {
+        expect(responses.length).toEqual(0);
+        expect(result.success).toEqual(false);
+
+        expect(result.errors.length).toEqual(1);
+
+        const errorA = result.errors[0];
+        expect(errorA.url).toEqual(
+          "https://myorg.maps.arcgis.com/sharing/rest/community/groups/group-id/invite"
+        );
+        expect(errorA.code).toEqual("ORG_3100");
+        expect(errorA.originalMessage).toEqual(
+          "error message for add-user request"
+        );
+
+        const errorAOptions: any = errorA.options;
+        expect(errorAOptions.params.users).toEqual(createUsernames(25, 30));
+        done();
+      })
+      .catch((error) => fail(error));
+  });
+
+  it("should not send any request for zero-length username array", (done) => {
+    const params: IInviteGroupUsersOptions = {
+      id: "group-id",
+      role: "group_member",
+      expiration: 1440,
+      users: [],
+      authentication: MOCK_AUTH,
+    };
+    fetchMock.post("*", () => 200);
+    inviteGroupUsers(params)
+      .then((result) => {
+        expect(fetchMock.called()).toEqual(false);
+        expect(result.success).toEqual(true);
+        expect(result.errors).toBeUndefined();
+
+        done();
+      })
+      .catch((error) => fail(error));
+  });
+});

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

@@ -0,0 +1,72 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { joinGroup, leaveGroup } from "../../src/groups/join";
+
+import { GroupEditResponse } from "../mocks/groups/responses";
+
+import { encodeParam } from "@esri/arcgis-rest-request";
+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_REQOPTS = {
+      authentication: 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"
+      })
+    };
+
+    it("should help a user join a group", done => {
+      fetchMock.once("*", GroupEditResponse);
+
+      joinGroup({ id: "5bc", ...MOCK_REQOPTS })
+        .then(() => {
+          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/join"
+          );
+          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);
+        });
+    });
+    it("should help a user leave a group", done => {
+      fetchMock.once("*", GroupEditResponse);
+
+      leaveGroup({ id: "5bc", ...MOCK_REQOPTS })
+        .then(() => {
+          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/leave"
+          );
+          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/notification.test.ts

@@ -0,0 +1,112 @@
+import { encodeParam } from "@esri/arcgis-rest-request";
+import { UserSession } from "@esri/arcgis-rest-auth";
+import { TOMORROW } from "@esri/arcgis-rest-auth/test/utils";
+
+import * as fetchMock from "fetch-mock";
+
+import { createGroupNotification } from "../../src/groups/notification";
+
+import { GroupNotificationResponse } from "../mocks/groups/responses";
+
+describe("groups", () => {
+  afterEach(fetchMock.restore);
+
+  describe("createGroupNotification", () => {
+    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 an email notification", done => {
+      fetchMock.once("*", GroupNotificationResponse);
+
+      const opts = {
+        id: "3ef",
+        subject: "this is the subject",
+        message: "this is the message",
+        ...MOCK_REQOPTS
+      };
+
+      createGroupNotification(opts)
+        .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/3ef/createNotification"
+          );
+          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("subject", "this is the subject")
+          );
+          expect(options.body).toContain(
+            encodeParam("message", "this is the message")
+          );
+          expect(options.body).toContain(
+            encodeParam("notificationChannelType", "email")
+          );
+          expect(options.body).toContain(encodeParam("notifyAll", true));
+          expect(response.success).toEqual(true);
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should create an email notification for specific users", done => {
+      fetchMock.once("*", GroupNotificationResponse);
+
+      const opts = {
+        id: "3ef",
+        subject: "this is the subject",
+        message: "this is the message",
+        users: ["casey", "atthebat"],
+        ...MOCK_REQOPTS
+      };
+
+      createGroupNotification(opts)
+        .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/3ef/createNotification"
+          );
+          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("subject", "this is the subject")
+          );
+          expect(options.body).toContain(
+            encodeParam("message", "this is the message")
+          );
+          expect(options.body).toContain(
+            encodeParam("notificationChannelType", "email")
+          );
+          expect(options.body).toContain(encodeParam("notifyAll", false));
+          expect(options.body).toContain(
+            encodeParam("users", "casey,atthebat")
+          );
+          expect(response.success).toEqual(true);
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+  });
+});

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

@@ -0,0 +1,72 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { protectGroup, unprotectGroup } from "../../src/groups/protect";
+
+import { GroupEditResponse } from "../mocks/groups/responses";
+
+import { encodeParam } from "@esri/arcgis-rest-request";
+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_REQOPTS = {
+      authentication: 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"
+      })
+    };
+
+    it("should protect a group", done => {
+      fetchMock.once("*", GroupEditResponse);
+
+      protectGroup({ id: "5bc", ...MOCK_REQOPTS })
+        .then(() => {
+          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/protect"
+          );
+          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);
+        });
+    });
+    it("should unprotect a group", done => {
+      fetchMock.once("*", GroupEditResponse);
+
+      unprotectGroup({ id: "5bc", ...MOCK_REQOPTS })
+        .then(() => {
+          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/unprotect"
+          );
+          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/remove-users.test.ts

@@ -0,0 +1,140 @@
+/* Copyright (c) 2019 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import {
+  removeGroupUsers,
+  IRemoveGroupUsersOptions,
+} from "../../src/groups/remove-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("remove-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 = [
+      { notRemoved: ["username1"] },
+      { notRemoved: ["username30"] },
+    ];
+
+    fetchMock.post("*", (url, options) => {
+      expect(url).toEqual(
+        "https://myorg.maps.arcgis.com/sharing/rest/community/groups/group-id/removeUsers"
+      );
+      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,
+    };
+
+    removeGroupUsers(params)
+      .then((result) => {
+        expect(requests.length).toEqual(0);
+        expect(responses.length).toEqual(0);
+        expect(result.notRemoved).toEqual(["username1", "username30"]);
+        expect(result.errors).toBeUndefined();
+        done();
+      })
+      .catch((error) => fail(error));
+  });
+
+  it("should return request failure", (done) => {
+    const responses = [
+      { notRemoved: ["username2"] },
+      {
+        error: {
+          code: 400,
+          messageCode: "ORG_3100",
+          message: "error message for remove-user request",
+        },
+      },
+    ];
+
+    fetchMock.post("*", () => responses.shift());
+
+    const params = {
+      id: "group-id",
+      users: createUsernames(0, 30),
+      authentication: MOCK_AUTH,
+    };
+
+    removeGroupUsers(params)
+      .then((result) => {
+        expect(responses.length).toEqual(0);
+
+        const expectedNotAdded = ["username2"];
+        expect(result.notRemoved).toEqual(expectedNotAdded);
+
+        expect(result.errors.length).toEqual(1);
+        const errorA = result.errors[0];
+        expect(errorA.url).toEqual(
+          "https://myorg.maps.arcgis.com/sharing/rest/community/groups/group-id/removeUsers"
+        );
+        expect(errorA.code).toEqual("ORG_3100");
+        expect(errorA.originalMessage).toEqual(
+          "error message for remove-user request"
+        );
+
+        const errorAOptions: any = errorA.options;
+        expect(errorAOptions.users).toEqual(createUsernames(25, 30));
+
+        done();
+      })
+      .catch((error) => fail(error));
+  });
+
+  it("should not send any request for zero-length username array", (done) => {
+    const params: IRemoveGroupUsersOptions = {
+      id: "group-id",
+      users: [],
+      authentication: MOCK_AUTH,
+    };
+    fetchMock.post("*", () => 200);
+    removeGroupUsers(params)
+      .then((result) => {
+        expect(fetchMock.called()).toEqual(false);
+        expect(result.notRemoved).toEqual([]);
+        expect(result.errors).toBeUndefined();
+
+        done();
+      })
+      .catch((error) => fail(error));
+  });
+});

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

@@ -0,0 +1,151 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { searchGroups, searchGroupContent } from "../../src/groups/search";
+import { GroupSearchResponse } from "../mocks/groups/responses";
+import { SearchQueryBuilder } from "../../src/util/SearchQueryBuilder";
+import { genericSearch } from "../../src/util/generic-search";
+
+import * as fetchMock from "fetch-mock";
+
+describe("groups", () => {
+  afterEach(fetchMock.restore);
+
+  describe("searchGroups", () => {
+    it("should make a simple, unauthenticated group search request", done => {
+      fetchMock.once("*", GroupSearchResponse);
+
+      searchGroups("water")
+        .then(() => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://www.arcgis.com/sharing/rest/community/groups?f=json&q=water"
+          );
+          expect(options.method).toBe("GET");
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should take num, start, sortField, sortOrder and construct the request", done => {
+      fetchMock.once("*", GroupSearchResponse);
+      searchGroups({
+        q: "water",
+        start: 4,
+        num: 7,
+        sortField: "owner",
+        sortOrder: "desc"
+      })
+        .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?f=json&q=water&num=7&start=4&sortField=owner&sortOrder=desc"
+          );
+          expect(options.method).toBe("GET");
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should search for group contents", done => {
+      fetchMock.once("*", GroupSearchResponse);
+
+      searchGroupContent({
+        groupId: "grp1234567890",
+        q: "water"
+      })
+        .then(() => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://www.arcgis.com/sharing/rest/content/groups/grp1234567890/search?f=json&q=water"
+          );
+          expect(options.method).toBe("GET");
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should catch search for group contents without group id", done => {
+      genericSearch(
+        {
+          q: "water"
+        },
+        "groupContent"
+      ).then(
+        () => fail(),
+        err => {
+          expect(err).toEqual(
+            new Error(
+              "you must pass a `groupId` option to `searchGroupContent`"
+            )
+          );
+          done();
+        }
+      );
+    });
+  });
+
+  it("should make a simple, single search request with a builder", done => {
+    fetchMock.once("*", GroupSearchResponse);
+    const expectedParam = "Trees AND owner:USFS";
+    const q = new SearchQueryBuilder()
+      .match("Trees")
+      .and()
+      .match("USFS")
+      .in("owner");
+    searchGroups(q)
+      .then(() => {
+        expect(fetchMock.called()).toEqual(true);
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          `https://www.arcgis.com/sharing/rest/community/groups?f=json&q=${encodeURIComponent(
+            expectedParam
+          )}`
+        );
+        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 make a simple, authenticated group search request", done => {
+      fetchMock.once("*", GroupSearchResponse);
+
+      searchGroups({ q: "water", 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/community/groups?f=json&q=water&token=fake-token"
+          );
+          expect(options.method).toBe("GET");
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+  });
+});