@masterportal/masterportalapi 2.39.0 → 2.40.1

package/CHANGELOG.md

@@ -17,13 +17,38 @@
 ### Fixed
 
 ---
+
+## 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
+- vectorStyle: enables support for additional polygon highlighting, including default styles.
+
+### Changed
+- Replace `XMLHttpRequest` with `fetch` in `initializeLayerList`
+
+### Fixed
+- OAF-Layer: bbox and bboxCrs are respected when building url.
+- OAF-Layer: prevent url to not use more than one questionmark.
+
+---
+
 ## 2.39.0 - 2024-06-18
 
 ### Changed
-    - peerDependencies:
-        - @cesium/engine: 6.2.0 to 9.2.0
+- peerDependencies:
+    - @cesium/engine: 6.2.0 to 9.2.0
 
 ---
+
 ## 2.38.0 - 2024-06-04
 
 ### Added

package/example/config/services.json

@@ -105,7 +105,8 @@
     "url": "https://api.hamburg.de/datasets/v1/schulen",
     "collection": "staatliche_schulen",
     "typ": "OAF",
-    "crs": "http://www.opengis.net/def/crs/EPSG/0/25832"
+    "crs": "http://www.opengis.net/def/crs/EPSG/0/25832",
+    "bboxCrs": "http://www.opengis.net/def/crs/EPSG/0/25832"
   },
   {
     "id": "8712",

package/package.json

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

package/src/layer/oaf.js

@@ -3,7 +3,6 @@ import {bbox} from "ol/loadingstrategy.js";
 import GeoJSON from "ol/format/GeoJSON.js";
 import {createVectorSource, createClusterVectorSource} from "./vector";
 import {onError, onLoad} from "../lib/wfsUtil";
-import {getParamsUrl} from "../lib/oafUtil";
 import * as webgl from "../renderer/webgl";
 
 /**
@@ -110,20 +109,75 @@ function loadSource (url, source, {onErrorFn, success, failure}, options, collec
         });
 }
 
+/**
+ * Creates the url for OAF request.
+ * @param {rawLayer} rawLayer layer specification as in services.json
+ * @param {object} loadingParams added as params to url
+ * @param {number[]} [extent] the current viewport extent
+ * @returns {string} the url
+ */
+export function createUrl (rawLayer, loadingParams) {
+    const bboxParam = loadingParams?.bbox || rawLayer.bbox,
+        rawUrl = rawLayer.url;
+    let bboxValue = typeof bboxParam === "string" && bboxParam.length ? bboxParam : null,
+        url = null;
+
+    url = new URL(rawUrl);
+    if (typeof rawLayer.collection === "string") {
+        if (!url.pathname.endsWith("/")) {
+            url.pathname += "/collections/" + rawLayer.collection + "/items";
+        }
+        else {
+            url.pathname = "collections/" + rawLayer.collection + "/items";
+        }
+
+    }
+    if (typeof rawLayer.limit === "number") {
+        url.searchParams.set("limit", rawLayer.limit);
+    }
+    if (Array.isArray(bboxParam) && bboxParam.length === 4) {
+        bboxValue = bboxParam.join(",");
+    }
+    if (bboxValue) {
+        url.searchParams.set("bbox", bboxParam);
+        if (typeof rawLayer.bboxCrs === "string" && rawLayer.bboxCrs !== "") {
+            url.searchParams.set("bbox-crs", rawLayer.bboxCrs);
+        }
+    }
+    if (typeof rawLayer.crs === "string") {
+        url.searchParams.set("crs", rawLayer.crs);
+    }
+    if (typeof rawLayer.datetime === "string" && rawLayer.datetime !== "") {
+        url.searchParams.set("datetime", rawLayer.datetime);
+    }
+    if (typeof rawLayer.params === "object" && Object.keys(rawLayer.params).length) {
+        Object.entries(rawLayer.params).forEach(([key, value]) => {
+            url.searchParams.set(key, value);
+        });
+    }
+
+    return url;
+}
+
 /**
  * Creates an ol/source element for the rawLayer by using a loader.
  * The 'featuresloadend' and 'featuresloaderror' events will be fired by using success and failure callbacks of the loader.
  * @param {rawLayer} rawLayer layer specification as in services.json
  * @param {options} [options] additional options
- * @param {String} url the parsed url
  * {@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.
  */
-function getLayerSource (rawLayer, options, url) {
+function getLayerSource (rawLayer, options) {
     const format = new GeoJSON();
     let source = null;
 
-    function loader (extent, resolution, projection, success, failure) {
+    function loader (extent, _, __, success, failure) {
+        const bboxParam = options.loadingStrategy === bbox ? extent : options.loadingParams.bbox,
+            url = createUrl(rawLayer, {
+                ...options.loadingParams,
+                bbox: bboxParam
+            });
+
         loadSource(url, source, {onErrorFn: onError, success, failure}, options);
     }
     source = createVectorSource(loader, options.loadingStrategy, format);
@@ -138,36 +192,6 @@ function getLayerSource (rawLayer, options, url) {
     return source;
 }
 
-/**
- * Creates the url for OAF request.
- * @param {rawLayer} rawLayer layer specification as in services.json
- * @returns {string} the url
- */
-function createUrl (rawLayer) {
-    let url = rawLayer.url,
-        appendingString;
-    const crsDefault = "";
-
-    url += typeof rawLayer.collection === "string" ? "/collections/" + rawLayer.collection + "/items?" : "";
-    url += typeof rawLayer.limit === "number" ? "limit=" + rawLayer.limit + "&" : "";
-    if (Array.isArray(rawLayer.bbox) && rawLayer.bbox.length === 4) {
-        appendingString = "";
-
-        rawLayer.bbox.forEach((bboxEntry, i) => {
-            appendingString += i !== rawLayer.bbox.length - 1 ? bboxEntry + "," : bboxEntry;
-        });
-        url += "bbox=" + appendingString + "&";
-    }
-    url += typeof rawLayer.bboxCrs === "string" && rawLayer.bboxCrs !== "" ? "bbox-crs=" + encodeURIComponent(rawLayer.bboxCrs) + "&" : "";
-    if (rawLayer.crs !== false) {
-        url += "crs=" + encodeURIComponent(typeof rawLayer.crs === "string" && rawLayer.crs !== "" ? rawLayer.crs : crsDefault) + "&";
-    }
-    url += typeof rawLayer.datetime === "string" && rawLayer.datetime !== "" ? "datetime=" + rawLayer.datetime + "&" : "";
-    url += getParamsUrl(rawLayer.params);
-
-    return url;
-}
-
 /**
  * Creates an ol/source element for the rawLayer by OAF (XML or Geojson)
  * @param {rawLayer} rawLayer layer specification as in services.json
@@ -182,9 +206,7 @@ function createLayerSource (rawLayer, options = {}) {
     if (!options.loadingStrategy) {
         options.loadingStrategy = bbox;
     }
-
-    const url = createUrl(rawLayer),
-        source = getLayerSource(rawLayer, options, url);
+    const source = getLayerSource(rawLayer, options);
 
     if (rawLayer.renderer === "webgl") {
         source.once("featuresloadend", event => {
@@ -261,4 +283,4 @@ function loadFeaturesManually (layerAttributes, layerSource) {
         });
 }
 
-export default {createLayer, createLayerSource, loadFeaturesManually};
+export default {createLayer, createLayerSource, createUrl, loadFeaturesManually};

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/src/rawLayerList.js

@@ -26,28 +26,25 @@ function initializeLayerList (layerConf = defaults.layerConf, callback) {
     }
 
     // case: parameter is URL
-    const Http = new XMLHttpRequest();
-
-    Http.open("GET", layerConf);
-    Http.timeout = 10000;
-    Http.send();
-    Http.onload = function () {
-        try {
-            layerList = JSON.parse(Http.responseText);
-        }
-        catch (error) {
-            console.error("An error occured when parsing the response after loading '" + layerConf + "':", error);
-            return callback(false, error);
-        }
-        if (typeof callback === "function") {
-            return callback(layerList);
-        }
-        return true;
-    };
-    Http.onerror = function (e) {
-        console.error("An error occured when trying to fetch services from '" + layerConf + "':", e);
-        callback(false, e);
-    };
+    fetch(layerConf, {method: "GET", timeout: 10000})
+        .then((response) => {
+            response.json()
+                .then((json) => {
+                    layerList = json;
+                    if (typeof callback === "function") {
+                        return callback(layerList);
+                    }
+                    return true;
+                })
+                .catch((error) => {
+                    console.error("An error occured when parsing the response after loading '" + layerConf + "':", error);
+                    return callback(false, error);
+                });
+        })
+        .catch((error) => {
+            console.error("An error occured when trying to fetch services from '" + layerConf + "':", error);
+            callback(false, error);
+        });
 }
 
 /**

package/src/vectorStyle/styleList.js

@@ -14,6 +14,7 @@ let styleList,
     configuredTools,
     mapMarkerPointStyleId,
     mapMarkerPolygonStyleId,
+    additionalPolygonStyleId,
     highlightFeaturesPointStyleId,
     highlightFeaturesPolygonStyleId,
     highlightFeaturesLineStyleId,
@@ -140,6 +141,23 @@ function getStyleIdForMapMarkerPolygon () {
     return styleId;
 }
 
+/**
+ * Gets the style id for an additional MapMarker.
+ * If the additionalPolygonStyleId exists, return it; otherwise, returns the default styleId.
+ * @returns {String} - The styleId of the additional MapMarker
+ */
+function getStyleIdForAdditionalMapMarkerPolygon () {
+    let styleId;
+
+    if (additionalPolygonStyleId) {
+        styleId = additionalPolygonStyleId;
+    }
+    else {
+        styleId = "defaultAdditionalMapMarkerPolygon";
+    }
+    return styleId;
+}
+
 /**
  * gets style id from HighlightFeatures
  * @returns {String} - Style id of highlightFeatures.
@@ -186,6 +204,7 @@ function parseStyles (data) {
     dataWithDefaultValue.push({styleId: "default", rules: [{style: {}}]},
         defaultStyle.defaultMapMarkerPoint,
         defaultStyle.defaultMapMarkerPolygon,
+        defaultStyle.defaultAdditionalMapMarkerPolygon,
         defaultStyle.defaultHighlightFeaturesPoint,
         defaultStyle.defaultHighlightFeaturesPolygon,
         defaultStyle.defaultHighlightFeaturesLine);
@@ -193,6 +212,7 @@ function parseStyles (data) {
     styleIds.push(getStyleIdsFromLayers(),
         getStyleIdForMapMarkerPoint(),
         getStyleIdForMapMarkerPolygon(),
+        getStyleIdForAdditionalMapMarkerPolygon(),
         getStyleIdForHighlightFeaturesPoint(),
         getStyleIdForHighlightFeaturesPolygon(),
         getStyleIdForHighlightFeaturesLine(),
@@ -222,6 +242,7 @@ async function initializeStyleList (styleGetters, Config, layers, tools, callbac
 
     mapMarkerPointStyleId = styleGetters.mapMarkerPointStyleId;
     mapMarkerPolygonStyleId = styleGetters.mapMarkerPolygonStyleId;
+    additionalPolygonStyleId = styleGetters.additionalPolygonStyleId;
     highlightFeaturesPointStyleId = styleGetters.highlightFeaturesPointStyleId;
     highlightFeaturesPolygonStyleId = styleGetters.highlightFeaturesPolygonStyleId;
     highlightFeaturesLineStyleId = styleGetters.highlightFeaturesLineStyleId;

package/src/vectorStyle/styles/defaultStyles.js

@@ -137,6 +137,17 @@ const defaultColors = {
                 }
             }]
         },
+        defaultAdditionalMapMarkerPolygon: {
+            styleId: "defaultAdditionalMapMarkerPolygon",
+            rules: [{
+                style: {
+                    polygonStrokeColor: [255, 255, 0, 1],
+                    polygonStrokeWidth: 4,
+                    polygonFillColor: [255, 255, 0, 0.3],
+                    polygonStrokeDash: [8]
+                }
+            }]
+        },
         defaultHighlightFeaturesPoint: {
             styleId: "defaultHighlightFeaturesPoint",
             rules: [{

package/test/layer/oaf.test.js

@@ -38,7 +38,7 @@ describe("oaf.js", function () {
             const attr = {
                     "id": "id",
                     "name": "Schulen",
-                    "url": "https://url.de",
+                    "url": "https://url",
                     "collection": "staatliche_schulen",
                     "typ": "OAF",
                     "bbox": "",
@@ -137,7 +137,7 @@ describe("oaf.js", function () {
             console.error = consoleError;
         });
         it("creates a GeoJSON VectorSource", function () {
-            global.fetch = jest.fn().mockImplementationOnce(() => {
+            global.fetch = jest.fn().mockImplementation(() => {
                 return new Promise((resolve) => {
                     resolve({
                         ok: true,
@@ -153,7 +153,7 @@ describe("oaf.js", function () {
             const rawLayer = {
                     id: "id",
                     name: "Schulen",
-                    url: "https://url.de",
+                    url: "https://url",
                     collection: "staatliche_schulen",
                     typ: "OAF",
                     limit: 10,
@@ -167,7 +167,7 @@ describe("oaf.js", function () {
             expect(layer.getSource().getFormat()).toBeInstanceOf(GeoJSON);
         });
         it("creates a VectorSource and onLoadingError is called", function () {
-            global.fetch = jest.fn().mockImplementationOnce(() => {
+            global.fetch = jest.fn().mockImplementation(() => {
                 return new Promise((resolve) => {
                     resolve({
                         ok: false,
@@ -184,7 +184,7 @@ describe("oaf.js", function () {
             const rawLayer = {
                     id: "id",
                     name: "Schulen",
-                    url: "https://url.de",
+                    url: "https://url",
                     collection: "staatliche_schulen",
                     typ: "OAF",
                     limit: 10,
@@ -206,7 +206,7 @@ describe("oaf.js", function () {
             });
         });
         it("creates a clustered VectorSource and beforeLoading, afterLoading and featuresFilter are called", function () {
-            global.fetch = jest.fn().mockImplementationOnce(() => {
+            global.fetch = jest.fn().mockImplementation(() => {
                 return new Promise((resolve) => {
                     resolve({
                         ok: true,
@@ -223,7 +223,7 @@ describe("oaf.js", function () {
                 rawLayer = {
                     id: "id",
                     name: "Schulen",
-                    url: "https://url.de",
+                    url: "https://url",
                     collection: "staatliche_schulen",
                     typ: "OAF",
                     limit: 10,
@@ -259,7 +259,7 @@ describe("oaf.js", function () {
         });
         it("creates a vectorSource with an additional listener, when renderer is \"webgl\"", () => {
             const
-                url = "https://url.de",
+                url = "https://url",
                 rawLayer = {
                     id: "id",
                     url: url,
@@ -290,7 +290,7 @@ describe("oaf.js", function () {
     describe("loadFeaturesManually", function () {
         it("loadFeaturesManually shall call fetch", function () {
             console.error = jest.fn();
-            global.fetch = jest.fn().mockImplementationOnce(() => {
+            global.fetch = jest.fn().mockImplementation(() => {
                 return new Promise((resolve) => {
                     resolve({
                         ok: true,
@@ -304,7 +304,7 @@ describe("oaf.js", function () {
 
             const rawLayer = {
                     id: "id",
-                    url: "url",
+                    url: "https://url",
                     featureNS: "http://www.deegree.org/app",
                     featureType: "krankenhaeuser_hh",
                     version: "1.0.0"
@@ -317,4 +317,84 @@ describe("oaf.js", function () {
             expect(global.fetch.mock.calls.length).toBe(1);
         });
     });
+    describe("createUrl", () => {
+        it("should append bbox, collection, limit, datetime, bboxCrs, and crs, as provided in rawLayer", () => {
+            const rawLayer = {
+                    id: "id",
+                    name: "Schulen",
+                    url: "https://url.de",
+                    collection: "staatliche_schulen",
+                    typ: "OAF",
+                    limit: 10,
+                    bbox: [0, 0, 10, 10],
+                    bboxCrs: "EPSG:4326",
+                    datetime: "123",
+                    crs: "EPSG:25832"
+                },
+                loadingParams = undefined,
+                createdUrl = oaf.createUrl(rawLayer, loadingParams);
+
+            expect(createdUrl.origin).toEqual(rawLayer.url);
+            expect(createdUrl.pathname).toEqual("/collections/" + rawLayer.collection + "/items");
+            expect(createdUrl.searchParams.get("limit")).toEqual("10");
+            expect(createdUrl.searchParams.get("bbox")).toEqual("0,0,10,10");
+            expect(createdUrl.searchParams.get("bbox-crs")).toEqual(rawLayer.bboxCrs);
+            expect(createdUrl.searchParams.get("crs")).toEqual(rawLayer.crs);
+            expect(createdUrl.searchParams.get("datetime")).toEqual(rawLayer.datetime);
+        });
+        it("should append the bbox, if provided as string in rawLayer", () => {
+            const rawLayer = {
+                    id: "id",
+                    name: "Schulen",
+                    url: "https://url.de",
+                    collection: "staatliche_schulen",
+                    typ: "OAF",
+                    bbox: "0,0,10,10",
+                    bboxCrs: "EPSG:4326"
+                },
+                loadingParams = undefined,
+                createdUrl = oaf.createUrl(rawLayer, loadingParams);
+
+            expect(createdUrl.origin).toEqual(rawLayer.url);
+            expect(createdUrl.pathname).toEqual("/collections/" + rawLayer.collection + "/items");
+            expect(createdUrl.searchParams.get("bbox")).toEqual("0,0,10,10");
+            expect(createdUrl.searchParams.get("bbox-crs")).toEqual(rawLayer.bboxCrs);
+        });
+        it("should append the bbox, if provided as string in loadingParams", () => {
+            const rawLayer = {
+                    id: "id",
+                    name: "Schulen",
+                    url: "https://mapservice.regensburg.de/cgi-bin/mapserv?map=wfs.map",
+                    collection: "staatliche_schulen",
+                    typ: "OAF"
+                },
+                loadingParams = {bbox: "0,0,10,10"},
+                createdUrl = oaf.createUrl(rawLayer, loadingParams);
+
+            expect(createdUrl.origin).toEqual("https://mapservice.regensburg.de");
+            expect(createdUrl.pathname).toEqual("/cgi-bin/mapserv/collections/" + rawLayer.collection + "/items");
+            expect(createdUrl.searchParams.get("map")).toEqual("wfs.map");
+            expect(createdUrl.searchParams.get("bbox")).toEqual("0,0,10,10");
+        });
+        it("should append additional key:value filters, if provided as in rawLayer.params", () => {
+            const rawLayer = {
+                    id: "id",
+                    name: "Schulen",
+                    url: "https://url/",
+                    collection: "staatliche_schulen",
+                    typ: "OAF",
+                    params: {
+                        kapitelbezeichnung: "Gymnasien",
+                        anzahl_schueler: ">1000"
+                    }
+                },
+                loadingParams = undefined,
+                createdUrl = oaf.createUrl(rawLayer, loadingParams);
+
+            expect(createdUrl.origin).toEqual("https://url");
+            expect(createdUrl.pathname).toEqual("/collections/" + rawLayer.collection + "/items");
+            expect(createdUrl.searchParams.get("kapitelbezeichnung")).toEqual("Gymnasien");
+            expect(createdUrl.searchParams.get("anzahl_schueler")).toEqual(">1000");
+        });
+    });
 });

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,14 +139,9 @@ 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().mockImplementationOnce(() => {
+            global.fetch = jest.fn().mockImplementation(() => {
                 return new Promise((resolve) => {
                     resolve({
                         ok: true,
@@ -202,7 +191,7 @@ describe("wfs.js", function () {
             });
         });
         it("creates a VectorSource with doNotLoadInitially", function () {
-            global.fetch = jest.fn().mockImplementationOnce(() => {
+            global.fetch = jest.fn().mockImplementation(() => {
                 return new Promise((resolve) => {
                     resolve({
                         ok: true,
@@ -255,7 +244,7 @@ describe("wfs.js", function () {
         it("creates a VectorSource with wfsFilter", function () {
             let secondFetchCalled = false;
 
-            global.fetch = jest.fn().mockImplementationOnce(() => {
+            global.fetch = jest.fn().mockImplementation(() => {
                 return new Promise((resolve) => {
                     resolve({
                         ok: true,
@@ -265,7 +254,7 @@ describe("wfs.js", function () {
                         }
                     });
                 });
-            }).mockImplementationOnce(() => {
+            }).mockImplementation(() => {
                 return new Promise((resolve) => {
                     resolve({
                         ok: true,
@@ -317,7 +306,7 @@ describe("wfs.js", function () {
             });
         });
         it("creates a VectorSource and onLoadingError is called", function () {
-            global.fetch = jest.fn().mockImplementationOnce(() => {
+            global.fetch = jest.fn().mockImplementation(() => {
                 // NOTE: fetch only rejects if a network error occurs, which do not apply to 4xx or 5xx http codes.
                 return new Promise((resolve) => {
                     resolve({
@@ -360,7 +349,7 @@ describe("wfs.js", function () {
             });
         });
         it("creates a clustered VectorSource and beforeLoading, afterLoading and featuresFilter are called", function () {
-            global.fetch = jest.fn().mockImplementationOnce(() => {
+            global.fetch = jest.fn().mockImplementation(() => {
                 return new Promise((resolve) => {
                     resolve({
                         ok: true,
@@ -442,7 +431,7 @@ describe("wfs.js", function () {
             expect(webgl.afterLoading).toHaveBeenCalledWith(features, layerParams.styleId, layerParams.excludeTypesFromParsing, layerParams.isPointLayer);
         });
         it("creates a vectorSource with credentials: include as params", () => {
-            global.fetch = jest.fn().mockImplementationOnce(() => {
+            global.fetch = jest.fn().mockImplementation(() => {
                 // NOTE: fetch only rejects if a network error occurs, which do not apply to 4xx or 5xx http codes.
                 return new Promise((resolve) => {
                     resolve({
@@ -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,17 +937,9 @@ 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);
-        });
     });
 
     describe("sendTransaction", () => {
@@ -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,14 +1202,10 @@ describe("wfs.js", function () {
                     setTimeout(resolve, 0);
                 });
             };
-
-            if (global.fetch) {
-                global.fetch.mockClear();
-            }
         });
 
         it("load features manually", async function () {
-            global.fetch = jest.fn().mockImplementationOnce(() => {
+            global.fetch = jest.fn().mockImplementation(() => {
                 return new Promise((resolve) => {
                     resolve({
                         ok: true,
@@ -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);

package/test/searchAddress/search.test.js

@@ -33,7 +33,7 @@ jest.mock("../../src/searchAddress/searchGazetteer", () => {
 
 import {searchGazetteer as mockedSearchGazetteer} from "../../src/searchAddress/searchGazetteer";
 
-describe.only("searchAddress", function () {
+describe("searchAddress", function () {
     describe("search", function () {
         it("rejects if missing configuration of what to search for", function (done) {
             search("Pflugacker", {}).catch(e => {

package/src/lib/oafUtil.js

@@ -1,22 +0,0 @@
-/**
- * Parsing the params object in to string for url
- * @param {Object} params the paramters in object
- * @returns {String} The url parameters in string format
- */
-function getParamsUrl (params) {
-    if (!params || typeof params !== "object" || params.constructor !== Object || !Object.keys(params).length) {
-        return "";
-    }
-
-    let paramsUrl = "";
-
-    Object.entries(params).forEach(([key, value]) => {
-        paramsUrl += "&" + key + "=" + value;
-    });
-
-    return paramsUrl;
-}
-
-export {
-    getParamsUrl
-};

package/tall

@@ -1,59 +0,0 @@
-v1.0.0
-v1.1.0
-v1.10.0
-v1.2.0
-v1.3.0
-v1.4.0
-v1.5.0
-v1.6.0
-v1.6.1
-v1.7.0
-v1.7.1
-v1.8.0
-v1.9.0
-v2.0.0
-v2.1.0
-v2.1.1
-v2.10.0
-v2.11.0
-v2.12.0
-v2.13.0
-v2.14.0
-v2.15.0
-v2.15.1
-v2.15.2
-v2.16.0
-v2.17.0
-v2.18.0
-v2.19.0
-v2.19.1
-v2.19.2
-v2.2.0
-v2.20.0
-v2.21.0
-v2.22.0
-v2.23.0
-v2.24.0
-v2.25.0
-v2.26.0
-v2.27.0
-v2.28.0
-v2.29.0
-v2.3.0
-v2.30.0
-v2.31.0
-v2.32.0
-v2.33.0
-v2.34.0
-v2.35.0
-v2.36.0
-v2.37.0
-v2.38.0
-v2.39.0
-v2.4.0
-v2.5.0
-v2.5.1
-v2.6.0
-v2.7.0
-v2.8.0
-v2.9.0

package/test/lib/oafUtil.test.js

@@ -1,24 +0,0 @@
-import {getParamsUrl} from "../../src/lib/oafUtil";
-
-describe("oafUtil.js", function () {
-    describe("getParamsUrl", function () {
-        const params = {
-            "anzahl_schueler": ">1000",
-            "bezirk": "Bergedorf"
-        };
-
-        it("should return the parsed paramsUrl", function () {
-            expect(getParamsUrl(params)).toEqual("&anzahl_schueler=>1000&bezirk=Bergedorf");
-        });
-
-        it("should return an empty string", function () {
-            expect(getParamsUrl("string")).toEqual("");
-            expect(getParamsUrl(0)).toEqual("");
-            expect(getParamsUrl(null)).toEqual("");
-            expect(getParamsUrl(undefined)).toEqual("");
-            expect(getParamsUrl(true)).toEqual("");
-            expect(getParamsUrl([])).toEqual("");
-            expect(getParamsUrl({})).toEqual("");
-        });
-    });
-});