@masterportal/masterportalapi 2.13.0 → 2.14.0

package/test/vectorStyle/lib/valueOperations.test.js

@@ -0,0 +1,191 @@
+import {getValueWithoutComma, getReferenceValue, compareValues, checkProperty, checkProperties} from "../../../src/vectorStyle/lib/valueOperations";
+import {GeoJSON} from "ol/format.js";
+
+
+const geojsonReader = new GeoJSON(),
+    jsonFeatures = {
+        "type": "FeatureCollection",
+        "features": [
+            {
+                "type": "Feature",
+                "geometry": {
+                    "type": "Point",
+                    "coordinates": [10.082125662581083, 53.518872973925404]
+                },
+                "properties": {
+                    "id": "test1",
+                    "name": "myName",
+                    "value": 50,
+                    "min": 10,
+                    "max": 100,
+                    "myObj": {
+                        "myCascade": 10,
+                        "myArray": [
+                            {
+                                "myValue": 20
+                            }
+                        ]
+                    }
+                }
+            },
+            {
+                "type": "Feature",
+                "geometry": {
+                    "type": "LineString",
+                    "coordinates": [[10.082125662581083, 53.518872973925404], [11.01, 53.6]]
+                },
+                "properties": {
+                    "id": "test2",
+                    "value": 50,
+                    "min": 10,
+                    "max": 100
+                }
+            }
+        ]
+    },
+    rules = [
+        {
+            "conditions": {
+                "properties": {
+                    "id": "test1"
+                },
+                "sequence": [1, 1]
+            },
+            "style": {
+                "polygonStrokeColor": [100, 0, 0, 1],
+                "labelField": "name"
+            }
+        },
+        {
+            "conditions": {
+                "properties": {
+                    "id": "test1"
+                }
+            },
+            "style": {
+                "polygonStrokeColor": [100, 100, 0, 1]
+            }
+        },
+        {
+            "style": {
+                "polygonStrokeColor": [100, 100, 100, 1]
+            }
+        }
+    ];
+
+let jsonObjects;
+
+
+beforeAll(function () {
+    jsonObjects = geojsonReader.readFeatures(jsonFeatures);
+});
+
+
+describe("getValueWithoutComma", function () {
+    it("should return original value", function () {
+        expect(getValueWithoutComma("22")).toEqual("22");
+        expect(getValueWithoutComma("test")).toEqual("test");
+    });
+    it("should return the value without comma", function () {
+        expect(getValueWithoutComma("22,6")).toEqual(22.6);
+        expect(getValueWithoutComma("22,667")).toEqual(22.667);
+    });
+});
+
+describe("getReferenceValue", function () {
+    it("should return plain reference value", function () {
+        expect(getReferenceValue(jsonObjects[0].getProperties(), "test1")).toEqual("test1");
+    });
+    it("should return reference value in object path", function () {
+        expect(getReferenceValue(jsonObjects[0].getProperties(), "@id")).toEqual("test1");
+    });
+    it("should return array of reference values", function () {
+        expect(Array.isArray(getReferenceValue(jsonObjects[0].getProperties(), [0, 50]))).toBe(true);
+        expect(getReferenceValue(jsonObjects[0].getProperties(), [0, 50])).toEqual([0, 50]);
+    });
+    it("should return array of reference values in object path", function () {
+        expect(Array.isArray(getReferenceValue(jsonObjects[0].getProperties(), ["@min", "@max"]))).toBe(true);
+        expect(getReferenceValue(jsonObjects[0].getProperties(), ["@min", "@max"])).toEqual([10, 100]);
+    });
+});
+
+describe("compareValues", function () {
+    it("should return true if values are the same", function () {
+        expect(compareValues("test", "test")).toBe(true);
+    });
+    it("should return true if boolean values are same", function () {
+        expect(compareValues(true, true)).toBe(true);
+    });
+    it("should return false if boolean values are different", function () {
+        expect(compareValues(true, false)).toBe(false);
+    });
+    it("should return true if values are the same but of different type", function () {
+        expect(compareValues("20", 20)).toBe(true);
+        expect(compareValues("20.0", 20)).toBe(true);
+    });
+    it("should return false if values cannot be parsed to same type", function () {
+        expect(compareValues("abc", 20)).toBe(false);
+    });
+    it("should return false if reference value is an invalid array", function () {
+        expect(compareValues(1, [0])).toBe(false);
+        expect(compareValues(1, [0, 1, 2])).toBe(false);
+        expect(compareValues(1, [0, 1, 2, 4, 5])).toBe(false);
+        expect(compareValues(1, ["0", 1])).toBe(false);
+        expect(compareValues(1, ["0", 1, 2, 3])).toBe(false);
+    });
+    it("should return false if feature value cannot be parsed to float and reference value is an array", function () {
+        expect(compareValues("abc", [0, 1, 2, 3])).toBe(false);
+    });
+    it("should return true if feature value is in range of reference values", function () {
+        expect(compareValues(20, [20, 25])).toBe(true);
+        expect(compareValues(21, [20, 25])).toBe(true);
+    });
+    it("should return false if feature value is not in range of reference values", function () {
+        expect(compareValues(19, [20, 25])).toBe(false);
+        expect(compareValues(25, [20, 25])).toBe(false);
+    });
+    it("should return true if feature value is in range of reference values defined by range", function () {
+        expect(compareValues(15, [0, 50, 10, 100])).toBe(true);
+    });
+    it("should return false if feature value is not in range of reference values defined by range", function () {
+        expect(compareValues(9, [0, 50, 10, 100])).toBe(false);
+    });
+});
+
+describe("checkProperty", function () {
+    it("should return true for fitting property", function () {
+        expect(checkProperty(jsonObjects[0].getProperties(), "id", "test1")).toBe(true);
+    });
+    it("should return false for non-fitting property", function () {
+        expect(checkProperty(jsonObjects[0].getProperties(), "id", "invalidId")).toBe(false);
+    });
+    it("should return false for invalid key / value", function () {
+        expect(checkProperty(jsonObjects[0].getProperties(), null, "test1")).toBe(false);
+        expect(checkProperty(jsonObjects[0].getProperties(), "id", null)).toBe(false);
+        expect(checkProperty(jsonObjects[0].getProperties(), "id", [0])).toBe(false);
+        expect(checkProperty(jsonObjects[0].getProperties(), "id", [0, 1, 2])).toBe(false);
+    });
+    it("should return true for a clustered feature", function () {
+        const clusterFeatureProperties = {
+            features: [jsonObjects[0]],
+            geometry: jsonObjects[0].getGeometry()
+        };
+
+        expect(checkProperty(clusterFeatureProperties, "id", "test1")).toBe(true);
+    });
+});
+
+describe("checkProperties", function () {
+    it("should return true for rule that fits all properties even with sequences", function () {
+        expect(checkProperties(jsonObjects[0], rules[0])).toBe(true);
+    });
+    it("should return true for rule that fits all properties without sequences", function () {
+        expect(checkProperties(jsonObjects[0], rules[1])).toBe(true);
+    });
+    it("should return true for rule that has no properties", function () {
+        expect(checkProperties(jsonObjects[0], rules[2])).toBe(true);
+    });
+    it("should return false for rule that has not fitting properties", function () {
+        expect(checkProperties(jsonObjects[1], rules[1])).toBe(false);
+    });
+});

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

