sintfacilis 1.0.0

package/packages/arcgis-rest-geocoding/test/bulk.test.ts

@@ -0,0 +1,194 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { bulkGeocode } from "../src/bulk";
+import { GeocodeAddresses } from "./mocks/responses";
+
+import * as fetchMock from "fetch-mock";
+
+const addresses = [
+  {
+    OBJECTID: 1,
+    SingleLine: "380 New York St. Redlands 92373"
+  },
+  {
+    OBJECTID: 2,
+    SingleLine: "1 World Way Los Angeles 90045"
+  },
+  {
+    OBJECTID: 3,
+    SingleLine: "foo bar baz"
+  }
+];
+
+describe("geocode", () => {
+  afterEach(fetchMock.restore);
+
+  it("should make a bulk geocoding request, even with an unmatchable record", done => {
+    fetchMock.once("*", GeocodeAddresses);
+
+    const MOCK_AUTH = {
+      getToken() {
+        return Promise.resolve("token");
+      },
+      portal: "https://mapsdev.arcgis.com"
+    };
+
+    bulkGeocode({ addresses, authentication: MOCK_AUTH })
+      .then(response => {
+        expect(fetchMock.called()).toEqual(true);
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          "https://geocode.arcgis.com/arcgis/rest/services/World/GeocodeServer/geocodeAddresses"
+        );
+        expect(options.method).toBe("POST");
+        expect(options.body).toContain("f=json");
+        expect(options.body).toContain(
+          `addresses=${encodeURIComponent(
+            '{"records":[{"attributes":{"OBJECTID":1,"SingleLine":"380 New York St. Redlands 92373"}},{"attributes":{"OBJECTID":2,"SingleLine":"1 World Way Los Angeles 90045"}},{"attributes":{"OBJECTID":3,"SingleLine":"foo bar baz"}}]}'
+          )}`
+        );
+        expect(options.body).toContain("token=token");
+        expect(response.spatialReference.latestWkid).toEqual(4326);
+        expect(response.locations[0].address).toEqual(
+          "380 New York St, Redlands, California, 92373"
+        );
+        expect(response.locations[0].location.x).toEqual(-117.19567031799994);
+        // the only property this lib tacks on
+        expect(response.locations[0].location.spatialReference.wkid).toEqual(
+          4326
+        );
+        expect(response.locations[2].score).toEqual(0);
+        done();
+      })
+      .catch(e => {
+        fail(e);
+      });
+  });
+
+  it("should throw an error when a bulk geocoding request is made without a token", done => {
+    fetchMock.once("*", GeocodeAddresses);
+
+    bulkGeocode({ addresses })
+      // tslint:disable-next-line
+      .catch(e => {
+        expect(e).toEqual(
+          "bulk geocoding using the ArcGIS service requires authentication"
+        );
+        done();
+      });
+  });
+
+  it("should send a bulk geocoding request to a custom url without a token", done => {
+    fetchMock.once("*", GeocodeAddresses);
+
+    bulkGeocode({
+      addresses,
+      endpoint:
+        "https://customer.gov/arcgis/rest/services/CompositeGeocoder/GeocodeServer/"
+    })
+      // tslint:disable-next-line
+      .then(response => {
+        expect(fetchMock.called()).toEqual(true);
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          "https://customer.gov/arcgis/rest/services/CompositeGeocoder/GeocodeServer/geocodeAddresses"
+        );
+        expect(options.method).toBe("POST");
+        expect(options.body).toContain("f=json");
+        expect(options.body).toContain(
+          `addresses=${encodeURIComponent(
+            '{"records":[{"attributes":{"OBJECTID":1,"SingleLine":"380 New York St. Redlands 92373"}},{"attributes":{"OBJECTID":2,"SingleLine":"1 World Way Los Angeles 90045"}},{"attributes":{"OBJECTID":3,"SingleLine":"foo bar baz"}}]}'
+          )}`
+        );
+        // expect(options.body).toContain("token=token");
+        expect(response.spatialReference.latestWkid).toEqual(4326);
+        expect(response.locations[0].address).toEqual(
+          "380 New York St, Redlands, California, 92373"
+        );
+        expect(response.locations[0].location.x).toEqual(-117.19567031799994);
+        // the only property this lib tacks on
+        expect(response.locations[0].location.spatialReference.wkid).toEqual(
+          4326
+        );
+        expect(response.locations[2].address).toEqual("foo bar baz");
+        done();
+      });
+  });
+
+  it("should send a bulk geocoding request with params correctly", done => {
+    fetchMock.once("*", GeocodeAddresses);
+
+    bulkGeocode({
+      addresses,
+      endpoint:
+        "https://customer.gov/arcgis/rest/services/CompositeGeocoder/GeocodeServer/",
+      params: {
+        outSR: 4326,
+        forStorage: true
+      }
+    })
+      // tslint:disable-next-line
+      .then(response => {
+        expect(fetchMock.called()).toEqual(true);
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          "https://customer.gov/arcgis/rest/services/CompositeGeocoder/GeocodeServer/geocodeAddresses"
+        );
+        expect(options.method).toBe("POST");
+        expect(options.body).toContain("f=json");
+        expect(options.body).toContain("outSR=4326");
+        expect(options.body).toContain("forStorage=true");
+        expect(options.body).toContain(
+          `addresses=${encodeURIComponent(
+            '{"records":[{"attributes":{"OBJECTID":1,"SingleLine":"380 New York St. Redlands 92373"}},{"attributes":{"OBJECTID":2,"SingleLine":"1 World Way Los Angeles 90045"}},{"attributes":{"OBJECTID":3,"SingleLine":"foo bar baz"}}]}'
+          )}`
+        );
+        // expect(options.body).toContain("token=token");
+        expect(response.spatialReference.latestWkid).toEqual(4326);
+        expect(response.locations[0].address).toEqual(
+          "380 New York St, Redlands, California, 92373"
+        );
+        expect(response.locations[0].location.x).toEqual(-117.19567031799994);
+        // the only property this lib tacks on
+        expect(response.locations[0].location.spatialReference.wkid).toEqual(
+          4326
+        );
+        expect(response.locations[2].address).toEqual("foo bar baz");
+        done();
+      });
+  });
+
+  it("should support rawResponse", done => {
+    fetchMock.once("*", GeocodeAddresses);
+
+    const MOCK_AUTH = {
+      getToken() {
+        return Promise.resolve("token");
+      },
+      portal: "https://mapsdev.arcgis.com"
+    };
+
+    bulkGeocode({ addresses, authentication: MOCK_AUTH, rawResponse: true })
+      .then((response: any) => {
+        expect(fetchMock.called()).toEqual(true);
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          "https://geocode.arcgis.com/arcgis/rest/services/World/GeocodeServer/geocodeAddresses"
+        );
+        expect(options.method).toBe("POST");
+        expect(response.status).toBe(200);
+        expect(response.ok).toBe(true);
+        expect(response.body.Readable).not.toBe(null);
+        response.json().then((raw: any) => {
+          expect(raw).toEqual(GeocodeAddresses);
+          done();
+        });
+        // this used to work with isomorphic-fetch
+        // expect(response instanceof Response).toBe(true);
+      })
+      .catch(e => {
+        fail(e);
+      });
+  });
+});

