@masterportal/masterportalapi 2.13.0 → 2.15.0

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,/);
+        });
+    });
+
+});

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

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

package/test/vectorStyle/styles/styleText.test.js

@@ -0,0 +1,49 @@
+import TextStyle from "../../../src/vectorStyle/styles/styleText";
+import {Text} from "ol/style.js";
+
+describe("styleText", () => {
+    const feature = {
+            geometryName: "geom",
+            id: "DE.HH.UP_GESUNDHEIT_KRANKENHAEUSER_2",
+            get: () => {
+                return [1, 2, 3];
+            },
+            getProperties: () => {
+                return feature;
+            }
+        },
+        style = {
+            type: "icon",
+            clusterType: "icon",
+            legendValue: "Krankenhaus",
+            imageName: "krankenhaus.png"
+        },
+        isClustered = false,
+        styleTextClass = new TextStyle(feature, style, isClustered);
+
+    styleTextClass.initialize(feature, style, isClustered);
+
+    describe("initialize", function () {
+        it("returns an instance of openlayers style", () => {
+            expect(typeof styleTextClass.initialize).toBe("function");
+        });
+    });
+
+    describe("getStyle", function () {
+        it("returns an instance of openlayers style", () => {
+            expect(styleTextClass.getStyle()).toBeInstanceOf(Text);
+        });
+    });
+
+    describe("createClusteredTextStyle", function () {
+        it("returns an instance of openlayers style", () => {
+            expect(styleTextClass.createClusteredTextStyle()).toBeInstanceOf(Text);
+        });
+    });
+
+    describe("createLabeledTextStyle", function () {
+        it("returns an instance of openlayers style", () => {
+            expect(styleTextClass.createLabeledTextStyle()).toBeInstanceOf(Text);
+        });
+    });
+});