@masterportal/masterportalapi 2.1.1

package/test/layer/wms.test.js

@@ -0,0 +1,256 @@
+import {Map, Attribution} from "ol";
+import TileLayer from "ol/layer/Tile";
+import ImageLayer from "ol/layer/Image";
+import TileWMS from "ol/source/TileWMS.js";
+import ImageWMS from "ol/source/ImageWMS.js";
+import TileGrid from "ol/tilegrid/TileGrid";
+import * as wms from "../../src/layer/wms";
+
+describe("wms.js", function () {
+    describe("generateSessionId", function () {
+        it("returns a number", function () {
+            const sid = wms.generateSessionId();
+
+            expect(typeof sid).toBe("number");
+        });
+    });
+
+    describe("addOptionalParams", () => {
+        let params;
+
+        beforeEach(() => {
+            params = {
+                CACHEID: "yeah",
+                FORMAT: "a",
+                LAYERS: "b",
+                VERSION: "c",
+                TRANSPARENT: "d",
+                SINGLETILE: "e"
+            };
+        });
+
+        it("adds the parameter TIME", () => {
+            const extendedParams = wms.addOptionalParams(params, {TIME: "The time"});
+
+            expect(extendedParams.CACHEID).toEqual("yeah");
+            expect(extendedParams.FORMAT).toEqual("a");
+            expect(extendedParams.LAYERS).toEqual("b");
+            expect(extendedParams.VERSION).toEqual("c");
+            expect(extendedParams.TRANSPARENT).toEqual("d");
+            expect(extendedParams.SINGLETILE).toEqual("e");
+            expect(extendedParams.TIME).toEqual("The time");
+            expect(extendedParams.STYLES).not.toBeDefined();
+        });
+        it("adds the parameter STYLES", () => {
+            const extendedParams = wms.addOptionalParams(params, {STYLES: "The style"});
+
+            expect(extendedParams.CACHEID).toEqual("yeah");
+            expect(extendedParams.FORMAT).toEqual("a");
+            expect(extendedParams.LAYERS).toEqual("b");
+            expect(extendedParams.VERSION).toEqual("c");
+            expect(extendedParams.TRANSPARENT).toEqual("d");
+            expect(extendedParams.SINGLETILE).toEqual("e");
+            expect(extendedParams.STYLES).toEqual("The style");
+            expect(extendedParams.TIME).not.toBeDefined();
+        });
+    });
+
+    describe("makeParams", function () {
+        it("does not set tile height/width for singleTile parameter object", function () {
+            const singleTileParams = wms.makeParams({singleTile: true, tilesize: 256});
+
+            expect(singleTileParams.SINGLETILE).toBe(true);
+            expect(singleTileParams.WIDTH).not.toBeDefined();
+            expect(singleTileParams.HEIGHT).not.toBeDefined();
+        });
+
+        it("does set tile height/width for multiTile parameter object", function () {
+            const multiTileParams = wms.makeParams({singleTile: false, tilesize: 256});
+
+            expect(multiTileParams.SINGLETILE).toBe(false);
+            expect(multiTileParams.WIDTH).toBe(256);
+            expect(multiTileParams.HEIGHT).toBe(256);
+        });
+
+        it("defaults the format to image/png", function () {
+            const params = wms.makeParams({});
+
+            expect(params.FORMAT).toEqual("image/png");
+        });
+
+        it("sets a session id", function () {
+            const params = wms.makeParams({});
+
+            expect(typeof params.CACHEID).toEqual("number");
+        });
+
+        it("copies the query parameters correctly", function () {
+            const params = wms.makeParams({
+                format: "image/jpeg",
+                layers: "atlas,things",
+                version: "1.1.1",
+                transparent: true
+            });
+
+            expect(params.FORMAT).toEqual("image/jpeg");
+            expect(params.LAYERS).toEqual("atlas,things");
+            expect(params.VERSION).toEqual("1.1.1");
+            expect(params.TRANSPARENT).toBe(true);
+        });
+    });
+
+    describe("createLayerSource", function () {
+        it("creates a TileWMS for multi tile requests", function () {
+            const source = wms.createLayerSource({singleTile: false});
+
+            expect(source).toBeInstanceOf(TileWMS);
+        });
+
+        it("creates an ImageWMS for single tile requests", function () {
+            const source = wms.createLayerSource({singleTile: true});
+
+            expect(source).toBeInstanceOf(ImageWMS);
+        });
+    });
+    describe("createLayerSource with a tileGrid", function () {
+        function attrFunction () {
+            return [new Attribution({
+                html: "© " +
+                "<a href=\"http://www.geo.admin.ch/internet/geoportal/" +
+                "en/home.html\">" +
+                "Pixelmap 1:1000000 / geo.admin.ch</a>"
+            })];
+        }
+        it("creates a TileWMS without tileGrid, options are undefined", function () {
+            const options = undefined,
+                source = wms.createLayerSource({singleTile: false, tilesize: "10"}, options);
+
+            expect(source).toBeInstanceOf(TileWMS);
+            expect(source.getTileGrid()).toEqual(null);
+        });
+        it("creates a TileWMS without tileGrid, options without resolutions", function () {
+            const options = {
+                    origin: [442800, 5809000]
+                },
+                source = wms.createLayerSource({singleTile: false, tilesize: "10"}, options);
+
+            expect(source).toBeInstanceOf(TileWMS);
+            expect(source.getTileGrid()).toEqual(null);
+        });
+        it("creates a TileWMS containing a tileGrid", function () {
+            const options = {
+                    resolutions: [2000, 1000],
+                    origin: [442800, 5809000]
+                },
+                rawLayer = {
+                    singleTile: false,
+                    tilesize: "10",
+                    gutter: "1",
+                    serverType: "geoserver",
+                    url: "https://url.de",
+                    olAttribution: attrFunction
+                },
+                source = wms.createLayerSource(rawLayer, options);
+
+            expect(source).toBeInstanceOf(TileWMS);
+            expect(source.getTileGrid()).toBeInstanceOf(TileGrid);
+            expect(source.getTileGrid().getOrigin()).toEqual(options.origin);
+            expect(source.getTileGrid().getResolutions()).toEqual(options.resolutions);
+            expect(source.getTileGrid().getTileSize()).toEqual(parseInt(rawLayer.tilesize, 10));
+            expect(source.getAttributions()).toBe(attrFunction);
+            expect(source.getUrls()).toEqual([rawLayer.url]);
+            /* eslint-disable no-underscore-dangle */
+            expect(source.gutter_).toEqual(rawLayer.gutter);
+        });
+
+        it("creates an ImageWMS for single tile requests, contains no tileGrid", function () {
+            const rawLayer = {
+                    singleTile: true,
+                    serverType: "geoserver",
+                    url: "https://url.de",
+                    olAttribution: attrFunction
+                },
+                source = wms.createLayerSource(rawLayer);
+
+            expect(source).toBeInstanceOf(ImageWMS);
+            expect(source.getAttributions()).toBe(attrFunction);
+            expect(source.getUrl()).toEqual(rawLayer.url);
+            /* eslint-disable no-underscore-dangle */
+            expect(source.serverType_).toEqual(rawLayer.serverType);
+        });
+    });
+
+    describe("createLayer", function () {
+        it("creates a TileLayer for multi tile requests", function () {
+            const layer = wms.createLayer({singleTile: false});
+
+            expect(layer).toBeInstanceOf(TileLayer);
+        });
+
+        it("creates an ImageLayer for single tile requests", function () {
+            const layer = wms.createLayer({singleTile: true});
+
+            expect(layer).toBeInstanceOf(ImageLayer);
+        });
+    });
+    describe("createLayer with additional params and options", function () {
+        it("creates a TileLayer for multi tile requests", function () {
+            const options = {
+                    resolutions: [2000, 1000],
+                    origin: [442800, 5809000]
+                },
+                layerParams = {
+                    name: "name",
+                    layers: "layer1, layer2"
+                },
+                layer = wms.createLayer({singleTile: false, tilesize: "10"}, layerParams, options);
+
+            expect(layer).toBeInstanceOf(TileLayer);
+            expect(layer.get("name")).toEqual("name");
+            expect(layer.get("layers")).toEqual("layer1, layer2");
+            expect(layer.getSource().getTileGrid()).toBeInstanceOf(TileGrid);
+            expect(layer.getSource().getTileGrid().getOrigin()).toEqual(options.origin);
+            expect(layer.getSource().getTileGrid().getResolutions()).toEqual(options.resolutions);
+        });
+
+        it("creates an ImageLayer for single tile requests", function () {
+            const layerParams = {
+                    name: "name",
+                    layers: "layer1, layer2"
+                },
+                layer = wms.createLayer({singleTile: true}, layerParams);
+
+            expect(layer).toBeInstanceOf(ImageLayer);
+            expect(layer.get("name")).toEqual("name");
+            expect(layer.get("layers")).toEqual("layer1, layer2");
+        });
+    });
+
+    describe("updateSource", function () {
+        function getLayerSessionId (layer) {
+            return layer.getSource().getParams().SESSIONID;
+        }
+
+        it("changes a layer's source's param's sessionid", function () {
+            const layer = wms.createLayer({}),
+                oldSession = getLayerSessionId(layer);
+
+            wms.updateSource(layer);
+
+            expect(oldSession).not.toEqual(getLayerSessionId(layer));
+        });
+    });
+
+    describe("getGfiURL", function () {
+        it("creates an URL for the given layer/map/coordinate", function () {
+            const layer = wms.createLayer({url: "example.com", typ: "WMS"}),
+                map = new Map(),
+                gfiURL = wms.getGfiURL(layer, map, [0, 0]);
+
+            expect(gfiURL).toContain("example.com");
+            expect(gfiURL).toContain("REQUEST=GetFeatureInfo");
+            // doesn't work here due to missing initialization; works in manual tests
+            // expect(gfiURL).toContain("X=0&Y=0");
+        });
+    });
+});