package/packages/arcgis-rest-geocoding/test/geocode.test.ts

@@ -0,0 +1,253 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { geocode } from "../src/geocode";
+import {
+  FindAddressCandidates,
+  FindAddressCandidates3857,
+  FindAddressCandidatesNullExtent
+} from "./mocks/responses";
+
+import * as fetchMock from "fetch-mock";
+
+const customGeocoderUrl =
+  "https://foo.com/arcgis/rest/services/Custom/GeocodeServer/";
+
+describe("geocode", () => {
+  afterEach(fetchMock.restore);
+
+  it("should make a simple, single geocoding request", done => {
+    fetchMock.once("*", FindAddressCandidates);
+
+    geocode("LAX")
+      .then(response => {
+        expect(fetchMock.called()).toEqual(true);
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          "https://geocode-api.arcgis.com/arcgis/rest/services/World/GeocodeServer/findAddressCandidates"
+        );
+        expect(options.method).toBe("POST");
+        expect(options.body).toContain("f=json");
+        expect(options.body).toContain("singleLine=LAX");
+        // the only properties this lib tacks on
+        expect(response.spatialReference.wkid).toEqual(4326);
+        expect(response.geoJson.features.length).toBeGreaterThan(0);
+        expect(response.geoJson.features[0].properties.score).toBeGreaterThan(0);
+        done();
+      })
+      .catch(e => {
+        fail(e);
+      });
+  });
+
+  it("should a geocoding request with custom parameters", done => {
+    fetchMock.once("*", FindAddressCandidates);
+
+    geocode({ address: "1600 Pennsylvania Avenue", city: "Washington D.C." })
+      .then(response => {
+        expect(fetchMock.called()).toEqual(true);
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          "https://geocode-api.arcgis.com/arcgis/rest/services/World/GeocodeServer/findAddressCandidates"
+        );
+        expect(options.method).toBe("POST");
+        expect(options.body).toContain("f=json");
+        expect(options.body).toContain(
+          `address=${encodeURIComponent("1600 Pennsylvania Avenue")}`
+        );
+        expect(options.body).toContain(
+          `city=${encodeURIComponent("Washington D.C.")}`
+        );
+        // the only property this lib tacks on
+        expect(response.spatialReference.wkid).toEqual(4326);
+        done();
+      })
+      .catch(e => {
+        fail(e);
+      });
+  });
+
+  it("should make a simple, single geocoding request with a named parameter", done => {
+    fetchMock.once("*", FindAddressCandidates);
+
+    geocode({
+      singleLine: "380 New York Street",
+      outFields: ["Addr_type", "Score"]
+    })
+      .then(response => {
+        expect(fetchMock.called()).toEqual(true);
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          "https://geocode-api.arcgis.com/arcgis/rest/services/World/GeocodeServer/findAddressCandidates"
+        );
+        const singleLineEncoded = encodeURIComponent("380 New York Street");
+        expect(options.body).toContain(`singleLine=${singleLineEncoded}`);
+        const outFieldsEncoded = encodeURIComponent(
+          ["Addr_type", "Score"].join(",")
+        );
+        expect(options.body).toContain(`outFields=${outFieldsEncoded}`);
+        expect(response.spatialReference.wkid).toEqual(4326);
+        done();
+      })
+      .catch(e => {
+        fail(e);
+      });
+  });
+
+  it("should make a simple, single geocoding request with a custom parameter", done => {
+    fetchMock.once("*", FindAddressCandidates);
+
+    geocode({
+      params: {
+        singleLine: "LAX",
+        countryCode: "USA",
+        outFields: ["Addr_type", "Score"]
+      }
+    })
+      .then(response => {
+        expect(fetchMock.called()).toEqual(true);
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          "https://geocode-api.arcgis.com/arcgis/rest/services/World/GeocodeServer/findAddressCandidates"
+        );
+        expect(options.method).toBe("POST");
+        expect(options.body).toContain("f=json");
+        expect(options.body).toContain("singleLine=LAX");
+        expect(options.body).toContain("countryCode=USA");
+        const outFieldsEncoded = encodeURIComponent(
+          ["Addr_type", "Score"].join(",")
+        );
+        expect(options.body).toContain(`outFields=${outFieldsEncoded}`);
+        // the only property this lib tacks on
+        expect(response.spatialReference.wkid).toEqual(4326);
+        done();
+      })
+      .catch(e => {
+        fail(e);
+      });
+  });
+
+  it("should make a single geocoding request to a custom geocoding service", done => {
+    fetchMock.once("*", FindAddressCandidates3857);
+
+    geocode({
+      endpoint: customGeocoderUrl,
+      params: {
+        outSr: 3857,
+        address: "380 New York St",
+        postal: 92373
+      }
+    })
+      .then(response => {
+        expect(fetchMock.called()).toEqual(true);
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          "https://foo.com/arcgis/rest/services/Custom/GeocodeServer/findAddressCandidates"
+        );
+        expect(options.method).toBe("POST");
+        expect(options.body).toContain("f=json");
+        expect(options.body).toContain(
+          `address=${encodeURIComponent("380 New York St")}`
+        );
+        expect(options.body).toContain("postal=92373");
+        expect(options.body).toContain("outSr=3857");
+        // the only properties this lib tacks on
+        expect(response.spatialReference.wkid).toEqual(102100);
+        expect(response.geoJson).toBeUndefined();
+        done();
+      })
+      .catch(e => {
+        fail(e);
+      });
+  });
+
+  it("should pass through all requestOptions when making a geocoding request", done => {
+    fetchMock.once("*", FindAddressCandidates3857);
+
+    geocode({
+      endpoint: customGeocoderUrl,
+      params: {
+        outSr: 3857,
+        address: "380 New York St",
+        postal: 92373
+      },
+      httpMethod: "GET"
+    })
+      .then(response => {
+        expect(fetchMock.called()).toEqual(true);
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          "https://foo.com/arcgis/rest/services/Custom/GeocodeServer/findAddressCandidates?f=json&outSr=3857&address=380%20New%20York%20St&postal=92373"
+        );
+        expect(options.method).toBe("GET");
+        // the only property this lib tacks on
+        expect(response.spatialReference.wkid).toEqual(102100);
+        done();
+      })
+      .catch(e => {
+        fail(e);
+      });
+  });
+
+  it("should handle geocoders that return null extents for location candidates", done => {
+    fetchMock.once("*", FindAddressCandidatesNullExtent);
+
+    geocode("LAX")
+      .then(response => {
+        expect(fetchMock.called()).toEqual(true);
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          "https://geocode-api.arcgis.com/arcgis/rest/services/World/GeocodeServer/findAddressCandidates"
+        );
+        expect(options.method).toBe("POST");
+        expect(options.body).toContain("f=json");
+        expect(options.body).toContain("singleLine=LAX");
+        // the only property this lib tacks on
+        expect(response.spatialReference.wkid).toEqual(4326);
+        expect(
+          response.candidates.every(candidate => candidate.extent == null)
+        );
+        done();
+      })
+      .catch(e => {
+        fail(e);
+      });
+  });
+
+  it("should support rawResponse", done => {
+    fetchMock.once("*", FindAddressCandidates);
+    geocode({
+      address: "1600 Pennsylvania Avenue",
+      city: "Washington D.C.",
+      rawResponse: true
+    })
+      .then((response: any) => {
+        expect(fetchMock.called()).toEqual(true);
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          "https://geocode-api.arcgis.com/arcgis/rest/services/World/GeocodeServer/findAddressCandidates"
+        );
+        expect(options.method).toBe("POST");
+        expect(options.body).toContain("f=json");
+        expect(options.body).toContain(
+          `address=${encodeURIComponent("1600 Pennsylvania Avenue")}`
+        );
+        expect(options.body).toContain(
+          `city=${encodeURIComponent("Washington D.C.")}`
+        );
+        expect(options.method).toBe("POST");
+        expect(response.status).toBe(200);
+        expect(response.ok).toBe(true);
+        expect(response.body.Readable).not.toBe(null);
+        response.json().then((raw: any) => {
+          expect(raw).toEqual(FindAddressCandidates);
+          done();
+        });
+        // this used to work with isomorphic-fetch
+        // expect(response instanceof Response).toBe(true);
+      })
+      .catch(e => {
+        fail(e);
+      });
+  });
+});

