autnam 1.0.0

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

@@ -0,0 +1,71 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import fetchMock from "fetch-mock";
+
+import { protectGroup, unprotectGroup } from "../../src/groups/protect.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 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 fetchMock from "fetch-mock";
+
+import {
+  removeGroupUsers,
+  IRemoveGroupUsersOptions
+} from "../../src/groups/remove-users.js";
+import { ArcGISIdentityManager, encodeParam } 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("remove-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 = [
+      { 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 fetchMock from "fetch-mock";
+
+import { searchGroups, searchGroupContent } from "../../src/groups/search.js";
+import { GroupSearchResponse } from "../mocks/groups/responses.js";
+import { SearchQueryBuilder } from "../../src/util/SearchQueryBuilder.js";
+import { genericSearch } from "../../src/util/generic-search.js";
+
+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);
+        });
+    });
+  });
+});

package/packages/arcgis-rest-portal/test/groups/update-user-membership.test.ts

@@ -0,0 +1,64 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import fetchMock from "fetch-mock";
+
+import { MOCK_USER_SESSION } from "../mocks/sharing/sharing.js";
+import { TOMORROW } from "../../../../scripts/test-helpers.js";
+import { updateUserMemberships } from "../../src/groups/update-user-membership.js";
+
+describe("udpate-user-membership", () => {
+  beforeEach((done) => {
+    fetchMock.post("https://myorg.maps.arcgis.com/sharing/rest/generateToken", {
+      token: "fake-token",
+      expires: TOMORROW.getTime(),
+      username: "jsmith"
+    });
+
+    // make sure session doesnt cache metadata
+    MOCK_USER_SESSION.refreshSession()
+      .then(() => done())
+      .catch();
+  });
+
+  afterEach(fetchMock.restore);
+
+  it("converts member to admin", (done) => {
+    fetchMock.post(
+      "https://myorg.maps.arcgis.com/sharing/rest/community/groups/3ef/updateUsers",
+      { results: [{ username: "casey", success: true }] }
+    );
+
+    updateUserMemberships({
+      authentication: MOCK_USER_SESSION,
+      id: "3ef",
+      users: ["larry", "curly", "moe"],
+      newMemberType: "admin"
+    }).then(() => {
+      const opts: RequestInit = fetchMock.lastOptions(
+        "https://myorg.maps.arcgis.com/sharing/rest/community/groups/3ef/updateUsers"
+      );
+      expect(opts.body).toContain("admins=larry%2Ccurly%2Cmoe");
+      done();
+    });
+  });
+  it("converts admin to member", (done) => {
+    fetchMock.post(
+      "https://myorg.maps.arcgis.com/sharing/rest/community/groups/3ef/updateUsers",
+      { results: [{ username: "casey", success: true }] }
+    );
+
+    updateUserMemberships({
+      authentication: MOCK_USER_SESSION,
+      id: "3ef",
+      users: ["larry", "curly", "moe"],
+      newMemberType: "member"
+    }).then(() => {
+      const opts: RequestInit = fetchMock.lastOptions(
+        "https://myorg.maps.arcgis.com/sharing/rest/community/groups/3ef/updateUsers"
+      );
+      expect(opts.body).toContain("users=larry%2Ccurly%2Cmoe");
+      done();
+    });
+  });
+});