@masterportal/masterportalapi 2.1.1

package/test/layer/vector.test.js

@@ -0,0 +1,76 @@
+import VectorSource from "ol/source/Vector.js";
+import Cluster from "ol/source/Cluster.js";
+import {bbox} from "ol/loadingstrategy.js";
+import {WFS} from "ol/format.js";
+import * as vector from "../../src/layer/vector";
+
+/* eslint-disable no-underscore-dangle */
+describe("vector.js", function () {
+    describe("createVectorSource", function () {
+        it("creates a VectorSource with all params", function () {
+            const loader = jest.fn(),
+                loadingStrategy = bbox,
+                format = new WFS(),
+                source = vector.createVectorSource(loader, loadingStrategy, format);
+
+            expect(source).toBeInstanceOf(VectorSource);
+            expect(source.getFormat()).toBeInstanceOf(WFS);
+            expect(source.loader_).toEqual(loader);
+            expect(source.strategy_).toEqual(loadingStrategy);
+        });
+        it("creates a VectorSource with an url", function () {
+            const url = "https://url.de",
+                loadingStrategy = bbox,
+                format = new WFS(),
+                source = vector.createVectorSource(url, loadingStrategy, format);
+
+            expect(source).toBeInstanceOf(VectorSource);
+            expect(source.getFormat()).toBeInstanceOf(WFS);
+            expect(source.getUrl()).toEqual(url);
+            expect(source.strategy_).toEqual(loadingStrategy);
+        });
+        it("creates a VectorSource without an url", function () {
+            const loader = jest.fn(),
+                loadingStrategy = bbox,
+                format = new WFS(),
+                source = vector.createVectorSource(loader, loadingStrategy, format);
+
+            expect(source).toBeInstanceOf(VectorSource);
+            expect(source.getFormat()).toBeInstanceOf(WFS);
+            expect(source.getUrl()).toEqual(undefined);
+            expect(source.loader_).toEqual(loader);
+            expect(source.strategy_).toEqual(loadingStrategy);
+        });
+
+    });
+    describe("createClusterVectorSource", function () {
+        it("creates a Cluster with without params", function () {
+            const source = vector.createClusterVectorSource(new VectorSource());
+
+            expect(source).toBeInstanceOf(Cluster);
+        });
+        it("creates a Cluster with all params", function () {
+            const layerSource = new VectorSource(),
+                clusterDistance = 60,
+                clusterGeometryFunction = jest.fn(() => "testGeometryFn"),
+                cluster = vector.createClusterVectorSource(layerSource, clusterDistance, clusterGeometryFunction);
+
+            expect(cluster).toBeInstanceOf(Cluster);
+            expect(cluster.getDistance()).toEqual(60);
+            expect(cluster.getSource()).toEqual(layerSource);
+            expect(typeof cluster.geometryFunction).toEqual("function");
+            expect(cluster.geometryFunction()).toEqual("testGeometryFn");
+        });
+        it("creates a Cluster without geometryFunction", function () {
+            const layerSource = new VectorSource(),
+                clusterDistance = 60,
+                cluster = vector.createClusterVectorSource(layerSource, clusterDistance, null);
+
+            expect(cluster).toBeInstanceOf(Cluster);
+            expect(cluster.getDistance()).toEqual(60);
+            expect(cluster.getSource()).toEqual(layerSource);
+            expect(typeof cluster.geometryFunction).toEqual("function");
+        });
+    });
+
+});

package/test/layer/vectorBase.test.js