package/test/lib/coordsToPairs.test.js

@@ -0,0 +1,9 @@
+import coordsToPairs from "../../src/lib/coordsToPairs";
+
+describe("coordsToPairs.js", function () {
+    describe("coordsToPairs", function () {
+        it("parses an array of ongoing coordinates to coordinate pairs", function () {
+            expect(coordsToPairs(["1.1", "2.2", "3.3", "4.4"])).toEqual([[1.1, 2.2], [3.3, 4.4]]);
+        });
+    });
+});

package/test/lib/getInitialLayers.test.js

@@ -0,0 +1,28 @@
+import getInitialLayers from "../../src/lib/getInitialLayers";
+import defaults from "../../src/defaults";
+
+describe("getInitialLayers.js", function () {
+    it("returns configured layers if given", function () {
+        const config = {layers: [{id: "1"}]},
+            initialLayers = getInitialLayers(config);
+
+        expect(initialLayers).toEqual(config.layers);
+    });
+
+    it("returns default initialization if no layers configured, but lgv services are in use", function () {
+        const config1 = {},
+            config2 = {layerConf: defaults.layerConf},
+            initialLayers1 = getInitialLayers(config1),
+            initialLayers2 = getInitialLayers(config2);
+
+        expect(initialLayers1).toEqual(defaults.layers);
+        expect(initialLayers2).toEqual(defaults.layers);
+    });
+
+    it("returns an empty array if neither user-specified nor default usable", function () {
+        const config = {layerConf: "example.com/services.json"},
+            initialLayers = getInitialLayers(config);
+
+        expect(initialLayers).toEqual([]);
+    });
+});

