@masterportal/masterportalapi 2.1.1

package/src/searchAddress/search.js

@@ -0,0 +1,184 @@
+import {zoomToSearchResult} from "../lib/zoomTo";
+
+import {parse} from "./parse";
+import {searchTypes} from "./types";
+import {searchGazetteer} from "./searchGazetteer";
+
+let abortController = null;
+
+/**
+ * Chains gazetteer request and response parser.
+ * @param {string} type from searchTypes
+ * @param {(string|string[])} values one or multiple strings, depending on type
+ * @returns {Promise<SearchResult[]>} parsed response
+ * @ignore
+ */
+function searchAndParse (type, values) {
+    return new Promise((resolve, reject) => {
+        searchGazetteer(type, values, abortController)
+            .then(results => {
+                const parsed = parse(type, results);
+
+                resolve(parsed);
+            })
+            .catch(e => reject(e));
+    });
+}
+
+/**
+ * Chains gazetteer request and response parser for street and house number.
+ * Combines streets with their available house numbers before returning.
+ * @param {string} searchstring string to search for
+ * @param {boolean} searchHouseNumbers whether to additionally search for house numbers
+ * @returns {Promise<SearchResult[]>} parsed response
+ * @ignore
+ */
+function searchAndParseStreetAndHouseNumber (searchstring, searchHouseNumbers) {
+    return new Promise((resolve, reject) => {
+        searchGazetteer(searchTypes.STREET, searchstring, abortController)
+            .then(streetResults => parse(searchTypes.STREET, streetResults))
+            .then(parsedStreetResults => {
+                const allSearches = [];
+
+                for (let i = 0; i < parsedStreetResults.length; i++) {
+                    // put street in front of street's street+hnr as ordering
+                    allSearches.push([parsedStreetResults[i]]);
+                    if (searchHouseNumbers) {
+                        allSearches.push(searchAndParse(searchTypes.HOUSE_NUMBERS_FOR_STREET, parsedStreetResults[i].name));
+                    }
+                }
+
+                return Promise.all(allSearches);
+            })
+            .then(allResults => resolve([].concat(...allResults)))
+            .catch(e => reject(e));
+    });
+}
+
+/**
+ * The search function uses the configured gazetteer to retrieve geospatial information
+ * regarding a search string. Use the parameters to decide what to search for. At least one
+ * searchX parameter must be true to start a search, or the search will be rejected.
+ * @param {String} searchstring search string
+ * @param {object} params parameter object
+ * @param {boolean} [params.zoom = false] whether to zoom to the result if it's a single hit
+ * @param {boolean} [params.zoomToParams] parameter object forwarded to ol/View.fit function {@link https://openlayers.org/en/latest/apidoc/module-ol_View.html#~FitOptions}
+ * @param {ol/Map} [params.map] map object must be given if zoomTo is true
+ * @param {boolean} [params.searchAddress = false] set true to search for a whole address
+ * @param {boolean} [params.searchStreets = false] set true to search for streets
+ * @param {boolean} [params.searchHouseNumbers = false] set true to search for house numbers; only works if searchStreets is true
+ * @param {boolean} [params.searchDistricts = false] set true to search for districts
+ * @param {boolean} [params.searchParcels = false] set true to search for parcels
+ * @param {boolean} [params.searchStreetKey = false] set true to search for street keys
+ * @param {boolean} [params.minCharacters = 3] minimum length of searchstring
+ * @param {boolean} [abortPreviousSearch = false] if true the previous search is aborted
+ * @returns {Promise<SearchResult[]>} resolves array of search results; rejects without value if search was canceled internally
+ */
+export function search (searchstring, params, abortPreviousSearch = false) {
+    if (abortPreviousSearch && abortController !== null) {
+        abortController.abort();
+    }
+    abortController = new AbortController();
+
+    return new Promise((resolve, reject) => {
+        const {
+                map,
+                zoom = false,
+                zoomToParams,
+                searchAddress = false,
+                searchStreets = false,
+                searchDistricts = false,
+                searchParcels = false,
+                searchStreetKey = false,
+                minCharacters = 3
+            } = params,
+            // promises array
+            searches = [];
+        let {
+            searchHouseNumbers = false
+        } = params;
+
+        // stop search if search string too short
+        if (searchstring.length < minCharacters) {
+            reject({error: "Search string too short."});
+            return;
+        }
+
+        // warn if zooming will not be possible
+        if (zoom && !map) {
+            console.warn("Instructed to zoom, but required map object was not given. Zooming will be skipped.");
+        }
+
+        // warn if supposed to search for house numbers, but not street - set searchHouseNumbers false for next check
+        if (!searchStreets && searchHouseNumbers) {
+            console.warn(`Search for '${searchstring}' supposed to retrieve house numbers, but not streets. Invalid search configuration. House numbers will not be searched for as a result.`);
+            searchHouseNumbers = false;
+        }
+
+        // stop search if no search to be done
+        if (!(searchAddress || searchStreets || searchHouseNumbers || searchDistricts || searchParcels || searchStreetKey)) {
+            reject({error: `Search for '${searchstring}' received no indication what to search for. Search is canceled.`});
+            return;
+        }
+
+        if (searchStreets) {
+            searches.push(searchAndParseStreetAndHouseNumber(searchstring, searchHouseNumbers));
+        }
+
+        if (searchAddress) {
+            // assume pattern like "Streetname 41b", split to ["Streetname", "41", "b"]
+            const values = searchstring.split(/(\d+)/).map(s => s.trim()).filter(x => x),
+                // if neither two (no affix like b) or three (with affix like b) parts found, not enough (or too many) params for method - don't search
+                type = [false, false, searchTypes.ADDRESS_UNAFFIXED, searchTypes.ADDRESS_AFFIXED][values.length];
+
+            if (type) {
+                searches.push(searchAndParse(type, values));
+            }
+        }
+
+        // needs pattern that looks like a name
+        if (searchDistricts && (/^[a-z-üäöß]+$/i).test(searchstring)) {
+            searches.push(searchAndParse(searchTypes.DISTRICT, searchstring));
+        }
+
+        // needs pattern like "A12345"
+        if (searchStreetKey && (/^[a-z]{1}[0-9]{1,5}$/i).test(searchstring)) {
+            searches.push(searchAndParse(searchTypes.STREET_KEY, searchstring));
+        }
+
+        if (searchParcels) {
+            let values;
+
+            // assume pattern like "1234/1...", "1234 1...", ...
+            if ((/^[0-9]{4}[\s|/][0-9]*$/).test(searchstring)) {
+                values = searchstring.split(/[\s|/]/);
+            }
+            // ... or "12345...", where separation is after fourth character
+            else if ((/^[0-9]{5,}$/).test(searchstring)) {
+                values = [searchstring.slice(0, 4), searchstring.slice(4)];
+            }
+
+            // if searchstring didn't match a pattern, don't search
+            if (values) {
+                searches.push(searchAndParse(searchTypes.PARCEL, values));
+            }
+        }
+
+        Promise.all(searches)
+            .then(arr => {
+                const flattened = [].concat(...arr);
+
+                if (zoom && map && flattened.length === 1) {
+                    try {
+                        zoomToSearchResult(map, flattened[0], zoomToParams);
+                    }
+                    catch (e) {
+                        console.error("Zooming to element from gazetteer failed.");
+                        console.error(e);
+                    }
+                }
+                resolve(flattened);
+            })
+            .catch(e => reject(e));
+    });
+}