@@ -0,0 +1,48 @@
+import VectorLayer from "ol/layer/Vector";
+import VectorSource from "ol/source/Vector.js";
+import * as vectorBase from "../../src/layer/vectorBase";
+
+describe("vectorBase.js", function () {
+
+    describe("createLayerSource", function () {
+        it("creates a layerSource", function () {
+            const source = vectorBase.createLayerSource();
+
+            expect(source).toBeInstanceOf(VectorSource);
+        });
+    });
+
+    describe("createLayer", function () {
+        it("creates a vector Base Layer", function () {
+            const attr = {
+                    name: "Albus Percival Wulfric Brian Dumbledore",
+                    typ: "VectorBase",
+                    gfiAttributes: "ignore",
+                    id: "Rawenclaw_01"
+                },
+                layer = vectorBase.createLayer(attr);
+
+            expect(layer).toBeInstanceOf(VectorLayer);
+            expect(layer.get("name")).toEqual("Albus Percival Wulfric Brian Dumbledore");
+            expect(layer.get("typ")).toEqual("VectorBase");
+            expect(layer.get("id")).toEqual("Rawenclaw_01");
+        });
+    });
+
+    describe("updateSource", function () {
+        it("updateSource will fetch layer again", function () {
+            const layer = vectorBase.createLayer({id: "id"}),
+                layerGetSourceMock = jest.fn(() => {
+                    return {
+                        clear: () => this,
+                        addFeatures: () => this
+                    };
+                });
+
+            layer.getSource = layerGetSourceMock;
+            vectorBase.updateSource(layer);
+            expect(layerGetSourceMock.mock.calls.length).toBe(2);
+        });
+    });
+
+});

package/test/layer/wfs.test.js

