@masterportal/masterportalapi 2.33.0 → 2.35.0

package/CHANGELOG.md

@@ -13,6 +13,23 @@
 
 ---
 
+## 2.35.0 - 2024-04-02
+
+### Added
+- WMS: Support for using CQL filters by attribute added.
+
+### Fixed
+- Issue Masterportal #1127: fixed styling of clustered and not clustered circles.
+- WFST parsing featureType wfs.js with attribute required true by default.
+
+---
+## 2.34.0 - 2024-03-04
+
+### Changed
+- stylePointCircle.js now has a zIndex of -1 to put unclustered Labels above clustered ones.
+
+---
+
 ## 2.33.0 - 2024-02-07
 
 ### Changed

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@masterportal/masterportalapi",
   "author": "Implementierungspartnerschaft Masterportal <info@masterportal.org> (https://www.masterportal.org)",
-  "version": "2.33.0",
+  "version": "2.35.0",
   "license": "MIT",
   "description": "Basic functions of the Masterportal as api",
   "repository": {

package/src/layer/wfs.js

@@ -447,7 +447,7 @@ function parseDescribeFeatureTypeResponse (responseData, featureType) {
             key: "",
             value: null,
             type: "string",
-            required: false
+            required: true
         }));
     }
     return [];

package/src/layer/wms.js

@@ -55,6 +55,7 @@ export function addOptionalParams (params, rawLayer) {
  * @param {boolean} rawLayer.singleTile - whether only one tile shall be requested that fills the whole view
  * @param {boolean} rawLayer.STYLES - styles of the layer, if available
  * @param {(string|number)} rawLayer.tilesize - if singleTile is true, this is the requested tilesize
+ * @param {string} rawLayer.cqlFilter - CQL filter
  * @returns {object} maps query parameter names to values
  */
 export function makeParams (rawLayer) {
@@ -66,7 +67,8 @@ export function makeParams (rawLayer) {
         LAYERS: rawLayer.layers,
         VERSION: rawLayer.version,
         TRANSPARENT: rawLayer.transparent,
-        SINGLETILE: rawLayer.singleTile
+        SINGLETILE: rawLayer.singleTile,
+        CQL_FILTER: rawLayer.cqlFilter
     }, rawLayer.singleTile ? {} : {WIDTH: rawLayer.tilesize, HEIGHT: rawLayer.tilesize});
 
     params = addOptionalParams(params, rawLayer);
@@ -90,6 +92,7 @@ async function defaultTileLoadFunction (imageTile, src) {
  * @param {function} [rawLayer.olAttribution] - optional function that takes a module:ol/Map~FrameState and returns a string or an array of strings representing source attributions
  * @param {string|number} [rawLayer.tilesize] - optional needed to create the tileGrid
  * @param {string|"anonymous"} [rawLayer.crossOrigin] - optional needed for CORS requests of image data, to enable canvas export
+ * @param {string} [rawLayer.cqlFilter] - optional CQL filter to add to the request
  * @param {object} options - optional resolutions and origin to create the TileGrid
  * @param {Array} [options.resolutions] - optional resolutions to create the TileGrid, must be in descending order
  * @param {Array} [options.origin] - optional origin to create the TileGrid

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

@@ -61,7 +61,7 @@ class PointStyle extends StyleClass {
             return createIconStyle(this.attributes, this.feature, isClustered);
         }
         else if (type === "circle") {
-            return createCircleStyle(this.attributes, isClustered);
+            return createCircleStyle(this.attributes, this.feature, isClustered);
         }
         else if (type === "nominal") {
             return isClustered ? createIconStyle(this.attributes, this.feature, isClustered) : createNominalPointStyle(this.attributes, this.feature, defaultStyle.point.imageName);

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

@@ -5,14 +5,16 @@ import {returnColor} from "../../lib/colorConvertions";
 * Creates pointStyle as circle.
 * all features get same circle.
 * @param {Object} attributes - The attributes from the circle
+* @param {Object} feature - The feature
 * @param {Boolean} isClustered - true if features are clustered
 * @returns {ol/style} - The created style.
 */
-export function createCircleStyle (attributes, isClustered) {
-    const radius = isClustered ? parseFloat(attributes.clusterCircleRadius, 10) : parseFloat(attributes.circleRadius, 10),
-        fillcolor = isClustered ? returnColor(attributes.clusterCircleFillColor, "rgb") : returnColor(attributes.circleFillColor, "rgb"),
-        strokecolor = isClustered ? returnColor(attributes.clusterCircleStrokeColor, "rgb") : returnColor(attributes.circleStrokeColor, "rgb"),
-        strokewidth = isClustered ? parseFloat(attributes.clusterCircleStrokeWidth, 10) : parseFloat(attributes.circleStrokeWidth, 10);
+export function createCircleStyle (attributes, feature, isClustered) {
+    const showCluster = isClustered && feature.get("features")?.length > 1,
+        radius = showCluster ? parseFloat(attributes.clusterCircleRadius, 10) : parseFloat(attributes.circleRadius, 10),
+        fillcolor = showCluster ? returnColor(attributes.clusterCircleFillColor, "rgb") : returnColor(attributes.circleFillColor, "rgb"),
+        strokecolor = showCluster ? returnColor(attributes.clusterCircleStrokeColor, "rgb") : returnColor(attributes.circleStrokeColor, "rgb"),
+        strokewidth = showCluster ? parseFloat(attributes.clusterCircleStrokeWidth, 10) : parseFloat(attributes.circleStrokeWidth, 10);
 
     return new Style({
         image: new CircleStyle({
@@ -24,6 +26,7 @@ export function createCircleStyle (attributes, isClustered) {
                 color: strokecolor,
                 width: strokewidth
             })
-        })
+        }),
+        zIndex: -1
     });
 }

package/test/layer/wms.test.js

@@ -25,7 +25,8 @@ describe("wms.js", function () {
                 LAYERS: "b",
                 VERSION: "c",
                 TRANSPARENT: "d",
-                SINGLETILE: "e"
+                SINGLETILE: "e",
+                CQL_FILTER: "f"
             };
         });
 
