@masterportal/masterportalapi 2.23.0 → 2.25.0

package/test/renderer/webgl.test.js

@@ -1,13 +1,24 @@
 import VectorSource from "ol/source/Vector.js";
+import VectorTileSource from "ol/source/VectorTile";
+import VectorTile from "ol/layer/VectorTile.js";
 import Feature from "ol/Feature";
 import Polygon from "ol/geom/Polygon";
+import MultiPoint from "ol/geom/MultiPoint";
 import * as webgl from "../../src/renderer/webgl";
 import WebGLPointsLayer from "ol/layer/WebGLPoints";
 import Layer from "ol/layer/Layer";
-import styleList from "../../src/vectorStyle/styleList";
+import {returnColor} from "../../src/vectorStyle/lib/colorConvertions";
+
+jest.mock("../../src/vectorStyle/styleList.js", () => {
+    const
+        original = jest.requireActual("../../src/vectorStyle/styleList.js");
+
+    original.returnStyleObject = jest.fn(() => "xyz");
+    return original;
+});
 
 describe("webgl.js", () => {
-    let layerParams, rawLayer, styleRule, styleObject;
+    let layerParams, layerParamsVectorTile, rawLayer, rawLayerVectorTile, styleRule, styleObject;
 
     beforeEach(() => {
         layerParams = {
@@ -27,6 +38,26 @@ describe("webgl.js", () => {
             featureType: "krankenhaeuser_hh",
             outputFormat: "XML"
         };
+        rawLayerVectorTile = {
+            id: "4000",
+            name: "XPLAN",
+            url: "https://xplanung.ldproxy.devops.diplanung.de/rest/services/xplansyn/tiles/WebMercatorQuad/{z}/{y}/{x}?f=mvt",
+            typ: "VectorTile",
+            epsg: "EPSG:3857",
+            tileSize: 512,
+            extent: [
+                902186.674876469653,
+                7054472.60470921732,
+                1161598.35425907862,
+                7175683.41171819717
+            ]
+        };
+        layerParamsVectorTile = {
+            id: "4000",
+            renderer: "webgl",
+            styleId: "4000",
+            visibility: true
+        };
         styleRule = {style: {
             polygonFillColor: [255, 0, 0, 0.5],
             polygonStrokeColor: [0, 255, 0, 0.5],
@@ -37,16 +68,10 @@ describe("webgl.js", () => {
         styleObject = {
             rules: [styleRule]
         };
-
-        jest.spyOn(styleList, "returnStyleObject").mockImplementation(() => styleObject);
-    });
-
-    afterEach(() => {
-        jest.restoreAllMocks();
     });
 
     describe("createLayer", () => {
-        const source = new VectorSource();
+        let source = new VectorSource();
 
         it("should return a WebGLPointsLayer", () => {
             layerParams.isPointLayer = true;
@@ -63,6 +88,28 @@ describe("webgl.js", () => {
             expect(webglLayer).not.toBeInstanceOf(WebGLPointsLayer);
             expect(webglLayer.get("isPointLayer")).toBeFalsy();
         });
+        it("vectorTile: should return a VectorTile layer", () => {
+            source = new VectorTileSource({...rawLayerVectorTile, ...layerParamsVectorTile});
+            layerParams.isPointLayer = false;
+            const webglLayer = webgl.createLayer({...rawLayerVectorTile, ...layerParamsVectorTile, source});
+
+            expect(webglLayer).toBeInstanceOf(Layer);
+            expect(webglLayer).toBeInstanceOf(VectorTile);
+            expect(webglLayer).not.toBeInstanceOf(WebGLPointsLayer);
+            expect(webglLayer.get("isPointLayer")).toBeFalsy();
+        });
+    });
+    describe("afterLoading", () => {
+        const feature = new Feature({
+            geometry: new MultiPoint([
+                [[0, 0, 0], [1, 0, 0], [1, 1, 0]]
+            ], "XYZ")
+        });
+
+        it("should extract single points from MultiPoint geometries, if isPointLayer", () => {
+            webgl.afterLoading([feature], layerParams.styleId, null, true);
+            expect(feature.getGeometry().getType()).toEqual("Point");
+        });
     });
     describe("private format and style functions", () => {
         const
@@ -106,6 +153,26 @@ describe("webgl.js", () => {
                 webgl.formatFeatureStyles($feature, styleObject);
                 expect($feature.styleRule).toEqual(styleRule);
             });
+            it("set the necessary style attributes on the feature for literal style syntax", () => {
+                $feature = feature.clone();
+                webgl.formatFeatureStyles($feature, styleObject);
+                expect($feature.get("fillColor")).toEqual(returnColor(styleRule.style.polygonFillColor, "hex"));
+                expect($feature.get("strokeColor")).toEqual(returnColor(styleRule.style.polygonStrokeColor, "hex"));
+                expect($feature.get("strokeWidth")).toEqual(styleRule.style.polygonStrokeWidth);
+                expect($feature.get("opacity")).toEqual(styleRule.style.polygonFillColor[3]);
+                expect($feature.get("circleSize")).toEqual(styleRule.style.circleRadius);
+            });
+            it("circle: bind the styling rule from the styleObject to each feature", () => {
+                styleRule.style.polygonFillColor = undefined;
+                styleRule.style.polygonStrokeColor = undefined;
+                styleRule.style.polygonStrokeWidth = undefined;
+                $feature = feature.clone();
+                webgl.formatFeatureStyles($feature, styleObject);
+                expect($feature.styleRule).toEqual(styleRule);
+                expect($feature.get("fillColor")).toEqual(returnColor(styleRule.style.circleFillColor, "hex"));
+                expect($feature.get("opacity")).toEqual(styleRule.style.circleFillColor[3]);
+                expect($feature.get("circleSize")).toEqual(styleRule.style.circleRadius);
+            });
         });
     });
 });

package/test/layer/vectorBase.test.js

@@ -1,83 +0,0 @@
-import Feature from "ol/Feature";
-import Point from "ol/geom/Point";
-import Polygon from "ol/geom/Polygon";
-import VectorLayer from "ol/layer/Vector";
-import VectorSource from "ol/source/Vector.js";
-import * as vectorBase from "../../src/layer/vectorBase";
-import * as webgl from "../../src/renderer/webgl.js";
-
-jest.mock("../../src/renderer/webgl.js", () => {
-    const original = jest.requireActual("../../src/renderer/webgl.js");
-
-    original.afterLoading = jest.fn();
-    return original;
-});
-
-describe("vectorBase.js", function () {
-
-    describe("createLayerSource", function () {
-        it("creates a layerSource with features", function () {
-            const attr = {
-                    features: [
-                        new Feature({geometry: new Polygon([[[565086.1948534324, 5934664.461947621], [565657.6945448224, 5934738.54524095], [565625.9445619675, 5934357.545446689], [565234.3614400891, 5934346.962119071], [565086.1948534324, 5934664.461947621]]])}),
-                        new Feature({geometry: new Point([565826.38, 5934174.40])})
-                    ]
-                },
-                source = vectorBase.createLayerSource(attr);
-
-            expect(source).toBeInstanceOf(VectorSource);
-        });
-
-        it("creates a layerSource without features", function () {
-            const source = vectorBase.createLayerSource({});
-
-            expect(source).toBeInstanceOf(VectorSource);
-        });
-        it("creates a vectorSource with an additional listener, when renderer is \"webgl\"", () => {
-            vectorBase.createLayerSource({renderer: "webgl"});
-
-            expect(webgl.afterLoading).toHaveBeenCalled();
-        });
-    });
-
-    describe("createLayer", function () {
-        const attr = {
-            name: "Albus Percival Wulfric Brian Dumbledore",
-            typ: "VectorBase",
-            gfiAttributes: "ignore",
-            id: "Rawenclaw_01"
-        };
-
-        it("creates a vector Base Layer", function () {
-            const 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");
-        });
-        it("creates a WebGLLayer, with param renderer \"webgl\"", function () {
-            const layer = vectorBase.createLayer({...attr, renderer: "webgl"});
-
-            expect(layer.constructor.name).toEqual("LocalWebGLLayer");
-            expect(layer.getSource()).toBeInstanceOf(VectorSource);
-        });
-    });
-
-    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);
-        });
-    });
-
-});