@@ -0,0 +1,388 @@
+import VectorLayer from "ol/layer/Vector.js";
+import VectorSource from "ol/source/Vector.js";
+import Cluster from "ol/source/Cluster.js";
+import {Style, Icon} from "ol/style.js";
+import map from "../../src/maps/map.js";
+import defaults from "../../src/defaults";
+import {WFS} from "ol/format.js";
+import * as wfs from "../../src/layer/wfs";
+import {featureCollection} from "./resources/wfsFeatures";
+import {wfsFilterQuery} from "./resources/wfsFilter";
+
+jest.mock("../../src/rawLayerList.js", () => {
+    const original = jest.requireActual("../../src/rawLayerList.js");
+
+    original.initializeLayerList = jest.fn();
+    return original;
+});
+
+
+describe("wfs.js", function () {
+    describe("createLayer", function () {
+        it("creates a VectorLayer without id", function () {
+            const layer = wfs.createLayer({version: "1.1.0"});
+
+            expect(layer).toBeInstanceOf(VectorLayer);
+            expect(layer.getSource()).toBeInstanceOf(VectorSource);
+        });
+        it("creates a VectorLayer without id and version", function () {
+            const warn = jest.spyOn(console, "warn").mockImplementation(() => ""),
+                layer = wfs.createLayer();
+
+            expect(layer).toBeInstanceOf(VectorLayer);
+            expect(layer.getSource()).toBeInstanceOf(VectorSource);
+            expect(warn).toHaveBeenCalled();
+
+            warn.mockReset();
+        });
+        it("creates a VectorLayer with source", function () {
+            const layer = wfs.createLayer({id: "id", version: "1.1.0"});
+
+            expect(layer).toBeInstanceOf(VectorLayer);
+            expect(layer.get("id")).toEqual("id");
+            expect(layer.getSource()).toBeInstanceOf(VectorSource);
+        });
+        it("creates a VectorLayer with style in rawLayer", function () {
+            function styleFunction () {
+                const icon = new Style({
+                    image: new Icon({
+                        src: "https://building.png",
+                        scale: 0.5,
+                        opacity: 1
+                    })
+                });
+
+                return [icon];
+            }
+            const layer = wfs.createLayer({id: "id", style: styleFunction, version: "1.1.0"});
+
+            expect(layer).toBeInstanceOf(VectorLayer);
+            expect(layer.get("id")).toEqual("id");
+            expect(layer.getSource()).toBeInstanceOf(VectorSource);
+            expect(layer.getStyleFunction()).toBeDefined();
+            expect(layer.getStyleFunction()).toEqual(styleFunction);
+
+        });
+    });
+    describe("createLayer with additional params and options", function () {
+        it("creates a VectorLayer with layerParams", function () {
+            const layerParams = {
+                    name: "name",
+                    layers: "layer1, layer2"
+                },
+                layer = wfs.createLayer({id: "id", version: "1.1.0"}, {layerParams});
+
+            expect(layer).toBeInstanceOf(VectorLayer);
+            expect(layer.get("id")).toEqual("id");
+            expect(layer.getSource()).toBeInstanceOf(VectorSource);
+            expect(layer.get("name")).toEqual("name");
+            expect(layer.get("layers")).toEqual("layer1, layer2");
+        });
+        it("creates a VectorLayer with style in options", function () {
+            function styleFunction () {
+                const icon = new Style({
+                    image: new Icon({
+                        src: "https://building.png",
+                        scale: 0.5,
+                        opacity: 1
+                    })
+                });
+
+                return [icon];
+            }
+            const options = {
+                    style: styleFunction
+                },
+                layerParams = {
+                    name: "name",
+                    layers: "layer1, layer2"
+                },
+                layer = wfs.createLayer({id: "id", version: "2.0.0"}, {layerParams, options});
+
+            expect(layer).toBeInstanceOf(VectorLayer);
+            expect(layer.get("id")).toEqual("id");
+            expect(layer.getSource()).toBeInstanceOf(VectorSource);
+            expect(layer.getStyleFunction()).toBeDefined();
+            expect(layer.getStyleFunction()).toEqual(styleFunction);
+            expect(layer.get("name")).toEqual("name");
+            expect(layer.get("layers")).toEqual("layer1, layer2");
+        });
+    });
+    describe("createLayerSource", function () {
+        const consoleError = console.error;
+
+        beforeEach(() => {
+            if (global.fetch) {
+                global.fetch.mockClear();
+            }
+        });
+        // to reset show error on load in console
+        afterEach(() => {
+            console.error = consoleError;
+        });
+        it("creates a VectorSource and beforeLoading, afterLoading and featuresFilter are called", function () {
+            global.fetch = jest.fn().mockImplementationOnce(() => {
+                return new Promise((resolve) => {
+                    resolve({
+                        ok: true,
+                        status: 200,
+                        text: () => {
+                            return featureCollection;
+                        }
+                    });
+                });
+            });
+
+            const map2D = map.createMap(defaults),
+                url = "https://url.de",
+                rawLayer = {
+                    id: "id",
+                    url: url,
+                    featureNS: "http://www.deegree.org/app",
+                    featureType: "krankenhaeuser_hh",
+                    version: "2.0.0"
+                },
+                beforeLoadingMock = jest.fn(),
+                afterLoadingMock = jest.fn(),
+                featuresFilterMock = jest.fn((features) => features),
+                // jest.fn().mockReturnValueOnce(10),
+                options = {
+                    beforeLoading: beforeLoadingMock,
+                    afterLoading: afterLoadingMock,
+                    featuresFilter: featuresFilterMock
+                },
+                layer = wfs.createLayer(rawLayer, {options});
+
+            layer.getSource().loadFeatures([-10000, -10000, 10000, 10000],
+                1,
+                map2D.getView().getProjection());
+
+            expect(layer).toBeInstanceOf(VectorLayer);
+            expect(layer.get("id")).toEqual("id");
+            expect(layer.getSource()).toBeInstanceOf(VectorSource);
+            expect(layer.getSource().getFormat()).toBeInstanceOf(WFS);
+            // eslint-disable-next-line no-underscore-dangle
+            expect(typeof layer.getSource().loader_).toEqual("function");
+            expect(beforeLoadingMock.mock.calls.length).toBe(1);
+
+            layer.getSource().on("featuresloadend", function () {
+                expect(featuresFilterMock.mock.calls.length).toBe(1);
+                expect(afterLoadingMock.mock.calls.length).toBe(1);
+            });
+        });
+        it("creates a VectorSource with doNotLoadInitially", function () {
+            global.fetch = jest.fn().mockImplementationOnce(() => {
+                return new Promise((resolve) => {
+                    resolve({
+                        ok: true,
+                        status: 200,
+                        text: () => {
+                            return featureCollection;
+                        }
+                    });
+                });
+            });
+
+            const map2D = map.createMap(defaults),
+                url = "https://url.de",
+                rawLayer = {
+                    id: "id",
+                    url: url,
+                    featureNS: "http://www.deegree.org/app",
+                    featureType: "krankenhaeuser_hh",
+                    version: "2.0.0"
+                },
+                beforeLoadingMock = jest.fn(),
+                afterLoadingMock = jest.fn(),
+                featuresFilterMock = jest.fn((features) => features),
+                // jest.fn().mockReturnValueOnce(10),
+                options = {
+                    doNotLoadInitially: true,
+                    beforeLoading: beforeLoadingMock,
+                    afterLoading: afterLoadingMock,
+                    featuresFilter: featuresFilterMock
+                },
+                layer = wfs.createLayer(rawLayer, {options});
+
+            layer.getSource().loadFeatures([-10000, -10000, 10000, 10000],
+                1,
+                map2D.getView().getProjection());
+
+            expect(layer).toBeInstanceOf(VectorLayer);
+            expect(layer.get("id")).toEqual("id");
+            expect(layer.getSource()).toBeInstanceOf(VectorSource);
+            expect(layer.getSource().getFormat()).toBeInstanceOf(WFS);
+            // eslint-disable-next-line no-underscore-dangle
+            expect(typeof layer.getSource().loader_).toEqual("function");
+            expect(beforeLoadingMock.mock.calls.length).toBe(1);
+
+            layer.getSource().on("featuresloadend", function () {
+                expect(featuresFilterMock.mock.calls.length).toBe(1);
+                expect(afterLoadingMock.mock.calls.length).toBe(1);
+            });
+        });
+        it("creates a VectorSource with wfsFilter", function () {
+            let secondFetchCalled = false;
+
+            global.fetch = jest.fn().mockImplementationOnce(() => {
+                return new Promise((resolve) => {
+                    resolve({
+                        ok: true,
+                        status: 200,
+                        text: () => {
+                            return wfsFilterQuery;
+                        }
+                    });
+                });
+            }).mockImplementationOnce(() => {
+                return new Promise((resolve) => {
+                    resolve({
+                        ok: true,
+                        status: 200,
+                        text: () => {
+                            secondFetchCalled = true;
+                            return featureCollection;
+                        }
+                    });
+                });
+            });
+
+            const map2D = map.createMap(defaults),
+                url = "https://url.de",
+                rawLayer = {
+                    id: "id",
+                    url: url,
+                    featureNS: "http://www.deegree.org/app",
+                    featureType: "krankenhaeuser_hh",
+                    version: "1.0.0"
+                },
+                beforeLoadingMock = jest.fn(),
+                afterLoadingMock = jest.fn(),
+                featuresFilterMock = jest.fn((features) => features),
+                options = {
+                    wfsFilter: "resources/xml/schulstandort.staatlich.1-4.grundschulen.xml",
+                    beforeLoading: beforeLoadingMock,
+                    afterLoading: afterLoadingMock,
+                    featuresFilter: featuresFilterMock
+                },
+                layer = wfs.createLayer(rawLayer, {options});
+
+            layer.getSource().loadFeatures([-10000, -10000, 10000, 10000],
+                1,
+                map2D.getView().getProjection());
+
+            expect(layer).toBeInstanceOf(VectorLayer);
+            expect(layer.get("id")).toEqual("id");
+
+            expect(layer.getSource()).toBeInstanceOf(VectorSource);
+            expect(layer.getSource().getFormat()).toBeInstanceOf(WFS);
+            // eslint-disable-next-line no-underscore-dangle
+            expect(typeof layer.getSource().loader_).toEqual("function");
+            expect(beforeLoadingMock.mock.calls.length).toBe(1);
+            layer.getSource().on("featuresloadend", function () {
+                expect(secondFetchCalled).toEqual(true);
+                expect(featuresFilterMock.mock.calls.length).toBe(1);
+                expect(afterLoadingMock.mock.calls.length).toBe(1);
+            });
+        });
+        it("creates a VectorSource and onLoadingError is called", function () {
+            global.fetch = jest.fn().mockImplementationOnce(() => {
+                // NOTE: fetch only rejects if a network error occurs, which do not apply to 4xx or 5xx http codes.
+                return new Promise((resolve) => {
+                    resolve({
+                        ok: false,
+                        status: 404,
+                        text: () => {
+                            return null;
+                        }
+                    });
+                });
+            });
+            // to reset show error on load in console when testing 'onLoadingError'
+            console.error = jest.fn();
+
+            const map2D = map.createMap(defaults),
+                url = "https://url.de",
+                rawLayer = {
+                    id: "id",
+                    url: url,
+                    featureNS: "http://www.deegree.org/app",
+                    featureType: "krankenhaeuser_hh",
+                    version: "2.0.0"
+                },
+                onLoadingErrorMock = jest.fn(),
+                options = {
+                    onLoadingError: onLoadingErrorMock
+                },
+                layer = wfs.createLayer(rawLayer, {options});
+
+            layer.getSource().loadFeatures([-10000, -10000, 10000, 10000],
+                1,
+                map2D.getView().getProjection());
+
+            expect(layer).toBeInstanceOf(VectorLayer);
+            expect(layer.get("id")).toEqual("id");
+            expect(layer.getSource()).toBeInstanceOf(VectorSource);
+            expect(layer.getSource().getFormat()).toBeInstanceOf(WFS);
+            // eslint-disable-next-line no-underscore-dangle
+            expect(typeof layer.getSource().loader_).toEqual("function");
+            layer.getSource().on("featuresloaderror", function () {
+                expect(onLoadingErrorMock.mock.calls.length).toBe(2);
+            });
+        });
+        it("creates a clustered VectorSource and beforeLoading, afterLoading and featuresFilter are called", function () {
+            global.fetch = jest.fn().mockImplementationOnce(() => {
+                return new Promise((resolve) => {
+                    resolve({
+                        ok: true,
+                        status: 200,
+                        text: () => {
+                            return featureCollection;
+                        }
+                    });
+                });
+            });
+
+            const map2D = map.createMap(defaults),
+                url = "https://url.de",
+                rawLayer = {
+                    id: "id",
+                    url: url,
+                    featureNS: "http://www.deegree.org/app",
+                    featureType: "krankenhaeuser_hh",
+                    clusterDistance: 60,
+                    version: "1.1.0"
+                },
+                beforeLoadingMock = jest.fn(),
+                afterLoadingMock = jest.fn(),
+                featuresFilterMock = jest.fn((features) => features),
+                clusterGeometryFunctionMock = jest.fn(),
+                options = {
+                    beforeLoading: beforeLoadingMock,
+                    afterLoading: afterLoadingMock,
+                    featuresFilter: featuresFilterMock,
+                    clusterGeometryFunction: clusterGeometryFunctionMock
+                },
+                layer = wfs.createLayer(rawLayer, {options});
+
+            layer.getSource().loadFeatures([-10000, -10000, 10000, 10000],
+                1,
+                map2D.getView().getProjection());
+
+            expect(layer).toBeInstanceOf(VectorLayer);
+            expect(layer.get("id")).toEqual("id");
+            expect(layer.getSource()).toBeInstanceOf(Cluster);
+            expect(layer.getSource().getDistance()).toEqual(60);
+            expect(layer.getSource().getSource().getFormat()).toBeInstanceOf(WFS);
+            // eslint-disable-next-line no-underscore-dangle
+            expect(typeof layer.getSource().loader_).toEqual("function");
+            expect(beforeLoadingMock.mock.calls.length).toBe(1);
+            layer.getSource().on("featuresloadend", function () {
+                expect(clusterGeometryFunctionMock.mock.calls.length).toBe(1);
+                expect(featuresFilterMock.mock.calls.length).toBe(1);
+                expect(afterLoadingMock.mock.calls.length).toBe(1);
+            });
+        });
+    });
+});
+