@masterportal/masterportalapi 2.40.0 → 2.40.1

package/CHANGELOG.md

@@ -18,6 +18,15 @@
 
 ---
 
+## 2.41.0 - 2024-11-05
+
+### Fixed
+- Tileset-Layer: custom tileset filename is allowed
+- WFS-Layer: url for describeFeatureType requests respects questionmark.
+- Issue #1279: Fixed keyboardEventTarget, so that keyboard interactions like KeyboardZoom and KeyboardPan work, if keyboardEventTarget id defined in config
+
+---
+
 ## 2.40.0 - 2024-07-17
 
 ### Added

package/package.json

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

package/src/layer/tileset.js

@@ -1,19 +1,22 @@
 /**
  * Creates the tileset.
+ * @param {Object} mpapiTileset - masterportal API Tileset object
  * @param {Object} rawLayer  attributes of the layer
  * @param {string} [rawLayer.url] - the URL of the Cesium terrain server
  * @param {string} [rawLayer.cesiumTerrainProviderOptions] - see https://cesiumjs.org/Cesium/Build/Documentation/CesiumTerrainProvider.html
  * @returns {Cesium.Cesium3DTileset} the tileset
  */
-function createTileSet (rawLayer) {
-    const url = rawLayer.url.split("?")[0] + "/tileset.json",
+function createTileSet (mpapiTileset, rawLayer) {
+    const baseUrl = rawLayer.url.split("?")[0],
+        // when no json file is given by url, use tileset.json as default
+        url = baseUrl + (baseUrl.endsWith(".json") ? "" : "/tileset.json"),
         options = {};
 
+    mpapiTileset.url = url;
 
     if (rawLayer.cesium3DTilesetOptions) {
         Object.assign(options, rawLayer.cesium3DTilesetOptions);
     }
-
     return Promise.resolve(Cesium.Cesium3DTileset.fromUrl(url, options));
 }
 
@@ -33,7 +36,7 @@ export default function Tileset (rawLayer) {
         typ: rawLayer.typ
     };
     if (Cesium) {
-        this.tileset = Promise.resolve(createTileSet(rawLayer));
+        this.tileset = Promise.resolve(createTileSet(this, rawLayer));
         this.tileset.then(function (tileset) {
             if (tileset) {
                 tileset.layerReferenceId = rawLayer.id;

package/src/layer/wfs.js

@@ -339,11 +339,12 @@ async function sendTransaction (srsName, feature, url, layer, transactionMethod)
         xmlDocument = null,
         transactionSummary = null,
         data = null;
+    const baseUrl = new URL(url),
 
-    const {featureNS, featurePrefix, featureType, version} = layer;
+        {featureNS, featurePrefix, featureType, version} = layer;
 
     try {
-        response = await fetch(url, {
+        response = await fetch(baseUrl, {
             method: "POST",
             headers: {"Content-Type": "text/xml"},
             credentials: layer.isSecured ? "include" : "omit",
@@ -358,6 +359,9 @@ async function sendTransaction (srsName, feature, url, layer, transactionMethod)
 
         xmlDocument = new DOMParser().parseFromString(data, "text/xml");
         transactionSummary = xmlDocument.getElementsByTagName("wfs:TransactionSummary");
+        if (transactionSummary.length === 0) {
+            transactionSummary = xmlDocument.getElementsByTagName("TransactionSummary");
+        }
 
         // NOTE: WFS-T services respond errors with the transaction as an XML response, even though it's the http code indicates different...
         if (transactionSummary.length === 0) {
@@ -453,6 +457,27 @@ function parseDescribeFeatureTypeResponse (responseData, featureType) {
     return [];
 }
 
+/**
+ * Creates the Url to get possible properties from.
+ *
+ * @param {string} url from the WFS-T
+ * @param {string} version of the WFS-T
+ * @param {string} featureType Name of the FeatureType according to the capabilities document
+ * @returns {URL} the created url
+ */
+function createReceivePossiblePropertiesUrl (url, version, featureType) {
+    const baseUrl = new URL(decodeURI(url));
+
+    baseUrl.searchParams.set("SERVICE", "WFS");
+    baseUrl.searchParams.set("REQUEST", "DescribeFeatureType");
+    baseUrl.searchParams.set("TYPENAME", featureType);
+    if (!baseUrl.searchParams.has("VERSION") && !baseUrl.searchParams.has("version")) {
+        baseUrl.searchParams.set("VERSION", version);
+    }
+
+    return baseUrl;
+}
+
 /**
  * Requests the possible properties of a feature and further values;
  * for more {@see FeatureProperty}.
@@ -464,8 +489,8 @@ function parseDescribeFeatureTypeResponse (responseData, featureType) {
  * @returns {Promise<Array>} If the request is successful, an array of prepared feature properties.
  */
 async function receivePossibleProperties (url, version, featureType, isSecured) {
-    const baseUrl = `${url}?SERVICE=WFS&REQUEST=DescribeFeatureType&VERSION=${version}&TYPENAME=${featureType}`;
-    let response;
+    const baseUrl = createReceivePossiblePropertiesUrl(url, version, featureType);
+    let response = null;
 
     try {
         response = await fetch(baseUrl, {
@@ -499,4 +524,4 @@ function loadFeaturesManually (layerAttributes, layerSource) {
         });
 }
 
-export default {createLayerSource, createLayer, sendTransaction, receivePossibleProperties, parseDescribeFeatureTypeResponse, writeTransactionBody, loadFeaturesManually};
+export default {createLayerSource, createLayer, createReceivePossiblePropertiesUrl, sendTransaction, receivePossibleProperties, parseDescribeFeatureTypeResponse, writeTransactionBody, loadFeaturesManually};

package/src/maps/ol/olMap.js

@@ -164,7 +164,7 @@ export function createMap (config = defaults, {mapParams, callback, errorCallbac
             ]),
             controls: [],
             view: createMapView(config),
-            keyboardEventTarget: config.mapInteractions?.keyboardEventTarget ? config.mapInteractions?.keyboardEventTarget : false
+            keyboardEventTarget: config.mapInteractions?.keyboardEventTarget ? document : false
         }, mapParams));
 
     map.set("mapMode", "2D");

package/test/layer/tileset.test.js

@@ -73,6 +73,17 @@ describe("tileset.js", function () {
             checkAttributes(layer2, attr2);
             expect(cesium3DTilesetSpy).toHaveBeenCalledTimes(2);
         });
+        it("add tileset.json to url, when url is not pointing to json file", function () {
+            const layer = new Tileset(attr);
+
+            expect(layer.url).toEqual(attr.url + "/tileset.json");
+        });
+        it("should not add tileset.json to url, when url is pointing to json file", function () {
+            const attr2 = Object.assign({}, attr, {url: "https://url/root.json"}),
+                layer = new Tileset(attr2);
+
+            expect(layer.url).toEqual(attr2.url);
+        });
     });
     describe("setOpacity", function () {
         it("calls setOpacity sets opacity to terrain style", function (done) {

package/test/layer/wfs.test.js

@@ -1,4 +1,3 @@
-import {enableFetchMocks} from "jest-fetch-mock";
 import VectorLayer from "ol/layer/Vector.js";
 import VectorSource from "ol/source/Vector.js";
 import Cluster from "ol/source/Cluster.js";
@@ -43,11 +42,6 @@ describe("wfs.js", function () {
         console.error = originalConsoleError;
     });
 
-    beforeEach(() => {
-        enableFetchMocks();
-        fetch.resetMocks();
-    });
-
     describe("createLayer", function () {
         it("creates a VectorLayer without id", function () {
             const layer = wfs.createLayer({version: "1.1.0"});
@@ -145,11 +139,6 @@ describe("wfs.js", function () {
         });
     });
     describe("createLayerSource", function () {
-        beforeEach(() => {
-            if (global.fetch) {
-                global.fetch.mockClear();
-            }
-        });
 
         it("creates a VectorSource and beforeLoading, afterLoading and featuresFilter are called", function () {
             global.fetch = jest.fn().mockImplementation(() => {
@@ -758,9 +747,9 @@ describe("wfs.js", function () {
                 "</xsd:schema>";
 
         it("should receive the possible properties", async () => {
-            fetch.mockResponseOnce(exampleDescribeFeatureType);
-
-            const properties = await wfs.receivePossibleProperties("https://team-waas-was-here.lgln", "1.1.0", "wfstpolygon", false),
+            let properties = null;
+            const baseUrl = new URL("https://team-waas-was-here.lgln/?SERVICE=WFS&REQUEST=DescribeFeatureType&TYPENAME=wfstpolygon&VERSION=1.1.0"),
+                options = {"credentials": "omit", "responseType": "text/xml"},
                 exampleProperties = [
                     {
                         key: "name",
@@ -799,6 +788,22 @@ describe("wfs.js", function () {
                     }
                 ];
 
+            baseUrl.searchParams.set("SERVICE", "WFS");
+            baseUrl.searchParams.set("REQUEST", "DescribeFeatureType");
+            global.fetch = jest.fn().mockImplementation(() => {
+                return new Promise((resolve) => {
+                    resolve({
+                        ok: true,
+                        status: 200,
+                        text: () => {
+                            return exampleDescribeFeatureType;
+                        }
+                    });
+                });
+            });
+
+            properties = await wfs.receivePossibleProperties("https://team-waas-was-here.lgln", "1.1.0", "wfstpolygon", false);
+
             expect(Array.isArray(properties)).toBe(true);
             expect(properties.length).toEqual(5);
             exampleProperties.forEach(property => {
@@ -807,14 +812,14 @@ describe("wfs.js", function () {
                 expect(parsedProperty).not.toEqual(undefined);
                 expect(parsedProperty).toEqual(property);
             });
-            expect(fetch).toHaveBeenCalledWith("https://team-waas-was-here.lgln?SERVICE=WFS&REQUEST=DescribeFeatureType&VERSION=1.1.0&TYPENAME=wfstpolygon", {"responseType": "text/xml", "credentials": "omit"});
 
+            expect(global.fetch).toHaveBeenCalledWith(baseUrl, options);
         });
 
         it("should receive the possible properties from a geoserver", async () => {
-            fetch.mockResponseOnce(geoserverDescribeFeatureType);
-
-            const properties = await wfs.receivePossibleProperties("https://team-waas-was-here.lgln", "1.1.0", "test_polygon", false),
+            let properties = null;
+            const baseUrl = new URL("https://team-waas-was-here.lgln/?SERVICE=WFS&REQUEST=DescribeFeatureType&TYPENAME=test_polygon&VERSION=1.1.0"),
+                options = {"credentials": "omit", "responseType": "text/xml"},
                 exampleProperties = [
                     {
                         key: "id",
@@ -839,6 +844,22 @@ describe("wfs.js", function () {
                     }
                 ];
 
+            baseUrl.searchParams.set("SERVICE", "WFS");
+            baseUrl.searchParams.set("REQUEST", "DescribeFeatureType");
+            global.fetch = jest.fn().mockImplementation(() => {
+                return new Promise((resolve) => {
+                    resolve({
+                        ok: true,
+                        status: 200,
+                        text: () => {
+                            return geoserverDescribeFeatureType;
+                        }
+                    });
+                });
+            });
+            properties = await wfs.receivePossibleProperties("https://team-waas-was-here.lgln", "1.1.0", "test_polygon", false);
+
+
             expect(Array.isArray(properties)).toBe(true);
             expect(properties.length).toEqual(3);
             exampleProperties.forEach(property => {
@@ -847,14 +868,14 @@ describe("wfs.js", function () {
                 expect(parsedProperty).not.toEqual(undefined);
                 expect(parsedProperty).toEqual(property);
             });
-            expect(fetch).toHaveBeenCalledWith("https://team-waas-was-here.lgln?SERVICE=WFS&REQUEST=DescribeFeatureType&VERSION=1.1.0&TYPENAME=test_polygon", {"responseType": "text/xml", "credentials": "omit"});
+            expect(global.fetch).toHaveBeenCalledWith(baseUrl, options);
 
         });
 
         it("should receive the possible properties with credentials", async () => {
-            fetch.mockResponseOnce(exampleDescribeFeatureType);
-
-            const properties = await wfs.receivePossibleProperties("https://team-waas-was-here.lgln", "1.1.0", "wfstpolygon", true),
+            let properties = null;
+            const baseUrl = new URL("https://team-waas-was-here.lgln/?SERVICE=WFS&REQUEST=DescribeFeatureType&TYPENAME=wfstpolygon&VERSION=1.1.0"),
+                options = {"credentials": "include", "responseType": "text/xml"},
                 exampleProperties = [
                     {
                         key: "name",
@@ -893,6 +914,21 @@ describe("wfs.js", function () {
                     }
                 ];
 
+            baseUrl.searchParams.set("SERVICE", "WFS");
+            baseUrl.searchParams.set("REQUEST", "DescribeFeatureType");
+            global.fetch = jest.fn().mockImplementation(() => {
+                return new Promise((resolve) => {
+                    resolve({
+                        ok: true,
+                        status: 200,
+                        text: () => {
+                            return exampleDescribeFeatureType;
+                        }
+                    });
+                });
+            });
+
+            properties = await wfs.receivePossibleProperties("https://team-waas-was-here.lgln", "1.1.0", "wfstpolygon", true);
             expect(Array.isArray(properties)).toBe(true);
             expect(properties.length).toEqual(5);
             exampleProperties.forEach(property => {
@@ -901,16 +937,8 @@ describe("wfs.js", function () {
                 expect(parsedProperty).not.toEqual(undefined);
                 expect(parsedProperty).toEqual(property);
             });
-            expect(fetch).toHaveBeenCalledWith("https://team-waas-was-here.lgln?SERVICE=WFS&REQUEST=DescribeFeatureType&VERSION=1.1.0&TYPENAME=wfstpolygon", {"responseType": "text/xml", "credentials": "include"});
-
-        });
+            expect(global.fetch).toHaveBeenCalledWith(baseUrl, options);
 
-        it("should throw an error if the properties can not be fetched", async () => {
-            fetch.mockAbortOnce();
-
-            await expect(async () => {
-                await wfs.receivePossibleProperties("https://team-waas-was-here.lgln", "1.1.0", "wfstgeom", false);
-            }).rejects.toThrow(Error);
         });
     });
 
@@ -968,14 +996,6 @@ describe("wfs.js", function () {
                 "    </wfs:Feature>\n" +
                 "  </wfs:InsertResults>\n" +
                 "</wfs:TransactionResponse>",
-            fetchResponseUpdate = "<?xml version='1.0' encoding='UTF-8'?>\n" +
-                "<wfs:TransactionResponse xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"http://www.opengis.net/wfs http://schemas.opengis.net/wfs/1.1.0/wfs.xsd\" xmlns:wfs=\"http://www.opengis.net/wfs\" xmlns:ogc=\"http://www.opengis.net/ogc\" version=\"1.1.0\">\n" +
-                "  <wfs:TransactionSummary>\n" +
-                "    <wfs:totalInserted>0</wfs:totalInserted>\n" +
-                "    <wfs:totalUpdated>1</wfs:totalUpdated>\n" +
-                "    <wfs:totalDeleted>0</wfs:totalDeleted>\n" +
-                "  </wfs:TransactionSummary>\n" +
-                "</wfs:TransactionResponse>",
             fetchResponseDelete = "<?xml version='1.0' encoding='UTF-8'?>\n" +
                 "<wfs:TransactionResponse xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"http://www.opengis.net/wfs http://schemas.opengis.net/wfs/1.1.0/wfs.xsd\" xmlns:wfs=\"http://www.opengis.net/wfs\" xmlns:ogc=\"http://www.opengis.net/ogc\" version=\"1.1.0\">\n" +
                 "  <wfs:TransactionSummary>\n" +
@@ -986,40 +1006,84 @@ describe("wfs.js", function () {
                 "</wfs:TransactionResponse>";
 
         it("should return the inserted feature if the transaction was successful", async function () {
-            fetch.mockResponseOnce(fetchResponseInsert);
+            global.fetch = jest.fn().mockImplementation(() => {
+                return new Promise((resolve) => {
+                    resolve({
+                        ok: true,
+                        status: 200,
+                        text: () => {
+                            return fetchResponseInsert;
+                        }
+                    });
+                });
+            });
 
             expect(await wfs.sendTransaction(srsName, feature, url, layer, insertTransaction)).toEqual(feature);
         });
 
         it("should return the inserted feature if the transaction was successful", async function () {
-            fetch.mockResponseOnce(fetchResponseInsert);
+            global.fetch = jest.fn().mockImplementation(() => {
+                return new Promise((resolve) => {
+                    resolve({
+                        ok: true,
+                        status: 200,
+                        text: () => {
+                            return fetchResponseInsert;
+                        }
+                    });
+                });
+            });
             layer.isSecured = true;
 
             expect(await wfs.sendTransaction(srsName, feature, url, layer, insertTransaction)).toEqual(feature);
         });
 
         it("should return the updated feature if the transaction was successful", async function () {
-            fetch.mockResponseOnce(fetchResponseUpdate);
+            global.fetch = jest.fn().mockImplementation(() => {
+                return new Promise((resolve) => {
+                    resolve({
+                        ok: true,
+                        status: 200,
+                        text: () => {
+                            return fetchResponseInsert;
+                        }
+                    });
+                });
+            });
             feature.setId(1);
 
             expect(await wfs.sendTransaction(srsName, feature, url, layer, updateTransaction)).toEqual(feature);
         });
 
         it("should return the deleted feature if the transaction was successful", async function () {
-            fetch.mockResponseOnce(fetchResponseDelete);
+            global.fetch = jest.fn().mockImplementation(() => {
+                return new Promise((resolve) => {
+                    resolve({
+                        ok: true,
+                        status: 200,
+                        text: () => {
+                            return fetchResponseDelete;
+                        }
+                    });
+                });
+            });
             feature.setId(1);
 
             expect(await wfs.sendTransaction(srsName, feature, url, layer, deleteTransaction)).toEqual(feature);
         });
 
-        it("should throw an error if fetch fails", async function () {
-            fetch.mockAbortOnce();
-
-            await expect(async () => wfs.sendTransaction(srsName, feature, url, layer, insertTransaction)).rejects.toThrow(Error);
-        });
-
         it("should throw an error if transaction type is not insert, selectedUpdate or delete", async function () {
-            fetch.mockResponseOnce(fetchResponseDelete);
+            global.fetch = jest.fn().mockImplementation(() => {
+                return new Promise((resolve) => {
+                    resolve({
+                        ok: true,
+                        status: 200,
+                        text: () => {
+                            return fetchResponseDelete;
+                        }
+                    });
+                });
+            });
             feature.setId(1);
 
             await expect(async () => wfs.sendTransaction(srsName, feature, url, layer, "löschen")).rejects.toThrow(Error);
@@ -1033,7 +1097,17 @@ describe("wfs.js", function () {
                 "  </ows:Exception>\n" +
                 "</ows:ExceptionReport>";
 
-            fetch.mockResponseOnce(failedResponse);
+            global.fetch = jest.fn().mockImplementation(() => {
+                return new Promise((resolve) => {
+                    resolve({
+                        ok: true,
+                        status: 200,
+                        text: () => {
+                            return failedResponse;
+                        }
+                    });
+                });
+            });
 
             await expect(async () => wfs.sendTransaction(srsName, feature, url, layer, insertTransaction)).rejects.toThrow(Error);
         });
@@ -1046,12 +1120,79 @@ describe("wfs.js", function () {
                 "  </ows:Exception>\n" +
                 "</ows:ExceptionReport>";
 
-            fetch.mockResponseOnce(failedResponse);
+            global.fetch = jest.fn().mockImplementation(() => {
+                return new Promise((resolve) => {
+                    resolve({
+                        ok: true,
+                        status: 200,
+                        text: () => {
+                            return failedResponse;
+                        }
+                    });
+                });
+            });
 
             await expect(async () => wfs.sendTransaction(srsName, feature, url, layer, insertTransaction)).rejects.toThrow("Cannot perform insert operation: Error in XML document (line: 1, column: 234, character offset: 233): Feature type \"{wrong}wfst\" is unknown.");
         });
     });
+    describe("createReceivePossiblePropertiesUrl", function () {
+        it("url without backslash at the end", () => {
+            const url = "https://team-waas-was-here.lgln",
+                version = "1.1.0",
+                featureType = "featureType",
+                createdUrl = wfs.createReceivePossiblePropertiesUrl(url, version, featureType);
+
+            expect(createdUrl.origin).toEqual(url);
+            expect(createdUrl.searchParams.get("SERVICE")).toEqual("WFS");
+            expect(createdUrl.searchParams.get("REQUEST")).toEqual("DescribeFeatureType");
+            expect(createdUrl.searchParams.get("TYPENAME")).toEqual(featureType);
+            expect(createdUrl.searchParams.get("VERSION")).toEqual(version);
+        });
+
+        it("url with backslash at the end", () => {
+            const url = "https://team-waas-was-here.lgln/",
+                version = "1.1.0",
+                featureType = "featureType",
+                createdUrl = wfs.createReceivePossiblePropertiesUrl(url, version, featureType);
+
+            expect(createdUrl.origin).toEqual("https://team-waas-was-here.lgln");
+            expect(createdUrl.searchParams.get("SERVICE")).toEqual("WFS");
+            expect(createdUrl.searchParams.get("REQUEST")).toEqual("DescribeFeatureType");
+            expect(createdUrl.searchParams.get("TYPENAME")).toEqual(featureType);
+            expect(createdUrl.searchParams.get("VERSION")).toEqual(version);
+        });
+
+        it("createUrl should respect questionmark in url", () => {
+            const url = "https://mapservice.regensburg.de/cgi-bin/mapserv?map=wfs.map",
+                version = "1.1.0",
+                featureType = "featureType",
+                createdUrl = wfs.createReceivePossiblePropertiesUrl(url, version, featureType);
+
+            expect(createdUrl.origin).toEqual("https://mapservice.regensburg.de");
+            expect(createdUrl.pathname).toEqual("/cgi-bin/mapserv");
+            expect(createdUrl.searchParams.get("map")).toEqual("wfs.map");
+            expect(createdUrl.searchParams.get("SERVICE")).toEqual("WFS");
+            expect(createdUrl.searchParams.get("REQUEST")).toEqual("DescribeFeatureType");
+            expect(createdUrl.searchParams.get("TYPENAME")).toEqual(featureType);
+            expect(createdUrl.searchParams.get("VERSION")).toEqual(version);
+        });
+
+        it("createUrl should respect version in url", () => {
+            const url = "https://www.geosnap.info/cgi-bin/qgis_mapserv.fcgi?VERSION=1.3.0&MAP=/var/www/data/gis_data/LRARW_Burgergis/buergergis.qgz",
+                version = "1.1.0",
+                featureType = "featureType",
+                createdUrl = wfs.createReceivePossiblePropertiesUrl(url, version, featureType);
+
+            expect(createdUrl.origin).toEqual("https://www.geosnap.info");
+            expect(createdUrl.pathname).toEqual("/cgi-bin/qgis_mapserv.fcgi");
+            expect(createdUrl.searchParams.get("MAP")).toEqual("/var/www/data/gis_data/LRARW_Burgergis/buergergis.qgz");
+            expect(createdUrl.searchParams.get("SERVICE")).toEqual("WFS");
+            expect(createdUrl.searchParams.get("REQUEST")).toEqual("DescribeFeatureType");
+            expect(createdUrl.searchParams.get("TYPENAME")).toEqual(featureType);
+            expect(createdUrl.searchParams.get("VERSION")).toEqual("1.3.0");
+        });
 
+    });
     describe("loadFeaturesManually", function () {
         let tick;
 
@@ -1061,10 +1202,6 @@ describe("wfs.js", function () {
                     setTimeout(resolve, 0);
                 });
             };
-
-            if (global.fetch) {
-                global.fetch.mockClear();
-            }
         });
 
         it("load features manually", async function () {
@@ -1079,8 +1216,33 @@ describe("wfs.js", function () {
                     });
                 });
             });
-
-            const format = new WFS(),
+            const feature = new Feature({
+                    geometry: new Polygon([
+                        [
+                            [
+                                9.17782024967994,
+                                50.20836600730087
+                            ],
+                            [
+                                9.200676227149245,
+                                50.20836600730087
+                            ],
+                            [
+                                9.200676227149245,
+                                50.20873353776312
+                            ],
+                            [
+                                9.17782024967994,
+                                50.20873353776312
+                            ],
+                            [
+                                9.17782024967994,
+                                50.20836600730087
+                            ]
+                        ]]),
+                    name: "My Polygon"
+                }),
+                format = new WFS(),
                 source = new VectorSource({
                     format: format,
                     url: "https://url.de",
@@ -1094,6 +1256,10 @@ describe("wfs.js", function () {
                     url: "https://url.de"
                 };
 
+            source.getFormat().readFeatures = jest.fn().mockImplementation(() => {
+                return [feature];
+            });
+
             wfs.loadFeaturesManually(layerAttributes, source);
             await tick();
             expect(source.getFeatures()).toHaveLength(1);