package/test/lib/oafUtil.test.js

@@ -0,0 +1,24 @@
+import {getParamsUrl} from "../../src/lib/oafUtil";
+
+describe("oafUtil.js", function () {
+    describe("getParamsUrl", function () {
+        const params = {
+            "anzahl_schueler": ">1000",
+            "bezirk": "Bergedorf"
+        };
+
+        it("should return the parsed paramsUrl", function () {
+            expect(getParamsUrl(params)).toEqual("&anzahl_schueler=>1000&bezirk=Bergedorf");
+        });
+
+        it("should return an empty string", function () {
+            expect(getParamsUrl("string")).toEqual("");
+            expect(getParamsUrl(0)).toEqual("");
+            expect(getParamsUrl(null)).toEqual("");
+            expect(getParamsUrl(undefined)).toEqual("");
+            expect(getParamsUrl(true)).toEqual("");
+            expect(getParamsUrl([])).toEqual("");
+            expect(getParamsUrl({})).toEqual("");
+        });
+    });
+});

package/test/lib/setBackgroundImage.test.js

@@ -0,0 +1,49 @@
+import setBackgroundImage from "../../src/lib/setBackgroundImage";
+import defaults from "../../src/defaults";
+
+describe("setBackgroundImage.js", function () {
+    beforeEach(() => {
+        document.body.innerHTML = "<div><div id='map'></div><div id='custom'></div></div>";
+    });
+
+    it("uses defaults fallback to get div", function () {
+        const backgroundImage = "example.com/background.png";
+
+        setBackgroundImage({backgroundImage});
+
+        expect(document.getElementById("map").style.backgroundImage).toContain(backgroundImage);
+        expect(document.getElementById("custom").style.backgroundImage).not.toContain(backgroundImage);
+    });
+
+    it("uses custom id if given", function () {
+        const backgroundImage = "example.com/background.png";
+
+        setBackgroundImage({backgroundImage, target: "custom"});
+
+        expect(document.getElementById("map").style.backgroundImage).not.toContain(backgroundImage);
+        expect(document.getElementById("custom").style.backgroundImage).toContain(backgroundImage);
+    });
+
+    it("does nothing if specified div was not found", function () {
+        const backgroundImage = "example.com/background.png";
+
+        setBackgroundImage({backgroundImage, target: "asdf"});
+
+        expect(document.getElementById("map").style.backgroundImage).not.toContain(backgroundImage);
+        expect(document.getElementById("custom").style.backgroundImage).not.toContain(backgroundImage);
+    });
+
+    it("preserves empty string as input to set explicitly no background image", function () {
+        const backgroundImage = "";
+
+        setBackgroundImage({backgroundImage});
+
+        expect(document.getElementById("map").style.backgroundImage).toBe("url()");
+    });
+
+    it("sets the default background image if none was given", function () {
+        setBackgroundImage();
+
+        expect(document.getElementById("map").style.backgroundImage).toContain(defaults.backgroundImage);
+    });
+});