@@ -0,0 +1,28 @@
+import PointStyle from "../../../../src/vectorStyle/styles/point/stylePoint";
+import {Style} from "ol/style.js";
+
+describe("stylePoint", () => {
+    const feature = {
+            geometryName: "geom",
+            id: "DE.HH.UP_GESUNDHEIT_KRANKENHAEUSER_2"
+        },
+        style = {
+            type: "icon",
+            clusterType: "icon",
+            legendValue: "Krankenhaus",
+            imageName: "krankenhaus.png"
+        },
+        isClustered = false,
+        stylePointClass = new PointStyle(feature, style, isClustered);
+
+    describe("setSize", function () {
+        it("defines setSize()", () => {
+            expect(typeof stylePointClass.setSize).toBe("function");
+        });
+    });
+    describe("getStyle", function () {
+        it("returns an instance of openlayers style", () => {
+            expect(stylePointClass.getStyle()).toBeInstanceOf(Style);
+        });
+    });
+});

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

@@ -0,0 +1,30 @@
+import * as stylePointCircle from "../../../../src/vectorStyle/styles/point/stylePointCircle";
+import {Style, Circle} from "ol/style.js";
+
+describe("stylePointCircle.js", () => {
+    describe("createCircleStyle", () => {
+        const attributes = {
+                circleRadius: 15,
+                circleFillColor: [10, 200, 100, 0.5],
+                circleStrokeColor: [10, 200, 100, 0.5],
+                circleStrokeWidth: 1
+            },
+            clusterAttributes = {
+                clusterCircleRadius: 20,
+                clusterCircleFillColor: [10, 200, 100, 0.5],
+                clusterCircleStrokeColor: [10, 200, 100, 0.5],
+                clusterCircleStrokeWidth: 1
+            };
+
+        it("should create circle style", () => {
+            expect(stylePointCircle.createCircleStyle(attributes, false)).toBeInstanceOf(Style);
+            expect(stylePointCircle.createCircleStyle(attributes, false).getImage()).toBeInstanceOf(Circle);
+            expect(stylePointCircle.createCircleStyle(attributes, false).getImage().getRadius()).toEqual(15);
+        });
+        it("should create circle cluster style", () => {
+            expect(stylePointCircle.createCircleStyle(clusterAttributes, true)).toBeInstanceOf(Style);
+            expect(stylePointCircle.createCircleStyle(clusterAttributes, true).getImage()).toBeInstanceOf(Circle);
+            expect(stylePointCircle.createCircleStyle(clusterAttributes, true).getImage().getRadius()).toEqual(20);
+        });
+    });
+});

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

