@masterportal/masterportalapi 2.13.0 → 2.15.0

package/test/lib/getValueFromObjectByPath.test.js

@@ -0,0 +1,61 @@
+import {getValueFromObjectByPath, getPathPartsFromPath} from "../../src/lib/getValueFromObjectByPath";
+
+describe("src/utils/getValueFromObjectByPath.js", () => {
+    describe("getPathPartsFromPath", () => {
+        it("should walk through the given string, collecting all parts seperated by a dot", () => {
+            const path = "first.second.third",
+                expected = ["first", "second", "third"];
+
+            expect(getPathPartsFromPath(path)).toEqual(expected);
+        });
+        it("should ignore escaped dots on the way, removing escape signs", () => {
+            const path = "first.sec\\.ond.third",
+                expected = ["first", "sec.ond", "third"];
+
+            expect(getPathPartsFromPath(path)).toEqual(expected);
+        });
+        it("should be able to escape escape signs", () => {
+            const path = "first.sec\\\\ond.third",
+                expected = ["first", "sec\\ond", "third"];
+
+            expect(getPathPartsFromPath(path)).toEqual(expected);
+        });
+    });
+    describe("getValueFromObjectByPath", () => {
+        it("should return undefined if anything but an object or array is given as first param", () => {
+            expect(getValueFromObjectByPath(undefined, "")).toBe(undefined);
+            expect(getValueFromObjectByPath(null, "")).toBe(undefined);
+            expect(getValueFromObjectByPath("string", "")).toBe(undefined);
+            expect(getValueFromObjectByPath(1234, "")).toBe(undefined);
+            expect(getValueFromObjectByPath(true, "")).toBe(undefined);
+            expect(getValueFromObjectByPath(false, "")).toBe(undefined);
+        });
+        it("should return undefined if anything but a string is given as second param", () => {
+            expect(getValueFromObjectByPath({}, undefined)).toBe(undefined);
+            expect(getValueFromObjectByPath({}, null)).toBe(undefined);
+            expect(getValueFromObjectByPath({}, 1234)).toBe(undefined);
+            expect(getValueFromObjectByPath({}, true)).toBe(undefined);
+            expect(getValueFromObjectByPath({}, false)).toBe(undefined);
+            expect(getValueFromObjectByPath({}, {})).toBe(undefined);
+            expect(getValueFromObjectByPath({}, [])).toBe(undefined);
+        });
+        it("should return undefined if the given depthBarrier is reached during walkthrough", () => {
+            expect(getValueFromObjectByPath({test: {test: 1}}, "@test.test", "@", ".", 1)).toBe(undefined);
+        });
+        it("should return undefined if the given path can't be followed through the given object", () => {
+            expect(getValueFromObjectByPath({}, "@test")).toBe(undefined);
+            expect(getValueFromObjectByPath({test: null}, "@test.test")).toBe(undefined);
+        });
+        it("should return the found value if the given path was successfully followed through the object", () => {
+            expect(getValueFromObjectByPath({test: 1}, "@test")).toEqual(1);
+            expect(getValueFromObjectByPath({test: {test: 1}}, "@test")).toEqual({test: 1});
+            expect(getValueFromObjectByPath({test: {test: {test: 1}}}, "@test.test")).toEqual({test: 1});
+        });
+        it("should be able to handle a path without prefix when no prefix is given", () => {
+            expect(getValueFromObjectByPath({test: 1}, "test", false)).toEqual(1);
+        });
+        it("should be able to handle a path with a complex prefix", () => {
+            expect(getValueFromObjectByPath({test: 1}, "1234test", "1234")).toEqual(1);
+        });
+    });
+});

package/test/lib/thousandsSeparator.test.js

