autculpa 1.0.0

package/packages/arcgis-rest-portal/test/mocks/users/user.ts

@@ -0,0 +1,174 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { IUser } from "@esri/arcgis-rest-request";
+
+export const AnonUserResponse: IUser = {
+  username: "jsmith",
+  fullName: "John Smith",
+  firstName: "John",
+  lastName: "Smith",
+  description: "Senior GIS Analyst for the city of Redlands.",
+  tags: ["GIS Analyst", "City of Redlands"],
+  culture: "en",
+  region: "US",
+  units: "metric",
+  thumbnail: "myProfile.jpg",
+  created: 1258501046000,
+  modified: 1290625562000,
+  provider: "arcgis"
+};
+
+export const GroupMemberUserResponse: IUser = {
+  ...AnonUserResponse,
+  availableCredits: 479.50998,
+  assignedCredits: 500.0,
+  preferredView: "Web",
+  email: "jsmith33@esri.com",
+  idpUsername: "null",
+  favGroupId: "829e32cca4dd475a8bb63bb56b16fe3e",
+  lastLogin: 1385766284000,
+  mfaEnabled: false,
+  access: "public",
+  storageUsage: 583650,
+  storageQuota: 2147483648,
+  orgId: "qWAReEOCnD7eTxOe",
+  role: "org_publisher",
+  privileges: [
+    "portal:admin:deleteItems",
+    "portal:admin:reassignItems",
+    "portal:admin:updateItems",
+    "portal:admin:viewItems",
+    "portal:admin:viewUsers",
+    "portal:user:createGroup",
+    "portal:user:createItem",
+    "portal:user:joinGroup",
+    "portal:user:shareToGroup",
+    "portal:user:shareToOrg"
+  ],
+  roleId: "RDnHQBSBbsJuIkUp",
+  level: "2",
+  disabled: false,
+  groups: [
+    {
+      id: "t6b",
+      title: "Street Maps",
+      isInvitationOnly: false,
+      owner: "whoknows",
+      description:
+        "The street map group provides street maps for the city of Redlands.",
+      snippet: "City of Redlands maps",
+      tags: ["Redlands", "street", "maps"],
+      phone: "http://www.esri.com",
+      thumbnail: "streets.jpg",
+      created: 1258501221000,
+      modified: 1272309404000,
+      access: "org",
+      userMembership: {
+        username: "jsmith",
+        memberType: "member",
+        applications: 0
+      },
+      protected: false,
+      isViewOnly: false,
+      isFav: false,
+      isOpenData: true,
+      autoJoin: false
+    }
+  ]
+};
+
+export const GroupNonMemberUserResponse: IUser = {
+  ...GroupMemberUserResponse,
+  groups: [
+    {
+      id: "abc",
+      title: "Street Maps",
+      isInvitationOnly: false,
+      owner: "whoknows",
+      description:
+        "The street map group provides street maps for the city of Redlands.",
+      snippet: "City of Redlands maps",
+      tags: ["Redlands", "street", "maps"],
+      phone: "http://www.esri.com",
+      thumbnail: "streets.jpg",
+      created: 1258501221000,
+      modified: 1272309404000,
+      access: "org",
+      userMembership: {
+        username: "jsmith",
+        memberType: "none",
+        applications: 0
+      },
+      protected: false,
+      isViewOnly: false,
+      isFav: false,
+      isOpenData: true,
+      autoJoin: false
+    }
+  ]
+};
+
+export const GroupAdminUserResponse: IUser = {
+  ...GroupMemberUserResponse,
+  groups: [
+    {
+      id: "t6b",
+      title: "Street Maps",
+      isInvitationOnly: false,
+      owner: "whoknows",
+      description:
+        "The street map group provides street maps for the city of Redlands.",
+      snippet: "City of Redlands maps",
+      tags: ["Redlands", "street", "maps"],
+      phone: "http://www.esri.com",
+      thumbnail: "streets.jpg",
+      created: 1258501221000,
+      modified: 1272309404000,
+      access: "org",
+      userMembership: {
+        username: "jsmith",
+        memberType: "admin",
+        applications: 0
+      },
+      protected: false,
+      isViewOnly: false,
+      isFav: false,
+      isOpenData: true,
+      autoJoin: false
+    }
+  ]
+};
+
+export const OrgAdminUserResponse: IUser = {
+  ...GroupAdminUserResponse,
+  role: "org_admin",
+  roleId: undefined,
+  groups: [
+    {
+      id: "t6b",
+      title: "Street Maps",
+      isInvitationOnly: false,
+      owner: "whoknows",
+      description:
+        "The street map group provides street maps for the city of Redlands.",
+      snippet: "City of Redlands maps",
+      tags: ["Redlands", "street", "maps"],
+      phone: "http://www.esri.com",
+      thumbnail: "streets.jpg",
+      created: 1258501221000,
+      modified: 1272309404000,
+      access: "org",
+      userMembership: {
+        username: "jsmith",
+        memberType: "owner",
+        applications: 0
+      },
+      protected: false,
+      isViewOnly: false,
+      isFav: false,
+      isOpenData: true,
+      autoJoin: false
+    }
+  ]
+};