@@ -0,0 +1,83 @@
+import * as stylePointIcon from "../../../../src/vectorStyle/styles/point/stylePointIcon";
+import {Style, Icon} from "ol/style.js";
+
+describe("stylePointIcon.js", () => {
+    describe("getRotationValue", function () {
+        it("should return correct rotation value", function () {
+            expect(stylePointIcon.getRotationValue({isDegree: true, value: "90"})).toEqual(1.5707963267948966);
+            expect(stylePointIcon.getRotationValue({isDegree: false, value: "10"})).toEqual(10);
+            expect(stylePointIcon.getRotationValue()).toEqual(0);
+        });
+        it("should return correct rotation value from an object path", function () {
+            const featureValues = {
+                geometryName: "geom",
+                id: "DE.HH.UP_GESUNDHEIT_KRANKENHAEUSER_2",
+                angle: 45
+            };
+
+            expect(stylePointIcon.getRotationValue({isDegree: false, value: "@angle"}, featureValues)).toEqual(45);
+        });
+    });
+    describe("createIconStyle", () => {
+        const attributes = {
+                imagePath: "/imagePath",
+                imageName: "bild.svg",
+                imageWidth: 10,
+                imageHeight: 20,
+                imageScale: 1,
+                imageOffsetX: 0,
+                imageOffsetY: 0,
+                imageOffsetXUnit: "px",
+                imageOffsetYUnit: "px",
+                rotation: 0
+            },
+            clusterAttributes = {
+                clusterImageName: "bild.svg",
+                clusterImageWidth: 10,
+                clusterImagePath: "/imagePath",
+                clusterImageHeight: 20,
+                clusterImageScale: 1
+            },
+            feature = {
+                getProperties: () => {
+                    return {
+                        name: "singleFeature",
+                        id: "123"
+                    };
+                }
+            },
+            clusteredFeature = {
+                get: () => {
+                    return [
+                        {
+                            name: "singleFeature1",
+                            id: "123"
+                        },
+                        {
+                            name: "singleFeature2",
+                            id: "456"
+                        }
+                    ];
+                }
+            };
+
+        it("should create icon point style", () => {
+            expect(stylePointIcon.createIconStyle(attributes, feature, false)).toBeInstanceOf(Style);
+            expect(stylePointIcon.createIconStyle(clusterAttributes, clusteredFeature, true)).toBeInstanceOf(Style);
+            expect(stylePointIcon.createIconStyle(attributes, feature, false).getImage()).toBeInstanceOf(Icon);
+            expect(stylePointIcon.createIconStyle(attributes, feature, false).getImage().getScale()).toEqual(1);
+        });
+        it("should create cluster icon point style", () => {
+            expect(stylePointIcon.createIconStyle(clusterAttributes, clusteredFeature, true)).toBeInstanceOf(Style);
+            expect(stylePointIcon.createIconStyle(clusterAttributes, clusteredFeature, true).getImage()).toBeInstanceOf(Icon);
+        });
+    });
+
+    describe("createSVGStyle", function () {
+        it("should create icon point style", function () {
+            expect(stylePointIcon.createSVGStyle("test")).toBeInstanceOf(Style);
+            expect(stylePointIcon.createSVGStyle("test").getImage()).toBeInstanceOf(Icon);
+            expect(stylePointIcon.createSVGStyle("test").getImage().getSrc()).toEqual("data:image/svg+xml;charset=utf-8,test");
+        });
+    });
+});

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