package/packages/arcgis-rest-geocoding/test/helpers.test.ts

@@ -0,0 +1,85 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { getGeocodeService } from "../src/helpers";
+import * as fetchMock from "fetch-mock";
+import { SharingInfo } from "./mocks/responses";
+
+const customGeocoderUrl =
+  "https://foo.com/arcgis/rest/services/Custom/GeocodeServer/";
+
+describe("geocode", () => {
+  afterEach(fetchMock.restore);
+
+  it("should retrieve metadata from the World Geocoding Service", done => {
+    fetchMock.once("*", SharingInfo);
+
+    getGeocodeService()
+      .then(response => {
+        expect(fetchMock.called()).toEqual(true);
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          "https://geocode-api.arcgis.com/arcgis/rest/services/World/GeocodeServer/?f=json"
+        );
+        expect(options.method).toBe("GET");
+        // expect(response).toEqual(SharingInfo); // need to fix something in order introspect the whole response
+        expect(response.currentVersion).toEqual(10.41);
+        expect(response.serviceDescription).toEqual(
+          "Sample geocoder for San Diego, California, USA"
+        );
+        done();
+      })
+      .catch(e => {
+        fail(e);
+      });
+  });
+
+  it("should make POST request for metadata from the World Geocoding Service", done => {
+    fetchMock.once("*", SharingInfo);
+
+    getGeocodeService({ httpMethod: "POST" })
+      .then(response => {
+        expect(fetchMock.called()).toEqual(true);
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          "https://geocode-api.arcgis.com/arcgis/rest/services/World/GeocodeServer/"
+        );
+        expect(options.method).toBe("POST");
+        expect(options.body).toContain("f=json");
+        // expect(paramsSpy).toHaveBeenCalledWith("f", "json");
+        // expect(response).toEqual(SharingInfo); // need to fix something in order introspect the whole response
+        expect(response.currentVersion).toEqual(10.41);
+        expect(response.serviceDescription).toEqual(
+          "Sample geocoder for San Diego, California, USA"
+        );
+        done();
+      })
+      .catch(e => {
+        fail(e);
+      });
+  });
+
+  it("should retrieve metadata from custom geocoding services", done => {
+    fetchMock.once("*", SharingInfo);
+
+    getGeocodeService({ endpoint: customGeocoderUrl })
+      .then(response => {
+        expect(fetchMock.called()).toEqual(true);
+        const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+        expect(url).toEqual(
+          "https://foo.com/arcgis/rest/services/Custom/GeocodeServer/?f=json"
+        );
+        expect(options.method).toBe("GET");
+        // how to introspect the whole response?
+        // expect(response).toEqual(SharingInfo);
+        expect(response.currentVersion).toEqual(10.41);
+        expect(response.serviceDescription).toEqual(
+          "Sample geocoder for San Diego, California, USA"
+        );
+        done();
+      })
+      .catch(e => {
+        fail(e);
+      });
+  });
+});