package/packages/arcgis-rest-portal/test/orgs/notification.test.ts

@@ -0,0 +1,142 @@
+import fetchMock from "fetch-mock";
+import { ArcGISIdentityManager, encodeParam } from "@esri/arcgis-rest-request";
+import { TOMORROW } from "../../../../scripts/test-helpers.js";
+
+import {
+  createOrgNotification,
+  ICreateOrgNotificationOptions
+} from "../../src/orgs/notification.js";
+
+function createUsernames(start: number, end: number): string[] {
+  const usernames = [];
+
+  for (let i = start; i < end; i++) {
+    usernames.push(`username${i}`);
+  }
+
+  return usernames;
+}
+
+describe("create-org-notification", () => {
+  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: true }];
+
+    fetchMock.post("*", (url, options) => {
+      expect(url).toEqual(
+        "https://myorg.maps.arcgis.com/sharing/rest/portals/self/createNotification"
+      );
+      expect(options.method).toBe("POST");
+      expect(options.body).toContain(encodeParam("f", "json"));
+      expect(options.body).toContain(encodeParam("subject", "Attention"));
+      expect(options.body).toContain(encodeParam("message", "This is a test"));
+      expect(options.body).toContain(
+        encodeParam("notificationChannelType", "email")
+      );
+      expect(options.body).toContain(
+        encodeParam("users", requests.shift().join(","))
+      );
+
+      return responses.shift();
+    });
+
+    const params: ICreateOrgNotificationOptions = {
+      users: createUsernames(0, 35),
+      subject: "Attention",
+      message: "This is a test",
+      notificationChannelType: "email",
+      authentication: MOCK_AUTH
+    };
+
+    createOrgNotification(params)
+      .then((result) => {
+        expect(requests.length).toEqual(0);
+        expect(responses.length).toEqual(0);
+        expect(result.success).toEqual(true);
+        expect(result.errors).toBeUndefined();
+        done();
+      })
+      .catch((error) => fail(error));
+  });
+
+  it("should return request failure", (done) => {
+    const responses = [
+      { success: true },
+      {
+        error: {
+          code: 400,
+          messageCode: "ORG_9001",
+          message: "error message for creating org notification"
+        }
+      }
+    ];
+
+    fetchMock.post("*", () => responses.shift());
+
+    const params: ICreateOrgNotificationOptions = {
+      users: createUsernames(0, 30),
+      subject: "Attention",
+      message: "This is a test",
+      notificationChannelType: "email",
+      authentication: MOCK_AUTH
+    };
+
+    createOrgNotification(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/portals/self/createNotification"
+        );
+        expect(errorA.code).toEqual("ORG_9001");
+        expect(errorA.originalMessage).toEqual(
+          "error message for creating org notification"
+        );
+
+        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: ICreateOrgNotificationOptions = {
+      message: "This won't get sent",
+      subject: "Attention",
+      notificationChannelType: "email",
+      users: [],
+      authentication: MOCK_AUTH
+    };
+    fetchMock.post("*", () => 200);
+    createOrgNotification(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/services/get-unique-service-name.test.ts

@@ -0,0 +1,64 @@
+/* Copyright (c) 2018-2020 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import * as isServiceNameAvailableModule from "../../src/services/is-service-name-available.js";
+import fetchMock from "fetch-mock";
+import { getUniqueServiceName } from "../../src/services/get-unique-service-name.js";
+import { ArcGISIdentityManager } from "@esri/arcgis-rest-request";
+import { TOMORROW } from "../../../../scripts/test-helpers.js";
+
+describe("get-unique-service-name:", () => {
+  afterEach(fetchMock.restore);
+
+  const MOCK_USER_SESSION = 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("does single check if unique", () => {
+    fetchMock.mock("*", { available: true }, { method: "GET" });
+
+    return getUniqueServiceName(
+      "myService",
+      "Feature Service",
+      MOCK_USER_SESSION,
+      0
+    ).then((result) => {
+      const call = fetchMock.lastCall();
+      expect(result).toBe("myService", "should return name");
+    });
+  });
+
+  it("makes multiple calls if already taken", () => {
+    fetchMock.get(
+      `${MOCK_USER_SESSION.portal}/portals/self/isServiceNameAvailable?f=json&name=myService&type=Feature%20Service&token=fake-token`,
+      {
+        available: false
+      }
+    );
+
+    fetchMock.get(
+      `${MOCK_USER_SESSION.portal}/portals/self/isServiceNameAvailable?f=json&name=myService_1&type=Feature%20Service&token=fake-token`,
+      {
+        available: true
+      }
+    );
+
+    return getUniqueServiceName(
+      "myService",
+      "Feature Service",
+      MOCK_USER_SESSION,
+      0
+    ).then((result) => {
+      expect(result).toBe("myService_1", "should return name");
+    });
+  });
+});

package/packages/arcgis-rest-portal/test/services/is-service-name-available.test.ts

@@ -0,0 +1,41 @@
+/* Copyright (c) 2018-2020 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import fetchMock from "fetch-mock";
+import { isServiceNameAvailable } from "../../src/services/is-service-name-available.js";
+import { ArcGISIdentityManager } from "@esri/arcgis-rest-request";
+import { TOMORROW } from "../../../../scripts/test-helpers.js";
+
+describe("is-service-name-available", () => {
+  const MOCK_USER_SESSION = 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("returns server response", () => {
+    fetchMock.once("*", { available: true }, { method: "GET" });
+
+    return isServiceNameAvailable(
+      "someService",
+      "Feature Service",
+      MOCK_USER_SESSION
+    ).then((result) => {
+      const [url]: [string, RequestInit] = fetchMock.lastCall("*");
+
+      expect(result.available).toBe(true, "should return the api response");
+      expect(url).toContain(
+        `${MOCK_USER_SESSION.portal}/portals/self/isServiceNameAvailable`
+      );
+      expect(url).toContain("name=someService");
+      expect(url).toContain("type=Feature");
+    });
+  });
+});

package/packages/arcgis-rest-portal/test/sharing/access.test.ts

@@ -0,0 +1,162 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import fetchMock from "fetch-mock";
+import { setItemAccess } from "../../src/sharing/access.js";
+
+import { TOMORROW } from "../../../../scripts/test-helpers.js";
+import { MOCK_USER_SESSION } from "../mocks/sharing/sharing.js";
+
+import { AnonUserResponse, OrgAdminUserResponse } from "../mocks/users/user.js";
+
+const SharingResponse = {
+  notSharedWith: [] as any,
+  itemId: "abc123"
+};
+
+describe("setItemAccess()", () => {
+  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("should share an item with everyone", (done) => {
+    fetchMock.once("*", SharingResponse);
+
+    setItemAccess({
+      authentication: MOCK_USER_SESSION,
+      id: "abc123",
+      access: "public"
+    })
+      .then((response) => {
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          "https://myorg.maps.arcgis.com/sharing/rest/content/users/jsmith/items/abc123/share"
+        );
+        expect(options.method).toBe("POST");
+        expect(response).toEqual(SharingResponse);
+        expect(options.body).toContain("f=json");
+        expect(options.body).toContain("everyone=true");
+        expect(options.body).toContain("account=true");
+        done();
+      })
+      .catch((e) => {
+        fail(e);
+      });
+  });
+
+  it("should share an item with an organization", (done) => {
+    fetchMock.once("*", SharingResponse);
+
+    setItemAccess({
+      authentication: MOCK_USER_SESSION,
+      id: "abc123",
+      access: "org"
+    })
+      .then((response) => {
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          "https://myorg.maps.arcgis.com/sharing/rest/content/users/jsmith/items/abc123/share"
+        );
+        expect(options.method).toBe("POST");
+        expect(response).toEqual(SharingResponse);
+        expect(options.body).toContain("f=json");
+        expect(options.body).toContain("everyone=false");
+        expect(options.body).toContain("org=true");
+        done();
+      })
+      .catch((e) => {
+        fail(e);
+      });
+  });
+
+  it("should stop sharing an item entirely", (done) => {
+    fetchMock.once("*", SharingResponse);
+
+    setItemAccess({
+      authentication: MOCK_USER_SESSION,
+      id: "abc123",
+      access: "private"
+    })
+      .then((response) => {
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          "https://myorg.maps.arcgis.com/sharing/rest/content/users/jsmith/items/abc123/share"
+        );
+        expect(options.method).toBe("POST");
+        expect(response).toEqual(SharingResponse);
+        expect(options.body).toContain("f=json");
+        expect(options.body).toContain("everyone=false");
+        expect(options.body).toContain("org=false");
+        expect(options.body).toContain("groups=");
+        done();
+      })
+      .catch((e) => {
+        fail(e);
+      });
+  });
+
+  it("should share another persons item if an org admin makes the request", (done) => {
+    fetchMock.once(
+      "https://myorg.maps.arcgis.com/sharing/rest/community/self?f=json&token=fake-token",
+      OrgAdminUserResponse
+    );
+
+    fetchMock.once(
+      "begin:https://myorg.maps.arcgis.com/sharing/rest/content/users/casey/items/abc123/share",
+      SharingResponse
+    );
+
+    setItemAccess({
+      authentication: MOCK_USER_SESSION,
+      id: "abc123",
+      access: "private",
+      owner: "casey"
+    })
+      .then((response) => {
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall();
+        expect(url).toEqual(
+          "https://myorg.maps.arcgis.com/sharing/rest/content/users/casey/items/abc123/share"
+        );
+        expect(options.method).toBe("POST");
+        expect(response).toEqual(SharingResponse);
+        expect(options.body).toContain("f=json");
+        expect(options.body).toContain("everyone=false");
+        expect(options.body).toContain("org=false");
+        expect(options.body).toContain("groups=");
+        done();
+      })
+      .catch((e) => {
+        fail(e);
+      });
+  });
+
+  it("should throw if the person trying to share doesnt own the item and is not an admin", (done) => {
+    fetchMock.once(
+      "https://myorg.maps.arcgis.com/sharing/rest/community/self?f=json&token=fake-token",
+      AnonUserResponse
+    );
+
+    setItemAccess({
+      authentication: MOCK_USER_SESSION,
+      id: "abc123",
+      access: "private",
+      owner: "casey"
+    }).catch((e) => {
+      expect(e.message).toEqual(
+        "This item can not be shared by jsmith. They are neither the item owner nor an organization admin."
+      );
+      done();
+    });
+  });
+});

package/packages/arcgis-rest-portal/test/sharing/helpers.test.ts

@@ -0,0 +1,55 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import fetchMock from "fetch-mock";
+import { getUserMembership } from "../../src/sharing/helpers.js";
+import { MOCK_USER_SESSION } from "../mocks/sharing/sharing.js";
+import {
+  GroupOwnerResponse,
+  GroupNoAccessResponse
+} from "./share-item-with-group.test.js";
+
+describe("sharing helpers ::", () => {
+  afterEach(fetchMock.restore);
+  describe("getUserMembership ::", () => {
+    it("should return nonmember if group could not be fetched", (done) => {
+      fetchMock.once(
+        "https://myorg.maps.arcgis.com/sharing/rest/community/groups/tb6?f=json&token=fake-token",
+        GroupNoAccessResponse
+      );
+      getUserMembership({
+        id: "ignoreme",
+        groupId: "tb6",
+        authentication: MOCK_USER_SESSION
+      })
+        .then((result) => {
+          expect(fetchMock.done()).toBeTruthy();
+          expect(result).toBe("none", "should return none");
+          done();
+        })
+        .catch((e) => {
+          fail(e);
+        });
+    });
+
+    it("should request the group and return the member type", (done) => {
+      fetchMock.once(
+        "https://myorg.maps.arcgis.com/sharing/rest/community/groups/tb6?f=json&token=fake-token",
+        GroupOwnerResponse
+      );
+      getUserMembership({
+        id: "ignoreme",
+        groupId: "tb6",
+        authentication: MOCK_USER_SESSION
+      })
+        .then((result) => {
+          expect(fetchMock.done()).toBeTruthy();
+          expect(result).toBe("owner", "should return owner");
+          done();
+        })
+        .catch((e) => {
+          fail(e);
+        });
+    });
+  });
+});