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

package/ol/layers/MapboxStyleLayer.test.js

@@ -1,226 +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: "foo",
-      url: "https://foo.com/styles"
-    });
-    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);
-  });
-  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 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/RealtimeLayer.test.js

@@ -1,67 +0,0 @@
-import fetch from "jest-fetch-mock";
-import Map from "ol/Map";
-import View from "ol/View";
-import WS from "jest-websocket-mock";
-import RealtimeLayer from "./RealtimeLayer";
-let layer;
-let onClick;
-let olMap;
-let server;
-describe("RealtimeLayer", () => {
-  beforeEach(() => {
-    server = new WS("ws://localhost:1234");
-    global.fetch = fetch;
-    fetch.resetMocks();
-    onClick = jest.fn();
-    layer = new RealtimeLayer({
-      url: "ws://localhost:1234",
-      apiKey: "apiKey",
-      onClick
-    });
-    olMap = new Map({
-      view: new View({
-        center: [831634, 5933959],
-        zoom: 9
-      })
-    });
-  });
-  afterEach(() => {
-    server.close();
-    WS.clean();
-  });
-  test("should be instanced.", () => {
-    expect(layer).toBeInstanceOf(RealtimeLayer);
-  });
-  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(RealtimeLayer);
-  });
-  test("should use the sort function.", () => {
-    const fn = () => true;
-    const laye = new RealtimeLayer({
-      url: "ws://localhost:1234",
-      apiKey: "apiKey",
-      sort: fn
-    });
-    expect(laye).toBeInstanceOf(RealtimeLayer);
-    expect(laye.sort).toBe(fn);
-  });
-  test("should use filter function.", () => {
-    const fn = () => true;
-    const laye = new RealtimeLayer({
-      url: "ws://localhost:1234",
-      apiKey: "apiKey",
-      filter: fn
-    });
-    expect(laye).toBeInstanceOf(RealtimeLayer);
-    expect(laye.filter).toBe(fn);
-  });
-});

package/ol/layers/RoutingLayer.test.js

@@ -1,39 +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);
-  });
-  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);
-  });
-});

package/ol/layers/VectorLayer.test.js

@@ -1,76 +0,0 @@
-import OLVectorLayer from "ol/layer/Vector";
-import VectorSource from "ol/source/Vector";
-import View from "ol/View";
-import Feature from "ol/Feature";
-import Point from "ol/geom/Point";
-import Map from "ol/Map";
-import VectorLayer from "./VectorLayer";
-const feature1 = new Feature({
-  attribute: "bar",
-  geometry: new Point([500, 500])
-});
-const olLayer = new OLVectorLayer({
-  source: new VectorSource({
-    features: [
-      feature1,
-      new Feature({
-        attribute: "foo",
-        geometry: new Point([50, 50])
-      })
-    ]
-  })
-});
-let layer;
-let map;
-let onClick;
-describe("VectorLayer", () => {
-  beforeEach(() => {
-    onClick = jest.fn();
-    layer = new VectorLayer({
-      name: "Layer",
-      olLayer,
-      onClick
-    });
-    map = new Map({
-      view: new View({ resolution: 5 }),
-      target: document.body
-    });
-  });
-  test("should be instanced.", () => {
-    expect(layer).toBeInstanceOf(VectorLayer);
-    expect(layer.hitTolerance).toBe(5);
-  });
-  test("should called terminate on initalization.", () => {
-    const spy = jest.spyOn(layer, "detachFromMap");
-    layer.attachToMap();
-    expect(spy).toHaveBeenCalledTimes(1);
-  });
-  test("should call getFeatureInfoAtCoordinate on click then the callback", async () => {
-    const coordinate = [500, 500];
-    const px = [10, 10];
-    const features = [feature1];
-    const evt = { type: "singleclick", map, coordinate };
-    const spy = jest.spyOn(layer, "getFeatureInfoAtCoordinate");
-    const spy2 = jest.spyOn(map, "getPixelFromCoordinate").mockReturnValue(px);
-    const spy3 = jest.spyOn(map, "getFeaturesAtPixel").mockReturnValue(features);
-    layer.attachToMap(map);
-    expect(onClick).toHaveBeenCalledTimes(0);
-    await map.dispatchEvent(evt);
-    expect(spy).toHaveBeenCalledTimes(1);
-    expect(spy).toHaveBeenCalledWith(coordinate);
-    expect(spy2).toHaveBeenCalledTimes(1);
-    expect(spy2).toHaveBeenCalledWith(coordinate);
-    expect(spy3).toHaveBeenCalledTimes(1);
-    expect(spy3.mock.calls[0][0]).toBe(px);
-    expect(spy3.mock.calls[0][1].layerFilter(layer.olLayer)).toBe(true);
-    expect(spy3.mock.calls[0][1].layerFilter({})).toBe(false);
-    expect(onClick).toHaveBeenCalledTimes(1);
-    expect(onClick).toHaveBeenCalledWith(features, layer, coordinate);
-  });
-  test("should clone", () => {
-    const clone = layer.clone({ name: "clone" });
-    expect(clone).not.toBe(layer);
-    expect(clone.name).toBe("clone");
-    expect(clone).toBeInstanceOf(VectorLayer);
-  });
-});

package/ol/layers/WMSLayer.test.js

@@ -1,57 +0,0 @@
-import OLView from "ol/View";
-import ImageLayer from "ol/layer/Image";
-import ImageWMS from "ol/source/ImageWMS";
-import fetch from "jest-fetch-mock";
-import Map from "ol/Map";
-import WMSLayer from "./WMSLayer";
-describe("WMSLayer", () => {
-  let map;
-  let layer;
-  beforeEach(() => {
-    map = new Map({
-      view: new OLView({ resolution: 5 }),
-      target: document.body
-    });
-    layer = new WMSLayer({
-      olLayer: new ImageLayer({
-        source: new ImageWMS({
-          url: "http://dummy",
-          params: { LAYERS: "layers" }
-        })
-      })
-    });
-    layer.attachToMap(map);
-    fetch.mockResponseOnce(JSON.stringify({ features: [] }));
-    global.fetch = fetch;
-  });
-  afterEach(() => {
-    layer.detachFromMap();
-  });
-  test("should initialize.", () => {
-    expect(layer).toBeInstanceOf(WMSLayer);
-  });
-  test("should called terminate on initalization.", () => {
-    const spy = jest.spyOn(layer, "detachFromMap");
-    layer.attachToMap();
-    expect(spy).toHaveBeenCalledTimes(1);
-  });
-  test("should return a promise resolving features.", async () => {
-    const data = await layer.getFeatureInfoAtCoordinate([50, 50]);
-    const params = new URL(fetch.mock.calls[0][0]).searchParams;
-    expect(params.get("REQUEST")).toBe("GetFeatureInfo");
-    expect(params.get("I")).toBe("50");
-    expect(params.get("J")).toBe("50");
-    expect(data.features).toEqual([]);
-  });
-  test("should return a layer instance and a coordinate.", async () => {
-    const data = await layer.getFeatureInfoAtCoordinate([50, 50]);
-    expect(data.coordinate).toEqual([50, 50]);
-    expect(data.layer).toBeInstanceOf(WMSLayer);
-  });
-  test("should clone", () => {
-    const clone = layer.clone({ name: "clone" });
-    expect(clone).not.toBe(layer);
-    expect(clone.name).toBe("clone");
-    expect(clone).toBeInstanceOf(WMSLayer);
-  });
-});