@masterportal/masterportalapi 2.19.2 → 2.21.0

package/test/maps/interactions/drawInteractions.test.js

@@ -0,0 +1,123 @@
+import {Draw} from "ol/interaction.js";
+import Feature from "ol/Feature";
+import Circle from "ol/geom/Circle";
+import VectorSource from "ol/source/Vector";
+
+import drawInteractions, {styleObject} from "../../../src/maps/interactions/drawInteractions";
+
+describe("src/maps/interactions/drawInteractions.js", () => {
+    describe("transformMapUnitRadius", () => {
+        it("should return the input meter radius in meter ", () => {
+            const radius = 100,
+                mapProjection = {
+                    getUnits: () => "m"
+                },
+                mapUnitRadius = drawInteractions.transformMapUnitRadius(radius, mapProjection);
+
+            expect(mapUnitRadius).toEqual(100);
+        });
+
+        it("should return the input degree radius in meter ", () => {
+            const radius = 100,
+                mapProjection = {
+                    getUnits: () => "degrees"
+                },
+                mapUnitRadius = drawInteractions.transformMapUnitRadius(radius, mapProjection);
+
+            expect(mapUnitRadius).toEqual(0.0008983152841195215);
+        });
+    });
+
+    describe("drawInnerCircle", () => {
+        it("should set radius for circle feature", () => {
+            const feature = new Feature({geometry: new Circle([565826.38, 5934174.40], 10)}),
+                mapProjection = {
+                    getUnits: () => "m"
+                },
+                options = {
+                    innerRadius: 100,
+                    interactive: false,
+                    outerRadius: 500
+                };
+
+            drawInteractions.drawInnerCircle(feature, mapProjection, options);
+
+            expect(feature.getGeometry().getRadius()).toEqual(100);
+        });
+    });
+
+    describe("setStyleObject", () => {
+        it("should set style object", () => {
+            const currentLayout = {
+                fillColor: [55, 126, 184],
+                fillTransparency: 0,
+                strokeColor: [0, 0, 0],
+                strokeWidth: 1
+            };
+
+            drawInteractions.setStyleObject(currentLayout);
+
+            expect(styleObject).toEqual({
+                rules: [
+                    {
+                        style: {
+                            circleFillColor: [
+                                55,
+                                126,
+                                184,
+                                1
+                            ],
+                            circleStrokeColor: [
+                                0,
+                                0,
+                                0
+                            ],
+                            circleStrokeWidth: 1,
+                            lineStrokeColor: [
+                                0,
+                                0,
+                                0
+                            ],
+                            lineStrokeWidth: 1,
+                            polygonFillColor: [
+                                55,
+                                126,
+                                184,
+                                1
+                            ],
+                            polygonStrokeColor: [
+                                0,
+                                0,
+                                0
+                            ],
+                            polygonStrokeWidth: 1
+                        }
+                    }
+                ]
+            });
+        });
+    });
+
+    describe("createDrawInteraction", () => {
+        it("should create a draw interaction", () => {
+            const source = new VectorSource(),
+                drawType = "pen",
+                drawInteraction = drawInteractions.createDrawInteraction(drawType, source);
+
+            expect(drawInteraction).not.toBeUndefined();
+            expect(drawInteraction).not.toBeNull();
+            expect(drawInteraction).toBeInstanceOf(Draw);
+        });
+
+        it("should return null, if drawType is not supported", () => {
+            const source = new VectorSource(),
+                drawType = "abc",
+                drawInteraction = drawInteractions.createDrawInteraction(drawType, source);
+
+            expect(drawInteraction).not.toBeUndefined();
+            expect(drawInteraction).toBeNull();
+            expect(drawInteraction).not.toBeInstanceOf(Draw);
+        });
+    });
+
+});

package/test/renderer/webgl.test.js

@@ -4,7 +4,6 @@ import Polygon from "ol/geom/Polygon";
 import * as webgl from "../../src/renderer/webgl";
 import WebGLPointsLayer from "ol/layer/WebGLPoints";
 import Layer from "ol/layer/Layer";
-import {packColor} from "ol/renderer/webgl/shaders";
 import styleList from "../../src/vectorStyle/styleList";
 
 describe("webgl.js", () => {
@@ -108,54 +107,5 @@ describe("webgl.js", () => {
                 expect($feature.styleRule).toEqual(styleRule);
             });
         });