package/src/searchAddress/searchGazetteer.js

@@ -0,0 +1,52 @@
+import {getGazetteerUrl} from "./gazetteerUrl";
+import {searchTypes} from "./types";
+
+/**
+ * Encodes given string(s) to be usable as URI component.
+ * @param {(string[]|string)} v value(s) to encode
+ * @returns {(string[]|string)} encoded value(s)
+ * @ignore
+ */
+export function encode (v) {
+    return Array.isArray(v) ? v.map(encodeURIComponent) : encodeURIComponent(v);
+}
+
+/**
+ * Builds the part of the url query where a stored query is addressed by id.
+ * @param {string} key internal name for query froms searchTypes
+ * @param {(string[]|string)} v string for single-value queries, string[] for multi-value queries, strings in order of appearance in URL
+ * @returns {string} URL query part like "&StoryQuery_ID=queryName&param=value"
+ * @ignore
+ */
+export function getIdQuery (key, v) {
+    return {
+        [searchTypes.STREET]: encodedValue => `&StoredQuery_ID=findeStrasse&strassenname=*${encodedValue}`,
+        [searchTypes.DISTRICT]: encodedValue => `&StoredQuery_ID=findeStadtteil&stadtteilname=${encodedValue}`,
+        [searchTypes.PARCEL]: encodedValue => `&StoredQuery_ID=Flurstueck&gemarkung=${encodedValue[0]}&flurstuecksnummer=${encodedValue[1]}`,
+        [searchTypes.STREET_KEY]: encodedValue => `&StoredQuery_ID=findeStrassenSchluessel&strassenschluessel=${encodedValue}`,
+        [searchTypes.ADDRESS_AFFIXED]: encodedValue => `&StoredQuery_ID=AdresseMitZusatz&strassenname=${encodedValue[0]}&hausnummer=${encodedValue[1]}&zusatz=${encodedValue[2]}`,
+        [searchTypes.ADDRESS_UNAFFIXED]: encodedValue => `&StoredQuery_ID=AdresseOhneZusatz&strassenname=${encodedValue[0]}&hausnummer=${encodedValue[1]}`,
+        [searchTypes.HOUSE_NUMBERS_FOR_STREET]: encodedValue => `&StoredQuery_ID=HausnummernZuStrasse&strassenname=${encodedValue}`
+    }[key](encode(v));
+}
+
+/**
+ * Retrieves xml text for a gazetteer search.
+ * @param {string} key internal name for query froms searchTypes
+ * @param {(string[]|string)} value value to search for
+ * @param {AbortController} abortController the controller to abort the search
+ * @returns {Promise<string>} xhr response text
+ * @ignore
+ */
+export function searchGazetteer (key, value, abortController) {
+    return new Promise((resolve, reject) => {
+        const url = getGazetteerUrl() + getIdQuery(key, value);
+
+        fetch(url, {
+            signal: abortController?.signal,
+            timeout: 6000
+        })
+            .then(response => resolve(response.text()))
+            .catch(error => reject(error));
+    });
+}