@@ -38,6 +39,7 @@ describe("wms.js", function () {
             expect(extendedParams.VERSION).toEqual("c");
             expect(extendedParams.TRANSPARENT).toEqual("d");
             expect(extendedParams.SINGLETILE).toEqual("e");
+            expect(extendedParams.CQL_FILTER).toEqual("f");
             expect(extendedParams.TIME).toEqual("The time");
             expect(extendedParams.STYLES).not.toBeDefined();
         });
@@ -50,6 +52,7 @@ describe("wms.js", function () {
             expect(extendedParams.VERSION).toEqual("c");
             expect(extendedParams.TRANSPARENT).toEqual("d");
             expect(extendedParams.SINGLETILE).toEqual("e");
+            expect(extendedParams.CQL_FILTER).toEqual("f");
             expect(extendedParams.STYLES).toEqual("The style");
             expect(extendedParams.TIME).not.toBeDefined();
         });

package/test/vectorStyle/createStyle.test.js

@@ -5,76 +5,14 @@ import PolygonStyle from "../../src/vectorStyle/styles/polygon/stylePolygon";
 import {Style, Stroke, Fill} from "ol/style.js";
 import {GeoJSON} from "ol/format.js";
 
+let rules,
+    jsonObjects,
+    multiLineStringRules,
+    multiPolygonRules,
+    isClustered;
+
 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]
-        }
-    }],
+    defaultStrokeColor = [0, 0, 0, 1],
     geojsonReader = new GeoJSON(),
     jsonFeatures = {
         "type": "FeatureCollection",
@@ -221,8 +159,6 @@ const wfsImgPathFromConfig = "/path/to/wfs/images",
         null;
     });
 
-let jsonObjects;
-
 
 beforeAll(function () {
     jsonObjects = geojsonReader.readFeatures(jsonFeatures);
@@ -231,10 +167,82 @@ afterAll(() => {
     warn.mockReset();
 });
 
+beforeEach(() => {
+    isClustered = false;
+    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]
+        }
+    }];
+});
+
 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);
@@ -254,7 +262,6 @@ describe("createStyle", () => {
                 }
             }],
             styleObject = {styleId: "styleId", styleMultiGeomOnlyWithRule: true, rules: stylingRules},
-            isClustered = false,
             multiLineStringFeature = jsonObjects[4],
             style = createStyle.createStyle(styleObject, multiLineStringFeature, isClustered, wfsImgPathFromConfig);
 
@@ -287,7 +294,6 @@ describe("createStyle", () => {
                 }
             }],
             styleObject = {styleId: "styleId", styleMultiGeomOnlyWithRule: true, rules: stylingRules},
-            isClustered = false,
             multiPolygonFeature = jsonObjects[5],
             style = createStyle.createStyle(styleObject, multiPolygonFeature, isClustered, wfsImgPathFromConfig);
 
