mobility-toolbox-js 2.0.0-beta.2 → 2.0.0-beta.20

package/README.md

@@ -8,13 +8,16 @@ The tools in this library have been inspired by many projects realized for publi
 [![Netlify Status](https://api.netlify.com/api/v1/badges/b368ab18-9dbf-416c-91f6-a82076b02c10/deploy-status)](https://app.netlify.com/sites/mobility-toolbox-js/deploys)
 
 ## Main Features
+
 * Display [real-time vehicle positions and prognosis data](http://tracker.geops.ch/) on a map.
 * Search for [stops and stations](https://maps2.trafimage.ch) all over the world.
 * Get [precise geographic courses](https://geops.github.io/geops-routing-demo/) for all modes of transport.
 * Generate beautiful maps for public transport, mobility and logistics
 
 ## Documentation and examples
-Visit https://mobility-toolbox-js.geops.io
+
+Visit https://master--mobility-toolbox-js.netlify.app/
 
 ## Version 1.x.x
+
 The master branch is now open for the version 2 development. The version 1 is still available in [1.x.x](https://github.com/geops/mobility-toolbox-js/tree/1.x.x) branch.

package/api/RoutingAPI.js

@@ -0,0 +1,15 @@
+import HttpAPI from "../common/api/HttpAPI";
+class RoutingAPI extends HttpAPI {
+  constructor(options = {}) {
+    super({
+      url: "https://api.geops.io/routing/v1/",
+      ...options
+    });
+  }
+  route(params, abortController = new AbortController()) {
+    return this.fetch("", params, {
+      signal: abortController.signal
+    });
+  }
+}
+export default RoutingAPI;

package/api/RoutingAPI.test.js

@@ -0,0 +1,25 @@
+import fetch from "jest-fetch-mock";
+import RoutingAPI from "./RoutingAPI";
+let api;
+describe("RoutingAPI", () => {
+  beforeEach(() => {
+    global.fetch = fetch;
+    fetch.resetMocks();
+    api = new RoutingAPI({ apiKey: "apiKey" });
+  });
+  describe("#route", () => {
+    test("should success", (done) => {
+      fetch.mockResponseOnce(JSON.stringify(global.fetchRouteResponse));
+      return api.route({
+        mot: "bus",
+        via: "47.3739194713294,8.538274823394632|47.37595378493421,8.537490375951839"
+      }).then((featureCollection) => {
+        expect(fetch.mock.calls[0][0]).toEqual("https://api.geops.io/routing/v1/?key=apiKey&mot=bus&via=47.3739194713294%2C8.538274823394632%7C47.37595378493421%2C8.537490375951839");
+        expect(featureCollection.features[0].geometry.type).toEqual("LineString");
+        expect(featureCollection.features[0].properties.lines).toBeDefined();
+        expect(featureCollection.features[0].properties.station_to).toBeDefined();
+        done();
+      });
+    });
+  });
+});

package/api/StopsAPI.js

@@ -0,0 +1,12 @@
+import HttpAPI from "../common/api/HttpAPI";
+class StopsAPI extends HttpAPI {
+  constructor(options = {}) {
+    super({ url: "https://api.geops.io/stops/v1/", ...options });
+  }
+  search(params, abortController = {}) {
+    return this.fetch("", params, {
+      signal: abortController.signal
+    });
+  }
+}
+export default StopsAPI;

package/api/StopsAPI.test.js

@@ -0,0 +1,22 @@
+import fetch from "jest-fetch-mock";
+import StopsAPI from "./StopsAPI";
+let api;
+describe("StopsAPI", () => {
+  beforeEach(() => {
+    global.fetch = fetch;
+    fetch.resetMocks();
+    api = new StopsAPI({ apiKey: "apiKey" });
+  });
+  describe("#search", () => {
+    test("should success", (done) => {
+      fetch.mockResponseOnce(JSON.stringify(global.stopsSearchResponse));
+      return api.search({
+        q: "Bern"
+      }).then((featureCollection) => {
+        expect(fetch.mock.calls[0][0]).toEqual("https://api.geops.io/stops/v1/?key=apiKey&q=Bern");
+        expect(featureCollection.features[0].properties.name).toEqual("Bern");
+        done();
+      });
+    });
+  });
+});

package/api/TralisAPI.js

@@ -0,0 +1,359 @@
+import WebSocketAPI from "../common/api/WebSocketAPI";
+import {
+  getModeSuffix,
+  cleanStopTime,
+  compareDepartures
+} from "./TralisAPIUtils";
+export const TralisModes = {
+  RAW: "raw",
+  TOPOGRAPHIC: "topographic",
+  SCHEMATIC: "schematic"
+};
+class TralisAPI {
+  constructor(options = {}) {
+    this.defineProperties(options);
+    this.subscribedStationUic = null;
+    this.departureUpdateTimeout = null;
+    this.maxDepartureAge = 30;
+    this.extraGeoms = {};
+    this.prefix = options.prefix || "";
+    this.onOpen = this.onOpen.bind(this);
+  }
+  defineProperties(options) {
+    let opt = options;
+    if (typeof options === "string") {
+      opt = { url: options };
+    }
+    const { apiKey } = opt;
+    let { url, projection, bbox, buffer = [100, 100] } = opt;
+    const wsApi = new WebSocketAPI();
+    if (apiKey) {
+      url = `${url || "wss://api.geops.io/tracker-ws/v1/"}?key=${apiKey}`;
+    }
+    Object.defineProperties(this, {
+      url: {
+        get: () => url,
+        set: (newUrl) => {
+          url = newUrl;
+          this.open();
+        }
+      },
+      projection: {
+        get: () => projection,
+        set: (newProjection) => {
+          if (newProjection !== projection) {
+            projection = newProjection;
+            if (this.wsApi) {
+              this.wsApi.send(`PROJECTION ${projection}`);
+            }
+          }
+        }
+      },
+      bbox: {
+        get: () => bbox,
+        set: (newBbox) => {
+          if (JSON.stringify(newBbox) !== JSON.stringify(bbox)) {
+            bbox = newBbox;
+            if (this.wsApi) {
+              this.wsApi.send(`BBOX ${bbox.join(" ")}`);
+            }
+          }
+        }
+      },
+      buffer: {
+        get: () => buffer,
+        set: (newBuffer) => {
+          if (JSON.stringify(newBuffer) !== JSON.stringify(buffer)) {
+            buffer = newBuffer;
+            if (this.wsApi) {
+              this.wsApi.send(`BUFFER ${buffer.join(" ")}`);
+            }
+          }
+        }
+      },
+      wsApi: {
+        value: wsApi,
+        writable: true
+      },
+      pingIntervalMs: {
+        value: options.pingIntervalMs || 1e4,
+        writable: true
+      },
+      reconnectTimeoutMs: {
+        value: options.pingIntervalMs || 100,
+        writable: true
+      }
+    });
+  }
+  open() {
+    this.close();
+    this.wsApi.connect(this.url, this.onOpen);
+    this.wsApi.websocket.onclose = () => {
+      this.onClose();
+    };
+  }
+  close() {
+    this.wsApi.close();
+  }
+  reset() {
+    this.wsApi.send("RESET");
+  }
+  onOpen() {
+    if (this.projection) {
+      this.wsApi.send(`PROJECTION ${this.projection}`);
+    }
+    if (this.bbox) {
+      this.wsApi.send(`BBOX ${this.bbox.join(" ")}`);
+    }
+    if (this.buffer) {
+      this.wsApi.send(`BUFFER ${this.buffer.join(" ")}`);
+    }
+    if (this.pingIntervalMs) {
+      window.clearInterval(this.pingInterval);
+      this.pingInterval = setInterval(() => {
+        this.wsApi.send("PING");
+      }, this.pingIntervalMs);
+    }
+  }
+  onClose() {
+    window.clearTimeout(this.pingInterval);
+    window.clearTimeout(this.reconnectTimeout);
+    if (this.reconnectTimeoutMs) {
+      this.reconnectTimeout = window.setTimeout(() => this.open(), this.reconnectTimeoutMs);
+    }
+  }
+  subscribe(channel, onSuccess, onError, quiet = false) {
+    this.wsApi.subscribe({ channel }, onSuccess, onError, quiet);
+  }
+  unsubscribe(channel, suffix, cb) {
+    this.wsApi.unsubscribe(`${channel}${getModeSuffix(TralisModes.SCHEMATIC, TralisModes)}${suffix}`, cb);
+    this.wsApi.unsubscribe(`${channel}${getModeSuffix(TralisModes.TOPOGRAPHIC, TralisModes)}${suffix || ""}`, cb);
+  }
+  filterDepartures(depObject, sortByMinArrivalTime = false) {
+    const departures = Object.keys(depObject).map((k) => depObject[k]);
+    departures.sort((a, b) => compareDepartures(a, b, sortByMinArrivalTime));
+    let future = new Date();
+    future.setMinutes(future.getMinutes() + this.maxDepartureAge);
+    future = future.getTime();
+    let past = new Date();
+    past.setMinutes(past.getMinutes() - this.maxDepartureAge);
+    past = past.getTime();
+    const departureArray = [];
+    const platformsBoarding = [];
+    let previousDeparture = null;
+    for (let i = departures.length - 1; i >= 0; i -= 1) {
+      const d = departures[i];
+      const t = new Date(d.time).getTime();
+      if (t > past && t < future) {
+        if (d.state === "BOARDING") {
+          if (platformsBoarding.indexOf(d.platform) === -1) {
+            platformsBoarding.push(d.platform);
+          } else {
+            d.state = "HIDDEN";
+          }
+        }
+        if (previousDeparture && d.to[0] === previousDeparture.to[0] && Math.abs(t - previousDeparture.time) < 1e3 && d.line.name === previousDeparture.line.name) {
+          d.state = "HIDDEN";
+        }
+        if (/(STOP_CANCELLED|JOURNEY_CANCELLED)/.test(d.state)) {
+          d.cancelled = true;
+        }
+        previousDeparture = d;
+        previousDeparture.time = t;
+        departureArray.unshift(d);
+      }
+    }
+    return departureArray;
+  }
+  subscribeDepartures(stationId, sortByMinArrivalTime, onMessage) {
+    window.clearTimeout(this.departureUpdateTimeout);
+    this.unsubscribeDepartures();
+    this.subscribedStationUic = stationId;
+    const channel = stationId ? `timetable_${stationId}` : null;
+    const departureObject = {};
+    this.subscribe(channel, (data) => {
+      if (data.source === channel) {
+        const content = data.content || {};
+        const tDiff = new Date(content.timestamp).getTime() - Date.now();
+        content.timediff = tDiff;
+        departureObject[content.call_id] = content;
+        window.clearTimeout(this.departureUpdateTimeout);
+        this.departureUpdateTimeout = window.setTimeout(() => {
+          const departures = this.filterDepartures(departureObject, sortByMinArrivalTime || false);
+          onMessage(departures);
+        }, 100);
+      }
+    }, () => {
+      onMessage([]);
+    });
+  }
+  unsubscribeDepartures(cb) {
+    if (this.subscribedStationUic) {
+      this.unsubscribe(`timetable_${this.subscribedStationUic}`, "", cb);
+      this.subscribedStationUic = null;
+    }
+  }
+  subscribeDisruptions(onMessage) {
+    this.subscribe(`${this.prefix}newsticker`, (data) => {
+      onMessage(data.content);
+    });
+  }
+  unsubscribeDisruptions(cb) {
+    this.unsubscribe(`${this.prefix}newsticker`, "", cb);
+  }
+  getStation(uic, mode) {
+    const params = {
+      channel: `station${getModeSuffix(mode, TralisModes)}`,
+      args: uic
+    };
+    return new Promise((resolve, reject) => {
+      this.wsApi.get(params, (data) => {
+        if (data.content) {
+          resolve(data.content);
+        } else {
+          reject();
+        }
+      });
+    });
+  }
+  getStations(mode) {
+    const stations = [];
+    const params = {
+      channel: `station${getModeSuffix(mode, TralisModes)}`
+    };
+    window.clearTimeout(this.stationUpdateTimeout);
+    return new Promise((resolve, reject) => {
+      this.wsApi.get(params, (data) => {
+        if (data.content) {
+          stations.push(data.content);
+          window.clearTimeout(this.stationUpdateTimeout);
+          this.stationUpdateTimeout = window.setTimeout(() => {
+            resolve(stations);
+          }, 50);
+        } else {
+          reject(data.content);
+        }
+      });
+    });
+  }
+  subscribeStations(mode, onMessage) {
+    this.unsubscribeStations();
+    this.subscribe(`station${getModeSuffix(mode, TralisModes)}`, (data) => {
+      if (data.content) {
+        onMessage(data.content);
+      }
+    });
+  }
+  unsubscribeStations(cb) {
+    window.clearTimeout(this.stationUpdateTimeout);
+    this.unsubscribe("station", "", cb);
+  }
+  subscribeExtraGeoms(onMessage) {
+    this.subscribe("extra_geoms", (data) => {
+      const extraGeom = data.content;
+      if (extraGeom) {
+        const { ref } = extraGeom.properties;
+        if (extraGeom.type === "Feature") {
+          this.extraGeoms[ref] = extraGeom;
+        } else {
+          delete this.extraGeoms[ref];
+        }
+        onMessage(Object.keys(this.extraGeoms).map((key) => this.extraGeoms[key]));
+      }
+    });
+  }
+  unsubscribeExtraGeoms(cb) {
+    this.unsubscribe("extra_geoms", "", cb);
+  }
+  subscribeTrajectory(mode, onMessage, quiet = false) {
+    this.unsubscribeTrajectory(onMessage);
+    this.subscribe(`trajectory${getModeSuffix(mode, TralisModes)}`, onMessage, null, quiet);
+  }
+  unsubscribeTrajectory(cb) {
+    this.unsubscribe(`trajectory`, "", cb);
+  }
+  subscribeDeletedVehicles(mode, onMessage, quiet = false) {
+    this.unsubscribeDeletedVehicles(onMessage);
+    this.subscribe(`deleted_vehicles${getModeSuffix(mode, TralisModes)}`, onMessage, null, quiet);
+  }
+  unsubscribeDeletedVehicles(cb) {
+    this.unsubscribe("deleted_vehicles", "", cb);
+  }
+  getFullTrajectory(id, mode, generalizationLevel) {
+    const channel = [`full_trajectory${getModeSuffix(mode, TralisModes)}`];
+    if (id) {
+      channel.push(id);
+    }
+    if ((!mode || mode === TralisModes.TOPOGRAPHIC) && generalizationLevel) {
+      channel.push(`gen${generalizationLevel}`);
+    }
+    const params = {
+      channel: channel.join("_")
+    };
+    return new Promise((resolve) => {
+      this.wsApi.get(params, (data) => {
+        if (data.content) {
+          resolve(data.content);
+        }
+      });
+    });
+  }
+  getFullTrajectories(ids, mode, generalizationLevel) {
+    const promises = ids.map((id) => this.getFullTrajectory(id, mode, generalizationLevel));
+    return Promise.all(promises);
+  }
+  subscribeFullTrajectory(id, mode) {
+    this.unsubscribeFullTrajectory(id);
+    this.subscribe(`full_trajectory${getModeSuffix(mode, TralisModes)}_${id}`, (data) => {
+      console.log("subscribe full_trajectory", data);
+    }, (err) => {
+      console.log("subscribe full_trajectory error", err);
+    });
+  }
+  unsubscribeFullTrajectory(id, cb) {
+    this.unsubscribe("full_trajectory", `_${id}`, cb);
+  }
+  getStopSequence(id) {
+    const params = {
+      channel: `stopsequence_${id}`
+    };
+    return new Promise((resolve, reject) => {
+      this.wsApi.get(params, (data) => {
+        if (data.content && data.content.length) {
+          const content = data.content.map((stopSequence) => cleanStopTime(stopSequence));
+          resolve(content);
+        }
+        resolve([]);
+      }, (err) => {
+        reject(err);
+      });
+    });
+  }
+  getStopSequences(ids) {
+    const promises = ids.map((id) => this.getStopSequence(id));
+    return Promise.all(promises);
+  }
+  subscribeStopSequence(id, onMessage) {
+    window.clearTimeout(this.fullTrajectoryUpdateTimeout);
+    this.unsubscribeStopSequence(id);
+    this.subscribe(`stopsequence_${id}`, (data) => {
+      if (data.content && data.content.length) {
+        const content = data.content.map((stopSequence) => cleanStopTime(stopSequence));
+        onMessage(content);
+      }
+    }, (err) => {
+      console.log("subscribe stopsequence error", err);
+    });
+  }
+  unsubscribeStopSequence(id, cb) {
+    this.unsubscribe(`stopsequence`, `_${id}`, cb);
+  }
+  subscribeHealthCheck(onMessage) {
+    this.unsubscribeHealthCheck();
+    this.subscribe("healthcheck", onMessage);
+  }
+  unsubscribeHealthCheck() {
+    this.unsubscribe("healthcheck");
+  }
+}
+export default TralisAPI;

package/api/TralisAPI.test.js

@@ -0,0 +1,67 @@
+import { TralisAPI, TralisModes } from ".";
+describe("TralisAPI", () => {
+  let tralisAPI;
+  let get;
+  beforeEach(() => {
+    get = jest.fn((params, cb) => {
+      cb({ content: "content" });
+    });
+    tralisAPI = new TralisAPI();
+    tralisAPI.wsApi = {
+      get
+    };
+  });
+  describe("#getFullTrajectory() calls fullTrajectory channel", () => {
+    test("without parameters", (done) => {
+      tralisAPI.getFullTrajectory().then(() => {
+        expect(get.mock.calls.length).toBe(1);
+        expect(get.mock.calls[0][0]).toEqual({
+          channel: "full_trajectory"
+        });
+        done();
+      });
+    });
+    [null, TralisModes.TOPOGRAPHIC].forEach((mode) => {
+      describe(`using mode ${mode}`, () => {
+        test("using id", (done) => {
+          tralisAPI.getFullTrajectory("foo", mode).then(() => {
+            expect(get.mock.calls.length).toBe(1);
+            expect(get.mock.calls[0][0]).toEqual({
+              channel: "full_trajectory_foo"
+            });
+            done();
+          });
+        });
+        test("using id and generalizationLevel param", (done) => {
+          tralisAPI.getFullTrajectory("foo", mode, 5).then(() => {
+            expect(get.mock.calls.length).toBe(1);
+            expect(get.mock.calls[0][0]).toEqual({
+              channel: "full_trajectory_foo_gen5"
+            });
+            done();
+          });
+        });
+      });
+    });
+    describe("using schematic mode ", () => {
+      test("using id", (done) => {
+        tralisAPI.getFullTrajectory("foo", TralisModes.SCHEMATIC).then(() => {
+          expect(get.mock.calls.length).toBe(1);
+          expect(get.mock.calls[0][0]).toEqual({
+            channel: "full_trajectory_schematic_foo"
+          });
+          done();
+        });
+      });
+      test("doesn't use generalizationLevel param", (done) => {
+        tralisAPI.getFullTrajectory("foo", TralisModes.SCHEMATIC, 10).then(() => {
+          expect(get.mock.calls.length).toBe(1);
+          expect(get.mock.calls[0][0]).toEqual({
+            channel: "full_trajectory_schematic_foo"
+          });
+          done();
+        });
+      });
+    });
+  });
+});

package/api/{tralis/TralisAPIUtils.js → TralisAPIUtils.js}

@@ -1,38 +1,19 @@
-/**
- * Get the websocket channel suffix, depending on the current mode.
- * @param {String} mode Mode 'topographic' ou 'schematic'.
- * @private
- */
-export const getModeSuffix = (mode, modes) =>
-  mode === modes.SCHEMATIC ? '_schematic' : '';
-
-/**
- * Compare two given departures for sort alogithm,
- * @param {Object} a First departure.
- * @param {Object} b Second departure.
- * @private
- */
+export const getModeSuffix = (mode, modes) => mode === modes.SCHEMATIC ? "_schematic" : "";
 export const compareDepartures = (a, b, sortByMinArrivalTime = false) => {
-  // First LEAVING and HIDDEN, then BOARDING and then sorted by time.
-  const topStates = ['HIDDEN', 'LEAVING', 'BOARDING'];
+  const topStates = ["HIDDEN", "LEAVING", "BOARDING"];
   const aTop = a.has_fzo && topStates.indexOf(a.state) > -1;
   const bTop = b.has_fzo && topStates.indexOf(b.state) > -1;
-
   if (aTop || bTop) {
     if (aTop !== bTop) {
       return aTop ? -1 : 1;
     }
-
     if (a.state !== b.state) {
-      // one is leaving
       return topStates.indexOf(a.state) - topStates.indexOf(b.state);
     }
   }
-
   let aDuration = null;
   let bDuration = null;
   const now = Date.now();
-
   if (sortByMinArrivalTime) {
     aDuration = new Date(a.min_arrival_time || a.time).getTime() - now;
     bDuration = new Date(b.min_arrival_time || b.time).getTime() - now;
@@ -40,34 +21,23 @@ export const compareDepartures = (a, b, sortByMinArrivalTime = false) => {
     aDuration = new Date(a.time).getTime() - now;
     bDuration = new Date(b.time).getTime() - now;
   }
-
   return aDuration - bDuration;
 };
-
-/**
- * Remove the delay from arrivalTime and departureTime
- * @private
- */
 export const cleanStopTime = (content) => {
   if (!content) {
     return;
   }
   content.stations.forEach((station) => {
-    // eslint-disable-next-line no-param-reassign
     station.arrivalTimeWithDelay = station.arrivalTime;
     if (station.departureTime) {
-      // eslint-disable-next-line no-param-reassign
       station.departureTimeWithDelay = station.departureTime;
     }
     if (station.arrivalDelay) {
-      // eslint-disable-next-line no-param-reassign
       station.arrivalTime -= station.arrivalDelay;
       if (station.departureTime) {
-        // eslint-disable-next-line no-param-reassign
         station.departureTime -= station.arrivalDelay;
       }
     }
   });
-  // eslint-disable-next-line consistent-return
   return content;
 };

package/api/index.js

@@ -1,3 +1,3 @@
-// eslint-disable-next-line import/prefer-default-export
-export { default as StopsAPI } from './stops/StopsAPI';
-export { default as TralisAPI, TralisModes } from './tralis/TralisAPI';
+export { default as RoutingAPI } from "./RoutingAPI";
+export { default as StopsAPI } from "./StopsAPI";
+export { default as TralisAPI, TralisModes } from "./TralisAPI";

package/common/api/HttpAPI.js

@@ -0,0 +1,32 @@
+import BaseObject from "ol/Object";
+import getUrlWithParams from "../utils/getUrlWithParams";
+class HttpAPI extends BaseObject {
+  constructor(options = {}) {
+    super();
+    this.url = options.url;
+    this.apiKey = options.apiKey;
+  }
+  fetch(path, params, config) {
+    if (!this.apiKey && !/key=/.test(this.url)) {
+      return Promise.reject(new Error(`No apiKey defined for request to ${this.url}`));
+    }
+    const searchParams = params || {};
+    const url = getUrlWithParams(`${this.url}${path || ""}`, {
+      key: this.apiKey,
+      ...searchParams
+    });
+    return fetch(url.toString(), config).then((response) => {
+      try {
+        return response.json().then((data) => {
+          if (data.error) {
+            throw new Error(data.error);
+          }
+          return data;
+        });
+      } catch (err) {
+        return Promise.reject(new Error(err));
+      }
+    });
+  }
+}
+export default HttpAPI;

package/common/api/HttpAPI.test.js

@@ -0,0 +1,50 @@
+import fetch from "jest-fetch-mock";
+import API from "./HttpAPI";
+let api;
+describe("HttpAPI", () => {
+  beforeEach(() => {
+    global.fetch = fetch;
+    fetch.resetMocks();
+    api = new API({ url: "https://foo.ch", apiKey: "apiKey" });
+  });
+  describe("#fetch", () => {
+    test("should success", () => {
+      fetch.mockResponseOnce(JSON.stringify({ foo: "bar" }));
+      return api.fetch("/path", {
+        q: "Bern",
+        fooUndefined: void 0,
+        fooNull: null,
+        fooEmpty: ""
+      }).then((response) => {
+        expect(fetch.mock.calls[0][0]).toEqual("https://foo.ch/path?key=apiKey&q=Bern&fooEmpty=");
+        expect(response).toEqual({ foo: "bar" });
+      });
+    });
+    describe("should display error message", () => {
+      test("reject error", (done) => {
+        fetch.mockRejectOnce(new Error("Fake error message"));
+        return api.fetch().catch((err) => {
+          expect(err.name).toEqual("Error");
+          expect(err.message).toEqual("Fake error message");
+          done();
+        });
+      });
+      test("if the response is invalid json", (done) => {
+        fetch.mockResponseOnce("invalid json");
+        api.fetch().catch((err) => {
+          expect(err.name).toEqual("FetchError");
+          expect(err.message).toEqual("invalid json response body at  reason: Unexpected token i in JSON at position 0");
+          done();
+        });
+      });
+      test("if the response contains an error message", (done) => {
+        fetch.mockResponseOnce('{"error":"foo2"}');
+        api.fetch().catch((err) => {
+          expect(err.name).toEqual("Error");
+          expect(err.message).toEqual("foo2");
+          done();
+        });
+      });
+    });
+  });
+});