package/src/searchAddress/showGeographicIdentifier.js

@@ -0,0 +1,20 @@
+import defaults from "../defaults";
+
+let showGeographicIdentifier = defaults.showGeographicIdentifier;
+
+/**
+ * Sets whether geographicIdentifier should be used as name of a search result.
+ * @param {boolean} show geographicIdentifier should be used as name of a search result
+ * @returns {void}
+ */
+export function setShowGeographicIdentifier (show) {
+    show ? showGeographicIdentifier = show : null;
+}
+
+/**
+ * Retrieves active gazetteer URL.
+ * @returns {boolean} geographicIdentifier should be used as name of a search result
+ */
+export function getShowGeographicIdentifier () {
+    return showGeographicIdentifier;
+}

package/src/searchAddress/types.js

@@ -0,0 +1,17 @@
+// enum-like object to avoid typos
+export const searchTypes = {
+    STREET: "street",
+    DISTRICT: "district",
+    PARCEL: "parcel",
+    STREET_KEY: "streetKey",
+    ADDRESS_AFFIXED: "addressAffixed",
+    ADDRESS_UNAFFIXED: "addressUnaffixed",
+    HOUSE_NUMBERS_FOR_STREET: "houseNumbersForStreet"
+};
+
+/**
+* @typedef {Object} SearchResult
+* @property {String} type which kind of hit this is
+* @property {object} properties contents of the hit as parsed by xml2js - e.g. contains $ keys for xml attributes
+* @property {object} geometry may be a point, a bbox, a polygon, ...
+*/

package/test/.eslintrc

@@ -0,0 +1,7 @@
+{
+    "env": {
+        "node": true,
+        "jest": true,
+        "browser": true
+    }
+}

package/test/crs.test.js