@@ -320,7 +326,6 @@ describe("createStyle", () => {
                 }
             }],
             styleObject = {styleId: "styleId", styleMultiGeomOnlyWithRule: true, rules: stylingRules},
-            isClustered = false,
             geometryCollectionFeature = jsonObjects[6],
             style = createStyle.createStyle(styleObject, geometryCollectionFeature, isClustered, wfsImgPathFromConfig);
 
@@ -353,7 +358,6 @@ describe("createStyle", () => {
                 }
             }],
             styleObject = {styleId: "styleId", styleMultiGeomOnlyWithRule: true, rules: stylingRules},
-            isClustered = false,
             multiPointFeature = jsonObjects[3],
             style = createStyle.createStyle(styleObject, multiPointFeature, isClustered, wfsImgPathFromConfig);
 
@@ -367,8 +371,6 @@ describe("createStyle", () => {
 });
 
 describe("getSimpleGeometryStyle", function () {
-    let isClustered = false;
-
     it("should return ol point style - not clustered", function () {
         const styleObject = createStyle.getSimpleGeometryStyle("Point", jsonObjects[0], rules[0], isClustered, wfsImgPathFromConfig);
 
@@ -400,12 +402,21 @@ describe("getSimpleGeometryStyle", function () {
     });
 
     it("should return ol point style - clustered", function () {
+        const geometry = jsonObjects[0].getGeometry();
+        let styleObject = null;
+
         isClustered = true;
-        const styleObject = createStyle.getSimpleGeometryStyle("Point", jsonObjects[0], rules[0], isClustered, wfsImgPathFromConfig);
+        jsonObjects[0].get = (key) => {
+            if (key === "features") {
+                return [{id: "cluster1"}, {id: "cluster2"}];
+            }
+            return geometry;
+        };
+        styleObject = createStyle.getSimpleGeometryStyle("Point", jsonObjects[0], rules[0], isClustered, wfsImgPathFromConfig);
 
         expect(styleObject).toBeInstanceOf(PointStyle);
         expect(typeof styleObject).toBe("object");
-        expect(styleObject.getStyle().getImage().getStroke().getColor()).toEqual([0, 0, 0, 1]);
+        expect(styleObject.getStyle().getImage().getStroke().getColor()).toEqual(defaultStrokeColor);
         expect(styleObject.getLegendInfos()[0].styleObject.circleStrokeColor).toEqual([255, 0, 0, 1]);
     });
     it("should return ol linestring style - clustered", function () {
@@ -435,51 +446,166 @@ describe("getSimpleGeometryStyle", function () {
 
 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);
+        const style = createStyle.getMultiGeometryStyle("MultiPoint", jsonObjects[3], rules, isClustered, wfsImgPathFromConfig);
+
+        expect(Array.isArray(style)).toBe(true);
+        expect(style.length).toEqual(2);
+    });
+    it("should include ol point style - use defaultStyle for stroke color", function () {
+        delete rules[0].style.circleStrokeColor;
+        const style = createStyle.getMultiGeometryStyle("MultiPoint", jsonObjects[3], rules, isClustered, wfsImgPathFromConfig);
+
+        expect(style[0]).toBeInstanceOf(PointStyle);
+        expect(style[1]).toBeInstanceOf(PointStyle);
+        expect(style[0].getStyle().getImage().getStroke().getColor()).toEqual(defaultStrokeColor);
+        expect(style[1].getStyle().getImage().getStroke().getColor()).toEqual(defaultStrokeColor);
+    });
+    it("should include ol point style - is clustered and use defaultStyle for stroke color", function () {
+        isClustered = true;
+        delete rules[0].style.circleStrokeColor;
+        const style = createStyle.getMultiGeometryStyle("MultiPoint", jsonObjects[3], rules, isClustered, wfsImgPathFromConfig);
+
+        expect(style[0]).toBeInstanceOf(PointStyle);
+        expect(style[1]).toBeInstanceOf(PointStyle);
+        expect(style[0].getStyle().getImage().getStroke().getColor()).toEqual(defaultStrokeColor);
+        expect(style[1].getStyle().getImage().getStroke().getColor()).toEqual(defaultStrokeColor);
     });
-    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 include ol point style- use rules for stroke color", function () {
+        const style = createStyle.getMultiGeometryStyle("MultiPoint", jsonObjects[3], rules, isClustered, wfsImgPathFromConfig);
+
+        expect(style[0]).toBeInstanceOf(PointStyle);
+        expect(style[1]).toBeInstanceOf(PointStyle);
+        expect(style[0].getStyle().getImage().getStroke().getColor()).toEqual(rules[0].style.circleStrokeColor);
+        expect(style[1].getStyle().getImage().getStroke().getColor()).toEqual(rules[0].style.circleStrokeColor);
+    });
+    it("should include ol point style- is clustered and use rules for stroke color", function () {
+        const geometry = jsonObjects[3].getGeometry();
+        let style = null;
+
+        isClustered = true;
+        jsonObjects[3].get = (key) => {
+            if (key === "features") {
+                return [{id: "cluster1"}, {id: "cluster2"}];
+            }
+            return geometry;
+        };
+        rules[0].style.clusterCircleStrokeColor = [1, 2, 3, 4];
+        style = createStyle.getMultiGeometryStyle("MultiPoint", jsonObjects[3], rules, isClustered, wfsImgPathFromConfig);
+
+        expect(style[0]).toBeInstanceOf(PointStyle);
+        expect(style[1]).toBeInstanceOf(PointStyle);
+        expect(style[0].getStyle().getImage().getStroke().getColor()).toEqual(rules[0].style.clusterCircleStrokeColor);
+        expect(style[1].getStyle().getImage().getStroke().getColor()).toEqual(rules[0].style.clusterCircleStrokeColor);
     });
     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);
+        const style = createStyle.getMultiGeometryStyle("MultiLineString", jsonObjects[4], multiLineStringRules, isClustered, wfsImgPathFromConfig);
+
+        expect(Array.isArray(style)).toBe(true);
+        expect(style.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("MultiLineString: should include ol line style - use defaultStyle for stroke color", function () {
+        delete multiLineStringRules[0].style.lineStrokeColor;
+        delete multiLineStringRules[1].style.lineStrokeColor;
+        const style = createStyle.getMultiGeometryStyle("MultiLineString", jsonObjects[4], multiLineStringRules, isClustered, wfsImgPathFromConfig);
+
+        expect(style[0]).toBeInstanceOf(LineStringStyle);
+        expect(style[1]).toBeInstanceOf(LineStringStyle);
+        expect(style[0].getStyle().getStroke()).toBeInstanceOf(Stroke);
+        expect(style[1].getStyle().getStroke()).toBeInstanceOf(Stroke);
+        expect(style[0].getStyle().getStroke().getColor()).toEqual(defaultStrokeColor);
+        expect(style[1].getStyle().getStroke().getColor()).toEqual(defaultStrokeColor);
+    });
+    it("MultiLineString: should include ol line style - use rules for stroke color", function () {
+        const style = createStyle.getMultiGeometryStyle("MultiLineString", jsonObjects[4], multiLineStringRules, isClustered, wfsImgPathFromConfig);
+
+        expect(style[0]).toBeInstanceOf(LineStringStyle);
+        expect(style[1]).toBeInstanceOf(LineStringStyle);
+        expect(style[0].getStyle().getStroke()).toBeInstanceOf(Stroke);
+        expect(style[1].getStyle().getStroke()).toBeInstanceOf(Stroke);
+        expect(style[0].getStyle().getStroke().getColor()).toEqual(multiLineStringRules[0].style.lineStrokeColor);
+        expect(style[1].getStyle().getStroke().getColor()).toEqual(multiLineStringRules[0].style.lineStrokeColor);
     });
     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);
+        const style = createStyle.getMultiGeometryStyle("MultiPolygon", jsonObjects[5], multiPolygonRules, isClustered, wfsImgPathFromConfig);
+
+        expect(Array.isArray(style)).toBe(true);
+        expect(style.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 include ol polygon style - use defaultStyle for stroke color", function () {
+        delete multiPolygonRules[0].style.polygonStrokeColor;
+        delete multiPolygonRules[1].style.polygonStrokeColor;
+        const style = createStyle.getMultiGeometryStyle("MultiPolygon", jsonObjects[5], multiPolygonRules, isClustered, wfsImgPathFromConfig);
+
+        expect(style[0]).toBeInstanceOf(PolygonStyle);
+        expect(style[0].getStyle().getStroke()).toBeInstanceOf(Stroke);
+        expect(style[0].getStyle().getFill()).toBeInstanceOf(Fill);
+        expect(style[0].getStyle().getStroke().getColor()).toEqual(defaultStrokeColor);
+        expect(style[1].getStyle().getStroke()).toBeInstanceOf(Stroke);
+        expect(style[1].getStyle().getFill()).toBeInstanceOf(Fill);
+        expect(style[1].getStyle().getStroke().getColor()).toEqual(defaultStrokeColor);
+    });
+    it("should include ol polygon style - use rules for stroke color", function () {
+        const style = createStyle.getMultiGeometryStyle("MultiPolygon", jsonObjects[5], multiPolygonRules, isClustered, wfsImgPathFromConfig);
+
+        expect(style[0]).toBeInstanceOf(PolygonStyle);
+        expect(style[0].getStyle().getStroke()).toBeInstanceOf(Stroke);
+        expect(style[0].getStyle().getFill()).toBeInstanceOf(Fill);
+        expect(style[0].getStyle().getStroke().getColor()).toEqual(multiPolygonRules[0].style.polygonStrokeColor);
+        expect(style[1].getStyle().getStroke()).toBeInstanceOf(Stroke);
+        expect(style[1].getStyle().getFill()).toBeInstanceOf(Fill);
+        expect(style[1].getStyle().getStroke().getColor()).toEqual(multiPolygonRules[0].style.polygonStrokeColor);
     });
     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);