@@ -0,0 +1,57 @@
+import * as stylePointInterval from "../../../../src/vectorStyle/styles/point/stylePointInterval";
+
+describe("stylePointInterval.js", () => {
+    describe("calculateSizeIntervalCircleBar", function () {
+        it("should be 10 at large circleBarRadius and small values input", function () {
+            expect(typeof stylePointInterval.calculateSizeIntervalCircleBar(5, 1, 3, 5)).toBe("number");
+            expect(stylePointInterval.calculateSizeIntervalCircleBar(5, 1, 3, 5)).toEqual(10);
+        });
+        it("should be 20 at large circleBarRadius and large values input", function () {
+            expect(typeof stylePointInterval.calculateSizeIntervalCircleBar(5, 2, 10, 5)).toBe("number");
+            expect(stylePointInterval.calculateSizeIntervalCircleBar(5, 2, 10, 5)).toEqual(30);
+        });
+        it("should be 10 at large circleBarRadius and stateValue is NaN input", function () {
+            expect(typeof stylePointInterval.calculateSizeIntervalCircleBar(NaN, 2, 10, 5)).toBe("number");
+            expect(stylePointInterval.calculateSizeIntervalCircleBar(NaN, 2, 10, 5)).toEqual(10);
+        });
+    });
+    describe("calculateLengthIntervalCircleBar", function () {
+        it("should be 1 for positive stateValue input", function () {
+            expect(typeof stylePointInterval.calculateLengthIntervalCircleBar(10, 1, 3, 1)).toBe("number");
+            expect(stylePointInterval.calculateLengthIntervalCircleBar(10, 1, 3, 1)).toEqual(1);
+        });
+        it("should be 12 fop negative stateValue input", function () {
+            expect(typeof stylePointInterval.calculateLengthIntervalCircleBar(10, 2, -1, 5)).toBe("number");
+            expect(stylePointInterval.calculateLengthIntervalCircleBar(10, 2, -1, 5)).toEqual(12);
+        });
+        it("should be 0 for stateValue is NaN input", function () {
+            expect(typeof stylePointInterval.calculateLengthIntervalCircleBar(10, 2, NaN, 5)).toBe("number");
+            expect(stylePointInterval.calculateLengthIntervalCircleBar(10, 2, NaN, 5)).toEqual(0);
+        });
+        it("should be 0 for stateValue is undefined input", function () {
+            expect(typeof stylePointInterval.calculateLengthIntervalCircleBar(10, 2, undefined, 5)).toBe("number");
+            expect(stylePointInterval.calculateLengthIntervalCircleBar(10, 2, undefined, 5)).toEqual(0);
+        });
+    });
+    describe("createIntervalCircleBar", function () {
+        const attributes = {
+                circleBarScalingFactor: 1,
+                circleBarRadius: 10,
+                circleBarLineStroke: [10, 200, 100, 0.5],
+                circleBarCircleFillColor: [10, 200, 100, 0.5],
+                circleBarCircleStrokeColor: [10, 200, 100, 0.5],
+                circleBarCircleStrokeWidth: 1,
+                circleBarLineStrokeColor: [10, 200, 100, 0.5],
+                scalingAttribute: ""
+            },
+            feature = {
+                getProperties: () => {
+                    return {id: 1, name: "test"};
+                }};
+
+        it("should be an svg by default values input", function () {
+            expect(stylePointInterval.createIntervalCircleBar(feature, attributes))
+                .toEqual("<svg width='20' height='20' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink'><line x1='10' y1='10' x2='10' y2='0' stroke='#0ac864' stroke-width='10' /><circle cx='10' cy='10' r='10' stroke='#0ac864' stroke-width='1' fill='#0ac864' /></svg>");
+        });
+    });
+});

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