@@ -0,0 +1,109 @@
+import {Map, View} from "ol";
+import proj4 from "proj4";
+import * as Proj from "ol/proj.js";
+import * as crs from "../src/crs";
+
+const namedProjections = [
+    ["EPSG:31467", "+title=Bessel/Gauß-Krüger 3 +proj=tmerc +lat_0=0 +lon_0=9 +k=1 +x_0=3500000 +y_0=0 +ellps=bessel +datum=potsdam +units=m +no_defs"],
+    ["EPSG:25832", "+title=ETRS89/UTM 32N +proj=utm +zone=32 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs"],
+    ["EPSG:8395", "+title=ETRS89/Gauß-Krüger 3 +proj=tmerc +lat_0=0 +lon_0=9 +k=1 +x_0=3500000 +y_0=0 +ellps=GRS80 +datum=GRS80 +units=m +no_defs"],
+    ["EPSG:4326", "+title=WGS 84 (long/lat) +proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs"]
+];
+
+describe("crs.js", function () {
+    beforeAll(() => crs.registerProjections(namedProjections));
+
+    describe("registerProjections", function () {
+        it("registers the projections", function () {
+            // registerProjection was called in beforeAll
+            namedProjections.forEach(namedProjection => {
+                const proj4Return = proj4.defs(namedProjection[0]),
+                    olReturn = Proj.get(namedProjection[0]);
+
+                expect(typeof proj4Return).toBe("object");
+                expect(typeof olReturn).toBe("object");
+            });
+        });
+    });
+
+    describe("getProjection", function () {
+        it("returns the proj4 projection", function () {
+            expect(crs.getProjection("EPSG:25832")).toEqual(proj4.defs("EPSG:25832"));
+        });
+    });
+
+    describe("getProjections", function () {
+        it("returns all known projections", function () {
+            const projections = crs.getProjections(),
+                projectionNames = projections.map(entry => entry.name),
+                knownProjectionNames = namedProjections.map(entry => entry[0]);
+
+            // proj4 may come with default projections, hence >=
+            expect(projectionNames.length >= knownProjectionNames.length).toBe(true);
+            projections.forEach(projection => expect(typeof projection).toBe("object"));
+            knownProjectionNames.forEach(name => expect(projectionNames).toContain(name.replace("EPSG:", "http://www.opengis.net/gml/srs/epsg.xml#")));
+        });
+    });
+
+    describe("transform", function () {
+        it("transforms based on projection names", function () {
+            const resultA = crs.transform("EPSG:25832", "EPSG:4326", [0, 0]),
+                resultB = crs.transform("EPSG:4326", "EPSG:25832", resultA);
+
+            expect(resultA[0]).toBeCloseTo(4.511256115);
+            expect(resultA[1]).toBe(0);
+            expect(resultB[0]).toBeCloseTo(0);
+            expect(resultB[1]).toBe(0);
+        });
+
+        it("transforms based on projections", function () {
+            const resultA = crs.transform(proj4.defs("EPSG:25832"), proj4.defs("EPSG:4326"), [0, 0]),
+                resultB = crs.transform(proj4.defs("EPSG:4326"), proj4.defs("EPSG:25832"), resultA);
+
+            expect(resultA[0]).toBeCloseTo(4.511256115);
+            expect(resultA[1]).toBe(0);
+            expect(resultB[0]).toBeCloseTo(0);
+            expect(resultB[1]).toBe(0);
+        });
+
+        it("returns undefined and logs error if transformation can not be performed", function () {
+            const consoleError = console.error,
+                mockError = jest.fn();
+            let result = null;
+
+            console.error = mockError;
+            result = crs.transform(proj4.defs("EPSG:WHOOPS_TYPO"), proj4.defs("EPSG:4326"), [0, 0]);
+            expect(result).toBeUndefined();
+            expect(mockError.mock.calls.length).toBe(1);
+            console.error = consoleError;
+        });
+    });
+
+    describe("transformToMapProjection", function () {
+        it("transforms point to map's current projection", function () {
+            const map = new Map({
+                    view: new View({
+                        projection: "EPSG:4326"
+                    })
+                }),
+                result = crs.transformToMapProjection(map, "EPSG:25832", [0, 0]);
+
+            expect(result[0]).toBeCloseTo(4.511256115);
+            expect(result[1]).toBe(0);
+        });
+    });
+
+    describe("transformFromMapProjection", function () {
+        it("transforms point from map's current projection", function () {
+            const map = new Map({
+                    view: new View({
+                        projection: "EPSG:25832"
+                    })
+                }),
+                result = crs.transformFromMapProjection(map, "EPSG:4326", [0, 0]);
+
+            expect(result[0]).toBeCloseTo(4.511256115);
+            expect(result[1]).toBe(0);
+        });
+    });
+});

package/test/layer/geojson/index.test.js

