autculpa 1.0.0

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

@@ -0,0 +1,183 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import fetchMock from "fetch-mock";
+
+import { createGroup } from "../../src/groups/create.js";
+import { updateGroup } from "../../src/groups/update.js";
+import { removeGroup } from "../../src/groups/remove.js";
+
+import { GroupEditResponse } from "../mocks/groups/responses.js";
+
+import {
+  encodeParam,
+  ArcGISIdentityManager,
+  IGroupAdd
+} from "@esri/arcgis-rest-request";
+
+import { TOMORROW } from "../../../../scripts/test-helpers.js";
+
+describe("groups", () => {
+  afterEach(fetchMock.restore);
+
+  describe("authenticted methods", () => {
+    const MOCK_AUTH = new ArcGISIdentityManager({
+      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,174 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import fetchMock from "fetch-mock";
+
+import {
+  getGroup,
+  getGroupCategorySchema,
+  getGroupContent,
+  getGroupUsers,
+  searchGroupUsers
+} from "../../src/groups/get.js";
+
+import {
+  GroupResponse,
+  GroupCategorySchemaResponse,
+  GroupContentResponse,
+  GroupUsersResponse,
+  SearchGroupUsersResponse
+} from "../mocks/groups/responses.js";
+
+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);
+          });
+      });
+    });
+  });
+});

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 fetchMock from "fetch-mock";
+
+import {
+  inviteGroupUsers,
+  IInviteGroupUsersOptions
+} from "../../src/groups/invite-users.js";
+
+import { encodeParam, ArcGISIdentityManager } from "@esri/arcgis-rest-request";
+import { TOMORROW } from "../../../../scripts/test-helpers.js";
+
+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 ArcGISIdentityManager({
+    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,71 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import fetchMock from "fetch-mock";
+
+import { joinGroup, leaveGroup } from "../../src/groups/join.js";
+
+import { GroupEditResponse } from "../mocks/groups/responses.js";
+
+import { encodeParam, ArcGISIdentityManager } from "@esri/arcgis-rest-request";
+import { TOMORROW } from "../../../../scripts/test-helpers.js";
+
+describe("groups", () => {
+  afterEach(fetchMock.restore);
+
+  describe("authenticted methods", () => {
+    const MOCK_REQOPTS = {
+      authentication: new ArcGISIdentityManager({
+        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,111 @@
+import fetchMock from "fetch-mock";
+
+import { encodeParam, ArcGISIdentityManager } from "@esri/arcgis-rest-request";
+import { TOMORROW } from "../../../../scripts/test-helpers.js";
+
+import { createGroupNotification } from "../../src/groups/notification.js";
+
+import { GroupNotificationResponse } from "../mocks/groups/responses.js";
+
+describe("groups", () => {
+  afterEach(fetchMock.restore);
+
+  describe("createGroupNotification", () => {
+    const MOCK_AUTH = new ArcGISIdentityManager({
+      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);
+        });
+    });
+  });
+});