@@ -0,0 +1,84 @@
+import * as stylePointNominal from "../../../../src/vectorStyle/styles/point/stylePointNominal";
+
+describe("stylePointNominal.js", () => {
+    describe("fillScalingAttributes", function () {
+        it("should return an object with empty = 0 for undefined input", function () {
+            expect(typeof stylePointNominal.fillScalingAttributes(undefined, undefined)).toBe("object");
+            expect(stylePointNominal.fillScalingAttributes(undefined, undefined)).toEqual({"empty": 0});
+        });
+        it("should return an object with empty = 0 for empty input", function () {
+            expect(typeof stylePointNominal.fillScalingAttributes({})).toBe("object");
+            expect(stylePointNominal.fillScalingAttributes({empty: 0})).toEqual({"empty": 0});
+        });
+        it("should return an object with empty = 1 for object with empty: 0 and false string input", function () {
+            expect(typeof stylePointNominal.fillScalingAttributes({empty: 0}, "test")).toBe("object");
+            expect(stylePointNominal.fillScalingAttributes({empty: 0}, "test")).toEqual({"empty": 1});
+        });
+        it("should return an object with empty = 0 for undefined input two", function () {
+            const scalingAttributesAsObject = {
+                    available: 0,
+                    charging: 0,
+                    outoforder: 0,
+                    empty: 0
+                },
+                scalingAttribute = "available";
+
+            expect(typeof stylePointNominal.fillScalingAttributes(scalingAttributesAsObject, scalingAttribute)).toBe("object");
+            expect(stylePointNominal.fillScalingAttributes(scalingAttributesAsObject, scalingAttribute))
+                .toEqual({"available": 2, "charging": 0, "outoforder": 0, "empty": 0});
+        });
+    });
+
+    describe("getScalingAttributesAsObject", function () {
+        it("should return an object with empty = 0 for undefined input", function () {
+            expect(typeof stylePointNominal.getScalingAttributesAsObject(undefined)).toBe("object");
+            expect(stylePointNominal.getScalingAttributesAsObject(undefined)).toEqual({"empty": 0});
+        });
+        it("should return an object with empty = 0 for empty input", function () {
+            expect(typeof stylePointNominal.getScalingAttributesAsObject({})).toBe("object");
+            expect(stylePointNominal.getScalingAttributesAsObject({})).toEqual({"empty": 0});
+        });
+        it("should return an object with available = 0 and empty = 0 for correct input", function () {
+            expect(typeof stylePointNominal.getScalingAttributesAsObject({available: [0, 220, 0, 0]})).toBe("object");
+            expect(stylePointNominal.getScalingAttributesAsObject({available: [0, 220, 0, 0]})).toEqual({available: 0, "empty": 0});
+        });
+    });
+
+    describe("calculateCircleSegment", function () {
+        it("should return a string that contains a circlesegment as svg-string for data of a semicircle input", function () {
+            const startAngelDegree = 0,
+                endAngelDegree = 180,
+                circleRadius = 21,
+                size = 58,
+                gap = 10;
+
+            expect(typeof stylePointNominal.calculateCircleSegment(startAngelDegree, endAngelDegree, circleRadius, size, gap)).toBe("string");
+            expect(stylePointNominal.calculateCircleSegment(startAngelDegree, endAngelDegree, circleRadius, size, gap))
+                .toEqual("M 49.920088659926655 27.16972940229918 A 21 21 0 0 0 8.079911340073345 27.16972940229918");
+
+            expect(typeof stylePointNominal.calculateCircleSegment(0, 360, circleRadius, size, gap)).toBe("string");
+            expect(stylePointNominal.calculateCircleSegment(0, 360, circleRadius, size, gap))
+                .toEqual("M 50 29 A 21 21 0 0 0 8 28.999999999999996 A 21 21 0 0 0 50 29");
+        });
+    });
+
+    describe("createNominalCircleSegments", function () {
+        const attributes = {
+                circleSegmentsRadius: 1,
+                circleSegmentsStrokeWidth: 10,
+                circleSegmentsBackgroundColor: [10, 200, 100, 0.5],
+                scalingValueDefaultColor: [10, 200, 100, 0.5],
+                circleSegmentsGap: 10,
+                scalingValues: 1
+            },
+            feature = {
+                get: () => {
+                    return undefined;
+                }};
+
+        it("should be an svg by default values input", function () {
+            expect(stylePointNominal.createNominalCircleSegments(feature, attributes))
+                .toEqual("<svg width='32' height='32' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink'><circle cx='16' cy='16' r='1' stroke='#0ac864' stroke-width='10' fill='#0ac864' fill-opacity='0.5'/></svg>");
+        });
+    });
+});

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

