@masterportal/masterportalapi 2.2.0 → 2.5.0

package/test/layer/entities.test.js

@@ -0,0 +1,277 @@
+import * as entities from "../../src/layer/entities";
+
+describe("entities.js", function () {
+    let attr,
+        map,
+        dataSources = [],
+        dataSourcesContent,
+        dataSourceValues,
+        cesiumCustomDataSourceSpy,
+        cesiumHeadingPitchRollSpy,
+        tick;
+
+    beforeEach(() => {
+        tick = () => {
+            return new Promise(resolve => {
+                setTimeout(resolve, 0);
+            });
+        };
+        dataSourcesContent = {};
+        dataSourceValues = [];
+        global.Cesium = {};
+        global.Cesium.Cartesian3 = {};
+        global.Cesium.Transforms = {};
+        global.Cesium.Cartesian3.fromDegrees = jest.fn();
+        global.Cesium.HeadingPitchRoll = jest.fn();
+        global.Cesium.Transforms.headingPitchRollQuaternion = jest.fn();
+        global.Cesium.CustomDataSource = function CustomDataSource (name) {
+            this.name = name;
+            this.entities = {
+                values: dataSourceValues,
+                add: (toAdd) => {
+                    dataSourceValues.push(toAdd);
+                    this.length++;
+                    return toAdd;
+                },
+                contains: (value) => dataSourceValues.includes(value)
+            };
+            this.length = 0;
+            this.forEach = () => dataSourceValues.forEach;
+        };
+        attr = {
+            id: "4003",
+            name: "EntitiesLayer",
+            typ: "Entities3D",
+            entities: [
+                {
+                    "url": "https://daten-hamburg.de/gdi3d/datasource-data/Simple_Building.glb",
+                    "attributes": {
+                        "name": "einfaches Haus in Planten und Blomen"
+                    },
+                    "latitude": 53.5631,
+                    "longitude": 9.9800,
+                    "height": 16,
+                    "heading": 0,
+                    "pitch": 0,
+                    "roll": 0,
+                    "scale": 5,
+                    "allowPicking": true,
+                    "show": true
+                }
+            ]
+        };
+        dataSources = {
+            getByName: (name) => {
+                return dataSourcesContent[name] ? [dataSourcesContent[name]] : [];
+            },
+            add: async (dataSource) => {
+                dataSourcesContent[dataSource.name] = dataSource;
+                return Promise.resolve(dataSource).then(function (value) {
+                    return value;
+                });
+            }
+        };
+        map = {
+            getDataSources: () => {
+                return dataSources;
+            }
+        };
+        cesiumCustomDataSourceSpy = jest.spyOn(global.Cesium, "CustomDataSource");
+        cesiumHeadingPitchRollSpy = jest.spyOn(global.Cesium.Transforms, "headingPitchRollQuaternion");
+    });
+
+    afterEach(() => {
+        global.Cesium = null;
+        jest.clearAllMocks();
+    });
+
+    function checkAttributes (layer, attrs) {
+        expect(layer.get("name")).toEqual(attrs.name);
+        expect(layer.get("typ")).toEqual(attrs.typ);
+        expect(layer.get("id")).toEqual(attrs.id);
+    }
+
+    describe("createLayer", function () {
+        it("creates a wrapper for terrain layer without map", function () {
+            const layer = entities.createLayer(attr);
+
+            checkAttributes(layer, attr);
+        });
+        it("creates a wrapper for entities layer with map and show is false", async function () {
+            attr.entities[0].show = false;
+            const layer = entities.createLayer(attr, map);
+
+            await tick();
+
+            checkAttributes(layer, attr);
+            expect(dataSourceValues.length).toEqual(1);
+            expect(dataSourceValues[0].show).toEqual(false);
+            expect(Object.keys(dataSourcesContent).length).toEqual(1);
+            expect(cesiumCustomDataSourceSpy).toHaveBeenCalledTimes(1);
+            expect(cesiumHeadingPitchRollSpy).toHaveBeenCalledTimes(1);
+        });
+        it("creates a wrapper for terrain layer with map and show not set", async function () {
+            attr.entities[0].show = undefined;
+            const layer = entities.createLayer(attr, map);
+
+            await tick();
+
+            checkAttributes(layer, attr);
+            expect(dataSourceValues.length).toEqual(1);
+            expect(dataSourceValues[0].show).toEqual(false);
+            expect(Object.keys(dataSourcesContent).length).toEqual(1);
+            expect(cesiumCustomDataSourceSpy).toHaveBeenCalledTimes(1);
+            expect(cesiumHeadingPitchRollSpy).toHaveBeenCalledTimes(1);
+        });
+        it("creates a wrapper for terrain layer with map and show is true", async function () {
+            attr.entities[0].show = true;
+            const layer = entities.createLayer(attr, map);
+
+            await tick();
+
+            checkAttributes(layer, attr);
+            expect(dataSourceValues.length).toEqual(1);
+            expect(dataSourceValues[0].show).toEqual(true);
+            expect(Object.keys(dataSourcesContent).length).toEqual(1);
+            expect(cesiumCustomDataSourceSpy).toHaveBeenCalledTimes(1);
+            expect(cesiumHeadingPitchRollSpy).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe("setVisible", function () {
+        let consoleWarnOrig;
+
+        beforeEach(() => {
+            consoleWarnOrig = console.warn;
+            console.warn = jest.fn();
+        });
+
+        afterEach(() => {
+            console.warn = consoleWarnOrig;
+        });
+
+        it("call setVisible without map shall not fail and shall do nothing", async function () {
+            attr.isSelected = false;
+            attr.entities[0].show = false;
+            const layer = entities.createLayer(attr, map);
+
+            entities.setVisible(true, attr);
+
+            await tick();
+
+            checkAttributes(layer, attr);
+            expect(dataSourceValues.length).toEqual(1);
+            expect(dataSourceValues[0].show).toEqual(false);
+        });
+        it("call setVisible without map and rawLayer shall not fail and shall do nothing", async function () {
+            attr.isSelected = false;
+            attr.entities[0].show = false;
+            const layer = entities.createLayer(attr, map);
+
+            entities.setVisible(true, null);
+
+            await tick();
+
+            checkAttributes(layer, attr);
+            expect(dataSourceValues.length).toEqual(1);
+            expect(dataSourceValues[0].show).toEqual(false);
+        });
+        it("call setVisible shall set show to true", async function () {
+            attr.isSelected = false;
+            attr.entities[0].show = false;
+            const layer = entities.createLayer(attr, map);
+
+            await tick();
+
+            expect(dataSourceValues[0].show).toEqual(false);
+
+            layer.setVisible(true, attr, map);
+
+            checkAttributes(layer, attr);
+            expect(dataSourceValues.length).toEqual(1);
+            expect(dataSourcesContent[attr.id].show).toEqual(true);
+        });
+        it("call setVisible shall only warn, if no dataSource found", async function () {
+            attr.isSelected = false;
+            attr.entities[0].show = false;
+            const layer = entities.createLayer(attr, map);
+
+            await tick();
+
+            checkAttributes(layer, attr);
+
+            attr.id = "notExist";
+            entities.setVisible(true, attr, map);
+
+            expect(dataSourceValues.length).toEqual(1);
+            expect(dataSourcesContent[attr.id]).toEqual(undefined);
+            expect(console.warn).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe("get", function () {
+        it("calls get for attributes", async function () {
+            const layer = entities.createLayer(attr, map);
+
+            checkAttributes(layer, attr);
+            expect(layer.get(null)).toEqual(undefined);
+            expect(layer.get(undefined)).toEqual(undefined);
+            expect(layer.get("")).toEqual(undefined);
+        });
+    });
+    describe("addEntities", function () {
+        let consoleWarnOrig;
+
+        beforeEach(() => {
+            consoleWarnOrig = console.warn;
+            console.warn = jest.fn();
+        });
+
+        afterEach(() => {
+            console.warn = consoleWarnOrig;
+        });
+
+        it("addEntities without map shall not fail", async function () {
+            const layer = entities.createLayer(attr, map);
+
+            await tick();
+            layer.createDataSource(attr);
+        });
+        it("addEntities without rawLayer shall not fail", async function () {
+            const layer = entities.createLayer(attr, map);
+
+            await tick();
+            layer.createDataSource(null, map);
+            expect(console.warn).toHaveBeenCalledTimes(1);
+        });
+
+        it("addEntities shall add entity twice", async function () {
+            attr.entities[0].show = false;
+            const layer = entities.createLayer(attr, map);
+
+            await tick();
+
+            checkAttributes(layer, attr);
+            expect(dataSourceValues.length).toEqual(1);
+
+            layer.createDataSource(attr, map);
+            expect(dataSourceValues.length).toEqual(2);
+            expect(dataSourceValues[0].show).toEqual(false);
+            expect(dataSourceValues[1].show).toEqual(false);
+        });
+        it("addEntities shall add entity and set Visible", async function () {
+            attr.entities[0].show = true;
+            const layer = entities.createLayer(attr, map);
+
+            await tick();
+
+            checkAttributes(layer, attr);
+            expect(dataSourceValues.length).toEqual(1);
+            expect(dataSourceValues[0].show).toEqual(true);
+
+            layer.createDataSource(attr, map);
+            expect(dataSourceValues.length).toEqual(2);
+            expect(dataSourceValues[0].show).toEqual(true);
+            expect(dataSourceValues[1].show).toEqual(true);
+        });
+    });
+});
+

package/test/layer/terrain.test.js

@@ -36,25 +36,12 @@ describe("terrain.js", function () {
     }
 
     describe("createLayer", function () {
-        it("creates a wrapper for terrain layer without map and not selected", function () {
-            const layer = terrain.createLayer(attr);
-
-            checkAttributes(layer, attr);
-        });
-        it("creates a wrapper for terrain layer with map and not selected", function () {
-            attr.isSelected = false;
+        it("creates a wrapper for terrain layer with map", function () {
             const layer = terrain.createLayer(attr, map);
 
             checkAttributes(layer, attr);
             expect(cesiumTerrainProviderSpy).toHaveBeenCalledTimes(0);
         });
-        it("creates a wrapper for terrain layer with map and selected", function () {
-            attr.isSelected = true;
-            const layer = terrain.createLayer(attr, map);
-
-            checkAttributes(layer, attr);
-            expect(cesiumTerrainProviderSpy).toHaveBeenCalledTimes(1);
-        });
     });
     describe("setVisible", function () {
         it("calls setVisible without map shall not fail", function () {

package/test/layer/tileset.test.js

@@ -45,22 +45,15 @@ describe("tileset.js", function () {
     }
 
     describe("createLayer", function () {
-        it("creates tileset layer without map and not selected", function () {
+        it("creates tileset layer without map", function () {
             const layer = new Tileset(attr);
 
             checkAttributes(layer, attr);
             expect(layer.tileSet).toEqual(undefined);
+            expect(layer.tileset.show).toEqual(undefined);
             expect(cesium3DTilesetSpy).toHaveBeenCalledTimes(1);
         });
-        it("creates tileset layer with map and selected", function () {
-            attr.isSelected = true;
-            const layer = new Tileset(attr, map);
-
-            checkAttributes(layer, attr);
-            expect(layer.tileset.show).toEqual(true);
-            expect(cesium3DTilesetSpy).toHaveBeenCalledTimes(1);
-        });
-        it("creates 2 tileset layers  with map and selected and checks attributes", function () {
+        it("creates 2 tileset layers  with map and checks attributes", function () {
             const attr2 = {
                     id: "4003",
                     name: "name",

package/test/layer/vectorTile.test.js

@@ -135,7 +135,7 @@ describe("vectorTile.js", function () {
                         1.3229159522920524,
                         0.6614579761460262,
                         0.2645831904584105,
-                        0.13229159522920522
+                        0.1322915952292052
                     ],
                     tileSize: 512
                 },
@@ -169,4 +169,4 @@ describe("vectorTile.js", function () {
             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);