package/test/lib/wfsUtil.test.js

@@ -0,0 +1,28 @@
+import {getVersion} from "../../src/lib/wfsUtil";
+
+describe("wfsUtil.js", function () {
+    describe("getVersion", function () {
+        it("should return the right version from option or rawlayers", function () {
+            expect(getVersion({version: "1.0.0"}, {version: "1.0.0"})).toEqual("1.0.0");
+            expect(getVersion({version: "1.1.0"}, {version: "1.0.0"})).toEqual("1.0.0");
+            expect(getVersion({version: "2.0.0"}, {version: "1.0.0"})).toEqual("1.0.0");
+            expect(getVersion({version: "1.0.0"}, {version: "1.1.0"})).toEqual("1.1.0");
+            expect(getVersion({version: "1.1.0"}, {version: "1.1.0"})).toEqual("1.1.0");
+            expect(getVersion({version: "2.0.0"}, {version: "1.1.0"})).toEqual("1.1.0");
+            expect(getVersion({version: "1.0.0"}, {version: "2.0.0"})).toEqual("2.0.0");
+            expect(getVersion({version: "1.1.0"}, {version: "2.0.0"})).toEqual("2.0.0");
+            expect(getVersion({version: "2.0.0"}, {version: "2.0.0"})).toEqual("2.0.0");
+            expect(getVersion({}, {version: "2.0.0"})).toEqual("2.0.0");
+            expect(getVersion({version: "2.0.0"}, {})).toEqual("2.0.0");
+        });
+
+        it("should return the right version 1.1.0", function () {
+            console.warn = jest.fn();
+            expect(getVersion({}, {})).toEqual("1.1.0");
+            expect(getVersion({version: "2.1.1"}, {})).toEqual("1.1.0");
+            expect(getVersion({}, {version: "2.1.1"})).toEqual("1.1.0");
+            expect(getVersion({version: "2.1.1"}, {version: "2.1.1"})).toEqual("1.1.0");
+            expect(console.warn).toHaveBeenCalled();
+        });
+    });
+});

package/test/lib/zoomTo.test.js

@@ -0,0 +1,74 @@
+import zoomTo, {zoomToSearchResult} from "../../src/lib/zoomTo";
+
+describe("zoomTo.js", function () {
+    describe("zoomTo", function () {
+        it("forwards its parameters to View's fit function", function () {
+            const fitMock = jest.fn(),
+                geometry = {},
+                params = {},
+                map = {
+                    getView: () => ({
+                        fit: fitMock
+                    })
+                };
+
+            zoomTo(map, geometry, params);
+
+            expect(fitMock).toHaveBeenCalledWith(geometry, params);
+        });
+
+        it("does not require params", function () {
+            const fitMock = jest.fn(),
+                geometry = {},
+                map = {
+                    getView: () => ({
+                        fit: fitMock
+                    })
+                };
+
+            zoomTo(map, geometry);
+
+            expect(fitMock).toHaveBeenCalledWith(geometry, expect.any(Object));
+        });
+    });
+
+    describe("zoomToSearchResult", function () {
+        it("transforms polygon search result and zooms to it", function () {
+            const fitMock = jest.fn(),
+                searchResult = {
+                    geometry: {
+                        type: "Polygon",
+                        coordinates: [1, 2, 3, 4]
+                    }
+                },
+                map = {
+                    getView: () => ({
+                        fit: fitMock
+                    })
+                };
+
+            zoomToSearchResult(map, searchResult);
+
+            expect(fitMock.mock.calls[0][0].getCoordinates()).toEqual([[[1, 2], [3, 4]]]);
+        });
+
+        it("transforms point search result and zooms to it", function () {
+            const fitMock = jest.fn(),
+                searchResult = {
+                    geometry: {
+                        type: "Point",
+                        coordinates: [1, 2]
+                    }
+                },
+                map = {
+                    getView: () => ({
+                        fit: fitMock
+                    })
+                };
+
+            zoomToSearchResult(map, searchResult);
+
+            expect(fitMock.mock.calls[0][0].getCoordinates()).toEqual([1, 2]);
+        });
+    });
+});