@@ -0,0 +1,24 @@
+import {createRegularShapeStyle} from "../../../../src/vectorStyle/styles/point/stylePointRegularShape";
+import {Style, RegularShape} from "ol/style.js";
+
+describe("createRegularShapeStyle", function () {
+    it("should create RegularShape style", function () {
+        const attributes = {
+            rsRadius: 10,
+            rsRadius2: 10,
+            rsPoints: 3,
+            rsAngle: 10,
+            rotation: 0,
+            rsScale: 1,
+            rsFillColor: [10, 200, 100, 0.5],
+            rsStrokeColor: [10, 200, 100],
+            rsStrokeWidth: 5
+        };
+
+        expect(createRegularShapeStyle(attributes)).toBeInstanceOf(Style);
+        expect(createRegularShapeStyle(attributes).getImage()).toBeInstanceOf(RegularShape);
+        expect(createRegularShapeStyle(attributes).getImage().getRadius()).toEqual(10);
+        expect(createRegularShapeStyle(attributes).getImage().getPoints()).toEqual(3);
+        expect(createRegularShapeStyle(attributes).getImage().getAngle()).toEqual(10);
+    });
+});

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

@@ -0,0 +1,95 @@
+import {drawHatch} from "../../../../src/vectorStyle/styles/polygon/polygonStyleHatch";
+
+describe("polygonStyleHatches", function () {
+    describe("drawHatch", function () {
+        let context = null;
+
+        beforeEach(function () {
+            context = {
+                stroke: jest.fn(),
+                translate: jest.fn(),
+                rotate: jest.fn(),
+                beginPath: jest.fn(),
+                rect: jest.fn(),
+                moveTo: jest.fn(),
+                lineTo: jest.fn(),
+                arc: jest.fn(),
+                lineWidth: 50
+            };
+            jest.spyOn(context, "translate");
+            jest.spyOn(context, "rotate");
+            jest.spyOn(context, "beginPath");
+            jest.spyOn(context, "rect");
+            jest.spyOn(context, "moveTo");
+            jest.spyOn(context, "lineTo");
+            jest.spyOn(context, "arc");
+        });
+
+        it("should draw patterns from known names to the context object", function () {
+            drawHatch(context, 100, "zig-line-horizontal");
+
+            expect(context.stroke).toHaveBeenCalledTimes(1);
+            expect(context.translate).toHaveBeenCalledTimes(2);
+            context.translate(50, 50);
+            expect(context.translate).toHaveBeenCalledWith(50, 50);
+            context.translate(-50, -50);
+            expect(context.translate).toHaveBeenCalledWith(-50, -50);
+            expect(context.rotate).toHaveBeenCalledTimes(1);
+            expect(context.rotate).toHaveBeenCalledWith(1.5707963267948966);
+            expect(context.beginPath).toHaveBeenCalledTimes(1);
+            expect(context.rect).toHaveBeenCalledTimes(0);
+            expect(context.moveTo).toHaveBeenCalledTimes(1);
+            expect(context.moveTo).toHaveBeenCalledWith(0, -25);
+            expect(context.lineTo).toHaveBeenCalledTimes(2);
+            expect(context.lineTo).toHaveBeenCalledWith(75, 50);
+            expect(context.lineTo).toHaveBeenCalledWith(0, 125);
+            expect(context.arc).toHaveBeenCalledTimes(0);
+        });
+
+        it("should draw patterns from custom definitions to the context object", function () {
+            drawHatch(context, 100, {
+                "draw": [
+                    {
+                        "type": "arc",
+                        "parameters": [
+                            0.5, 0.5, 7.5, -4.14, 1.14
+                        ]
+                    },
+                    {
+                        "type": "arc",
+                        "parameters": [
+                            0.55, 0.5, 7.5, -2, 1.14
+                        ]
+                    },
+                    {
+                        "type": "line",
+                        "parameters": [
+                            [0.66, 0.75],
+                            [1, 0.75]
+                        ]
+                    },
+                    {
+                        "type": "rect",
+                        "parameters": [
+                            [0, 0, 1, 1]
+                        ]
+                    }
+                ]
+            });
+
+            expect(context.stroke).toHaveBeenCalledTimes(4);
+            expect(context.translate).toHaveBeenCalledTimes(0);
+            expect(context.rotate).toHaveBeenCalledTimes(0);
+            expect(context.beginPath).toHaveBeenCalledTimes(4);
+            expect(context.rect).toHaveBeenCalledTimes(1);
+            expect(context.rect).toHaveBeenCalledWith(0, 0, 100, 100);
+            expect(context.moveTo).toHaveBeenCalledTimes(1);
+            expect(context.moveTo).toHaveBeenCalledWith(66, 75);
+            expect(context.lineTo).toHaveBeenCalledTimes(1);
+            expect(context.lineTo).toHaveBeenCalledWith(100, 75);
+            expect(context.arc).toHaveBeenCalledTimes(2);
+            expect(context.arc).toHaveBeenCalledWith(50, 50, 7.5, -4.14, 1.14, false);
+            expect(context.arc).toHaveBeenCalledWith(55.00000000000001, 50, 7.5, -2, 1.14, false);
+        });
+    });
+});

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

