sintfacilis 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-types";
+
+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,144 @@
+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 {
+  createOrgNotification,
+  ICreateOrgNotificationOptions,
+} from "../../src/orgs/notification";
+
+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 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: 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,59 @@
+/* Copyright (c) 2018-2020 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import * as isServiceNameAvailableModule from "../../src/services/is-service-name-available";
+
+import { getUniqueServiceName } from "../../src/services/get-unique-service-name";
+import { UserSession } from "@esri/arcgis-rest-auth";
+import { TOMORROW } from "@esri/arcgis-rest-auth/test/utils";
+
+describe("get-unique-service-name:", () => {
+  const MOCK_USER_SESSION = 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("does single check if unique", () => {
+    const spy = spyOn(
+      isServiceNameAvailableModule,
+      "isServiceNameAvailable"
+    ).and.callFake(() => Promise.resolve({ available: true }));
+    return getUniqueServiceName(
+      "myService",
+      "Feature Service",
+      MOCK_USER_SESSION,
+      0
+    ).then((result) => {
+      expect(result).toBe("myService", "should return name");
+      expect(spy.calls.count()).toBe(1, "should check one name");
+    });
+  });
+
+  it("makes multiple calls if already taken", () => {
+    let callNum = 1;
+    const spy = spyOn(
+      isServiceNameAvailableModule,
+      "isServiceNameAvailable"
+    ).and.callFake(() => {
+      const result = callNum === 2;
+      callNum++;
+      return Promise.resolve({ available: result });
+    });
+    return getUniqueServiceName(
+      "myService",
+      "Feature Service",
+      MOCK_USER_SESSION,
+      0
+    ).then((result) => {
+      expect(result).toBe("myService_1", "should return name");
+      expect(spy.calls.count()).toBe(2, "should check two names");
+    });
+  });
+});

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

@@ -0,0 +1,46 @@
+/* Copyright (c) 2018-2020 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import * as requestModule from "@esri/arcgis-rest-request";
+import { isServiceNameAvailable } from "../../src/services/is-service-name-available";
+import { UserSession } from "@esri/arcgis-rest-auth";
+import { TOMORROW } from "@esri/arcgis-rest-auth/test/utils";
+
+describe("is-service-name-available", () => {
+  const MOCK_USER_SESSION = 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("returns server response", () => {
+    const spy = spyOn(requestModule, "request").and.callFake(() =>
+      Promise.resolve({ available: true })
+    );
+    return isServiceNameAvailable(
+      "someService",
+      "Feature Service",
+      MOCK_USER_SESSION
+    ).then((result) => {
+      expect(result.available).toBe(true, "should return the api response");
+      expect(spy.calls.count()).toBe(1, "should make one request");
+      expect(spy.calls.argsFor(0)[0]).toBe(
+        `${MOCK_USER_SESSION.portal}/portals/self/isServiceNameAvailable`
+      );
+      const opts = spy.calls.argsFor(0)[1];
+
+      expect(opts.params.name).toBe(
+        "someService",
+        "passes in the service name"
+      );
+      expect(opts.params.type).toBe("Feature Service", "passes in the type");
+    });
+  });
+});

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 { setItemAccess } from "../../src/sharing/access";
+import * as fetchMock from "fetch-mock";
+
+import { TOMORROW } from "@esri/arcgis-rest-auth/test/utils";
+import { MOCK_USER_SESSION } from "../mocks/sharing/sharing";
+
+import { AnonUserResponse, OrgAdminUserResponse } from "../mocks/users/user";
+
+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 * as fetchMock from "fetch-mock";
+import { getUserMembership } from "../../src/sharing/helpers";
+import { MOCK_USER_SESSION } from "../mocks/sharing/sharing";
+import {
+  GroupOwnerResponse,
+  GroupNoAccessResponse
+} from "./share-item-with-group.test";
+
+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);
+        });
+    });
+  });
+});