+        const style = createStyle.getMultiGeometryStyle("GeometryCollection", jsonObjects[6], rules, isClustered, wfsImgPathFromConfig);
+
+        expect(Array.isArray(style)).toBe(true);
+        expect(style.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("should include ol line and point style - use defaultStyle for stroke color", function () {
+        delete rules[0].style.circleStrokeColor;
+        delete rules[0].style.lineStrokeColor;
+        delete multiLineStringRules[0].style.lineStrokeColor;
+        const style = createStyle.getMultiGeometryStyle("GeometryCollection", jsonObjects[6], rules, isClustered, wfsImgPathFromConfig),
+            multiLineStyle = createStyle.getMultiGeometryStyle("GeometryCollection", jsonObjects[6], multiLineStringRules, isClustered, wfsImgPathFromConfig);
+
+        expect(style[0]).toBeInstanceOf(PointStyle);
+        expect(style[0].getStyle().getImage().getStroke()).toBeInstanceOf(Stroke);
+        expect(style[0].getStyle().getImage().getStroke().getColor()).toEqual(defaultStrokeColor);
+        expect(style[1]).toBeInstanceOf(LineStringStyle);
+        expect(style[1].getStyle().getStroke()).toBeInstanceOf(Stroke);
+        expect(style[1].getStyle().getStroke().getColor()).toEqual(defaultStrokeColor);
+
+        expect(multiLineStyle[0]).toBeInstanceOf(PointStyle);
+        expect(multiLineStyle[0].getStyle().getImage().getStroke().getColor()).toEqual(defaultStrokeColor);
+        expect(multiLineStyle[1]).toBeInstanceOf(LineStringStyle);
+        expect(multiLineStyle[1].getStyle().getStroke()).toBeInstanceOf(Stroke);
+        expect(multiLineStyle[1].getStyle().getStroke().getColor()).toEqual(defaultStrokeColor);
+    });
+    it("should include ol line and point style - use rules for stroke color", function () {
+        const style = createStyle.getMultiGeometryStyle("GeometryCollection", jsonObjects[6], rules, isClustered, wfsImgPathFromConfig),
+            multiLineStyle = createStyle.getMultiGeometryStyle("GeometryCollection", jsonObjects[6], multiLineStringRules, isClustered, wfsImgPathFromConfig);
+
+        expect(style[0]).toBeInstanceOf(PointStyle);
+        expect(style[0].getStyle().getImage().getStroke()).toBeInstanceOf(Stroke);
+        expect(style[0].getStyle().getImage().getStroke().getColor()).toEqual(rules[0].style.circleStrokeColor);
+        expect(style[1]).toBeInstanceOf(LineStringStyle);
+        expect(style[1].getStyle().getStroke()).toBeInstanceOf(Stroke);
+        expect(style[1].getStyle().getStroke().getColor()).toEqual(rules[0].style.lineStrokeColor);
+
+        expect(multiLineStyle[0]).toBeInstanceOf(PointStyle);
+        // multiLineStringRules[0].style.circleStrokeColor is not defined --> use defaultStrokeColor
+        expect(multiLineStyle[0].getStyle().getImage().getStroke().getColor()).toEqual(defaultStrokeColor);
+        expect(multiLineStyle[1]).toBeInstanceOf(LineStringStyle);
+        expect(multiLineStyle[1].getStyle().getStroke()).toBeInstanceOf(Stroke);
+        expect(multiLineStyle[1].getStyle().getStroke().getColor()).toEqual(multiLineStringRules[0].style.lineStrokeColor);
     });
-    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);
+    it("features with more geometries than rules (rules: 1, geometries: 2) should have style for all geometries - 'styleMultiGeomOnlyWithRule' is not set", function () {
+        const style = createStyle.getMultiGeometryStyle("MultiLineString", jsonObjects[4], rulesWithOneEntry, isClustered, wfsImgPathFromConfig);
+
+        expect(Array.isArray(style)).toBe(true);
+        expect(style.length).toEqual(2);
+        expect(style[0].getStyle().getStroke().getColor()).toEqual(rulesWithOneEntry[0].style.lineStrokeColor);
+        expect(style[1].getStyle()).toEqual(null);
     });
 });
 