@@ -0,0 +1,58 @@
+import thousandsSeparator from "../../src/lib/thousandsSeparator";
+
+describe("src/utils/thousandsSeparator.js", () => {
+    it("should return an empty string if the given param is not a number nor a string", () => {
+        expect(typeof thousandsSeparator(undefined)).toBe("string");
+        expect(thousandsSeparator(undefined)).toEqual("");
+        expect(typeof thousandsSeparator(null)).toBe("string");
+        expect(thousandsSeparator(null)).toEqual("");
+        expect(typeof thousandsSeparator([])).toBe("string");
+        expect(thousandsSeparator([])).toEqual("");
+        expect(typeof thousandsSeparator({})).toBe("string");
+        expect(thousandsSeparator({})).toEqual("");
+        expect(typeof thousandsSeparator(false)).toBe("string");
+        expect(thousandsSeparator(false)).toEqual("");
+        expect(typeof thousandsSeparator(true)).toBe("string");
+        expect(thousandsSeparator(true)).toEqual("");
+    });
+    it("should convert a number into a string", () => {
+        expect(typeof thousandsSeparator(1)).toBe("string");
+    });
+    it("should convert a negative number into a string", () => {
+        expect(typeof thousandsSeparator(-1)).toBe("string");
+    });
+    it("should return a string if a string was given", () => {
+        expect(typeof thousandsSeparator("1")).toBe("string");
+    });
+    it("should add the given letter(s) as thousands separator", () => {
+        expect(thousandsSeparator(1000, "delimAbs")).toEqual("1delimAbs000");
+    });
+    it("should add the given letter(s) as decimal point for positive value", () => {
+        expect(thousandsSeparator(1000.1, "delimAbs", "delimDec")).toEqual("1delimAbs000delimDec1");
+    });
+    it("should create a number in german format by default for positive value", () => {
+        expect(thousandsSeparator(1000.1)).toEqual("1.000,1");
+    });
+    it("should be able to add a higher number of thousands separators", () => {
+        expect(thousandsSeparator(1123456789.123456)).toEqual("1.123.456.789,123456");
+    });
+    it("should be able to add a higher number of thousands separators if a string was given", () => {
+        expect(thousandsSeparator("1123456789.123456")).toEqual("1.123.456.789,123456");
+    });
+    it("should add the given letter(s) as thousands seperator", () => {
+        expect(thousandsSeparator(-1000, "delimAbs")).toEqual("-1delimAbs000");
+    });
+    it("should add the given letter(s) as decimal point for negative value", () => {
+        expect(thousandsSeparator(-1000.1, "delimAbs", "delimDec")).toEqual("-1delimAbs000delimDec1");
+    });
+    it("should create a number in german format by default for negative value", () => {
+        expect(thousandsSeparator(-1000.1)).toEqual("-1.000,1");
+    });
+    it("should be able to add a higher number of thousands seperators", () => {
+        expect(thousandsSeparator(-1123456789.123456)).toEqual("-1.123.456.789,123456");
+    });
+    it("should be able to add a higher number of thousands seperators if a string was given", () => {
+        expect(thousandsSeparator("-1123456789.123456")).toEqual("-1.123.456.789,123456");
+    });
+});
+

package/test/renderer/webgl.test.js

