mobility-toolbox-js 2.0.0-beta.30 → 2.0.0-beta.34

package/common/mixins/UserInteractionsLayerMixin.test.js

@@ -1,199 +0,0 @@
-import VectorLayer from "ol/layer/Vector";
-import VectorSource from "ol/source/Vector";
-import BaseLayer from "../layers/Layer";
-import mixin from "./UserInteractionsLayerMixin";
-const olLayer = new VectorLayer({ source: new VectorSource() });
-const Layer = mixin(BaseLayer);
-describe("Layer", () => {
-  test("should initialize.", () => {
-    const layer = new Layer();
-    expect(layer).toBeInstanceOf(Layer);
-  });
-  test("should define default properties.", () => {
-    const layer = new Layer();
-    expect(layer).toBeInstanceOf(Layer);
-    expect(layer.userInteractions).toEqual(true);
-    expect(layer.userClickInteractions).toEqual(true);
-    expect(layer.userHoverInteractions).toEqual(true);
-    expect(layer.defaultUserInteractions).toBe(true);
-    expect(layer.userClickCallbacks).toEqual([]);
-    expect(layer.userHoverCallbacks).toEqual([]);
-    expect(layer.userClickEventsKeys).toEqual([]);
-    expect(layer.userHoverEventsKeys).toEqual([]);
-  });
-  test("should set userInteractionsXXX to false.", () => {
-    const options = {
-      userInteractions: false,
-      userClickInteractions: false,
-      userHoverInteractions: false,
-      defaultUserInteractions: false
-    };
-    const layer = new Layer(options);
-    expect(layer).toBeInstanceOf(Layer);
-    expect(layer.userInteractions).toBe(false);
-    expect(layer.userClickInteractions).toBe(false);
-    expect(layer.userHoverInteractions).toBe(false);
-    expect(layer.defaultUserInteractions).toBe(false);
-  });
-  test("should set onClick using constructor", () => {
-    const fn = () => {
-    };
-    const layer = new Layer({
-      onClick: fn,
-      onHover: fn
-    });
-    expect(layer.userClickCallbacks[0]).toBe(fn);
-    expect(layer.userHoverCallbacks[0]).toBe(fn);
-    expect(layer.userClickEventsKeys.length).toBe(0);
-    expect(layer.userHoverEventsKeys.length).toBe(0);
-  });
-  describe("#attachToMap()", () => {
-    test("should not add events if no callbacks", () => {
-      const layer = new Layer({
-        olLayer
-      });
-      expect(layer.map).toBe(void 0);
-      const obj = {};
-      layer.attachToMap(obj);
-      expect(layer.userClickEventsKeys.length).toBe(0);
-      expect(layer.userHoverEventsKeys.length).toBe(0);
-    });
-    test("should add events", () => {
-      const fn = () => {
-      };
-      const layer = new Layer({
-        olLayer,
-        onClick: fn,
-        onHover: fn
-      });
-      expect(layer.map).toBe(void 0);
-      const obj = {};
-      layer.attachToMap(obj);
-      expect(layer.userClickEventsKeys.length).toBe(1);
-      expect(layer.userHoverEventsKeys.length).toBe(1);
-    });
-  });
-  describe("#onClick()", () => {
-    test("adds function to callback array", () => {
-      const layer = new Layer();
-      const fn = jest.fn();
-      const fn2 = jest.fn();
-      layer.onClick(fn);
-      expect(layer.userClickCallbacks).toEqual([fn]);
-      layer.onClick(fn2);
-      expect(layer.userClickCallbacks).toEqual([fn, fn2]);
-      expect(layer.userClickEventsKeys.length).toBe(0);
-      layer.attachToMap({});
-      expect(layer.userClickEventsKeys.length).toBe(2);
-    });
-  });
-  describe("#onHover()", () => {
-    test("adds function to callback array", () => {
-      const layer = new Layer();
-      const fn = jest.fn();
-      const fn2 = jest.fn();
-      layer.onHover(fn);
-      expect(layer.userHoverCallbacks).toEqual([fn]);
-      layer.onHover(fn2);
-      expect(layer.userHoverCallbacks).toEqual([fn, fn2]);
-      expect(layer.userHoverEventsKeys.length).toBe(0);
-      layer.attachToMap({});
-      expect(layer.userHoverEventsKeys.length).toBe(2);
-    });
-  });
-  describe("#onUserClickCallback()", () => {
-    const evt = { type: "signleclick", coordinate: [0, 0] };
-    const getFeatureInfo = (layer, features = []) => ({
-      features,
-      layer,
-      coordinate: evt.coordinate,
-      event: evt
-    });
-    test("calls click callback functions", async (done) => {
-      const layer = new Layer();
-      const goodFeatureInfo = getFeatureInfo(layer, [{ name: "test" }]);
-      const fn = jest.fn();
-      const fn2 = jest.fn();
-      const spy = jest.spyOn(layer, "getFeatureInfoAtCoordinate").mockResolvedValue(goodFeatureInfo);
-      layer.onClick(fn);
-      layer.onClick(fn2);
-      layer.attachToMap({});
-      layer.onUserClickCallback(evt).then((featureInfo) => {
-        expect(spy).toHaveBeenCalledTimes(1);
-        expect(spy).toHaveBeenCalledWith(evt.coordinate);
-        expect(featureInfo).toBe(goodFeatureInfo);
-        expect(fn).toHaveBeenCalledTimes(1);
-        expect(fn.mock.calls[0][0]).toBe(goodFeatureInfo.features);
-        expect(fn.mock.calls[0][1]).toBe(goodFeatureInfo.layer);
-        expect(fn.mock.calls[0][2]).toBe(goodFeatureInfo.coordinate);
-        expect(fn2).toHaveBeenCalledTimes(1);
-        expect(fn2.mock.calls[0][0]).toBe(goodFeatureInfo.features);
-        expect(fn2.mock.calls[0][1]).toBe(goodFeatureInfo.layer);
-        expect(fn2.mock.calls[0][2]).toBe(goodFeatureInfo.coordinate);
-        done();
-      });
-    });
-    describe("returns empty feature info", () => {
-      test("if an error is thrown in click callback", (done) => {
-        const layer = new Layer();
-        layer.onClick(() => {
-          throw new Error("foo");
-        });
-        const goodFeatureInfo = getFeatureInfo(layer, [{ name: "test" }]);
-        jest.spyOn(layer, "getFeatureInfoAtCoordinate").mockResolvedValue(goodFeatureInfo);
-        layer.attachToMap({});
-        layer.onUserClickCallback(evt).then((featureInfo) => {
-          expect(featureInfo).toEqual(getFeatureInfo(layer));
-          done();
-        });
-      });
-    });
-  });
-  describe("#onUserMoveCallback()", () => {
-    const evt = { type: "pointermove", coordinate: [0, 0] };
-    const getFeatureInfo = (layer, features = []) => ({
-      features,
-      layer,
-      coordinate: evt.coordinate,
-      event: evt
-    });
-    test("calls hover callback functions", (done) => {
-      const layer = new Layer();
-      const goodFeatureInfo = getFeatureInfo(layer, [{ name: "test" }]);
-      const fn = jest.fn();
-      const fn2 = jest.fn();
-      const spy = jest.spyOn(layer, "getFeatureInfoAtCoordinate").mockResolvedValue(goodFeatureInfo);
-      layer.onHover(fn);
-      layer.onHover(fn2);
-      layer.attachToMap({});
-      layer.onUserMoveCallback(evt).then((featureInfo) => {
-        expect(spy).toHaveBeenCalledTimes(1);
-        expect(spy).toHaveBeenCalledWith(evt.coordinate);
-        expect(featureInfo).toBe(goodFeatureInfo);
-        expect(fn).toHaveBeenCalledTimes(1);
-        expect(fn.mock.calls[0][0]).toBe(goodFeatureInfo.features);
-        expect(fn.mock.calls[0][1]).toBe(goodFeatureInfo.layer);
-        expect(fn.mock.calls[0][2]).toBe(goodFeatureInfo.coordinate);
-        expect(fn2).toHaveBeenCalledTimes(1);
-        expect(fn2.mock.calls[0][0]).toBe(goodFeatureInfo.features);
-        expect(fn2.mock.calls[0][1]).toBe(goodFeatureInfo.layer);
-        expect(fn2.mock.calls[0][2]).toBe(goodFeatureInfo.coordinate);
-        done();
-      });
-    });
-    describe("returns empty feature info", () => {
-      test("if an error is thrown in hover callback", (done) => {
-        const layer = new Layer();
-        layer.onHover(() => {
-          throw new Error("foo");
-        });
-        jest.spyOn(layer, "getFeatureInfoAtCoordinate").mockResolvedValue(getFeatureInfo(layer, [{ name: "test" }]));
-        layer.attachToMap({});
-        layer.onUserMoveCallback(evt).then((featureInfo) => {
-          expect(featureInfo).toEqual(getFeatureInfo(layer));
-          done();
-        });
-      });
-    });
-  });
-});