@@ -0,0 +1,133 @@
+import VectorLayer from "ol/layer/Vector";
+import VectorSource from "ol/source/Vector.js";
+import Feature from "ol/Feature";
+import {Style, Icon} from "ol/style.js";
+import {geojson} from "../../../src";
+
+const features = [new Feature(), new Feature()];
+
+describe("geojson/index", function () {
+    describe("createLayer", function () {
+        it("creates an ol/layer/Vector", function () {
+            const layer = geojson.createLayer({});
+
+            expect(layer).toBeInstanceOf(VectorLayer);
+        });
+
+        it("uses default layer style, unless layerStyle is explicitly given", function () {
+            function styleFunction () {
+                return null;
+            }
+            const styledLayer = geojson.createLayer({id: "id", style: styleFunction});
+
+            expect(styledLayer).toBeInstanceOf(VectorLayer);
+            expect(styledLayer.get("id")).toEqual("id");
+            expect(styledLayer.getSource()).toBeInstanceOf(VectorSource);
+            expect(styledLayer.getStyleFunction()).toBeDefined();
+            expect(styledLayer.getStyleFunction()).toEqual(styleFunction);
+        });
+    });
+    describe("createLayer with additional params and options", function () {
+        it("creates a VectorLayer with layerParams", function () {
+            const layerParams = {
+                    name: "name",
+                    layers: "layer1, layer2"
+                },
+                layer = geojson.createLayer({id: "id"}, {layerParams});
+
+            expect(layer).toBeInstanceOf(VectorLayer);
+            expect(layer.get("id")).toEqual("id");
+            expect(layer.getSource()).toBeInstanceOf(VectorSource);
+            expect(layer.get("name")).toEqual("name");
+            expect(layer.get("layers")).toEqual("layer1, layer2");
+        });
+        it("creates a VectorLayer with style in options", function () {
+            function styleFunction () {
+                const icon = new Style({
+                    image: new Icon({
+                        src: "https://building.png",
+                        scale: 0.5,
+                        opacity: 1
+                    })
+                });
+
+                return [icon];
+            }
+            const options = {
+                    style: styleFunction
+                },
+                layerParams = {
+                    name: "name",
+                    layers: "layer1, layer2"
+                },
+                layer = geojson.createLayer({id: "id"}, {layerParams, options});
+
+            expect(layer).toBeInstanceOf(VectorLayer);
+            expect(layer.get("id")).toEqual("id");
+            expect(layer.getSource()).toBeInstanceOf(VectorSource);
+            expect(layer.getStyleFunction()).toBeDefined();
+            expect(layer.getStyleFunction()).toEqual(options.style);
+            expect(layer.get("name")).toEqual("name");
+            expect(layer.get("layers")).toEqual("layer1, layer2");
+        });
+    });
+
+    describe("createLayerSource", function () {
+        it("sets format and url for remote geojson", function () {
+            const source = geojson.createLayerSource({url: "example.com/geo.json"}, {loadingStrategy: {}});
+
+            expect(source.getFormat()).toBeDefined();
+            expect(source.getUrl()).toBeDefined();
+        });
+
+    });
+
+    describe("setFeatureStyle", function () {
+        it("sets a given style to all given features", function () {
+            function styleFunction () {
+                return null;
+            }
+
+            geojson.setFeatureStyle(features, styleFunction);
+            expect(features[0].getStyle()).toBe(styleFunction);
+            expect(features[1].getStyle()).toBe(styleFunction);
+        });
+    });
+
+    describe("hideAllFeatures", function () {
+        it("sets all features' styles of a layer to the null constant function", function () {
+            const layer = geojson.createLayer({id: "id"});
+
+            layer.getSource().addFeatures(features);
+
+            geojson.hideAllFeatures(layer);
+            layer.getSource().getFeatures().forEach(feature => expect(feature.getStyle()()).toBeNull());
+        });
+    });
+    describe("showAllFeatures", function () {
+        it("sets all features' styles of a layer to undefined", function () {
+            const layer = geojson.createLayer({id: "id"});
+
+            layer.getSource().addFeatures(features);
+            geojson.hideAllFeatures(layer);
+            geojson.showAllFeatures(layer);
+            layer.getSource().getFeatures().forEach(feature => expect(feature.getStyle()).toBeUndefined());
+        });
+    });
+    describe("showFeaturesById", function () {
+        it("sets features with id visible, and all others invisible; unknown ids are ignored", () => {
+            const layer = geojson.createLayer({id: "id"});
+
+            layer.getSource().addFeatures(features);
+
+            geojson.showFeaturesById(layer, []);
+            expect(features[0].getStyle()()).toBeNull();
+            expect(features[1].getStyle()()).toBeNull();
+
+            geojson.showFeaturesById(layer, ["2", "9"]);
+
+            expect(features[0].getStyle()()).toBeNull();
+            expect(features[1].getStyle()()).toBeNull();
+        });
+    });
+});

package/test/layer/geojson/style.test.js