-        describe("getRenderFunctions", () => {
-            it("should read the style from styleRule and pack them to single float", () => {
-                const renderFunctions = webgl.getRenderFunctions();
-
-                $feature = feature.clone();
-                webgl.formatFeatureStyles($feature, styleObject);
-                expect(renderFunctions.fill.attributes.color($feature)).toEqual(packColor(styleRule.style.polygonFillColor));
-                expect(renderFunctions.fill.attributes.opacity($feature)).toEqual(styleRule.style.polygonFillColor[3]);
-                expect(renderFunctions.stroke.attributes.color($feature)).toEqual(packColor(styleRule.style.polygonStrokeColor));
-                expect(renderFunctions.stroke.attributes.width($feature)).toEqual(styleRule.style.polygonStrokeWidth);
-                expect(renderFunctions.stroke.attributes.opacity($feature)).toEqual(styleRule.style.polygonStrokeColor[3]);
-                expect(renderFunctions.point.attributes.color($feature)).toEqual(packColor(styleRule.style.circleFillColor));
-                expect(renderFunctions.point.attributes.size($feature)).toEqual(styleRule.style.circleRadius);
-                expect(renderFunctions.point.attributes.opacity($feature)).toEqual(styleRule.style.circleFillColor[3]);
-            });
-            it("should return default values if style is empty, i.e. \"default\" style", () => {
-                const renderFunctions = webgl.getRenderFunctions();
-
-                styleObject = {
-                    rules: [{
-                        style: {}
-                    }]
-                };
-                $feature = feature.clone();
-                webgl.formatFeatureStyles($feature, styleObject);
-                expect(typeof renderFunctions.fill.attributes.color($feature)).toEqual("number");
-                expect(typeof renderFunctions.fill.attributes.opacity($feature)).toEqual("number");
-                expect(typeof renderFunctions.stroke.attributes.color($feature)).toEqual("number");
-                expect(typeof renderFunctions.stroke.attributes.width($feature)).toEqual("number");
-                expect(typeof renderFunctions.stroke.attributes.opacity($feature)).toEqual("number");
-                expect(typeof renderFunctions.point.attributes.color($feature)).toEqual("number");
-                expect(typeof renderFunctions.point.attributes.size($feature)).toEqual("number");
-                expect(typeof renderFunctions.point.attributes.opacity($feature)).toEqual("number");
-            });
-            it("should return default values if no style rule is found", () => {
-                const renderFunctions = webgl.getRenderFunctions();
-
-                $feature = feature.clone();
-                expect(feature.styleRule).toBeUndefined();
-                expect(typeof renderFunctions.fill.attributes.color($feature)).toEqual("number");
-                expect(typeof renderFunctions.fill.attributes.opacity($feature)).toEqual("number");
-                expect(typeof renderFunctions.stroke.attributes.color($feature)).toEqual("number");
-                expect(typeof renderFunctions.stroke.attributes.width($feature)).toEqual("number");
-                expect(typeof renderFunctions.stroke.attributes.opacity($feature)).toEqual("number");
-                expect(typeof renderFunctions.point.attributes.color($feature)).toEqual("number");
-                expect(typeof renderFunctions.point.attributes.size($feature)).toEqual("number");
-                expect(typeof renderFunctions.point.attributes.opacity($feature)).toEqual("number");
-            });
-        });
     });
 });

package/test/vectorStyle/styles/point/stylePoint.test.js

@@ -27,8 +27,11 @@ describe("stylePoint", () => {
             expect(typeof stylePointClass.setSize).toBe("function");
         });
     });
-    describe("getStyle", function () {
+    describe("createStyle", function () {
         it("returns an instance of openlayers style", () => {
+            const createdStyle = stylePointClass.createStyle();
+
+            stylePointClass.setStyle(createdStyle);
             expect(stylePointClass.getStyle()).toBeInstanceOf(Style);
         });
         it("returns an instance of openlayers circleStyle", () => {
@@ -39,6 +42,9 @@ describe("stylePoint", () => {
                 legendValue: "Krankenhaus",
                 imageName: "krankenhaus.png"
             };
+            const createdStyle = stylePointClass.createStyle();
+
+            stylePointClass.setStyle(createdStyle);
 
             expect(stylePointClass.getStyle()).toBeInstanceOf(Style);
             expect(stylePointClass.getStyle().getImage()).toBeInstanceOf(CircleStyle);

package/test/vectorStyle/styles/polygon/stylePolygon.test.js

@@ -15,8 +15,11 @@ describe("stylePolygon", () => {
         isClustered = false,
         stylePolygonClass = new PolygonStyle(feature, style, isClustered);
 
-    describe("getStyle", function () {
+    describe("createStyle", function () {
         it("returns an instance of openlayers style", () => {
+            const createdStyle = stylePolygonClass.createStyle();
+
+            stylePolygonClass.setStyle(createdStyle);
             expect(stylePolygonClass.getStyle()).toBeInstanceOf(Style);
         });
     });

package/test/vectorStyle/styles/styleCircle.test.js

@@ -0,0 +1,31 @@
+import CircleStyle from "../../../src/vectorStyle/styles/styleCircle";
+import {Style} from "ol/style.js";
+
+describe("styleCircle", () => {
+    const feature = {
+            geometryName: "geom",
+            id: "DE.HH.UP_GESUNDHEIT_KRANKENHAEUSER_2"
+        },
+        style = {
+            type: "icon",
+            legendValue: "Krankenhaus",
+            imageName: "krankenhaus.png"
+        },
+        isClustered = false,
+        styleCircleClass = new CircleStyle(feature, style, isClustered);
+
+    describe("initialize", function () {
+        it("returns an instance of openlayers style", () => {
+            expect(typeof styleCircleClass.initialize).toBe("function");
+        });
+    });
+
+    describe("createStyle", function () {
+        it("returns an instance of openlayers style", () => {
+            const createdStyle = styleCircleClass.createStyle();
+
+            styleCircleClass.setStyle(createdStyle);
+            expect(styleCircleClass.getStyle()).toBeInstanceOf(Style);
+        });
+    });
+});

package/test/vectorStyle/styles/styleLine.test.js

@@ -21,8 +21,11 @@ describe("styleLine", () => {
         });
     });
 
-    describe("getStyle", function () {
+    describe("createStyle", function () {
         it("returns an instance of openlayers style", () => {
+            const createdStyle = styleLineClass.createStyle();
+
+            styleLineClass.setStyle(createdStyle);
             expect(styleLineClass.getStyle()).toBeInstanceOf(Style);
         });
     });