package/common/utils/createTrackerFilters.test.js

@@ -1,79 +0,0 @@
-import createTrackerFilters from "./createTrackerFilters";
-const u1 = {
-  properties: {
-    routeIdentifier: "001.000827.004:7",
-    operator: "FoO",
-    line: {
-      name: "U1"
-    }
-  }
-};
-const ireta = {
-  properties: {
-    routeIdentifier: "0022.000827.004:7",
-    operator: "BAR",
-    line: {
-      name: "IRETA"
-    }
-  }
-};
-const arb = {
-  properties: {
-    routeIdentifier: "00333.000827.004:7",
-    operator: "qux",
-    line: {
-      name: "ARB"
-    }
-  }
-};
-const trajectories = [u1, ireta, arb];
-describe("#createTrackerFilter()", () => {
-  test("returns null", () => {
-    const filterFunc = createTrackerFilters();
-    expect(filterFunc).toBe(null);
-  });
-  describe("using line", () => {
-    test("as string", () => {
-      const filterFunc = createTrackerFilters("u1,foo");
-      expect(trajectories.filter(filterFunc)).toEqual([u1]);
-    });
-    test("as array of string", () => {
-      const filterFunc = createTrackerFilters(["u1", "foo", "IRETA"]);
-      expect(trajectories.filter(filterFunc)).toEqual([u1, ireta]);
-    });
-  });
-  describe("using route identifier", () => {
-    test("as string", () => {
-      const filterFunc = createTrackerFilters(null, "1,foo");
-      expect(trajectories.filter(filterFunc)).toEqual([u1]);
-    });
-    test("as array of string", () => {
-      const filterFunc = createTrackerFilters(null, ["22", "foo", "1"]);
-      expect(trajectories.filter(filterFunc)).toEqual([u1, ireta]);
-    });
-  });
-  describe("using operator", () => {
-    test("as string", () => {
-      const filterFunc = createTrackerFilters(null, null, "foo");
-      expect(trajectories.filter(filterFunc)).toEqual([u1]);
-    });
-    test("as array of string", () => {
-      const filterFunc = createTrackerFilters(null, null, ["bar", "foo", "1"]);
-      expect(trajectories.filter(filterFunc)).toEqual([u1, ireta]);
-    });
-  });
-  describe("using regexLine", () => {
-    test("as string", () => {
-      const filterFunc = createTrackerFilters(null, null, null, "^(S|R$|RE|PE|D|IRE|RB|TER)");
-      expect(trajectories.filter(filterFunc)).toEqual([ireta]);
-    });
-    test("as array of string", () => {
-      const filterFunc = createTrackerFilters(null, null, null, [
-        "^IR",
-        "^ARB$",
-        "foo"
-      ]);
-      expect(trajectories.filter(filterFunc)).toEqual([ireta, arb]);
-    });
-  });
-});

