@masterportal/masterportalapi 2.19.1 → 2.20.0

package/src/renderer/webgl.js

@@ -1,9 +1,9 @@
 import WebGLPointsLayer from "ol/layer/WebGLPoints";
 import WebGLVectorLayerRenderer from "ol/renderer/webgl/VectorLayer";
 import VectorLayer from "ol/layer/Layer";
-import {packColor} from "ol/renderer/webgl/shaders";
 import styleList from "../vectorStyle/styleList";
 import {getRulesForFeature} from "../vectorStyle/lib/getRuleForIndex";
+import {returnColor} from "../vectorStyle/lib/colorConvertions";
 
 /**
  * The default style for OpenLayers WebGLPoints class
@@ -11,82 +11,26 @@ import {getRulesForFeature} from "../vectorStyle/lib/getRuleForIndex";
  * @private
  */
 const defaultStyle = {
-    symbol: {
-        symbolType: "circle",
-        size: 20,
-        color: "#006688",
-        rotateWithView: false,
-        offset: [0, 0],
-        opacity: 0.6
-    }
-};
-
-/**
- * parses the styling rules for the renderer
- * @static
- * @private
- * @returns {Object} the style options object with conditional functions
- */
-export function getRenderFunctions () {
-    return {
-        /**
-         * Used for polygon fills
-         * Reads the relevant properties from the Masterportal style object
-         * @see https://bitbucket.org/geowerkstatt-hamburg/masterportal/src/dev/doc/style.json.md
-         */
-        fill: {
-            attributes: {
-                color: (feature) => {
-                    return packColor(feature.styleRule?.style.polygonFillColor || "#006688");
-                },
-                opacity: (feature) => {
-                    return typeof feature.styleRule?.style.polygonFillColor?.[3] === "number" ?
-                        feature.styleRule.style.polygonFillColor[3] : 1;
-                }
-            }
-        },
-        stroke: {
-            /**
-             * Used for polygon edges and lineStrings
-             * Reads the relevant properties from the Masterportal style object
-             * @see https://bitbucket.org/geowerkstatt-hamburg/masterportal/src/dev/doc/style.json.md
-             */
-            attributes: {
-                color: (feature) => {
-                    return packColor(feature.styleRule?.style.polygonStrokeColor || "#006688");
-                },
-                width: (feature) => {
-                    return feature.styleRule?.style.polygonStrokeWidth || 1;
-                },
-                opacity: (feature) => {
-                    return typeof feature.styleRule?.style.polygonStrokeColor?.[3] === "number" ?
-                        feature.styleRule.style.polygonStrokeColor[3] : 1;
-                }
-            }
-        },
-        point: {
-            /**
-             * As of now, the generic VectorLayerRenderer only supports points rendered as quads
-             * available attributes: color, size, opacity
-             * Due to that, we use WebGLPoints Layer Class for point geom types
-             * Reads the relevant properties from the Masterportal style object
-             * @see https://bitbucket.org/geowerkstatt-hamburg/masterportal/src/dev/doc/style.json.md
-             */
-            attributes: {
-                color: (feature) => {
-                    return packColor(feature.styleRule?.style.circleFillColor || "#006688");
-                },
-                size: (feature) => {
-                    return feature.styleRule?.style.circleRadius || 20;
-                },
-                opacity: (feature) => {
-                    return typeof feature.styleRule?.style.circleFillColor?.[3] === "number" ?
-                        feature.styleRule.style.circleFillColor[3] : 1;
-                }
-            }
+        symbol: {
+            symbolType: "circle",
+            size: 20,
+            color: "#006688",
+            rotateWithView: false,
+            offset: [0, 0],
+            opacity: 0.6
         }
+    },
+
+    /** @type {import('../src/ol/style/literal.js').LiteralStyle} */
+    style = {
+        "stroke-color": ["get", "STROKECOLOR"],
+        // NOTICE: does not work with ol 7.4.0, throws errors -> use 1 pixel width
+        // "stroke-width": ["get", "STROKEWIDTH"],
+        "stroke-width": 1,
+        "fill-color": ["get", "FILLCOLOR"],
+        "opacity": ["get", "OPACITY"],
+        "size": ["get", "CIRCLESIZE"]
     };
-}
 
 /**
  * Creates a layer object to extend from.
@@ -109,7 +53,9 @@ export function createVectorLayerRenderer () {
          * @experimental
          */
         createRenderer () {
-            return new WebGLVectorLayerRenderer(this, getRenderFunctions());
+            return new WebGLVectorLayerRenderer(this, {
+                style
+            });
         }
     }
 
