delectusnon 1.0.0

package/packages/arcgis-rest-items/test/create.test.ts

@@ -0,0 +1,371 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import * as fetchMock from "fetch-mock";
+
+import { createFolder, createItem, createItemInFolder } from "../src/create";
+
+import { ItemSuccessResponse } from "./mocks/item";
+
+import { UserSession } from "@esri/arcgis-rest-auth";
+import { TOMORROW } from "@esri/arcgis-rest-auth/test/utils";
+import { encodeParam } from "@esri/arcgis-rest-request";
+
+describe("search", () => {
+  afterEach(fetchMock.restore);
+
+  describe("Authenticated methods", () => {
+    // setup a UserSession to use in all these tests
+    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"
+    });
+
+    const MOCK_USER_REQOPTS = {
+      authentication: MOCK_USER_SESSION
+    };
+
+    it("should create an item with data", done => {
+      fetchMock.once("*", ItemSuccessResponse);
+      const fakeItem = {
+        owner: "dbouwman",
+        title: "my fake item",
+        description: "yep its fake",
+        snipped: "so very fake",
+        type: "Web Mapping Application",
+        typeKeywords: ["fake", "kwds"],
+        tags: ["fakey", "mcfakepants"],
+        properties: {
+          key: "somevalue"
+        },
+        data: {
+          values: {
+            key: "value"
+          }
+        }
+      };
+      createItem({
+        item: fakeItem,
+        owner: "dbouwman",
+        ...MOCK_USER_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/content/users/dbouwman/addItem"
+          );
+          expect(options.method).toBe("POST");
+          expect(options.body).toContain("f=json");
+          expect(options.body).toContain(encodeParam("token", "fake-token"));
+          expect(options.body).toContain("owner=dbouwman");
+          // ensure the array props are serialized into strings
+          expect(options.body).toContain(
+            encodeParam("typeKeywords", "fake, kwds")
+          );
+          expect(options.body).toContain(
+            encodeParam("tags", "fakey, mcfakepants")
+          );
+          expect(options.body).toContain(
+            encodeParam("properties", JSON.stringify(fakeItem.properties))
+          );
+
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should create an item without an explicit owner", done => {
+      fetchMock.once("*", ItemSuccessResponse);
+      const fakeItem = {
+        title: "my fake item",
+        owner: "dbouwman",
+        description: "yep its fake",
+        snipped: "so very fake",
+        type: "Web Mapping Application",
+        typeKeywords: ["fake", "kwds"],
+        tags: ["fakey", "mcfakepants"],
+        properties: {
+          key: "somevalue"
+        }
+      };
+      createItem({
+        item: fakeItem,
+        ...MOCK_USER_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/content/users/dbouwman/addItem"
+          );
+          expect(options.method).toBe("POST");
+          expect(options.body).toContain("f=json");
+          expect(options.body).toContain(encodeParam("token", "fake-token"));
+          expect(options.body).toContain("owner=dbouwman");
+          // ensure the array props are serialized into strings
+          expect(options.body).toContain(
+            encodeParam("typeKeywords", "fake, kwds")
+          );
+          expect(options.body).toContain(
+            encodeParam("tags", "fakey, mcfakepants")
+          );
+          expect(options.body).toContain(
+            encodeParam("properties", JSON.stringify(fakeItem.properties))
+          );
+
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should create an item with only a username from auth", done => {
+      fetchMock.once("*", ItemSuccessResponse);
+      const fakeItem = {
+        title: "my fake item",
+        description: "yep its fake",
+        snipped: "so very fake",
+        type: "Web Mapping Application",
+        typeKeywords: ["fake", "kwds"],
+        tags: ["fakey", "mcfakepants"],
+        properties: {
+          key: "somevalue"
+        }
+      };
+      // why not just use item.owner??
+      createItem({
+        item: fakeItem,
+        ...MOCK_USER_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/content/users/casey/addItem"
+          );
+          expect(options.method).toBe("POST");
+          expect(options.body).toContain("f=json");
+          expect(options.body).toContain(encodeParam("token", "fake-token"));
+          // expect(options.body).toContain("owner=casey");
+          // ensure the array props are serialized into strings
+          expect(options.body).toContain(
+            encodeParam("typeKeywords", "fake, kwds")
+          );
+          expect(options.body).toContain(
+            encodeParam("tags", "fakey, mcfakepants")
+          );
+          expect(options.body).toContain(
+            encodeParam("properties", JSON.stringify(fakeItem.properties))
+          );
+
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should create an item with no tags or typeKeywords", done => {
+      fetchMock.once("*", ItemSuccessResponse);
+      const fakeItem = {
+        title: "my fake item",
+        description: "yep its fake",
+        snipped: "so very fake",
+        type: "Web Mapping Application",
+        properties: {
+          key: "somevalue"
+        }
+      };
+      createItem({
+        item: fakeItem,
+        ...MOCK_USER_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/content/users/casey/addItem"
+          );
+          expect(options.method).toBe("POST");
+          expect(options.body).toContain("f=json");
+          expect(options.body).toContain(encodeParam("token", "fake-token"));
+          expect(options.body).toContain(
+            encodeParam("type", "Web Mapping Application")
+          );
+          // ensure the array props are serialized into strings
+          expect(options.body).toContain(
+            encodeParam("properties", JSON.stringify(fakeItem.properties))
+          );
+
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should create an item in a folder", done => {
+      fetchMock.once("*", ItemSuccessResponse);
+      const fakeItem = {
+        owner: "dbouwman",
+        title: "my fake item",
+        description: "yep its fake",
+        snipped: "so very fake",
+        type: "Web Mapping Application",
+        typeKeywords: ["fake", "kwds"],
+        tags: ["fakey", "mcfakepants"]
+      };
+      createItemInFolder({
+        owner: "dbouwman",
+        item: fakeItem,
+        folder: "someFolder",
+        ...MOCK_USER_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/content/users/dbouwman/someFolder/addItem"
+          );
+          expect(options.method).toBe("POST");
+          expect(options.body).toContain("f=json");
+          expect(options.body).toContain(encodeParam("token", "fake-token"));
+          expect(options.body).toContain("owner=dbouwman");
+          // ensure the array props are serialized into strings
+          expect(options.body).toContain(
+            encodeParam("typeKeywords", "fake, kwds")
+          );
+          expect(options.body).toContain(
+            encodeParam("tags", "fakey, mcfakepants")
+          );
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should create an item in a folder and pass through arbitrary params", done => {
+      fetchMock.once("*", ItemSuccessResponse);
+      const fakeItem = {
+        owner: "dbouwman",
+        title: "my fake item",
+        description: "yep its fake",
+        snipped: "so very fake",
+        type: "Web Mapping Application",
+        typeKeywords: ["fake", "kwds"],
+        tags: ["fakey", "mcfakepants"]
+      };
+      createItemInFolder({
+        owner: "dbouwman",
+        item: fakeItem,
+        folder: "someFolder",
+        params: {
+          foo: "bar"
+        },
+        ...MOCK_USER_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/content/users/dbouwman/someFolder/addItem"
+          );
+          expect(options.method).toBe("POST");
+          expect(options.body).toContain("f=json");
+          expect(options.body).toContain(encodeParam("token", "fake-token"));
+          expect(options.body).toContain("owner=dbouwman");
+          expect(options.body).toContain("foo=bar");
+          // ensure the array props are serialized into strings
+          expect(options.body).toContain(
+            encodeParam("typeKeywords", "fake, kwds")
+          );
+          expect(options.body).toContain(
+            encodeParam("tags", "fakey, mcfakepants")
+          );
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should create an item in a folder when no owner is passed", done => {
+      fetchMock.once("*", ItemSuccessResponse);
+      const fakeItem = {
+        owner: "casey",
+        title: "my fake item",
+        description: "yep its fake",
+        snipped: "so very fake",
+        type: "Web Mapping Application",
+        typeKeywords: ["fake", "kwds"],
+        tags: ["fakey", "mcfakepants"]
+      };
+      createItemInFolder({
+        item: fakeItem,
+        ...MOCK_USER_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/content/users/casey/addItem"
+          );
+          expect(options.method).toBe("POST");
+          expect(options.body).toContain("f=json");
+          expect(options.body).toContain(encodeParam("token", "fake-token"));
+          expect(options.body).toContain("owner=casey");
+          // ensure the array props are serialized into strings
+          expect(options.body).toContain(
+            encodeParam("typeKeywords", "fake, kwds")
+          );
+          expect(options.body).toContain(
+            encodeParam("tags", "fakey, mcfakepants")
+          );
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should create a folder", done => {
+      fetchMock.once("*", ItemSuccessResponse);
+      const title = "an amazing folder";
+      createFolder({
+        title,
+        ...MOCK_USER_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/content/users/casey/createFolder"
+          );
+          expect(options.method).toBe("POST");
+          expect(options.body).toContain(
+            "title=" + title.replace(/\s/g, "%20")
+          );
+          expect(options.body).toContain("f=json");
+          expect(options.body).toContain(encodeParam("token", "fake-token"));
+
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+  }); // auth requests
+});

package/packages/arcgis-rest-items/test/get.test.ts

@@ -0,0 +1,181 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import * as fetchMock from "fetch-mock";
+
+import { getItem, getItemData, getItemResources } from "../src/get";
+
+import { ItemResponse, ItemDataResponse } from "./mocks/item";
+
+import { GetItemResourcesResponse } from "./mocks/resources";
+
+import { UserSession } from "@esri/arcgis-rest-auth";
+import { TOMORROW } from "@esri/arcgis-rest-auth/test/utils";
+
+describe("get", () => {
+  afterEach(fetchMock.restore);
+
+  it("should return an item by id", done => {
+    fetchMock.once("*", ItemResponse);
+
+    getItem("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/items/3ef?f=json"
+        );
+        expect(options.method).toBe("GET");
+        done();
+      })
+      .catch(e => {
+        fail(e);
+      });
+  });
+
+  it("should return an item data by id", done => {
+    fetchMock.once("*", ItemDataResponse);
+
+    getItemData("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/items/3ef/data?f=json"
+        );
+        expect(options.method).toBe("GET");
+        done();
+      })
+      .catch(e => {
+        fail(e);
+      });
+  });
+
+  it("should return binary item data by id", done => {
+    // Blob() is only available in the browser
+    if (typeof window !== "undefined") {
+      fetchMock.once("*", {
+        sendAsJson: false,
+        headers: { "Content-Type": "application/zip" },
+        body: new Blob()
+      });
+
+      getItemData("3ef", { file: true })
+        .then(response => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://www.arcgis.com/sharing/rest/content/items/3ef/data"
+          );
+          expect(options.method).toBe("GET");
+          expect(response instanceof Blob).toBeTruthy();
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    } else {
+      done();
+    }
+  });
+
+  describe("Authenticated methods", () => {
+    // setup a UserSession to use in all these tests
+    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"
+    });
+
+    const MOCK_USER_REQOPTS = {
+      authentication: MOCK_USER_SESSION
+    };
+
+    it("should return an item by id using a token", done => {
+      fetchMock.once("*", ItemResponse);
+
+      getItem("3ef", MOCK_USER_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/content/items/3ef?f=json&token=fake-token"
+          );
+          expect(options.method).toBe("GET");
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should return an item data by id using a token", done => {
+      fetchMock.once("*", ItemDataResponse);
+
+      getItemData("3ef", MOCK_USER_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/content/items/3ef/data?f=json&token=fake-token"
+          );
+          expect(options.method).toBe("GET");
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("get item resources", done => {
+      fetchMock.once("*", GetItemResourcesResponse);
+      getItemResources({
+        id: "3ef",
+        ...MOCK_USER_REQOPTS
+      })
+        .then(response => {
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://myorg.maps.arcgis.com/sharing/rest/content/items/3ef/resources"
+          );
+          expect(options.method).toBe("POST");
+          expect(options.body).toContain("f=json");
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("get item resources with extra parameters", done => {
+      fetchMock.once("*", GetItemResourcesResponse);
+      getItemResources({
+        id: "3ef",
+        ...MOCK_USER_REQOPTS,
+        params: {
+          resourcesPrefix: "foolder"
+        }
+      })
+        .then(response => {
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://myorg.maps.arcgis.com/sharing/rest/content/items/3ef/resources"
+          );
+          expect(options.method).toBe("POST");
+          expect(options.body).toContain("f=json");
+          expect(options.body).toContain("resourcesPrefix=foolder");
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+  }); // auth requests
+});

package/packages/arcgis-rest-items/test/mocks/item.ts

@@ -0,0 +1,33 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { IItem } from "@esri/arcgis-rest-common-types";
+
+export const ItemSuccessResponse: any = {
+  success: true,
+  id: "3efakeitemid0000"
+};
+
+export const ItemResponse: IItem = {
+  id: "4bc",
+  owner: "jeffvader",
+  title: "DS Plans",
+  description: "The plans",
+  snippet: "Yeah these are the ones",
+  tags: ["plans", "star dust"],
+  type: "Web Map",
+  typeKeywords: ["Javascript", "hubSiteApplication"],
+  properties: {
+    parentId: "3eb"
+  },
+  created: 123,
+  modified: 456,
+  protected: false
+};
+
+export const ItemDataResponse: any = {
+  source: "3ef",
+  values: {
+    key: "value"
+  }
+};

package/packages/arcgis-rest-items/test/mocks/resources.ts

@@ -0,0 +1,31 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+export const GetItemResourcesResponse: any = {
+  total: 3,
+  start: 1,
+  num: 3,
+  nextStart: -1,
+  resources: [
+    {
+      resource: "image/banner.jpg"
+    },
+    {
+      resource: "image/logo.jpg"
+    },
+    {
+      resource: "text/desc.txt"
+    }
+  ]
+};
+
+export const RemoveItemResourceResponse: any = {
+  success: true
+};
+
+export const UpdateItemResourceResponse: any = {
+  success: true,
+  itemId: "0c66beb52dff4994be67937cdadbdbf1",
+  owner: "jsmith",
+  folder: null
+};

package/packages/arcgis-rest-items/test/mocks/search.ts

@@ -0,0 +1,63 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { ISearchResult } from "../../src/search";
+
+export const SearchResponse: ISearchResult = {
+  query: "",
+  total: 10795,
+  start: 1,
+  num: 1,
+  nextStart: 2,
+  results: [
+    {
+      id: "a5b",
+      owner: "dcadminqa",
+      created: 1496748288000,
+      modified: 1508856526000,
+      name: "survey123_7d7a9fabcb0c44bcaf1d6473cd088a07",
+      title: " Drug Activity Reporter",
+      type: "Feature Service",
+      typeKeywords: [
+        "ArcGIS Server",
+        "Data",
+        "Feature Access",
+        "Feature Service",
+        "OwnerView",
+        "Service",
+        "Survey123",
+        "Survey123 Hub",
+        "Hosted Service"
+      ],
+      description: "Some Description",
+      tags: [],
+      snippet: "Some Snippet",
+      thumbnail: "thumbnail/ago_downloaded.png",
+      documentation: "WAT docs",
+      extent: [[-180, -90], [180, 90]],
+      categories: [],
+      spatialReference: null,
+      accessInformation: null,
+      licenseInfo: null,
+      culture: null,
+      properties: {},
+      url:
+        "https://servicesqa.arcgis.com/97KLIFOSt5CxbiRI/arcgis/rest/services/survey123_7d7a9fabcb0c44bcaf1d6473cd088a07/FeatureServer",
+      proxyFilter: null,
+      access: "shared",
+      size: -1,
+      appCategories: [],
+      industries: [],
+      languages: [],
+      largeThumbnail: null,
+      banner: null,
+      screenshots: [],
+      listed: false,
+      numComments: 0,
+      numRatings: 0,
+      avgRating: 0,
+      numViews: 4,
+      protected: false
+    }
+  ]
+};