package/common/utils/getMapboxMapCopyrights.test.js

@@ -1,40 +0,0 @@
-import getMapboxMapCopyrights from "./getMapboxMapCopyrights";
-describe("getMapboxMapCopyrights()", () => {
-  test("returns an empty array if map is not defined", () => {
-    expect(getMapboxMapCopyrights().length).toBe(0);
-  });
-  test("returns an empty array if map.style is not defined", () => {
-    expect(getMapboxMapCopyrights({}).length).toBe(0);
-  });
-  test("returns non depluicated copyrights in an array", () => {
-    expect(getMapboxMapCopyrights({
-      style: {
-        sourceCaches: {
-          used: {
-            used: true,
-            getSource() {
-              return {
-                attribution: '<a href="https://www.openmaptiles.org/" target="_blank">\xA9 OpenMapTiles</a> <a href="https://www.openstreetmap.org/about/" target="_blank">&copy; OpenStreetMap contributors</a>'
-              };
-            }
-          },
-          "not used": {
-            used: false
-          },
-          "also used": {
-            used: true,
-            getSource() {
-              return {
-                attribution: '<a href="https://www.openmaptiles.org/" target="_blank">&copy; OpenMapTiles</a> <a href="https://www.imagico.de/" target="_blank">&copy; imagico</a>'
-              };
-            }
-          }
-        }
-      }
-    })).toEqual([
-      '<a href="https://www.openmaptiles.org/" target="_blank">\xA9 OpenMapTiles</a>',
-      '<a href="https://www.openstreetmap.org/about/" target="_blank">\xA9 OpenStreetMap contributors</a>',
-      '<a href="https://www.imagico.de/" target="_blank">\xA9 imagico</a>'
-    ]);
-  });
-});

