mobility-toolbox-js 2.0.1-beta.13 → 2.2.0-beta.0

package/ol/layers/Layer.test.js

@@ -1,174 +0,0 @@
-import VectorLayer from "ol/layer/Vector";
-import VectorSource from "ol/source/Vector";
-import Map from "ol/Map";
-import Group from "ol/layer/Group";
-import Layer from "./Layer";
-let olLayer;
-let map;
-describe("Layer", () => {
-  beforeEach(() => {
-    map = new Map({});
-    olLayer = new VectorLayer({ source: new VectorSource() });
-  });
-  test("should initialize.", () => {
-    const layer = new Layer({ name: "Layer", olLayer });
-    expect(layer).toBeInstanceOf(Layer);
-  });
-  test("should be visible by default.", () => {
-    const layer = new Layer({ name: "Layer", olLayer });
-    expect(layer.visible).toBe(true);
-  });
-  test("should be invisible if defined.", () => {
-    const layer = new Layer({ name: "Layer", visible: false, olLayer });
-    expect(layer.visible).toBe(false);
-  });
-  test("should be invisible if set.", () => {
-    const layer = new Layer({ name: "Layer", olLayer });
-    layer.setVisible(false);
-    expect(layer.visible).toBe(false);
-  });
-  test("should visibility stay unchanged", () => {
-    const layer = new Layer({ name: "Layer", visible: false, olLayer });
-    layer.setVisible(false);
-    expect(layer.visible).toBe(false);
-  });
-  test("should return its name.", () => {
-    const layer = new Layer({ name: "Layer", visible: false, olLayer });
-    expect(layer.name).toEqual("Layer");
-  });
-  test("should call terminate on initialization.", () => {
-    const layer = new Layer({ name: "Layer", olLayer });
-    const spy = jest.spyOn(layer, "detachFromMap");
-    layer.attachToMap();
-    expect(spy).toHaveBeenCalledTimes(1);
-  });
-  test("should remove the layer when we call terminate.", () => {
-    const layer = new Layer({ name: "Layer", olLayer });
-    const spy = jest.spyOn(layer, "detachFromMap");
-    layer.attachToMap(map);
-    expect(spy).toHaveBeenCalledTimes(1);
-    layer.detachFromMap(map);
-    expect(spy).toHaveBeenCalledTimes(2);
-  });
-  test("should manage copyrights as string.", () => {
-    const spy = jest.spyOn(VectorSource.prototype, "setAttributions");
-    const layer = new Layer({ name: "Layer", copyrights: "foo", olLayer });
-    layer.attachToMap(map);
-    expect(spy).toHaveBeenCalledWith(["foo"]);
-  });
-  test("should manage copyrights as array.", () => {
-    const spy = jest.spyOn(VectorSource.prototype, "setAttributions");
-    const layer = new Layer({ name: "Layer", copyrights: ["bar"], olLayer });
-    layer.attachToMap(map);
-    expect(spy).toHaveBeenCalledWith(["bar"]);
-  });
-  test("should set attributions for Group.", () => {
-    const spy = jest.spyOn(VectorSource.prototype, "setAttributions");
-    const layer = new Layer({
-      name: "Layer",
-      copyrights: ["bar"],
-      olLayer: new Group({ layers: [olLayer] })
-    });
-    layer.attachToMap(map);
-    expect(spy).toHaveBeenCalledWith(["bar"]);
-  });
-  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", olLayer });
-    expect(layer.visible).toBe(true);
-    const spy = jest.fn();
-    const spy2 = jest.fn();
-    layer.attachToMap(map);
-    layer.onHover(spy);
-    layer.onClick(spy2);
-    expect(spy).toHaveBeenCalledTimes(0);
-    expect(spy2).toHaveBeenCalledTimes(0);
-    await map.dispatchEvent({ type: "pointermove", map, coordinate: [0, 0] });
-    await map.dispatchEvent({ type: "singleclick", map, coordinate: [0, 0] });
-    expect(spy).toHaveBeenCalledTimes(1);
-    expect(spy2).toHaveBeenCalledTimes(1);
-    spy.mockReset();
-    spy2.mockReset();
-    layer.setVisible(false);
-    await map.dispatchEvent({ type: "pointermove", map, coordinate: [0, 0] });
-    await map.dispatchEvent({ type: "singleclick", map, coordinate: [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", olLayer, visible: false });
-    expect(layer.visible).toBe(false);
-    const spy = jest.fn();
-    const spy2 = jest.fn();
-    layer.attachToMap(map);
-    layer.onHover(spy);
-    layer.onClick(spy2);
-    expect(spy).toHaveBeenCalledTimes(0);
-    expect(spy2).toHaveBeenCalledTimes(0);
-    await map.dispatchEvent({ type: "pointermove", map, coordinate: [0, 0] });
-    await map.dispatchEvent({ type: "singleclick", map, coordinate: [0, 0] });
-    expect(spy).toHaveBeenCalledTimes(0);
-    expect(spy2).toHaveBeenCalledTimes(0);
-    spy.mockReset();
-    spy2.mockReset();
-    layer.setVisible(true);
-    await map.dispatchEvent({ type: "pointermove", map, coordinate: [0, 0] });
-    await map.dispatchEvent({ type: "singleclick", map, coordinate: [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", olLayer, visible: true });
-    expect(layer.visible).toBe(true);
-    const spy = jest.fn();
-    const spy2 = jest.fn();
-    layer.attachToMap(map);
-    layer.onHover(spy);
-    layer.onClick(spy2);
-    expect(spy).toHaveBeenCalledTimes(0);
-    expect(spy2).toHaveBeenCalledTimes(0);
-    await map.dispatchEvent({
-      type: "pointermove",
-      map,
-      coordinate: [0, 0]
-    });
-    await map.dispatchEvent({
-      type: "singleclick",
-      map,
-      coordinate: [0, 0]
-    });
-    expect(spy).toHaveBeenCalledTimes(1);
-    expect(spy2).toHaveBeenCalledTimes(1);
-    spy.mockReset();
-    spy2.mockReset();
-    layer.detachFromMap(map);
-    await map.dispatchEvent({
-      type: "pointermove",
-      map,
-      coordinate: [0, 0]
-    });
-    await map.dispatchEvent({
-      type: "singleclick",
-      map,
-      coordinate: [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"],
-      olLayer: new Group({ layers: [olLayer] })
-    });
-    const clone = layer.clone({ name: "clone" });
-    expect(clone).not.toBe(layer);
-    expect(clone.name).toBe("clone");
-    expect(clone).toBeInstanceOf(Layer);
-  });
-});

package/ol/layers/MapboxLayer.test.js

@@ -1,160 +0,0 @@
-import OlMap from "ol/Map";
-import View from "ol/View";
-import gllib from "mapbox-gl";
-import MapboxLayer from "./MapboxLayer";
-let layer;
-let map;
-let consoleOutput;
-const styleUrl = "foo.com/styles";
-describe("MapboxLayer", () => {
-  describe("without apiKey", () => {
-    beforeEach(() => {
-      consoleOutput = [];
-      console.warn = (message) => consoleOutput.push(message);
-      layer = new MapboxLayer({
-        name: "Layer",
-        url: styleUrl
-      });
-      map = new OlMap({
-        target: document.createElement("div"),
-        view: new View({ center: [0, 0] })
-      });
-    });
-    test("should be instanced.", () => {
-      expect(layer).toBeInstanceOf(MapboxLayer);
-      expect(layer.styleUrl).toBe(styleUrl);
-    });
-    test("should not initalized mapbox map.", () => {
-      layer.attachToMap();
-      expect(layer.mbMap).toBe();
-    });
-    test("should initalized mapbox map and warn the user if there is no api key defined.", () => {
-      layer.attachToMap(map);
-      expect(layer.mbMap).toBeInstanceOf(gllib.Map);
-      expect(consoleOutput[0]).toBe("No apiKey is defined for request to foo.com/styles");
-    });
-    test("should called terminate on initalization.", () => {
-      const spy = jest.spyOn(layer, "detachFromMap");
-      layer.attachToMap();
-      expect(spy).toHaveBeenCalledTimes(1);
-    });
-    test("should clone", () => {
-      const clone = layer.clone({ name: "clone" });
-      expect(clone).not.toBe(layer);
-      expect(clone.name).toBe("clone");
-      expect(clone).toBeInstanceOf(MapboxLayer);
-    });
-  });
-  describe("with apiKey", () => {
-    beforeEach(() => {
-      layer = new MapboxLayer({
-        name: "Layer",
-        url: styleUrl,
-        apiKey: "apiKey"
-      });
-      map = new OlMap({
-        target: document.createElement("div"),
-        view: new View({ center: [0, 0] })
-      });
-    });
-    test("should be instanced with apiKey.", () => {
-      expect(layer).toBeInstanceOf(MapboxLayer);
-      expect(layer.styleUrl).toBe(styleUrl);
-    });
-    test("should not initalized mapbox map.", () => {
-      layer.attachToMap();
-      expect(layer.mbMap).toBe();
-    });
-    test("should initalized mapbox map, with 'apiKey' prop", () => {
-      const layer1 = new MapboxLayer({
-        name: "Layer",
-        url: styleUrl,
-        apiKey: "apiKeyVal"
-      });
-      layer1.attachToMap(map);
-      expect(layer1.mbMap.options.style).toBe("foo.com/styles?key=apiKeyVal");
-    });
-    test("should initalized mapbox map, with 'apiKeyName' prop", () => {
-      const layer1 = new MapboxLayer({
-        name: "Layer",
-        url: styleUrl,
-        apiKey: "test",
-        apiKeyName: "apiKey"
-      });
-      layer1.attachToMap(map);
-      expect(layer1.mbMap.options.style).toBe("foo.com/styles?apiKey=test");
-    });
-  });
-  describe("#getFeatureInfoAtCoordinate()", () => {
-    let layer1;
-    beforeEach(() => {
-      layer1 = new MapboxLayer({
-        name: "Layer",
-        url: styleUrl,
-        apiKey: "test",
-        apiKeyName: "apiKey"
-      });
-      layer1.attachToMap(map);
-      layer1.mbMap.isStyleLoaded = jest.fn(() => true);
-      layer1.mbMap.getSource = jest.fn(() => true);
-    });
-    afterEach(() => {
-      layer1.mbMap.getSource.mockRestore();
-      layer1.mbMap.isStyleLoaded.mockRestore();
-    });
-    test("should set the mapboxFeature as a property", (done) => {
-      const mapboxFeature = {
-        id: "2",
-        type: "Feature",
-        properties: {
-          foo: "bar"
-        },
-        source: "barr",
-        sourceLayer: "fooo"
-      };
-      layer1.mbMap.project = jest.fn((coord) => ({ x: coord[0], y: coord[1] }));
-      layer1.mbMap.queryRenderedFeatures = jest.fn(() => [mapboxFeature]);
-      layer1.getFeatureInfoAtCoordinate([0, 0], {}).then((featureInfo) => {
-        expect(featureInfo.features[0].get("mapboxFeature")).toBe(mapboxFeature);
-        done();
-      });
-      layer1.mbMap.project.mockRestore();
-      layer1.mbMap.queryRenderedFeatures.mockRestore();
-    });
-    describe("should use hitTolerance property", () => {
-      beforeEach(() => {
-        layer1.mbMap.project = jest.fn((coord) => ({
-          x: coord[0],
-          y: coord[1]
-        }));
-      });
-      afterEach(() => {
-        layer1.mbMap.project.mockRestore();
-        layer1.mbMap.queryRenderedFeatures.mockRestore();
-      });
-      test("when hitTolerance is not set", (done) => {
-        layer1.mbMap.queryRenderedFeatures = jest.fn((pixelBounds) => {
-          expect(pixelBounds).toEqual([
-            { x: -5, y: -5 },
-            { x: 5, y: 5 }
-          ]);
-          done();
-          return [];
-        });
-        layer1.getFeatureInfoAtCoordinate([0, 0], {});
-      });
-      test("when hitTolerance is set to 10", (done) => {
-        layer1.hitTolerance = 10;
-        layer1.mbMap.queryRenderedFeatures = jest.fn((pixelBounds) => {
-          expect(pixelBounds).toEqual([
-            { x: -10, y: -10 },
-            { x: 10, y: 10 }
-          ]);
-          done();
-          return [];
-        });
-        layer1.getFeatureInfoAtCoordinate([0, 0], {});
-      });
-    });
-  });
-});

package/ol/layers/MapboxStyleLayer.test.js

@@ -1,231 +0,0 @@
-import OlMap from "ol/Map";
-import View from "ol/View";
-import gllib from "maplibre-gl";
-import Layer from "./Layer";
-import MaplibreLayer from "./MaplibreLayer";
-import MapboxStyleLayer from "./MapboxStyleLayer";
-let source;
-let layer;
-let map;
-let onClick;
-const styleLayer = {
-  id: "layer"
-};
-describe("MapboxStyleLayer", () => {
-  beforeEach(() => {
-    onClick = jest.fn();
-    source = new MaplibreLayer({
-      name: "Layer",
-      apiKey: false
-    });
-    layer = new MapboxStyleLayer({
-      name: "mapbox layer",
-      visible: true,
-      mapboxLayer: source,
-      styleLayer,
-      onClick
-    });
-    map = new OlMap({
-      target: document.createElement("div"),
-      view: new View({ center: [0, 0] })
-    });
-  });
-  afterEach(() => {
-    if (layer.map) {
-      layer.detachFromMap(map);
-    }
-    if (source.map) {
-      source.detachFromMap(map);
-    }
-  });
-  test("should be instanced.", () => {
-    expect(layer).toBeInstanceOf(MapboxStyleLayer);
-    expect(layer.styleLayers[0]).toBe(styleLayer);
-    expect(layer.clickCallbacks[0]).toBe(onClick);
-  });
-  test("should not initalized mapbox map.", () => {
-    layer.attachToMap();
-    expect(layer.mbMap).toBe();
-    layer.detachFromMap();
-  });
-  test("should initalized mapbox map.", () => {
-    source.attachToMap(map);
-    layer.attachToMap(map);
-    expect(layer.mapboxLayer.mbMap).toBeInstanceOf(gllib.Map);
-    layer.detachFromMap();
-    source.detachFromMap();
-  });
-  test("should add onClick callback.", () => {
-    const onClick2 = jest.fn();
-    layer.onClick(onClick2);
-    expect(layer.clickCallbacks[1]).toBe(onClick2);
-  });
-  test("should called terminate on initalization.", () => {
-    const spy = jest.spyOn(layer, "detachFromMap");
-    layer.attachToMap();
-    expect(spy).toHaveBeenCalledTimes(1);
-    layer.detachFromMap(map);
-  });
-  test("should return coordinates, features and a layer instance.", async () => {
-    source.attachToMap(map);
-    layer.attachToMap(map);
-    const data = await layer.getFeatureInfoAtCoordinate([50, 50]);
-    expect(data.coordinate).toEqual([50, 50]);
-    expect(data.features).toEqual([]);
-    expect(data.layer).toBeInstanceOf(MapboxStyleLayer);
-    layer.detachFromMap(map);
-    source.detachFromMap(map);
-  });
-  test("should call onClick callback", async () => {
-    const coordinate = [500, 500];
-    const features = [];
-    const evt = { type: "singleclick", map, coordinate };
-    layer.attachToMap(map);
-    expect(onClick).toHaveBeenCalledTimes(0);
-    await map.dispatchEvent(evt);
-    expect(onClick).toHaveBeenCalledTimes(1);
-    expect(onClick).toHaveBeenCalledWith(features, layer, coordinate);
-    layer.detachFromMap();
-  });
-  test("should call super class terminate function.", () => {
-    layer.attachToMap(map);
-    const spy = jest.spyOn(Layer.prototype, "detachFromMap");
-    layer.detachFromMap(map);
-    expect(spy).toHaveBeenCalledTimes(1);
-    spy.mockRestore();
-  });
-  test("should call super class terminate if the mapboxLayer associated has been terminated before.", () => {
-    layer.attachToMap(map);
-    source.detachFromMap(map);
-    const spy = jest.spyOn(Layer.prototype, "detachFromMap");
-    layer.detachFromMap(map);
-    expect(spy).toHaveBeenCalledTimes(1);
-    spy.mockRestore();
-  });
-  test("should clone", () => {
-    const clone = layer.clone({ name: "clone" });
-    expect(clone).not.toBe(layer);
-    expect(clone.name).toBe("clone");
-    expect(clone).toBeInstanceOf(MapboxStyleLayer);
-  });
-  test("should add layer on load", () => {
-    const style = { layers: [] };
-    layer.mapboxLayer.mbMap = {
-      getStyle: () => style,
-      getSource: () => ({}),
-      getLayer: () => null,
-      setLayoutProperty: () => null,
-      addLayer: (styleLayerr) => style.layers.push(styleLayerr)
-    };
-    layer.onLoad();
-    expect(style.layers[0]).toBe(styleLayer);
-  });
-  describe("should set disabled property to false on load", () => {
-    test("when layer uses styleLayer property", () => {
-      const styles = { layers: [] };
-      layer.mapboxLayer.mbMap = {
-        getStyle: () => styles,
-        getSource: () => ({}),
-        getLayer: () => null,
-        setLayoutProperty: () => null,
-        addLayer: (styleLayerr) => styles.layers.push(styleLayerr)
-      };
-      expect(layer).toBeInstanceOf(MapboxStyleLayer);
-      layer.onLoad();
-      expect(layer.disabled).toBe(false);
-    });
-  });
-  describe("should set disabled property to true on load", () => {
-    test("when layer uses styleLayersFilter property", () => {
-      const styles = { layers: [styleLayer] };
-      const layer2 = new MapboxStyleLayer({
-        name: "mapbox layer",
-        mapboxLayer: source,
-        styleLayersFilter: () => false
-      });
-      layer2.mapboxLayer.mbMap = {
-        getStyle: () => styles,
-        getSource: () => ({}),
-        getLayer: () => null,
-        setLayoutProperty: () => null,
-        addLayer: () => ({})
-      };
-      layer2.onLoad();
-      expect(layer2.disabled).toBe(true);
-    });
-  });
-  describe("#getFeatureInfoAtCoordinate()", () => {
-    beforeEach(() => {
-      source.attachToMap(map);
-      source.mbMap.isStyleLoaded = jest.fn(() => true);
-      source.mbMap.getSource = jest.fn(() => true);
-    });
-    afterEach(() => {
-      source.mbMap.getSource.mockRestore();
-      source.mbMap.isStyleLoaded.mockRestore();
-    });
-    test("should request features on layers ids from styleLayers property", () => {
-      source.mbMap.getStyle = jest.fn(() => ({
-        layers: [{ id: "foo" }, { id: "layer" }, { id: "bar" }]
-      }));
-      layer.attachToMap(map);
-      layer.mapboxLayer.getFeatureInfoAtCoordinate = jest.fn(() => Promise.resolve({ features: [] }));
-      layer.getFeatureInfoAtCoordinate([0, 0]).then(() => {
-      });
-      expect(layer.mapboxLayer.getFeatureInfoAtCoordinate).toHaveBeenCalledWith([0, 0], { layers: ["layer"], validate: false });
-      layer.mapboxLayer.getFeatureInfoAtCoordinate.mockRestore();
-      source.mbMap.getStyle.mockRestore();
-    });
-    test("should request features on layers ids from styleLayersFilter property", () => {
-      source.mbMap.getStyle = jest.fn(() => ({
-        layers: [{ id: "foo" }, { id: "layer" }, { id: "bar" }, { id: "foo2" }]
-      }));
-      const layer2 = new MapboxStyleLayer({
-        name: "mapbox layer",
-        visible: true,
-        mapboxLayer: source,
-        styleLayer,
-        styleLayersFilter: ({ id }) => /foo/.test(id)
-      });
-      layer2.attachToMap(map);
-      layer2.mapboxLayer.getFeatureInfoAtCoordinate = jest.fn(() => Promise.resolve({ features: [] }));
-      layer2.getFeatureInfoAtCoordinate([0, 0]).then(() => {
-      });
-      expect(layer2.mapboxLayer.getFeatureInfoAtCoordinate).toHaveBeenCalledWith([0, 0], {
-        layers: ["foo", "foo2"],
-        validate: false
-      });
-      layer2.mapboxLayer.getFeatureInfoAtCoordinate.mockRestore();
-      source.mbMap.getStyle.mockRestore();
-    });
-    test("should request features on layers ids from queryRenderedLayersFilter property", () => {
-      source.mbMap.getStyle = jest.fn(() => ({
-        layers: [
-          { id: "foo" },
-          { id: "bar2" },
-          { id: "layer" },
-          { id: "bar" },
-          { id: "foo2" }
-        ]
-      }));
-      const layer2 = new MapboxStyleLayer({
-        name: "mapbox layer",
-        visible: true,
-        mapboxLayer: source,
-        styleLayer,
-        styleLayersFilter: ({ id }) => /foo/.test(id),
-        queryRenderedLayersFilter: ({ id }) => /bar/.test(id)
-      });
-      layer2.attachToMap(map);
-      layer2.mapboxLayer.getFeatureInfoAtCoordinate = jest.fn(() => Promise.resolve({ features: [] }));
-      layer2.getFeatureInfoAtCoordinate([0, 0]).then(() => {
-      });
-      expect(layer2.mapboxLayer.getFeatureInfoAtCoordinate).toHaveBeenCalledWith([0, 0], {
-        layers: ["bar2", "bar"],
-        validate: false
-      });
-      layer2.mapboxLayer.getFeatureInfoAtCoordinate.mockRestore();
-      source.mbMap.getStyle.mockRestore();
-    });
-  });
-});

package/ol/layers/RoutingLayer.test.js

@@ -1,40 +0,0 @@
-import fetch from "jest-fetch-mock";
-import Map from "ol/Map";
-import View from "ol/View";
-import RoutingLayer from "./RoutingLayer";
-let layer;
-let onClick;
-let olMap;
-describe("RoutingLayer", () => {
-  beforeEach(() => {
-    global.fetch = fetch;
-    fetch.resetMocks();
-    onClick = jest.fn();
-    layer = new RoutingLayer({
-      onClick,
-      apiKey: "apiKey"
-    });
-    olMap = new Map({
-      view: new View({
-        center: [831634, 5933959],
-        zoom: 9
-      })
-    });
-  });
-  test("should be instanced.", () => {
-    expect(layer).toBeInstanceOf(RoutingLayer);
-    expect(layer.clickCallbacks[0]).toBe(onClick);
-  });
-  test("should called terminate on initalization.", () => {
-    const spy = jest.spyOn(layer, "detachFromMap");
-    fetch.mockResponseOnce(JSON.stringify(global.fetchTrajectoriesResponse));
-    layer.attachToMap(olMap);
-    expect(spy).toHaveBeenCalledTimes(1);
-  });
-  test("should clone", () => {
-    const clone = layer.clone({ name: "clone" });
-    expect(clone).not.toBe(layer);
-    expect(clone.name).toBe("clone");
-    expect(clone).toBeInstanceOf(RoutingLayer);
-  });
-});