@@ -132,9 +78,24 @@ export function formatFeatureStyles (feature, styleObject) {
     // extract first matching rule only
     const rule = getRulesForFeature(styleObject, feature)[0];
 
-    // don't set on properties to avoid GFI issues
     // undefined if no match
     feature.styleRule = rule;
+
+    if (rule && rule.style) {
+        // TODO set style on properties will be visible in GFI
+        const polygonFillColor = returnColor(rule.style.polygonFillColor, "hex"),
+            circleFillColor = returnColor(rule.style.circleFillColor, "hex"),
+            fillColor = polygonFillColor ? polygonFillColor : circleFillColor,
+            polygonStrokeColor = returnColor(rule.style.polygonStrokeColor, "hex"),
+            polygonStrokeWidth = rule.style.polygonStrokeWidth,
+            size = rule.style.circleRadius;
+
+        feature.set("FILLCOLOR", fillColor ? fillColor : "#006688");
+        feature.set("STROKECOLOR", polygonStrokeColor ? polygonStrokeColor : "#006688");
+        feature.set("STROKEWIDTH", polygonStrokeWidth ? polygonStrokeWidth : 1);
+        feature.set("OPACITY", polygonFillColor ? polygonFillColor[3] : 1);
+        feature.set("CIRCLESIZE", size ? size : 20);
+    }
 }
 
 /**

package/src/vectorStyle/createStyle.js

@@ -6,8 +6,7 @@ import LineStringStyle from "./styles/styleLine";
 import CesiumStyle from "./styles/styleCesium";
 import {getRuleForIndex, getRulesForFeature} from "./lib/getRuleForIndex";
 
-const legendsOfAllStyles = [],
-    uniqueStyles = [];
+const legendsOfAllStyles = [];
 let legendInformationLength = 0;
 
 /**
@@ -30,17 +29,13 @@ function isMultiGeometry (geometryType) {
  */
 function getSimpleGeometryStyle (geometryType, feature, rule, isClustered, wfsImgPathFromConfig) {
     const style = rule?.style,
-        legendValue = style ? style.legendValue : null,
-        alreadyExisitingStyle = uniqueStyles.find(element => element.featureStyle === style && element.geometryType === geometryType);
+        legendValue = style ? style.legendValue : null;
     let styleObject,
         styleObjectForLegend = null;
 
     feature.legendValue = legendValue ? legendValue : null;
 
-    if (alreadyExisitingStyle) {
-        styleObject = alreadyExisitingStyle.featureStyleObject;
-    }
-    else if (geometryType === "Point") {
+    if (geometryType === "Point") {
         styleObject = new PointStyle(feature, style, isClustered);
         if (isClustered) {
             styleObjectForLegend = new PointStyle(feature, style, false);
@@ -78,7 +73,6 @@ function getSimpleGeometryStyle (geometryType, feature, rule, isClustered, wfsIm
         styleObjectForLegend.initialize(feature, style, false, wfsImgPathFromConfig);
         styleObjectForLegend.legendValue = legendValue;
     }
-    uniqueStyles.push({featureStyle: style, featureStyleObject: styleObject, geometryType});
     styleObject.initialize(feature, style, isClustered, wfsImgPathFromConfig);
     styleObject.addLegendInfo(geometryType, styleObjectForLegend === null ? styleObject : styleObjectForLegend, rule);
     styleObject.legendValue = legendValue;
@@ -122,6 +116,7 @@ function getMultiGeometryStyle (geometryType, feature, rules, isClustered, wfsIm
                 console.warn("Multi encapsulated multiGeometries are not supported.");
             }
             else if (!simpleStyle.styleMultiGeomOnlyWithRule || rule) {
+                simpleStyle.getStyle()?.setGeometry(geometry);
                 olStyle.push(simpleStyle);
             }
         });
@@ -136,7 +131,7 @@ function getMultiGeometryStyle (geometryType, feature, rules, isClustered, wfsIm
     else {
         const simpleStyle = getSimpleGeometryStyle(geometryType, feature, rules, isClustered, wfsImgPathFromConfig);
 
-        simpleStyle.getStyle().setGeometry(geometryType);
+        simpleStyle.getStyle()?.setGeometry(geometryType);
         olStyle.push(simpleStyle);
     }
     return olStyle;
@@ -227,10 +222,22 @@ function createStyle (styleObject, feature, isClustered, wfsImgPathFromConfig) {
         style = Array.isArray(rules) && rules.length > 0 ? rules[0].style : null,
         hasLabelField = style?.labelField,
         geometryStyle = getGeometryStyle(feature, rules, isClustered, wfsImgPathFromConfig),
-        legendInformation = Array.isArray(geometryStyle) ? geometryStyle[0].legendInfos : geometryStyle.legendInfos,
-        styleObjectGeometry = Array.isArray(geometryStyle) ? geometryStyle.map(styleItem => styleItem.getStyle()) : geometryStyle.getStyle();
+        legendInformation = Array.isArray(geometryStyle) ? geometryStyle[0].legendInfos : geometryStyle.legendInfos;
+    let styleObjectGeometry = null;
+
+    if (Array.isArray(geometryStyle)) {
+        styleObjectGeometry = [];
+        geometryStyle.forEach(styleItem => {
+            if (styleItem.getStyle() !== null) {
+                styleObjectGeometry.push(styleItem.getStyle());
+            }
+        });
+    }
+    else {
+        styleObjectGeometry = geometryStyle.getStyle();
+    }
 
-    if (geometryStyle.length > 1) {
+    if (Array.isArray(geometryStyle) && geometryStyle.length > 1) {
         for (const i in geometryStyle) {
             captureLegendFromFeature(styleObject.styleId, geometryStyle[i].legendInfos);
         }
@@ -238,9 +245,8 @@ function createStyle (styleObject, feature, isClustered, wfsImgPathFromConfig) {
     else {
         captureLegendFromFeature(styleObject.styleId, legendInformation);
     }
-
     // label style is optional and depends on some fields
-    if (isClustered || hasLabelField) {
+    if (styleObjectGeometry !== null && (isClustered || hasLabelField)) {
         if (Array.isArray(styleObjectGeometry)) {
             styleObjectGeometry[0].setText(getLabelStyle(feature, style, isClustered));
         }

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

@@ -38,14 +38,14 @@ class PointStyle extends StyleClass {
         this.setFeature(feature);
         this.setIsClustered(isClustered);
         this.overwriteStyling(styles);
-        this.setStyle(this.getStyle());
+        this.setStyle(this.createStyle());
     }
 
     /**
      * This function returns a style for each feature.
      * @returns {ol/style} - The created style.
      */
-    getStyle () {
+    createStyle () {
         if (this.nullStyle) {
             return null;
         }

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

@@ -28,14 +28,14 @@ class PolygonStyle extends StyleClass {
         this.setFeature(feature);
         this.setIsClustered(isClustered);
         this.overwriteStyling(styles);
-        this.setStyle(this.getStyle());
+        this.setStyle(this.createStyle());
     }
 
     /**
      * This function returns a style for each feature.
      * @returns {ol/style} - The created style.
      */
-    getStyle () {
+    createStyle () {
         if (this.nullStyle) {
             return null;
         }

package/src/vectorStyle/styles/style.js

@@ -35,6 +35,14 @@ class StyleClass {
         this.style = value;
     }
 
+    /**
+     * Getter for style.
+     * @returns {ol/style} - The style.
+     */
+    getStyle () {
+        return this.style;
+    }
+
     /*
      * setter for styles
      * @param {object} styles styles

package/src/vectorStyle/styles/styleCesium.js

@@ -22,14 +22,14 @@ class CesiumStyle extends StyleClass {
     initialize (rule) {
         this.overwriteStyling(rule.style);
         this.setConditions(rule.conditions);
-        this.setStyle(this.getStyle());
+        this.setStyle(this.createStyle());
     }
 
     /**
      * This function returns a style for each feature.
      * @returns {ol/style} - The created style.
      */
-    getStyle () {
+    createStyle () {
         return this.createCondition(this.get("conditions"), this.get("style"));
     }
 

package/src/vectorStyle/styles/styleLine.js

@@ -26,14 +26,14 @@ class LineStringStyle extends StyleClass {
         this.setFeature(feature);
         this.setIsClustered(isClustered);
         this.overwriteStyling(styles);
-        this.setStyle(this.getStyle());
+        this.setStyle(this.createStyle());
     }
 
     /**
      * This function returns a style for each feature.
      * @returns {ol/style/Style} - The created style.
      */
-    getStyle () {
+    createStyle () {
         if (this.nullStyle) {
             return null;
         }

package/src/vectorStyle/styles/styleText.js

@@ -28,14 +28,14 @@ class TextStyle extends StyleClass {
         this.setFeature(feature);
         this.setIsClustered(isClustered);
         this.overwriteStyling(styles);
-        this.setStyle(this.getStyle());
+        this.setStyle(this.createStyle());
     }
 
     /**
     * This function returns a style for each feature.
     * @returns {ol/style} - The created style.
     */
-    getStyle () {
+    createStyle () {
         if (this.nullStyle) {
             return null;
         }

package/test/layer/wfs.test.js

@@ -414,5 +414,57 @@ describe("wfs.js", function () {
             expect(webgl.afterLoading).toHaveBeenCalled();
         });
     });
+    describe("loadFeaturesManually", function () {
+        const consoleError = console.error;
+        let tick;
+
+        beforeEach(() => {
+            tick = () => {
+                return new Promise(resolve => {
+                    setTimeout(resolve, 0);
+                });
+            };
+
+            if (global.fetch) {
+                global.fetch.mockClear();
+            }
+        });
+        // to reset show error on load in console
+        afterEach(() => {
+            console.error = consoleError;
+        });
+
+        it("load features manually", async function () {
+            global.fetch = jest.fn().mockImplementationOnce(() => {
+                return new Promise((resolve) => {
+                    resolve({
+                        ok: true,
+                        status: 200,
+                        text: () => {
+                            return featureCollection;
+                        }
+                    });
+                });
+            });
+
+            const format = new WFS(),
+                source = new VectorSource({
+                    format: format,
+                    url: "https://url.de",
+                    version: "1.1.0",
+                    featureType: "krankenhaeuser_hh",
+                    featureNS: "http://www.deegree.org/app"
+                }),
+                layerAttributes = {
+                    crs: "EPSG:25832",
+                    version: "1.1.0",
+                    url: "https://url.de"
+                };
+
+            wfs.loadFeaturesManually(layerAttributes, source);
+            await tick();
+            expect(source.getFeatures()).toHaveLength(1);
+        });
+    });
 });
 

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

@@ -0,0 +1,50 @@
+import {Draw} from "ol/interaction.js";
+import VectorSource from "ol/source/Vector";
+
+import drawInteractions from "../../../src/maps/interactions/drawInteractions";
+
+describe("src/maps/interactions/drawInteractions.js", () => {
+    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);
+        });
+    });
+
+    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);
+        });
+    });
+});

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/createStyle.test.js

@@ -239,6 +239,129 @@ describe("createStyle", () => {
 
         expect(style).toBeInstanceOf(Style);
     });
+
+    it("should return the correct style for a feature with geometry of type MultiLineString ", () => {
+        const stylingRules = [{
+                "conditions": {
+                    "sequence": [0, 0]
+                },
+                "style": {
+                    "lineStrokeColor": [0, 41, 255, 1],
+                    "lineStrokeDash": [10, 2000],
+                    "lineStrokeDashOffset": 0,
+                    "lineStrokeWidth": 4
+                }
+            }],
+            styleObject = {styleId: "styleId", styleMultiGeomOnlyWithRule: true, rules: stylingRules},
+            isClustered = false,
+            multiLineStringFeature = jsonObjects[4],
+            style = createStyle.createStyle(styleObject, multiLineStringFeature, isClustered, wfsImgPathFromConfig);
+
+        expect(style === null).toBe(false);
+        expect(style).toBeInstanceOf(Array);
+        style.forEach(aStyle => {
+            expect(aStyle).toBeInstanceOf(Style);
+        });
+    });
+
+    it("should return the correct style for a feature with geometry of type MultiPolygon ", () => {
+        const stylingRules = [{
+                "conditions": {
+                    "sequence": [0, 0]
+                },
+                "style": {
+                    "polygonStrokeColor": [
+                        161,
+                        113,
+                        14,
+                        1
+                    ],
+                    "polygonStrokeWidth": 0.2,
+                    "polygonFillColor": [
+                        161,
+                        113,
+                        14,
+                        1
+                    ]
+                }
+            }],
+            styleObject = {styleId: "styleId", styleMultiGeomOnlyWithRule: true, rules: stylingRules},
+            isClustered = false,
+            multiPolygonFeature = jsonObjects[5],
+            style = createStyle.createStyle(styleObject, multiPolygonFeature, isClustered, wfsImgPathFromConfig);
+
+        expect(style === null).toBe(false);
+        expect(style).toBeInstanceOf(Array);
+        style.forEach(aStyle => {
+            expect(aStyle).toBeInstanceOf(Style);
+        });
+    });
+
+    it("should return the correct style for a feature with geometry of type GeometryCollection ", () => {
+        const stylingRules = [{
+                "conditions": {
+                    "sequence": [0, 0]
+                },
+                "style": {
+                    "polygonStrokeColor": [
+                        161,
+                        113,
+                        14,
+                        1
+                    ],
+                    "polygonStrokeWidth": 0.2,
+                    "polygonFillColor": [
+                        161,
+                        113,
+                        14,
+                        1
+                    ]
+                }
+            }],
+            styleObject = {styleId: "styleId", styleMultiGeomOnlyWithRule: true, rules: stylingRules},
+            isClustered = false,
+            geometryCollectionFeature = jsonObjects[6],
+            style = createStyle.createStyle(styleObject, geometryCollectionFeature, isClustered, wfsImgPathFromConfig);
+
+        expect(style === null).toBe(false);
+        expect(style).toBeInstanceOf(Array);
+        style.forEach(aStyle => {
+            expect(aStyle).toBeInstanceOf(Style);
+        });
+    });
+
+    it("should return the correct style for a feature with geometry of type MultiPoint ", () => {
+        const stylingRules = [{
+                "conditions": {
+                    "sequence": [0, 0]
+                },
+                "style": {
+                    "circleRadius": 6,
+                    "circleStrokeColor": [
+                        24,
+                        116,
+                        205,
+                        1
+                    ],
+                    "circleFillColor": [
+                        135,
+                        206,
+                        250,
+                        1
+                    ]
+                }
+            }],
+            styleObject = {styleId: "styleId", styleMultiGeomOnlyWithRule: true, rules: stylingRules},
+            isClustered = false,
+            multiPointFeature = jsonObjects[3],
+            style = createStyle.createStyle(styleObject, multiPointFeature, isClustered, wfsImgPathFromConfig);
+
+        expect(style === null).toBe(false);
+        expect(style).toBeInstanceOf(Array);
+        style.forEach(aStyle => {
+            expect(aStyle).toBeInstanceOf(Style);
+        });
+    });
 });
 
 describe("getSimpleGeometryStyle", function () {

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);