package/common/utils/removeDuplicate.test.js

@@ -1,19 +0,0 @@
-import removeDuplicate from "./removeDuplicate";
-describe("removeDuplicate()", () => {
-  test("removes duplicates", () => {
-    expect(removeDuplicate([
-      "a",
-      " ",
-      "   ",
-      "b",
-      "a",
-      void 0,
-      null,
-      "A",
-      0,
-      "c",
-      "b",
-      "B"
-    ])).toEqual(["a", "b", "c"]);
-  });
-});

package/common/utils/timeUtils.test.js

@@ -1,10 +0,0 @@
-import { getUTCDateString, getUTCTimeString } from "./timeUtils";
-describe("timeUtils", () => {
-  test("getUTCDateString should be correct.", () => {
-    expect(getUTCDateString(new Date(2020, 5, 30))).toBe("20200630");
-    expect(getUTCDateString(new Date("January 1, 2021 00:15:30 GMT+2:00"))).toBe("20201231");
-  });
-  test("getUTCTimeString should be correct.", () => {
-    expect(getUTCTimeString(new Date(2020, 5, 30, 11, 5, 1, 123))).toBe("11:5:1.123");
-  });
-});

package/common/utils/trackerConfig.test.js

@@ -1,23 +0,0 @@
-import { getTypeIndex } from "./trackerConfig";
-describe("trackerConfig", () => {
-  describe("#getTypeIndex()", () => {
-    test("retrurn the type is it's not a string", () => {
-      const obj = { foo: "foo" };
-      expect(getTypeIndex(obj)).toBe(obj);
-      expect(getTypeIndex(0)).toBe(0);
-      expect(getTypeIndex(null)).toBe(null);
-      expect(getTypeIndex(void 0)).toBe(void 0);
-    });
-    test("find good index for new tracker values", () => {
-      expect(getTypeIndex("tram")).toBe(0);
-      expect(getTypeIndex("subway")).toBe(1);
-      expect(getTypeIndex("bus")).toBe(3);
-      expect(getTypeIndex("ferry")).toBe(4);
-      expect(getTypeIndex("cablecar")).toBe(5);
-      expect(getTypeIndex("gondola")).toBe(6);
-      expect(getTypeIndex("funicular")).toBe(7);
-      expect(getTypeIndex("coach")).toBe(8);
-      expect(getTypeIndex("rail")).toBe(9);
-    });
-  });
-});