@@ -494,12 +620,22 @@ describe("isMultiGeometry", function () {
 });
 
 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 point style with correct settings", function () {
+        const style = createStyle.getGeometryStyle(jsonObjects[0], rules, isClustered, wfsImgPathFromConfig);
+
+        expect(style).toBeInstanceOf(PointStyle);
+        expect(Array.isArray(style.getStyle().getImage().getStroke().getColor())).toBe(true);
+        expect(style.getStyle().getImage().getStroke().getColor()).toEqual(rules[0].style.circleStrokeColor);
+    });
+    it("should return 'MultiPoint' style with correct settings", function () {
+        const style = createStyle.getGeometryStyle(jsonObjects[3], rules, isClustered, wfsImgPathFromConfig);
+
+        expect(Array.isArray(style)).toBe(true);
+        expect(style.length).toEqual(2);
+        expect(style[0].getStyle().getImage().getStroke().getColor()).toEqual(rules[0].style.circleStrokeColor);
+        expect(style[1].getStyle().getImage().getStroke().getColor()).toEqual(rules[0].style.circleStrokeColor);
     });
     it("should return null as style if no rule is found", function () {
-        expect(createStyle.getGeometryStyle(jsonObjects[0], [], wfsImgPathFromConfig).getStyle()).toBe(null);
+        expect(createStyle.getGeometryStyle(jsonObjects[0], [], isClustered, wfsImgPathFromConfig).getStyle()).toBe(null);
     });
 });

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