@@ -0,0 +1,61 @@
+import PolygonStyle from "../../../../src/vectorStyle/styles/polygon/stylePolygon";
+import {Style} from "ol/style.js";
+
+describe("stylePolygon", () => {
+    const feature = {
+            geometryName: "geom",
+            id: "DE.HH.UP_GESUNDHEIT_KRANKENHAEUSER_2"
+        },
+        style = {
+            type: "icon",
+            clusterType: "icon",
+            legendValue: "Krankenhaus",
+            imageName: "krankenhaus.png"
+        },
+        isClustered = false,
+        stylePolygonClass = new PolygonStyle(feature, style, isClustered);
+
+    describe("getStyle", function () {
+        it("returns an instance of openlayers style", () => {
+            expect(stylePolygonClass.getStyle()).toBeInstanceOf(Style);
+        });
+    });
+
+    describe("getPolygonFillHatch", () => {
+        it("should generate a polygon fill pattern with the given parameters", () => {
+            const params = {
+                    pattern: "diagonal",
+                    size: 30,
+                    lineWidth: 10,
+                    backgroundColor: [0, 0, 0, 1],
+                    patternColor: [255, 255, 255, 1]
+                },
+                canvas = stylePolygonClass.getPolygonFillHatch(params);
+
+            expect(canvas).toBeInstanceOf(HTMLCanvasElement);
+            expect(canvas.width).toEqual(30);
+            expect(canvas.height).toEqual(30);
+        });
+    });
+
+
+    describe("getPolygonFillHatchLegendDataUrl", () => {
+        it("should generate a legend data URL for the given style", () => {
+            const HatchStyle = {
+                    polygonFillHatch: {
+                        pattern: "diagonal",
+                        size: 30,
+                        lineWidth: 10,
+                        backgroundColor: [0, 0, 0, 1],
+                        patternColor: [255, 255, 255, 1]
+                    },
+                    polygonStrokeColor: [0, 0, 0, 1],
+                    polygonStrokeWidth: "2"
+                },
+                dataUrl = stylePolygonClass.getPolygonFillHatchLegendDataUrl(HatchStyle);
+
+            expect(dataUrl).toMatch(/^data:image\/png;base64,/);
+        });
+    });
+
+});