@@ -0,0 +1,46 @@
+import {Style} from "ol/style.js";
+
+import style, {setCustomStyles} from "../../../src/layer/geojson/style";
+
+const types = [
+    "Point",
+    "LineString",
+    "MultiLineString",
+    "MultiPoint",
+    "MultiPolygon",
+    "Polygon",
+    "GeometryCollection",
+    "Circle"
+];
+
+function mockFeature (type) {
+    return {
+        getGeometry: () => ({
+            getType: () => type
+        })
+    };
+}
+
+describe("geojson/style", function () {
+    // reset module in case another test changed it
+    beforeEach(() => setCustomStyles({}));
+
+    describe("style", function () {
+        it("returns default styling for all openlayers feature types", function () {
+            types.forEach(type => expect(style(mockFeature(type))).toBeInstanceOf(Style));
+        });
+
+        it("uses custom styles first, if set", function () {
+            const custom = {
+                Point: 1,
+                Polygon: 1
+            };
+
+            setCustomStyles(custom);
+
+            types.forEach(type => custom[type]
+                ? expect(typeof style(mockFeature(type))).toBe("number")
+                : expect(style(mockFeature(type))).toBeInstanceOf(Style));
+        });
+    });
+});

package/test/layer/lib.test.js

@@ -0,0 +1,83 @@
+import * as lib from "../../src/layer/lib";
+
+describe("wms.js", function () {
+    describe("isLayerVisibleInResolution", function () {
+        it("returns true if layer is visible from x to y and resolution r is x<=r<=y", function () {
+            const mockLayer = {
+                getMaxResolution: () => 5,
+                getMinResolution: () => 2
+            };
+
+            expect(lib.isLayerVisibleInResolution(mockLayer, {resolution: 1})).toBe(false);
+            expect(lib.isLayerVisibleInResolution(mockLayer, {resolution: 2})).toBe(true);
+            expect(lib.isLayerVisibleInResolution(mockLayer, {resolution: 3})).toBe(true);
+            expect(lib.isLayerVisibleInResolution(mockLayer, {resolution: 4})).toBe(true);
+            expect(lib.isLayerVisibleInResolution(mockLayer, {resolution: 5})).toBe(true);
+            expect(lib.isLayerVisibleInResolution(mockLayer, {resolution: 6})).toBe(false);
+        });
+    });
+
+    describe("getLegendURLs", function () {
+        const expectedBaseString = "example.com?SERVICE=WMS&REQUEST=GetLegendGraphic&FORMAT=image/png&VERSION=0.0.1&LAYER=";
+
+        it("returns the defined legendURL if given via services.json", function () {
+            const legendURL = lib.getLegendURLs({
+                legendURL: "example.com/legend.png",
+                layers: "a,b",
+                url: "example.com",
+                version: "0.0.1",
+                typ: "WMS"
+            });
+
+            expect(legendURL).toEqual(["example.com/legend.png"]);
+        });
+
+        it("returns an empty array if legendURL is defined as 'ignore' services.json", function () {
+            const legendURL = lib.getLegendURLs({
+                legendURL: "ignore",
+                layers: "a,b",
+                url: "example.com",
+                version: "0.0.1",
+                typ: "WMS"
+            });
+
+            expect(legendURL).toEqual([]);
+        });
+
+        it("returns an empty array if no layers were requested", function () {
+            const legendURLs = lib.getLegendURLs({
+                layers: "",
+                url: "example.com",
+                version: "0.0.1",
+                typ: "WMS"
+            });
+
+            expect(legendURLs.length).toBe(0);
+        });
+
+        it("returns one correct legend URL if one layer was requested", function () {
+            const legendURLs = lib.getLegendURLs({
+                layers: "a",
+                url: "example.com",
+                version: "0.0.1",
+                typ: "WMS"
+            });
+
+            expect(legendURLs.length).toBe(1);
+            expect(legendURLs[0]).toEqual(expectedBaseString + "a");
+        });
+
+        it("returns multiple correct legend URLs if multiple layers were requested", function () {
+            const legendURLs = lib.getLegendURLs({
+                layers: "a,b",
+                url: "example.com",
+                version: "0.0.1",
+                typ: "WMS"
+            });
+
+            expect(legendURLs.length).toBe(2);
+            expect(legendURLs[0]).toEqual(expectedBaseString + "a");
+            expect(legendURLs[1]).toEqual(expectedBaseString + "b");
+        });
+    });
+});