@@ -7,24 +7,61 @@ describe("stylePointCircle.js", () => {
                 circleRadius: 15,
                 circleFillColor: [10, 200, 100, 0.5],
                 circleStrokeColor: [10, 200, 100, 0.5],
-                circleStrokeWidth: 1
-            },
-            clusterAttributes = {
+                circleStrokeWidth: 1,
                 clusterCircleRadius: 20,
                 clusterCircleFillColor: [10, 200, 100, 0.5],
                 clusterCircleStrokeColor: [10, 200, 100, 0.5],
                 clusterCircleStrokeWidth: 1
+            },
+            feature = {
+                getProperties: () => {
+                    return {
+                        name: "singleFeature",
+                        id: "123"
+                    };
+                },
+                get: () => {
+                    return [];
+                }
+            },
+            clusteredFeature = {
+                get: () => {
+                    return [
+                        {
+                            name: "singleFeature1",
+                            id: "123"
+                        },
+                        {
+                            name: "singleFeature2",
+                            id: "456"
+                        }
+                    ];
+                }
             };
 
         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);
+            const style = stylePointCircle.createCircleStyle(attributes, feature, false);
+
+            expect(style).toBeInstanceOf(Style);
+            expect(style.getImage()).toBeInstanceOf(Circle);
+            expect(style.getImage().getRadius()).toEqual(15);
+            expect(style.getImage().getFill().getColor()).toEqual(attributes.circleFillColor);
         });
         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);
+            const style = stylePointCircle.createCircleStyle(attributes, clusteredFeature, true);
+
+            expect(style).toBeInstanceOf(Style);
+            expect(style.getImage()).toBeInstanceOf(Circle);
+            expect(style.getImage().getRadius()).toEqual(20);
+            expect(style.getImage().getFill().getColor()).toEqual(attributes.clusterCircleFillColor);
+        });
+        it("should create circle not cluster style - respects feature.get('features')", () => {
+            const style = stylePointCircle.createCircleStyle(attributes, feature, true);
+
+            expect(style).toBeInstanceOf(Style);
+            expect(style.getImage()).toBeInstanceOf(Circle);
+            expect(style.getImage().getRadius()).toEqual(15);
+            expect(style.getImage().getFill().getColor()).toEqual(attributes.circleFillColor);
         });
     });
 });