@@ -0,0 +1,161 @@
+import VectorSource from "ol/source/Vector.js";
+import Feature from "ol/Feature";
+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", () => {
+    let layerParams, rawLayer, styleRule, styleObject;
+
+    beforeEach(() => {
+        layerParams = {
+            name: "webglTestLayer",
+            id: "123",
+            typ: "WFS",
+            renderer: "webgl",
+            styleId: "123"
+        };
+        rawLayer = {
+            url: "https://url.de",
+            name: "wfsSourceLayer",
+            id: "123",
+            typ: "WFS",
+            version: "2.0.0",
+            featureNS: "http://www.deegree.org/app",
+            featureType: "krankenhaeuser_hh",
+            outputFormat: "XML"
+        };
+        styleRule = {style: {
+            polygonFillColor: [255, 0, 0, 0.5],
+            polygonStrokeColor: [0, 255, 0, 0.5],
+            polygonStrokeWidth: 2,
+            circleFillColor: [0, 0, 255, 0.5],
+            circleRadius: 6
+        }};
+        styleObject = {
+            rules: [styleRule]
+        };
+
+        jest.spyOn(styleList, "returnStyleObject").mockImplementation(() => styleObject);
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    describe("createLayer", () => {
+        const source = new VectorSource();
+
+        it("should return a WebGLPointsLayer", () => {
+            layerParams.isPointLayer = true;
+            const webglLayer = webgl.createLayer({...rawLayer, ...layerParams, source});
+
+            expect(webglLayer).toBeInstanceOf(WebGLPointsLayer);
+            expect(webglLayer.get("isPointLayer")).toBeTruthy();
+        });
+        it("should return a custom Layer", () => {
+            layerParams.isPointLayer = false;
+            const webglLayer = webgl.createLayer({...rawLayer, ...layerParams, source});
+
+            expect(webglLayer).toBeInstanceOf(Layer);
+            expect(webglLayer).not.toBeInstanceOf(WebGLPointsLayer);
+            expect(webglLayer.get("isPointLayer")).toBeFalsy();
+        });
+    });
+    describe("private format and style functions", () => {
+        const
+            feature = new Feature({
+                geometry: new Polygon([
+                    [[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0], [0, 0, 0]]
+                ], "XYZ"),
+                apple: "42",
+                pear: "true",
+                pumpkin: "false"
+            });
+        let $feature;
+
+        describe("formatFeatureGeometry", () => {
+            it("should remove any Z components from the geometry", () => {
+                $feature = feature.clone();
+                webgl.formatFeatureGeometry($feature);
+                /* eslint-disable-next-line max-nested-callbacks */
+                expect($feature.getGeometry().getCoordinates()[0].every(coord => coord.length === 2)).toBeTruthy();
+            });
+        });
+        describe("formatFeatureData", () => {
+            it("should not format excluded formats 'number' and 'boolean", () => {
+                $feature = feature.clone();
+                webgl.formatFeatureData($feature, ["number", "boolean"]);
+                expect(typeof $feature.get("apple")).toEqual("string");
+                expect(typeof $feature.get("pear")).toEqual("string");
+                expect(typeof $feature.get("pumpkin")).toEqual("string");
+            });
+            it("should format numbers and booleans", () => {
+                $feature = feature.clone();
+                webgl.formatFeatureData($feature, []);
+                expect(typeof $feature.get("apple")).toEqual("number");
+                expect(typeof $feature.get("pear")).toEqual("boolean");
+                expect(typeof $feature.get("pumpkin")).toEqual("boolean");
+            });
+        });
+        describe("formatFeatureStyles", () => {
+            it("bind the styling rule from the styleObject to each feature", () => {
+                $feature = feature.clone();
+                webgl.formatFeatureStyles($feature, styleObject);
+                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

@@ -0,0 +1,335 @@
+import createStyle from "../../src/vectorStyle/createStyle";
+import PointStyle from "../../src/vectorStyle/styles/point/stylePoint";
+import LineStringStyle from "../../src/vectorStyle/styles/styleLine";
+import PolygonStyle from "../../src/vectorStyle/styles/polygon/stylePolygon";
+import {Style, Stroke, Fill} from "ol/style.js";
+import {GeoJSON} from "ol/format.js";
+
+const wfsImgPathFromConfig = "/path/to/wfs/images",
+    rules = [
+        {
+            conditions: {
+                properties: {
+                    id: "test1"
+                }
+            },
+            style: {
+                legendValue: "legendValueText",
+                circleStrokeColor: [255, 0, 0, 1],
+                type: "circle",
+                lineStrokeColor: [100, 0, 0, 1],
+                polygonStrokeColor: [100, 100, 0, 1]
+            }
+        },
+        {
+            style: {
+                legendValue: "LineStringLegend",
+                lineStrokeColor: [255, 0, 0, 1]
+            }
+        },
+        {
+            style: {
+                legendValue: "PolygonLegend",
+                polygonStrokeColor: [255, 0, 0, 255]
+            }
+        },
+        {
+            conditions: {
+                properties: {
+                    value: [0, 50, "@min", "@max"]
+                }
+            },
+            style: {
+                legendValue: "legendValueText",
+                circleStrokeColor: [255, 0, 0, 1]
+            }
+        },
+        {
+            style: {
+                legendValue: "legendValueText",
+                circleStrokeColor: [255, 255, 255, 1]
+            }
+        }
+    ],
+    multiLineStringRules = [{
+        style: {
+            legendValue: "legendValueText",
+            lineStrokeColor: [255, 255, 255, 1]
+        }
+    },
+    {
+        style: {
+            legendValue: "legendValueText",
+            lineStrokeColor: [255, 0, 0, 1]
+        }
+    }],
+    multiPolygonRules = [{
+        style: {
+            legendValue: "legendValueText",
+            polygonStrokeColor: [100, 100, 0, 1]
+        }
+    },
+    {
+        style: {
+            legendValue: "legendValueText",
+            polygonStrokeColor: [255, 0, 0, 1]
+        }
+    }],
+    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
+                }
+            },
+            {
+                "type": "Feature",
+                "geometry": {
+                    "type": "Polygon",
+                    "coordinates": [[10.082125662581083, 53.518872973925404], [11.01, 53.6], [11.5, 54.0]]
+                },
+                "properties": {
+                    "id": "test1",
+                    "value": 50,
+                    "min": 10,
+                    "max": 100
+                }
+            },
+            {
+                "type": "Feature",
+                "geometry": {
+                    "type": "MultiPoint",
+                    "coordinates": [[11.01, 53.6], [11.5, 54.0]]
+                },
+                "properties": {
+                    "id": "test1",
+                    "value": 50,
+                    "min": 10,
+                    "max": 100
+                }
+            },
+            {
+                "type": "Feature",
+                "geometry": {
+                    "type": "MultiLineString",
+                    "coordinates": [
+                        [[10, 10], [20, 20], [10, 40]],
+                        [[40, 40], [30, 30], [40, 20], [30, 10]]
+                    ]
+                },
+                "properties": {
+                    "id": "test1",
+                    "value": 50,
+                    "min": 10,
+                    "max": 100
+                }
+            },
+            {
+                "type": "Feature",
+                "geometry": {
+                    "type": "MultiPolygon",
+                    "coordinates": [
+                        [
+                            [[30, 20], [45, 40], [10, 40], [30, 20]]
+                        ],
+                        [
+                            [[15, 5], [40, 10], [10, 20], [5, 10], [15, 5]]
+                        ]
+                    ]
+                },
+                "properties": {
+                    "id": "test1",
+                    "value": 50,
+                    "min": 10,
+                    "max": 100
+                }
+            },
+            {
+                "type": "Feature",
+                "geometry": {
+                    "type": "GeometryCollection",
+                    "geometries": [
+                        {
+                            "type": "Point",
+                            "coordinates": [100.0, 0.0]
+                        },
+                        {
+                            "type": "LineString",
+                            "coordinates": [
+                                [101.0, 0.0], [102.0, 1.0]
+                            ]
+                        }
+                    ]
+                },
+                "properties": {
+                    "@test": "test",
+                    "id": "test1",
+                    "value": 50,
+                    "min": 10,
+                    "max": 100
+                }
+            }
+        ]
+    },
+    rulesWithOneEntry = [
+        {
+            "conditions": {
+                "sequence": [0, 0],
+                "properties": {
+                    "@Datastreams.0.Observations.0.result": [81, 101]}},
+            "style": {
+                "legendValue": "legendValueText",
+                "lineStrokeColor": [37, 52, 148, 1],
+                "lineStrokeDash": [20, 20, 5, 2000],
+                "lineStrokeDashOffset": 20,
+                "lineStrokeWidth": 5,
+                "labelField": ""}}
+    ],
+    warn = jest.spyOn(console, "warn").mockImplementation(() => {
+        null;
+    });
+
+let jsonObjects;
+
+
+beforeAll(function () {
+    jsonObjects = geojsonReader.readFeatures(jsonFeatures);
+});
+afterAll(() => {
+    warn.mockReset();
+});
+
+describe("createStyle", () => {
+    it("should return the correct style for a feature", () => {
+        const styleObject = {styleId: "myStyle", rules: [{style: {type: "Point"}}]},
+            isClustered = false,
+            style = createStyle.createStyle(styleObject, jsonObjects[0], isClustered, wfsImgPathFromConfig);
+
+        expect(style).toBeInstanceOf(Style);
+    });
+});
+
+describe("getSimpleGeometryStyle", function () {
+    it("should return ol point style", function () {
+        expect(createStyle.getSimpleGeometryStyle("Point", jsonObjects[0], rules[0], wfsImgPathFromConfig)).toBeInstanceOf(PointStyle);
+        expect(typeof createStyle.getSimpleGeometryStyle("Point", jsonObjects[0], rules[0], wfsImgPathFromConfig).getStyle().getImage().getStroke().getColor()).toBe("object");
+        expect(createStyle.getSimpleGeometryStyle("Point", jsonObjects[0], rules[0], wfsImgPathFromConfig).getStyle().getImage().getStroke().getColor()).toEqual([0, 0, 0, 1]);
+    });
+    it("should return ol linestring style", function () {
+        expect(createStyle.getSimpleGeometryStyle("LineString", jsonObjects[1], rules[1], wfsImgPathFromConfig)).toBeInstanceOf(LineStringStyle);
+        expect(typeof createStyle.getSimpleGeometryStyle("LineString", jsonObjects[1], rules[1], wfsImgPathFromConfig).getStyle().getStroke().getColor()).toBe("object");
+        expect(createStyle.getSimpleGeometryStyle("LineString", jsonObjects[1], rules[1], wfsImgPathFromConfig).getStyle().getStroke().getColor()).toEqual([255, 0, 0, 1]);
+    });
+    it("should return ol polygon style", function () {
+        expect(createStyle.getSimpleGeometryStyle("Polygon", jsonObjects[2], rules[2], wfsImgPathFromConfig)).toBeInstanceOf(PolygonStyle);
+        expect(typeof createStyle.getSimpleGeometryStyle("Polygon", jsonObjects[2], rules[2], wfsImgPathFromConfig).getStyle().getStroke().getColor()).toBe("object");
+        expect(createStyle.getSimpleGeometryStyle("Polygon", jsonObjects[2], rules[2], wfsImgPathFromConfig).getStyle().getStroke().getColor()).toEqual([255, 0, 0, 255]);
+    });
+    it("should return ol default style", function () {
+        expect(createStyle.getSimpleGeometryStyle("not exist", jsonObjects[0], null, wfsImgPathFromConfig)).toBeInstanceOf(Style);
+    });
+});
+
+describe("getMultiGeometryStyle", function () {
+    it("should return style array for multipoint", function () {
+        expect(Array.isArray(createStyle.getMultiGeometryStyle("MultiPoint", jsonObjects[3], rules, wfsImgPathFromConfig))).toBe(true);
+        expect(createStyle.getMultiGeometryStyle("MultiPoint", jsonObjects[3], rules, wfsImgPathFromConfig).length).toEqual(2);
+    });
+    it("should include ol point style", function () {
+        expect(createStyle.getMultiGeometryStyle("MultiPoint", jsonObjects[3], rules, wfsImgPathFromConfig)[0]).toBeInstanceOf(PointStyle);
+        expect(typeof createStyle.getMultiGeometryStyle("MultiPoint", jsonObjects[3], rules, wfsImgPathFromConfig)[0]).toBe("object");
+        expect(Array.isArray(createStyle.getMultiGeometryStyle("MultiPoint", jsonObjects[3], rules, wfsImgPathFromConfig)[0].getStyle().getImage().getStroke().getColor())).toBe(true);
+        expect(createStyle.getMultiGeometryStyle("MultiPoint", jsonObjects[3], rules, wfsImgPathFromConfig)[0].getStyle().getImage().getStroke().getColor()).toEqual([0, 0, 0, 1]);
+    });
+    it("should return style array for MultiLineString", function () {
+        expect(Array.isArray(createStyle.getMultiGeometryStyle("MultiLineString", jsonObjects[4], multiLineStringRules, wfsImgPathFromConfig))).toBe(true);
+        expect(createStyle.getMultiGeometryStyle("MultiLineString", jsonObjects[4], multiLineStringRules, wfsImgPathFromConfig).length).toEqual(2);
+    });
+    it("should include ol stroke style", function () {
+        expect(createStyle.getMultiGeometryStyle("MultiLineString", jsonObjects[4], multiLineStringRules, wfsImgPathFromConfig)[0]).toBeInstanceOf(LineStringStyle);
+        expect(createStyle.getMultiGeometryStyle("MultiLineString", jsonObjects[4], multiLineStringRules, wfsImgPathFromConfig)[0].getStyle().getStroke()).toBeInstanceOf(Stroke);
+        expect(Array.isArray(createStyle.getMultiGeometryStyle("MultiLineString", jsonObjects[4], multiLineStringRules, wfsImgPathFromConfig)[0].getStyle().getStroke().getColor())).toBe(true);
+        expect(createStyle.getMultiGeometryStyle("MultiLineString", jsonObjects[4], multiLineStringRules, wfsImgPathFromConfig)[0].getStyle().getStroke().getColor()).toEqual([255, 255, 255, 1]);
+    });
+    it("should return style array for MultiPolygon", function () {
+        expect(Array.isArray(createStyle.getMultiGeometryStyle("MultiPolygon", jsonObjects[5], multiPolygonRules, wfsImgPathFromConfig))).toBe(true);
+        expect(createStyle.getMultiGeometryStyle("MultiPolygon", jsonObjects[5], multiPolygonRules, wfsImgPathFromConfig).length).toEqual(2);
+    });
+    it("should include ol polygon style", function () {
+        expect(createStyle.getMultiGeometryStyle("MultiPolygon", jsonObjects[5], multiPolygonRules, wfsImgPathFromConfig)[0]).toBeInstanceOf(PolygonStyle);
+        expect(createStyle.getMultiGeometryStyle("MultiPolygon", jsonObjects[5], multiPolygonRules, wfsImgPathFromConfig)[0].getStyle().getStroke()).toBeInstanceOf(Stroke);
+        expect(createStyle.getMultiGeometryStyle("MultiPolygon", jsonObjects[5], multiPolygonRules, wfsImgPathFromConfig)[0].getStyle().getFill()).toBeInstanceOf(Fill);
+        expect(Array.isArray(createStyle.getMultiGeometryStyle("MultiPolygon", jsonObjects[5], multiPolygonRules, wfsImgPathFromConfig)[0].getStyle().getStroke().getColor())).toBe(true);
+        expect(createStyle.getMultiGeometryStyle("MultiPolygon", jsonObjects[5], multiPolygonRules, wfsImgPathFromConfig)[0].getStyle().getStroke().getColor()).toEqual([100, 100, 0, 1]);
+    });
+    it("should return style array for GeometryCollection", function () {
+        expect(Array.isArray(createStyle.getMultiGeometryStyle("GeometryCollection", jsonObjects[6], rules, wfsImgPathFromConfig))).toBe(true);
+        expect(createStyle.getMultiGeometryStyle("GeometryCollection", jsonObjects[6], rules, wfsImgPathFromConfig).length).toEqual(2);
+    });
+    it("should include ol line and point style", function () {
+        expect(createStyle.getMultiGeometryStyle("GeometryCollection", jsonObjects[6], rules, wfsImgPathFromConfig)[0]).toBeInstanceOf(PointStyle);
+        expect(createStyle.getMultiGeometryStyle("GeometryCollection", jsonObjects[6], multiLineStringRules, wfsImgPathFromConfig)[1]).toBeInstanceOf(LineStringStyle);
+        expect(createStyle.getMultiGeometryStyle("GeometryCollection", jsonObjects[6], rules, wfsImgPathFromConfig)[0].getStyle().getImage().getStroke()).toBeInstanceOf(Stroke);
+        expect(Array.isArray(createStyle.getMultiGeometryStyle("GeometryCollection", jsonObjects[6], rules, wfsImgPathFromConfig)[0].getStyle().getImage().getStroke().getColor())).toBe(true);
+        expect(createStyle.getMultiGeometryStyle("GeometryCollection", jsonObjects[6], rules, wfsImgPathFromConfig)[0].getStyle().getImage().getStroke().getColor()).toEqual([0, 0, 0, 1]);
+        expect(createStyle.getMultiGeometryStyle("GeometryCollection", jsonObjects[6], multiLineStringRules, wfsImgPathFromConfig)[1].getStyle().getStroke()).toBeInstanceOf(Stroke);
+    });
+    it("features with more geometries than rules (rules: 1, geometries: 2) should have style for all geometries - styleMultiGeomOnlyWithRule=false", function () {
+        expect(Array.isArray(createStyle.getMultiGeometryStyle("MultiLineString", jsonObjects[4], rulesWithOneEntry, wfsImgPathFromConfig))).toBe(true);
+        expect(createStyle.getMultiGeometryStyle("MultiLineString", jsonObjects[4], rulesWithOneEntry, wfsImgPathFromConfig).length).toEqual(2);
+    });
+});
+
+describe("isMultiGeometry", function () {
+    it("should return true with multi geometries", function () {
+        expect(createStyle.isMultiGeometry("MultiPoint")).toBe(true);
+        expect(createStyle.isMultiGeometry("MultiLineString")).toBe(true);
+        expect(createStyle.isMultiGeometry("MultiPolygon")).toBe(true);
+        expect(createStyle.isMultiGeometry("GeometryCollection")).toBe(true);
+        expect(createStyle.isMultiGeometry("Point")).toBe(false);
+    });
+});
+
+describe("getGeometryStyle", function () {
+    it("should return ol style with correct settings", function () {
+        expect(createStyle.getGeometryStyle(jsonObjects[0], rules, wfsImgPathFromConfig)).toBeInstanceOf(PointStyle);
+        expect(Array.isArray(createStyle.getGeometryStyle(jsonObjects[0], rules, wfsImgPathFromConfig).getStyle().getImage().getStroke().getColor())).toBe(true);
+        expect(createStyle.getGeometryStyle(jsonObjects[0], rules, wfsImgPathFromConfig).getStyle().getImage().getStroke().getColor()).toEqual([0, 0, 0, 1]);
+    });
+    it("should return default style if no rule is found", function () {
+        expect(Array.isArray(createStyle.getGeometryStyle(jsonObjects[0], [], wfsImgPathFromConfig).getStyle().getImage().getStroke().getColor())).toBe(true);
+        expect(createStyle.getGeometryStyle(jsonObjects[0], [], wfsImgPathFromConfig).getStyle().getImage().getStroke().getColor()).toEqual([0, 0, 0, 1]);
+    });
+});

package/test/vectorStyle/lib/colorConvertions.test.js

@@ -0,0 +1,42 @@
+import {normalizeRgbColor, componentToHex, rgbToHex, hexToRgb} from "../../../src/vectorStyle/lib/colorConvertions";
+
+describe("normalizeRgbColor", function () {
+    it("should be extend the given array with length 3 by value 1", function () {
+        expect(Array.isArray(normalizeRgbColor([255, 255, 255]))).toBe(true);
+        expect(normalizeRgbColor([255, 255, 255])).toEqual([255, 255, 255, 1]);
+    });
+    it("should be extend the given array with length 2 by value 1, 1", function () {
+        expect(Array.isArray(normalizeRgbColor([255, 255]))).toBe(true);
+        expect(normalizeRgbColor([255, 255])).toEqual([255, 255, 1, 1]);
+    });
+    it("should be return the input value, which is an array with length 4", function () {
+        expect(Array.isArray(normalizeRgbColor([0, 0, 0, 0]))).toBe(true);
+        expect(normalizeRgbColor([0, 0, 0, 0])).toEqual([0, 0, 0, 0]);
+    });
+    it("should be return the input value, which is an array with length > 4", function () {
+        expect(Array.isArray(normalizeRgbColor([1, 2, 3, 4, 5]))).toBe(true);
+        expect(normalizeRgbColor([1, 2, 3, 4, 5])).toEqual([1, 2, 3, 4]);
+    });
+});
+
+describe("componentToHex", function () {
+    it("should return the parsed 16 digits value", function () {
+        expect(componentToHex(2)).toEqual("02");
+        expect(componentToHex(213)).toEqual("d5");
+    });
+});
+
+describe("rgbToHex", function () {
+    it("should return the parsed hex value", function () {
+        expect(rgbToHex(2, 213, 33)).toEqual("#02d521");
+    });
+});
+
+describe("hexToRgb", function () {
+    it("should return the parsed rgb value", function () {
+        expect(hexToRgb("#020521")).toEqual([2, 5, 21]);
+    });
+    it("should return null", function () {
+        expect(hexToRgb("")).toEqual(null);
+    });
+});