@masterportal/masterportalapi 2.21.0 → 2.22.0

package/CHANGELOG.md

@@ -3,13 +3,35 @@
 
  The [Semantic Versioning](https://semver.org/spec/v2.0.0.html) is used.
 
-## 2.21.0 - 2023-07-20
+## Unreleased - in development
+### Added
+
+### Changed
+
+### Deprecated
+
+### Removed
+
+### Fixed
+
+
+---
+## 2.22.0 - 2023-07-25
 ### Added
 - VectorStyle: Add Styling rules for Geoemtries of type `Circle`.
 - Add Styling and zIndex to draw interactions and improve the draw behavior.
 
 ### Changed
 - Changed peerDependency from cesium 1.106.0 to @cesium/engine 2.4.1.
+- WFS: 
+    - Migrated writeTransaction and sendTransaction from masterportal the masterportalAPI.
+    - Exports in src/layer/wfs.js changed to export default {} to provide  ES-Syntax.
+### Deprecated
+
+### Removed
+
+### Fixed
+- WFS: fixed a bug that prevented parsing GeoServer responses.
 
 ---
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@masterportal/masterportalapi",
   "author": "Implementierungspartnerschaft Masterportal <info@masterportal.org> (https://www.masterportal.org)",
-  "version": "2.21.0",
+  "version": "2.22.0",
   "license": "MIT",
   "description": "Basic functions of the Masterportal as api",
   "repository": {
@@ -38,6 +38,7 @@
     "jest": "^29.5.0",
     "jest-canvas-mock": "^2.5.0",
     "jest-environment-jsdom": "^29.5.0",
+    "jest-fetch-mock": "^3.0.3",
     "jsdoc": "^4.0.2",
     "parcel": "^2.8.3",
     "process": "^0.11.10",

package/src/index.js

@@ -4,7 +4,7 @@ import drawInteractions from "./maps/interactions/drawInteractions";
 import rawLayerList from "./rawLayerList";
 import * as wms from "./layer/wms";
 import wmts from "./layer/wmts";
-import * as wfs from "./layer/wfs";
+import wfs from "./layer/wfs";
 import * as geojson from "./layer/geojson";
 import * as vectorBase from "./layer/vectorBase";
 import * as vectorTile from "./layer/vectorTile";

package/src/layer/wfs.js

@@ -154,7 +154,7 @@ function createUrl (rawLayer, version, projection, bboxParam) {
  * {@link https://openlayers.org/en/latest/apidoc/module-ol_source_Vector-VectorSource.html failure/success see}
  * @returns {(ol.source.VectorSource|ol.source.Cluster)} VectorSource or Cluster, depending on whether clusterDistance is set.
  */
-export function createLayerSource (rawLayer, options = {}) {
+function createLayerSource (rawLayer, options = {}) {
     if (!options.loadingStrategy) {
         options.loadingStrategy = bbox;
     }
@@ -175,10 +175,15 @@ export function createLayerSource (rawLayer, options = {}) {
         }
         else {
             const bboxParam = options.loadingStrategy === bbox ? `&bbox=${extent.join(",")},${projection.getCode()}` : "";
-            let url = createUrl(rawLayer, version, projection, bboxParam);
+            let url = createUrl(rawLayer, version, projection, bboxParam),
+                params = {};
 
             if (options.loadingParams) {
                 for (const key in options.loadingParams) {
+                    if (key === "xhrParameters") {
+                        params = options.loadingParams.xhrParameters;
+                        continue;
+                    }
                     const option = Array.isArray(options.loadingParams[key]) ? options.loadingParams[key].join(",") : options.loadingParams[key];
 
                     if (option !== undefined && key === "bbox") {
@@ -189,7 +194,7 @@ export function createLayerSource (rawLayer, options = {}) {
                     }
                 }
             }
-            loadWFS(url, {}, source, {onErrorFn: onError, success, failure}, options);
+            loadWFS(url, params, source, {onErrorFn: onError, success, failure}, options);
         }
     }
     format.featureType = rawLayer.featureType;
@@ -224,7 +229,7 @@ export function createLayerSource (rawLayer, options = {}) {
  * @param {options} [optionalParams.options] - additional options
  * @returns {ol.Layer} Layer that can be added to map.
  */
-export function createLayer (rawLayer = {}, {layerParams = {}, options = {}} = {}) {
+function createLayer (rawLayer = {}, {layerParams = {}, options = {}} = {}) {
     let layer, source;
 
     // use WebGL render pipeline, if specified
@@ -260,13 +265,227 @@ export function createLayer (rawLayer = {}, {layerParams = {}, options = {}} = {
     return layer;
 }
 
+/**
+ * Writes a wfs transaction including the given feature for given layer
+ * inserting, updated or deleting the feature depending on the given selectedInteraction.
+ *
+ * @param {ol/Feature} feature Feature to be inserted, updated or deleted.
+ * @param {Object} transactionOptions Information about the layer to be manipulated.
+ * @param {string} transactionMethod Which transaction to perform. Possible values are: "insert"|"delete"|"selectedUpdate"
+ * @param {string} srsName EPSG code currently used by the map.
+ * @returns {string} WFS Transaction as an XML Node as String.
+ */
+
+function writeTransactionBody (feature, transactionOptions, transactionMethod, version = "1.1.0") {
+    const transactionPosition = {
+            insert: 0,
+            selectedUpdate: 1,
+            delete: 2
+        },
+        transaction = [[], [], []];
+
+    if (transactionMethod !== "insert" && transactionMethod !== "delete" && transactionMethod !== "selectedUpdate") {
+        throw new Error("transactionMethod has to be \"insert\", \"selectedUpdate\" or \"delete\".");
+    }
+
+    transaction[transactionPosition[transactionMethod]].push(feature);
+    return new XMLSerializer()
+        .serializeToString(new WFS({version})
+            .writeTransaction(...transaction, transactionOptions));
+}
+
+/**
+ * Checks if it is an unknown or special error and returns the code and the error message
+ *
+ * @param {Object} xmlDocument with the error
+ * @returns {Object} the code and the specific or unknown error looking like this {code, message}
+ */
+function getExceptionFromTransactionResponse (xmlDocument) {
+    const response = {code: null, message: "genericFailedTransaction"},
+        exception = xmlDocument.getElementsByTagName(`${xmlDocument.getElementsByTagName("Exception").length === 0 ? "ows:" : ""}Exception`)[0],
+        exceptionText = exception.getElementsByTagName(`${xmlDocument.getElementsByTagName("ExceptionText").length === 0 ? "ows:" : ""}ExceptionText`)[0];
+
+    if (exceptionText !== undefined) {
+        response.message = exceptionText.textContent;
+        console.error("WfsTransaction: An error occurred when sending the transaction to the service.", exceptionText.textContent);
+    }
+    else {
+        response.message = "WfsTransaction: An unkown error occurred when sending the transaction to the service.";
+        console.error(response.message);
+    }
+    if (exception?.attributes.getNamedItem("code") || exception?.attributes.getNamedItem("exceptionCode")) {
+        response.code = exception.attributes.getNamedItem(`${exception?.attributes.getNamedItem("code") ? "c" : "exceptionC"}ode`).textContent;
+    }
+
+    return response;
+}
+
+
+/**
+ * Sends a transaction to the service and returns the feature.
+ *
+ * @param {string} srsName of the coordinate reference system
+ * @param {ol/Feature} feature Feature to by inserted / updated / deleted.
+ * @param {string} url of the wfs-t service
+ * @param {Object} layer the configured representation of the layer in the Masterportal
+ * @param {string} transactionMethod which transaction to perform. Possible values are: "insert"|"delete"|"selectedUpdate"
+ * @returns {ol/Feature} the given feature
+ * @throws {Error} error if occurs
+ */
+async function sendTransaction (srsName, feature, url, layer, transactionMethod) {
+    let exception,
+        response,
+        xmlDocument = null,
+        transactionSummary = null,
+        data = null;
+
+    const {featureNS, featurePrefix, featureType, version} = layer;
+
+    try {
+        response = await fetch(url, {
+            method: "POST",
+            headers: {"Content-Type": "text/xml"},
+            credentials: layer.isSecured ? "include" : "omit",
+            body: writeTransactionBody(feature,
+                {featureNS, featurePrefix, featureType, version, srsName},
+                transactionMethod,
+                version),
+            responseType: "text"
+        });
+
+        data = await response.text();
+
+        xmlDocument = new DOMParser().parseFromString(data, "text/xml");
+        transactionSummary = xmlDocument.getElementsByTagName("wfs: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) {
+            exception = getExceptionFromTransactionResponse(xmlDocument);
+            throw new Error(exception.code ? exception.code + ": " + exception.message : exception.message);
+        }
+    }
+    catch (e) {
+        console.error(e);
+        throw e;
+    }
+
+    return feature;
+}
+
+/**
+ * Parses the response of a DescribeFeatureType request
+ * and prepares its values for later use as an input value for the user.
+ *
+ * @param {string} responseData XML response data
+ * @param {string} featureType Name of the feature type of the service.
+ * @returns {Array} If an <element> with a name of the featureType is present, an array of prepared feature properties; else an empty Array.
+ */
+function parseDescribeFeatureTypeResponse (responseData, featureType) {
+
+    const parsedResponse = new DOMParser().parseFromString(responseData, "application/xml");
+
+    let prefix = "",
+        foundElement = null;
+
+    if (parsedResponse.getElementsByTagName("xsd:element").length > 0) {
+        prefix = "xsd:";
+    }
+    else if (parsedResponse.getElementsByTagName("xs:element").length > 0) {
+        prefix = "xs";
+    }
+
+    // Check if featureType applies to the response
+    foundElement = Object.values(parsedResponse.getElementsByTagName(prefix + "element")).find(element => element.getAttribute("name") === featureType);
+
+    if (foundElement) {
+        let sequenceElements;
+
+        if (foundElement.hasChildNodes()) {
+            sequenceElements = Object.values(foundElement.getElementsByTagName(prefix + "sequence"));
+        }
+        else {
+            sequenceElements = Object.values(parsedResponse.getElementsByTagName(prefix + "sequence"));
+        }
+
+        const elements = [];
+
+        sequenceElements.forEach(sequenceElement => {
+            elements.push(...Object.values(sequenceElement.getElementsByTagName(prefix + "element")));
+        });
+
+        return elements.map(el => Object.values(el.attributes).reduce((obj, att) => {
+            if (att.localName === "minOccurs") {
+                obj.required = att.value === "1";
+            }
+            else if (att.localName === "type") {
+                if (att.value.trim().startsWith("gml")) {
+                    obj.type = "geometry";
+                }
+                else {
+                    let value = att.value;
+
+                    if (prefix.length > 0) {
+                        value = value.replace(prefix, "");
+                    }
+
+                    switch (value) {
+                        case "long":
+                            obj.type = "integer";
+                            break;
+                        default:
+                            obj.type = value;
+                    }
+                }
+            }
+            else if (att.localName === "name") {
+                obj.label = obj.key = att.value;
+            }
+            return obj;
+        }, {
+            label: "",
+            key: "",
+            value: null,
+            type: "string",
+            required: false
+        }));
+    }
+    return [];
+}
+
+/**
+ * Requests the possible properties of a feature and further values;
+ * for more {@see FeatureProperty}.
+ *
+ * @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
+ * @param {boolean} isSecured Whether the layer is secured by BasicAuth and should include or omit the credentials prompt
+ * @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;
+
+    try {
+        response = await fetch(baseUrl, {
+            responseType: "text/xml",
+            credentials: isSecured ? "include" : "omit"
+        });
+        return parseDescribeFeatureTypeResponse(await response.text(), featureType);
+    }
+    catch (e) {
+        console.error(e);
+        throw e;
+    }
+}
+
 /**
  * Load the features manually.
  * @param {Object} layerAttributes raw layer attributes.
  * @param {module:ol/vector/Source} layerSource - the source of the layer
  * @returns {void}
  */
-export function loadFeaturesManually (layerAttributes, layerSource) {
+function loadFeaturesManually (layerAttributes, layerSource) {
     const getUrl = createUrl(layerAttributes, layerAttributes.version, {getCode: () => layerAttributes.crs}, "");
 
     fetch(getUrl, layerSource)
@@ -278,3 +497,5 @@ export function loadFeaturesManually (layerAttributes, layerSource) {
             console.error(error);
         });
 }
+
+export default {createLayerSource, createLayer, sendTransaction, receivePossibleProperties, parseDescribeFeatureTypeResponse, writeTransactionBody, loadFeaturesManually};

package/src/maps/ol/olMap.js

@@ -6,7 +6,7 @@ import defaults from "../../defaults";
 import * as wms from "../../layer/wms";
 import wmts from "../../layer/wmts";
 import * as geojson from "../../layer/geojson";
-import * as wfs from "../../layer/wfs";
+import wfs from "../../layer/wfs";
 import * as vectorBase from "../../layer/vectorBase";
 import * as vectortile from "../../layer/vectorTile";
 import * as oaf from "../../layer/oaf";

package/test/layer/wfs.test.js

@@ -1,3 +1,4 @@
+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";
@@ -5,10 +6,13 @@ import {Style, Icon} from "ol/style.js";
 import map from "../../src/maps/map.js";
 import defaults from "../../src/defaults";
 import {WFS} from "ol/format.js";
-import * as wfs from "../../src/layer/wfs";
+import wfs from "../../src/layer/wfs";
 import {featureCollection} from "./resources/wfsFeatures";
 import {wfsFilterQuery} from "./resources/wfsFilter";
 import * as webgl from "../../src/renderer/webgl.js";
+import {Feature} from "ol";
+import Polygon from "ol/geom/Polygon";
+
 
 jest.mock("../../src/rawLayerList.js", () => {
     const original = jest.requireActual("../../src/rawLayerList.js");
@@ -26,6 +30,22 @@ jest.mock("../../src/renderer/webgl.js", () => {
 
 
 describe("wfs.js", function () {
+
+    const originalConsoleError = console.error;
+
+    beforeAll(() => {
+        console.error = jest.fn();
+    });
+
+    afterAll(() => {
+        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"});
@@ -123,17 +143,12 @@ describe("wfs.js", function () {
         });
     });
     describe("createLayerSource", function () {
-        const consoleError = console.error;
-
         beforeEach(() => {
             if (global.fetch) {
                 global.fetch.mockClear();
             }
         });
-        // to reset show error on load in console
-        afterEach(() => {
-            console.error = consoleError;
-        });
+
         it("creates a VectorSource and beforeLoading, afterLoading and featuresFilter are called", function () {
             global.fetch = jest.fn().mockImplementationOnce(() => {
                 return new Promise((resolve) => {
@@ -312,8 +327,6 @@ describe("wfs.js", function () {
                     });
                 });
             });
-            // to reset show error on load in console when testing 'onLoadingError'
-            console.error = jest.fn();
 
             const map2D = map.createMap(defaults),
                 url = "https://url.de",
@@ -413,9 +426,618 @@ describe("wfs.js", function () {
             source.getListeners("featuresloadend")[0]({features: []});
             expect(webgl.afterLoading).toHaveBeenCalled();
         });
+        it("creates a vectorSource with credentials: include as params", () => {
+            global.fetch = jest.fn().mockImplementationOnce(() => {
+                // NOTE: fetch only rejects if a network error occurs, which do not apply to 4xx or 5xx http codes.
+                return new Promise((resolve) => {
+                    resolve({
+                        ok: true,
+                        status: 200,
+                        text: () => {
+                            return featureCollection;
+                        }
+                    });
+                });
+            });
+
+            const map2D = map.createMap(defaults),
+                url = "https://url.de",
+                rawLayer = {
+                    id: "id",
+                    url: url,
+                    featureNS: "http://www.deegree.org/app",
+                    featureType: "krankenhaeuser_hh",
+                    version: "2.0.0"
+                },
+                options = {
+                    loadingParams: {xhrParameters: {credentials: "include"}}
+                },
+                layer = wfs.createLayer(rawLayer, {options});
+
+            layer.getSource().loadFeatures([-10000, -10000, 10000, 10000],
+                1,
+                map2D.getView().getProjection());
+
+            expect(fetch).toHaveBeenCalledWith("https://url.de/?service=WFS&version=2.0.0&request=GetFeature&srsName=EPSG%3A25832&typeNames=krankenhaeuser_hh&bbox=-10000,-10000,10000,10000,EPSG:25832", {"credentials": "include"});
+        });
+    });
+    describe("parseDescribeFeatureTypeResponse", () => {
+        const exampleDescribeFeatureType = "<?xml version='1.0' encoding='UTF-8'?>\n" +
+                "<schema xmlns=\"http://www.w3.org/2001/XMLSchema\" xmlns:gml=\"http://www.opengis.net/gml\" xmlns:app=\"http://www.deegree.org/app\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" targetNamespace=\"http://www.deegree.org/app\" elementFormDefault=\"qualified\" attributeFormDefault=\"unqualified\">\n" +
+                "  <import namespace=\"http://www.opengis.net/gml\" schemaLocation=\"http://schemas.opengis.net/gml/3.1.1/base/gml.xsd\"/>\n" +
+                "  <element name=\"wfstgeom\" substitutionGroup=\"gml:_Feature\">\n" +
+                "    <complexType>\n" +
+                "      <complexContent>\n" +
+                "        <extension base=\"gml:AbstractFeatureType\">\n" +
+                "          <sequence>\n" +
+                "            <element name=\"name\" minOccurs=\"0\" type=\"string\"/>\n" +
+                "            <element name=\"nummer\" minOccurs=\"0\" type=\"integer\"/>\n" +
+                "            <element name=\"bemerkung\" minOccurs=\"0\" type=\"string\"/>\n" +
+                "            <element name=\"datum\" minOccurs=\"0\" type=\"date\"/>\n" +
+                "            <element name=\"geom\" minOccurs=\"0\" type=\"gml:GeometryPropertyType\"/>\n" +
+                "          </sequence>\n" +
+                "        </extension>\n" +
+                "      </complexContent>\n" +
+                "    </complexType>\n" +
+                "  </element>\n" +
+                "</schema>",
+            exampleProperties = [
+                {
+                    key: "name",
+                    label: "name",
+                    required: false,
+                    type: "string",
+                    value: null
+                },
+                {
+                    key: "nummer",
+                    label: "nummer",
+                    required: false,
+                    type: "integer",
+                    value: null
+                },
+                {
+                    key: "bemerkung",
+                    label: "bemerkung",
+                    required: false,
+                    type: "string",
+                    value: null
+                },
+                {
+                    key: "datum",
+                    label: "datum",
+                    required: false,
+                    type: "date",
+                    value: null
+                },
+                {
+                    key: "geom",
+                    label: "geom",
+                    required: false,
+                    type: "geometry",
+                    value: null
+                }
+            ],
+
+            exampleDescribeFeatureType2 = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n" +
+                "<xsd:schema xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:gml=\"http://www.opengis.net/gml/3.2\" xmlns:gsm_wfs=\"gsm_wfs\" xmlns:wfs=\"http://www.opengis.net/wfs/2.0\" elementFormDefault=\"qualified\" targetNamespace=\"gsm_wfs\">\n" +
+                "<xsd:import namespace=\"http://www.opengis.net/gml/3.2\" schemaLocation=\"https://geoportal-konfig.muenchen.de/geoserver/schemas/gml/3.2.1/gml.xsd\"/>\n" +
+                "<xsd:complexType name=\"wfstgeomType\">\n" +
+                "<xsd:complexContent>\n" +
+                "<xsd:extension base=\"gml:AbstractFeatureType\">\n" +
+                "<xsd:sequence>\n" +
+                "<xsd:element maxOccurs=\"1\" minOccurs=\"0\" name=\"name\" nillable=\"true\" type=\"xsd:string\"/>\n" +
+                "<xsd:element maxOccurs=\"1\" minOccurs=\"0\" name=\"nummer\" nillable=\"true\" type=\"xsd:double\"/>\n" +
+                "<xsd:element maxOccurs=\"1\" minOccurs=\"0\" name=\"shape\" nillable=\"true\" type=\"gml:GeometryPropertyType\"/>\n" +
+                "</xsd:sequence>\n" +
+                "</xsd:extension>\n" +
+                "</xsd:complexContent>\n" +
+                "</xsd:complexType>\n" +
+                "<xsd:element name=\"wfstgeom\" substitutionGroup=\"gml:AbstractFeature\" type=\"gsm_wfs:kultur_rbe1_museenType\"/>\n" +
+                "</xsd:schema>",
+
+            exampleProperties2 = [
+                {
+                    key: "name",
+                    label: "name",
+                    required: false,
+                    type: "string",
+                    value: null
+                },
+                {
+                    key: "nummer",
+                    label: "nummer",
+                    required: false,
+                    type: "double",
+                    value: null
+                },
+                {
+                    key: "shape",
+                    label: "shape",
+                    required: false,
+                    type: "geometry",
+                    value: null
+                }
+            ];
+
+        let featureType;
+
+        it("should retrieve the element values (required, type, key) from the parsed XML string if an element with name = featureType can be found in the XML for Example 1", () => {
+            featureType = "wfstgeom";
+
+            const featureProperties = wfs.parseDescribeFeatureTypeResponse(exampleDescribeFeatureType, featureType);
+
+            expect(Array.isArray(featureProperties)).toBe(true);
+            expect(featureProperties.length).toEqual(5);
+            exampleProperties.forEach(property => {
+                const parsedProperty = featureProperties.find(({key}) => key === property.key);
+
+                expect(parsedProperty).not.toEqual(undefined);
+                expect(parsedProperty).toEqual(property);
+            });
+        });
+        it("should return an empty array if no element with name = featureType can be found in the XML Example 1", () => {
+            featureType = "myCoolType";
+
+            const featureProperties = wfs.parseDescribeFeatureTypeResponse(exampleDescribeFeatureType, featureType);
+
+            expect(Array.isArray(featureProperties)).toBe(true);
+            expect(featureProperties.length).toEqual(0);
+        });
+        it("should retrieve the element values (required, type, key) from the parsed XML string if an element with name = featureType can be found in the XML for Example 2", () => {
+            featureType = "wfstgeom";
+
+            const featureProperties = wfs.parseDescribeFeatureTypeResponse(exampleDescribeFeatureType2, featureType);
+
+            expect(Array.isArray(featureProperties)).toBe.true;
+            expect(featureProperties.length).toEqual(3);
+
+            exampleProperties2.forEach(property => {
+                const parsedProperty = featureProperties.find(({key}) => key === property.key);
+
+                expect(parsedProperty).not.toEqual(undefined);
+                expect(parsedProperty).toEqual(property);
+            });
+        });
+        it("should return an empty array if no element with name = featureType can be found in the XML Example 2", () => {
+            featureType = "myCoolType";
+
+            const featureProperties = wfs.parseDescribeFeatureTypeResponse(exampleDescribeFeatureType2, featureType);
+
+            expect(Array.isArray(featureProperties)).toBe(true);
+            expect(featureProperties.length).toEqual(0);
+        });
+
+    });
+    describe("writeTransactionBody", () => {
+        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"
+            }),
+
+            transactionOptions = {
+                featureNS: "myNS",
+                featurePrefix: "myPrefix",
+                featureType: "Polygon",
+                srsName: "EPSG:4326"
+            };
+
+
+        it("should write a transaction body for inserting a feature", () => {
+            const transactionBody = wfs.writeTransactionBody(feature, transactionOptions, "insert"),
+                expectedBody = "<Transaction xmlns=\"http://www.opengis.net/wfs\" service=\"WFS\" version=\"1.1.0\" xmlns:ns1=\"http://www.w3.org/2001/XMLSchema-instance\" ns1:schemaLocation=\"http://www.opengis.net/wfs http://schemas.opengis.net/wfs/1.1.0/wfs.xsd\"><Insert><Polygon xmlns=\"myNS\"><geometry><Polygon xmlns=\"http://www.opengis.net/gml\" srsName=\"EPSG:4326\"><exterior><LinearRing srsName=\"EPSG:4326\"><posList srsDimension=\"2\">50.20836600730087 9.17782024967994 50.20836600730087 9.200676227149245 50.20873353776312 9.200676227149245 50.20873353776312 9.17782024967994 50.20836600730087 9.17782024967994</posList></LinearRing></exterior></Polygon></geometry><name>My Polygon</name></Polygon></Insert></Transaction>";
+
+            expect(transactionBody).toEqual(expectedBody);
+        });
+
+        it("should write a transaction body for updating a feature", () => {
+            feature.setId(1);
+            const transactionBody = wfs.writeTransactionBody(feature, transactionOptions, "selectedUpdate"),
+                expectedBody = "<Transaction xmlns=\"http://www.opengis.net/wfs\" service=\"WFS\" version=\"1.1.0\" xmlns:ns1=\"http://www.w3.org/2001/XMLSchema-instance\" ns1:schemaLocation=\"http://www.opengis.net/wfs http://schemas.opengis.net/wfs/1.1.0/wfs.xsd\"><Update typeName=\"myPrefix:Polygon\" xmlns:myPrefix=\"myNS\"><Property><Name>geometry</Name><Value><Polygon xmlns=\"http://www.opengis.net/gml\" srsName=\"EPSG:4326\"><exterior><LinearRing srsName=\"EPSG:4326\"><posList srsDimension=\"2\">50.20836600730087 9.17782024967994 50.20836600730087 9.200676227149245 50.20873353776312 9.200676227149245 50.20873353776312 9.17782024967994 50.20836600730087 9.17782024967994</posList></LinearRing></exterior></Polygon></Value></Property><Property><Name>name</Name><Value>My Polygon</Value></Property><Filter xmlns=\"http://www.opengis.net/ogc\"><FeatureId fid=\"1\"/></Filter></Update></Transaction>";
+
+            expect(transactionBody).toEqual(expectedBody);
+        });
+
+        it("should write a transaction body for deleting a feature", () => {
+            feature.setId(1);
+            const transactionBody = wfs.writeTransactionBody(feature, transactionOptions, "delete"),
+                expectedBody = "<Transaction xmlns=\"http://www.opengis.net/wfs\" service=\"WFS\" version=\"1.1.0\" xmlns:ns1=\"http://www.w3.org/2001/XMLSchema-instance\" ns1:schemaLocation=\"http://www.opengis.net/wfs http://schemas.opengis.net/wfs/1.1.0/wfs.xsd\"><Delete typeName=\"myPrefix:Polygon\" xmlns:myPrefix=\"myNS\"><Filter xmlns=\"http://www.opengis.net/ogc\"><FeatureId fid=\"1\"/></Filter></Delete></Transaction>";
+
+            expect(transactionBody).toEqual(expectedBody);
+        });
+
+        it("should throw error if transactionMethod is invalid", () => {
+            expect(() => wfs.writeTransactionBody(feature, transactionOptions, "remove")).toThrow(Error);
+            expect(() => wfs.writeTransactionBody(feature, transactionOptions, "remove")).toThrow("transactionMethod has to be \"insert\", \"selectedUpdate\" or \"delete\".");
+        });
+    });
+
+    describe("receivePossibleProperties", () => {
+        const exampleDescribeFeatureType = "<?xml version='1.0' encoding='UTF-8'?>\n" +
+                "<schema xmlns=\"http://www.w3.org/2001/XMLSchema\" xmlns:gml=\"http://www.opengis.net/gml\" xmlns:sf=\"http://cite.opengeospatial.org/gmlsf\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" targetNamespace=\"http://cite.opengeospatial.org/gmlsf\" elementFormDefault=\"qualified\" attributeFormDefault=\"unqualified\">\n" +
+                "  <import namespace=\"http://www.opengis.net/gml\" schemaLocation=\"http://schemas.opengis.net/gml/3.1.1/base/gml.xsd\"/>\n" +
+                "  <element name=\"wfstpoint\" substitutionGroup=\"gml:_Feature\">\n" +
+                "    <complexType>\n" +
+                "      <complexContent>\n" +
+                "        <extension base=\"gml:AbstractFeatureType\">\n" +
+                "          <sequence>\n" +
+                "            <element name=\"geometry\" minOccurs=\"0\" type=\"gml:PointPropertyType\"/>\n" +
+                "            <element name=\"name\" minOccurs=\"0\" type=\"string\"/>\n" +
+                "            <element name=\"baumnummer\" minOccurs=\"0\" type=\"integer\"/>\n" +
+                "            <element name=\"bemerkung\" minOccurs=\"0\" type=\"string\"/>\n" +
+                "            <element name=\"datum\" minOccurs=\"0\" type=\"date\"/>\n" +
+                "            <element name=\"isNew\" minOccurs=\"0\" type=\"boolean\"/>\n" +
+                "            <element name=\"isUpdate\" minOccurs=\"0\" type=\"boolean\"/>\n" +
+                "          </sequence>\n" +
+                "        </extension>\n" +
+                "      </complexContent>\n" +
+                "    </complexType>\n" +
+                "  </element>\n" +
+                "  <element name=\"wfstline\" substitutionGroup=\"gml:_Feature\">\n" +
+                "    <complexType>\n" +
+                "      <complexContent>\n" +
+                "        <extension base=\"gml:AbstractFeatureType\">\n" +
+                "          <sequence>\n" +
+                "            <element name=\"geometry\" minOccurs=\"0\" type=\"gml:LineStringPropertyType\"/>\n" +
+                "            <element name=\"name\" minOccurs=\"0\" type=\"string\"/>\n" +
+                "            <element name=\"nummer\" minOccurs=\"0\" type=\"integer\"/>\n" +
+                "            <element name=\"bemerkung\" minOccurs=\"0\" type=\"string\"/>\n" +
+                "            <element name=\"datum\" minOccurs=\"0\" type=\"date\"/>\n" +
+                "          </sequence>\n" +
+                "        </extension>\n" +
+                "      </complexContent>\n" +
+                "    </complexType>\n" +
+                "  </element>\n" +
+                "  <element name=\"wfstpolygon\" substitutionGroup=\"gml:_Feature\">\n" +
+                "    <complexType>\n" +
+                "      <complexContent>\n" +
+                "        <extension base=\"gml:AbstractFeatureType\">\n" +
+                "          <sequence>\n" +
+                "            <element name=\"name\" minOccurs=\"0\" type=\"string\"/>\n" +
+                "            <element name=\"nummer\" minOccurs=\"0\" type=\"integer\"/>\n" +
+                "            <element name=\"bemerkung\" minOccurs=\"0\" type=\"string\"/>\n" +
+                "            <element name=\"datum\" minOccurs=\"0\" type=\"date\"/>\n" +
+                "            <element name=\"geom\" minOccurs=\"0\" type=\"gml:GeometryPropertyType\"/>\n" +
+                "          </sequence>\n" +
+                "        </extension>\n" +
+                "      </complexContent>\n" +
+                "    </complexType>\n" +
+                "  </element>\n" +
+                "</schema>",
+            geoserverDescribeFeatureType = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><xsd:schema xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:gml=\"http://www.opengis.net/gml/3.2\" xmlns:test=\"http://opengeo.org/test\" xmlns:wfs=\"http://www.opengis.net/wfs/2.0\" elementFormDefault=\"qualified\" targetNamespace=\"http://opengeo.org/test\">\n" +
+                "  <xsd:import namespace=\"http://www.opengis.net/gml/3.2\" schemaLocation=\"https://geoservice.norderstedt.de/geoserver/schemas/gml/3.2.1/gml.xsd\"/>\n" +
+                "  <xsd:complexType name=\"test_polygonType\">\n" +
+                "    <xsd:complexContent>\n" +
+                "      <xsd:extension base=\"gml:AbstractFeatureType\">\n" +
+                "        <xsd:sequence>\n" +
+                "          <xsd:element maxOccurs=\"1\" minOccurs=\"0\" name=\"id\" nillable=\"true\" type=\"xsd:long\"/>\n" +
+                "          <xsd:element maxOccurs=\"1\" minOccurs=\"0\" name=\"geom\" nillable=\"true\" type=\"gml:SurfacePropertyType\"/>\n" +
+                "          <xsd:element maxOccurs=\"1\" minOccurs=\"0\" name=\"hochkomma\" nillable=\"true\" type=\"xsd:string\"/>\n" +
+                "        </xsd:sequence>\n" +
+                "      </xsd:extension>\n" +
+                "    </xsd:complexContent>\n" +
+                "  </xsd:complexType>\n" +
+                "  <xsd:element name=\"test_polygon\" substitutionGroup=\"gml:AbstractFeature\" type=\"test:test_polygonType\"/>\n" +
+                "</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),
+                exampleProperties = [
+                    {
+                        key: "name",
+                        label: "name",
+                        required: false,
+                        type: "string",
+                        value: null
+                    },
+                    {
+                        key: "nummer",
+                        label: "nummer",
+                        required: false,
+                        type: "integer",
+                        value: null
+                    },
+                    {
+                        key: "bemerkung",
+                        label: "bemerkung",
+                        required: false,
+                        type: "string",
+                        value: null
+                    },
+                    {
+                        key: "datum",
+                        label: "datum",
+                        required: false,
+                        type: "date",
+                        value: null
+                    },
+                    {
+                        key: "geom",
+                        label: "geom",
+                        required: false,
+                        type: "geometry",
+                        value: null
+                    }
+                ];
+
+            expect(Array.isArray(properties)).toBe(true);
+            expect(properties.length).toEqual(5);
+            exampleProperties.forEach(property => {
+                const parsedProperty = properties.find(({key}) => key === property.key);
+
+                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"});
+
+        });
+
+        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),
+                exampleProperties = [
+                    {
+                        key: "id",
+                        label: "id",
+                        required: false,
+                        type: "integer",
+                        value: null
+                    },
+                    {
+                        key: "geom",
+                        label: "geom",
+                        required: false,
+                        type: "geometry",
+                        value: null
+                    },
+                    {
+                        key: "hochkomma",
+                        label: "hochkomma",
+                        required: false,
+                        type: "string",
+                        value: null
+                    }
+                ];
+
+            expect(Array.isArray(properties)).toBe(true);
+            expect(properties.length).toEqual(3);
+            exampleProperties.forEach(property => {
+                const parsedProperty = properties.find(({key}) => key === property.key);
+
+                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"});
+
+        });
+
+        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),
+                exampleProperties = [
+                    {
+                        key: "name",
+                        label: "name",
+                        required: false,
+                        type: "string",
+                        value: null
+                    },
+                    {
+                        key: "nummer",
+                        label: "nummer",
+                        required: false,
+                        type: "integer",
+                        value: null
+                    },
+                    {
+                        key: "bemerkung",
+                        label: "bemerkung",
+                        required: false,
+                        type: "string",
+                        value: null
+                    },
+                    {
+                        key: "datum",
+                        label: "datum",
+                        required: false,
+                        type: "date",
+                        value: null
+                    },
+                    {
+                        key: "geom",
+                        label: "geom",
+                        required: false,
+                        type: "geometry",
+                        value: null
+                    }
+                ];
+
+            expect(Array.isArray(properties)).toBe(true);
+            expect(properties.length).toEqual(5);
+            exampleProperties.forEach(property => {
+                const parsedProperty = properties.find(({key}) => key === property.key);
+
+                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"});
+
+        });
+
+        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);
+        });
+    });
+
+    describe("sendTransaction", () => {
+        const layer = {
+                id: Symbol("layerId"),
+                url: "some.good.url",
+                isSecured: false,
+                featureNS: "wfsgeom",
+                featurePrefix: "test",
+                featureType: "Polygon",
+                version: "1.1.0"
+            },
+            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"
+            }),
+            srsName = "EPSG:4326",
+            url = "https://team-waas-was-here.lgln",
+            insertTransaction = "insert",
+            updateTransaction = "selectedUpdate",
+            deleteTransaction = "delete",
+            fetchResponseInsert = "<?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>1</wfs:totalInserted>\n" +
+                "    <wfs:totalUpdated>0</wfs:totalUpdated>\n" +
+                "    <wfs:totalDeleted>0</wfs:totalDeleted>\n" +
+                "  </wfs:TransactionSummary>\n" +
+                "  <wfs:InsertResults>\n" +
+                "    <wfs:Feature>\n" +
+                "      <ogc:FeatureId fid=\"wfst.59\"/>\n" +
+                "    </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" +
+                "    <wfs:totalInserted>0</wfs:totalInserted>\n" +
+                "    <wfs:totalUpdated>0</wfs:totalUpdated>\n" +
+                "    <wfs:totalDeleted>1</wfs:totalDeleted>\n" +
+                "  </wfs:TransactionSummary>\n" +
+                "</wfs:TransactionResponse>";
+
+        it("should return the inserted feature if the transaction was successful", async function () {
+            fetch.mockResponseOnce(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);
+            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);
+            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);
+            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);
+            feature.setId(1);
+
+            await expect(async () => wfs.sendTransaction(srsName, feature, url, layer, "löschen")).rejects.toThrow(Error);
+        });
+
+        it("should send a request and show an alert with a generic error message if no transactionsSummary is present in the XML response", async () => {
+            const failedResponse = "<?xml version='1.0' encoding='UTF-8'?>\n" +
+                "<ows:ExceptionReport xmlns:ows=\"http://www.opengis.net/ows\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"http://www.opengis.net/ows http://schemas.opengis.net/ows/1.0.0/owsExceptionReport.xsd\" version=\"1.0.0\">\n" +
+                "  <ows:Exception" +
+                "    <ows:ExceptionText>Cannot perform insert operation: Error in XML document (line: 1, column: 234, character offset: 233): Feature type \"{wrong}wfst\" is unknown.</ows:ExceptionText>\n" +
+                "  </ows:Exception>\n" +
+                "</ows:ExceptionReport>";
+
+            fetch.mockResponseOnce(failedResponse);
+
+            await expect(async () => wfs.sendTransaction(srsName, feature, url, layer, insertTransaction)).rejects.toThrow(Error);
+        });
+
+        it("should send a request, show an alert with a generic error message if no transactionsSummary is present in the XML response and log an error if an exceptionText is present in the XML response", async () => {
+            const failedResponse = "<?xml version='1.0' encoding='UTF-8'?>\n" +
+                "<ows:ExceptionReport xmlns:ows=\"http://www.opengis.net/ows\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"http://www.opengis.net/ows http://schemas.opengis.net/ows/1.0.0/owsExceptionReport.xsd\" version=\"1.0.0\">\n" +
+                "  <ows:Exception>" +
+                "    <ows:ExceptionText>Cannot perform insert operation: Error in XML document (line: 1, column: 234, character offset: 233): Feature type \"{wrong}wfst\" is unknown.</ows:ExceptionText>\n" +
+                "  </ows:Exception>\n" +
+                "</ows:ExceptionReport>";
+
+            fetch.mockResponseOnce(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("loadFeaturesManually", function () {
-        const consoleError = console.error;
         let tick;
 
         beforeEach(() => {
@@ -429,10 +1051,6 @@ describe("wfs.js", function () {
                 global.fetch.mockClear();
             }
         });
-        // to reset show error on load in console
-        afterEach(() => {
-            console.error = consoleError;
-        });
 
         it("load features manually", async function () {
             global.fetch = jest.fn().mockImplementationOnce(() => {
@@ -468,3 +1086,4 @@ describe("wfs.js", function () {
     });
 });
 
+