@masterportal/masterportalapi 2.1.1 → 2.4.0

package/test/layer/vectorTile.test.js

@@ -0,0 +1,172 @@
+import OpenLayersVectorTileLayer from "ol/layer/VectorTile";
+import OpenLayersVectorTileSource from "ol/source/VectorTile";
+import OpenLayersTileGrid from "ol/tilegrid/TileGrid";
+
+import {Feature} from "ol";
+import Polygon from "ol/geom/Polygon";
+
+import * as vectorTile from "../../src/layer/vectorTile";
+import {registerProjections} from "../../src/crs";
+import defaults from "../../src/defaults";
+
+jest.mock("../../src/rawLayerList.js", () => {
+    const original = jest.requireActual("../../src/rawLayerList.js");
+
+    original.initializeLayerList = jest.fn();
+    return original;
+});
+
+describe("vectorTile.js", function () {
+
+    beforeAll(() => registerProjections());
+
+    const layerParams = {
+            name: "VT Test",
+            id: "VT_01",
+            url: "https://example.org"
+        },
+        tileGridParams = {
+            extent: [0, 0, 1, 1],
+            tileSize: 512,
+            minZoom: 0
+        },
+
+        vtStyle = {
+            "version": 8,
+            "sources": {
+                "test": {
+                    "type": "vector"
+                }
+            },
+            "layers": [
+                {
+                    "type": "fill",
+                    "source": "test",
+                    "source-layer": "Background",
+                    "paint": {"fill-color": "rgb(255,253,238)", "fill-opacity": 1}
+                }
+            ]
+        },
+
+        feature = new Feature({
+            geometry: new Polygon([[0, 0], [0, 1], [1, 1], [0, 0]]),
+            layer: "Background"
+        });
+
+    describe("createTileGrid", function () {
+        it("creates a ol/tilegrid/TileGrid with default values for not required parameters", function () {
+            const tileGrid = vectorTile.createTileGrid(tileGridParams);
+
+            expect(tileGrid).toBeInstanceOf(OpenLayersTileGrid);
+            expect(tileGrid.getExtent()).toEqual(tileGridParams.extent);
+            expect(tileGrid.getResolutions()).toEqual(defaults.options.map(x => x.resolution));
+            expect(tileGrid.getTileSize()).toEqual(new Array(2).fill(tileGridParams.tileSize));
+            expect(tileGrid.getMinZoom()).toBe(tileGrid.minZoom);
+            expect(tileGrid.getOrigin()).toEqual([tileGridParams.extent[0], tileGridParams.extent[3]]);
+        });
+    });
+
+    describe("createLayerSource", function () {
+        it("creates a layerSource", function () {
+            const tileGrid = vectorTile.createTileGrid(tileGridParams),
+                sourceParams = {
+                    tileGrid: tileGrid,
+                    tileSize: tileGrid.getTileSize(),
+                    zDirection: 1,
+                    minZoom: 0,
+                    maxZoom: 22
+                },
+                source = vectorTile.createLayerSource("https://foo.example.org", sourceParams);
+
+            expect(source).toBeInstanceOf(OpenLayersVectorTileSource);
+        });
+    });
+
+    describe("createLayer", function () {
+        it("creates a vector Tile Layer", function () {
+            const layer = vectorTile.createLayer(layerParams);
+
+            expect(layer).toBeInstanceOf(OpenLayersVectorTileLayer);
+            expect(layer.getSource()).toBeInstanceOf(OpenLayersVectorTileSource);
+            expect(layer.get("name")).toEqual("VT Test");
+            expect(layer.get("id")).toEqual("VT_01");
+        });
+
+        it("should log an error when required param is missing", function () {
+            const spyConsole = jest.spyOn(console, "error").mockImplementation(() => ""),
+                layer = vectorTile.createLayer({
+                    name: "VT Test",
+                    id: "VT_01"
+                });
+
+            expect(layer).toBeUndefined();
+            expect(console.error).toHaveBeenCalled();
+            expect(spyConsole.mock.calls[0][0]).toContain("Cancelled creation of layer \"VT_01\"(VT Test) because of missing required parameters");
+            spyConsole.mockRestore();
+        });
+
+        it("should apply default values for all not required ones", function () {
+            const defaultValues = { // defaults defined in services.json.md
+                    zDirection: 1,
+                    epsg: "EPSG:25832", // default value from config.json.md/MapView. Should be the default CRS
+                    extent: [ // If not set, the portal's coordinate reference system's extent is used
+                        // Note: this should be the extent of the projection but is the extent of EPSG:3857
+                        //       this is because in masterportalAPI is no definition of the extent of the
+                        //       default projection which is EPSG:25832
+                        -20015077.371242613,
+                        -20015077.371242613,
+                        20015077.371242613,
+                        20015077.371242613
+                    ],
+                    origin: [ // if not set, the portal's coordinate reference system's top-left corner is used.
+                        // Note: this should be the top left corner of the projection extent but is top left
+                        //       corner of extent of EPSG:3857 this is because in masterportalAPI is no
+                        //       definition of the extent of the default projection which is EPSG:25832
+                        -20015077.371242613,
+                        20015077.371242613
+                    ],
+                    resolutions: [ // If not used, the portal's resolutions are used. (Missing default resolution definition? used default resolutions from masterportal-api)
+                        66.14579761460263,
+                        26.458319045841044,
+                        15.874991427504629,
+                        10.583327618336419,
+                        5.2916638091682096,
+                        2.6458319045841048,
+                        1.3229159522920524,
+                        0.6614579761460262,
+                        0.2645831904584105,
+                        0.13229159522920522
+                    ],
+                    tileSize: 512
+                },
+                layer = vectorTile.createLayer(layerParams),
+                source = layer.getSource(),
+                tileGrid = source.getTileGrid();
+
+            expect(layer.getExtent()).toEqual(defaultValues.extent);
+
+            expect(source.getProjection().getCode()).toEqual(defaultValues.epsg);
+
+            expect(tileGrid.getExtent()).toEqual(defaultValues.extent);
+            expect(tileGrid.getOrigin()).toEqual(defaultValues.origin);
+            expect(tileGrid.getResolutions()).toEqual(defaultValues.resolutions);
+            expect(tileGrid.getTileSize()).toEqual(new Array(2).fill(defaultValues.tileSize));
+        });
+    });
+
+    describe("setStyle", function () {
+        it("should apply a given style", function () {
+            const layer = vectorTile.createLayer(layerParams);
+
+            let featureStyle = null;
+
+            vectorTile.setStyle(layer, vtStyle);
+
+            expect(typeof layer.getStyle()).toBe("function");
+
+            featureStyle = layer.getStyle()(feature, 1.3229159522920524);
+
+            expect(featureStyle[0].getFill().getColor()).toBe("rgba(255,253,238,1)");
+        });
+    });
+});