package/mapbox/layers/Layer.test.js

@@ -1,182 +0,0 @@
-import { Map } from "maplibre-gl";
-import { toLonLat } from "ol/proj";
-import Layer from "./Layer";
-let map;
-let mapElement;
-describe("Layer", () => {
-  beforeEach(() => {
-    mapElement = document.createElement("div");
-    const { style } = mapElement;
-    style.position = "absolute";
-    style.left = "0px";
-    style.top = "0px";
-    style.width = "400px";
-    style.height = "400px";
-    mapElement.setAttribute("id", "map");
-    document.body.appendChild(mapElement);
-    map = new Map({
-      container: document.getElementById("map"),
-      style: `path/to/style`,
-      center: toLonLat([831634, 5933959]),
-      zoom: 9
-    });
-  });
-  afterEach(() => {
-    document.body.removeChild(mapElement);
-  });
-  test("should initialize.", () => {
-    const layer = new Layer({ name: "Layer" });
-    expect(layer).toBeInstanceOf(Layer);
-  });
-  test("should be visible by default.", () => {
-    const layer = new Layer({ name: "Layer" });
-    expect(layer.visible).toBe(true);
-  });
-  test("should be invisible if defined.", () => {
-    const layer = new Layer({ name: "Layer", visible: false });
-    expect(layer.visible).toBe(false);
-  });
-  test("should be invisible if set.", () => {
-    const layer = new Layer({ name: "Layer" });
-    layer.visible = false;
-    expect(layer.visible).toBe(false);
-  });
-  test("should visibility stay unchanged", () => {
-    const layer = new Layer({ name: "Layer", visible: false });
-    layer.visible = false;
-    expect(layer.visible).toBe(false);
-  });
-  test("should return its name.", () => {
-    const layer = new Layer({ name: "Layer", visible: false });
-    expect(layer.name).toEqual("Layer");
-  });
-  test("should call terminate on initialization.", () => {
-    const layer = new Layer({ name: "Layer" });
-    const spy = jest.spyOn(layer, "detachFromMap");
-    layer.attachToMap(map);
-    expect(spy).toHaveBeenCalledTimes(1);
-  });
-  test("should listen for click/hover events when layer is visible by default then should not when hidden.", async () => {
-    global.console.error = jest.fn();
-    const layer = new Layer({ name: "Layer" });
-    expect(layer.visible).toBe(true);
-    const spy = jest.fn();
-    const spy2 = jest.fn();
-    layer.onHover(spy);
-    layer.onClick(spy2);
-    layer.attachToMap(map);
-    expect(spy).toHaveBeenCalledTimes(0);
-    expect(spy2).toHaveBeenCalledTimes(0);
-    await map.fire("mousemove", {
-      type: "mousemove",
-      lngLat: { toArray: () => [0, 0] },
-      coordinate: [0, 0]
-    });
-    await map.fire("click", {
-      type: "click",
-      lngLat: { toArray: () => [0, 0] }
-    });
-    expect(spy).toHaveBeenCalledTimes(1);
-    expect(spy2).toHaveBeenCalledTimes(1);
-    spy.mockReset();
-    spy2.mockReset();
-    layer.visible = false;
-    await map.fire("mousemove", {
-      type: "mousemove",
-      lngLat: { toArray: () => [0, 0] }
-    });
-    await map.fire("click", {
-      type: "click",
-      lngLat: { toArray: () => [0, 0] }
-    });
-    expect(spy).toHaveBeenCalledTimes(0);
-    expect(spy2).toHaveBeenCalledTimes(0);
-    global.console.error.mockRestore();
-  });
-  test("should not listen for click/hover events when layer is not visible by default then should not when visible.", async () => {
-    global.console.error = jest.fn();
-    const layer = new Layer({ name: "Layer", visible: false });
-    expect(layer.visible).toBe(false);
-    const spy = jest.fn();
-    const spy2 = jest.fn();
-    layer.onHover(spy);
-    layer.onClick(spy2);
-    layer.attachToMap(map);
-    expect(spy).toHaveBeenCalledTimes(0);
-    expect(spy2).toHaveBeenCalledTimes(0);
-    await map.fire("mousemove", {
-      type: "mousemove",
-      lngLat: { toArray: () => [0, 0] },
-      coordinate: [0, 0]
-    });
-    await map.fire("click", {
-      type: "click",
-      lngLat: { toArray: () => [0, 0] }
-    });
-    expect(spy).toHaveBeenCalledTimes(0);
-    expect(spy2).toHaveBeenCalledTimes(0);
-    spy.mockReset();
-    spy2.mockReset();
-    layer.visible = true;
-    await map.fire("mousemove", {
-      type: "mousemove",
-      lngLat: { toArray: () => [0, 0] },
-      coordinate: [0, 0]
-    });
-    await map.fire("click", {
-      type: "click",
-      lngLat: { toArray: () => [0, 0] }
-    });
-    expect(spy).toHaveBeenCalledTimes(1);
-    expect(spy2).toHaveBeenCalledTimes(1);
-    global.console.error.mockRestore();
-  });
-  test("should not listen for click/hover events  after layer.detachFromMap()", async () => {
-    global.console.error = jest.fn();
-    const layer = new Layer({ name: "Layer", visible: true });
-    expect(layer.visible).toBe(true);
-    const spy = jest.fn();
-    const spy2 = jest.fn();
-    layer.onHover(spy);
-    layer.onClick(spy2);
-    layer.attachToMap(map);
-    expect(spy).toHaveBeenCalledTimes(0);
-    expect(spy2).toHaveBeenCalledTimes(0);
-    await map.fire("mousemove", {
-      type: "mousemove",
-      lngLat: { toArray: () => [0, 0] },
-      coordinate: [0, 0]
-    });
-    await map.fire("click", {
-      type: "click",
-      lngLat: { toArray: () => [0, 0] }
-    });
-    expect(spy).toHaveBeenCalledTimes(1);
-    expect(spy2).toHaveBeenCalledTimes(1);
-    spy.mockReset();
-    spy2.mockReset();
-    layer.detachFromMap();
-    await map.fire("mousemove", {
-      type: "mousemove",
-      lngLat: { toArray: () => [0, 0] },
-      coordinate: [0, 0]
-    });
-    await map.fire("click", {
-      type: "click",
-      lngLat: { toArray: () => [0, 0] }
-    });
-    expect(spy).toHaveBeenCalledTimes(0);
-    expect(spy2).toHaveBeenCalledTimes(0);
-    global.console.error.mockRestore();
-  });
-  test("should clone", () => {
-    const layer = new Layer({
-      name: "Layer",
-      copyrights: ["bar"]
-    });
-    const clone = layer.clone({ name: "clone" });
-    expect(clone).not.toBe(layer);
-    expect(clone.name).toBe("clone");
-    expect(clone).toBeInstanceOf(Layer);
-  });
-});

package/mapbox/layers/RealtimeLayer.test.js

@@ -1,10 +0,0 @@
-import RealtimeLayer from "./RealtimeLayer";
-let layer;
-describe("RealtimeLayer", () => {
-  beforeEach(() => {
-    layer = new RealtimeLayer();
-  });
-  test("should be instanced.", () => {
-    expect(layer).toBeInstanceOf(RealtimeLayer);
-  });
-});