mobility-toolbox-js 2.0.0-beta.35 → 2.0.0-beta.38

package/ol/layers/MapboxLayer.test.js

@@ -0,0 +1,164 @@
+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 = 'http://foo.com/styles';
+describe('MapboxLayer', () => {
+    describe('without apiKey', () => {
+        beforeEach(() => {
+            // Mock console statement
+            consoleOutput = [];
+            // eslint-disable-next-line no-console
+            console.error = (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 defined for mapbox layer with style url to http://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('http://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('http://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) => {
+                    // Use default hoitTolerance
+                    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) => {
+                    // Use default hoitTolerance
+                    expect(pixelBounds).toEqual([
+                        { x: -10, y: -10 },
+                        { x: 10, y: 10 },
+                    ]);
+                    done();
+                    return [];
+                });
+                layer1.getFeatureInfoAtCoordinate([0, 0], {});
+            });
+        });
+    });
+});

package/ol/layers/MapboxStyleLayer.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=MapboxStyleLayer.test.d.ts.map

package/ol/layers/MapboxStyleLayer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapboxStyleLayer.test.d.ts","sourceRoot":"","sources":["../../../src/ol/layers/MapboxStyleLayer.test.js"],"names":[],"mappings":""}

package/ol/layers/MapboxStyleLayer.test.js

@@ -0,0 +1,232 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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.', () => __awaiter(void 0, void 0, void 0, function* () {
+        source.attachToMap(map);
+        layer.attachToMap(map);
+        const data = yield 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', () => __awaiter(void 0, void 0, void 0, function* () {
+        const coordinate = [500, 500];
+        const features = [];
+        const evt = { type: 'singleclick', map, coordinate };
+        layer.attachToMap(map);
+        expect(onClick).toHaveBeenCalledTimes(0);
+        yield 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.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=RealtimeLayer.test.d.ts.map

package/ol/layers/RealtimeLayer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RealtimeLayer.test.d.ts","sourceRoot":"","sources":["../../../src/ol/layers/RealtimeLayer.test.js"],"names":[],"mappings":""}

package/ol/layers/RealtimeLayer.test.js

@@ -0,0 +1,71 @@
+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';
+// create a WS instance, listening on port 1234 on localhost
+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(() => {
+        // ...or gracefully close the connection
+        server.close();
+        // The WS class also has a static "clean" method to gracefully close all open connections,
+        // particularly useful to reset the environment between test runs.
+        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, // reverse the array
+        });
+        expect(laye).toBeInstanceOf(RealtimeLayer);
+        expect(laye.filter).toBe(fn);
+    });
+});

package/ol/layers/RoutingLayer.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=RoutingLayer.test.d.ts.map

package/ol/layers/RoutingLayer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RoutingLayer.test.d.ts","sourceRoot":"","sources":["../../../src/ol/layers/RoutingLayer.test.js"],"names":[],"mappings":""}

package/ol/layers/RoutingLayer.test.js

@@ -0,0 +1,39 @@
+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.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=VectorLayer.test.d.ts.map

package/ol/layers/VectorLayer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VectorLayer.test.d.ts","sourceRoot":"","sources":["../../../src/ol/layers/VectorLayer.test.js"],"names":[],"mappings":""}

package/ol/layers/VectorLayer.test.js

@@ -0,0 +1,87 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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', () => __awaiter(void 0, void 0, void 0, function* () {
+        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);
+        yield 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.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=WMSLayer.test.d.ts.map

package/ol/layers/WMSLayer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WMSLayer.test.d.ts","sourceRoot":"","sources":["../../../src/ol/layers/WMSLayer.test.js"],"names":[],"mappings":""}