package/test/layer/wmts.test.js

@@ -0,0 +1,26 @@
+import {get as getProjection} from "ol/proj";
+import {getWidth} from "ol/extent";
+
+import * as wmts from "../../src/layer/wmts";
+
+describe.only("wmts.js", function () {
+    describe("generateArrays", function () {
+        it("should fill the arrays resolutions and matrixIds with numbers", function () {
+            const size = getWidth(getProjection("EPSG:3857").getExtent()) / 256,
+                resLength = 20,
+                resolutions = new Array(resLength),
+                matrixIds = new Array(resLength);
+
+            wmts.generateArrays(resolutions, matrixIds, resLength, size);
+
+            resolutions.forEach((element, index) => {
+                expect(typeof element).toBe("number");
+                expect(resolutions[index]).toBe(size / Math.pow(2, index));
+            });
+            matrixIds.forEach((id, index) => {
+                expect(typeof id).toBe("number");
+                expect(matrixIds[index]).toBe(index);
+            });
+        });
+    });
+});

package/test/map.test.js

@@ -167,8 +167,41 @@ describe("map.js", function () {
                 const map3D = map.createMap(config, "3D");
 
                 expect(map3D.mapMode).toBe("3D");
-                map.setCameraParameter(config.cameraParameter, map3D, config.cesiumLib);
+                expect(map3D.getCesiumScene().camera.getAltitude()).toBe(config.cameraParameter.altitude);
+                expect(map3D.getCesiumScene().camera.getHeading()).toBe(config.cameraParameter.heading);
+                expect(map3D.getCesiumScene().camera.getTilt()).toBe(config.cameraParameter.tilt);
+            });
+        });
+        it("set the camera parameter from config under camera", function () {
+            const config = {
+                map2D: {
+                    getView: () => {
+                        return {
+                            getProjection: () => {
+                                return {getCode: () => "code"};
+                            }
+                        };
+                    },
+                    getViewport: () => {
+                        return {
+                            appendChild: jest.fn()
+                        };
+                    }
+                },
+                cameraParameter: {
+                    camera: {
+                        altitude: 272.3469798217454,
+                        heading: -0.30858728378862876,
+                        tilt: 0.9321791580603296
+                    }
+                },
+                cesiumLib: "https://lib.virtualcitymap.de/v3.6.x/lib/Cesium/Cesium.js"
+            };
 
+            load3DScript(config.cesiumLib, function Loaded3DCallback () {
+                const map3D = map.createMap(config, "3D");
+
+                expect(map3D.mapMode).toBe("3D");
                 expect(map3D.getCesiumScene().camera.getAltitude()).toBe(config.cameraParameter.altitude);
                 expect(map3D.getCesiumScene().camera.getHeading()).toBe(config.cameraParameter.heading);
                 expect(map3D.getCesiumScene().camera.getTilt()).toBe(config.cameraParameter.tilt);