@masterportal/masterportalapi 2.1.1

package/test/layer/oaf.test.js

@@ -0,0 +1,245 @@
+import VectorLayer from "ol/layer/Vector.js";
+import VectorSource from "ol/source/Vector.js";
+import Cluster from "ol/source/Cluster.js";
+import {Style, Icon} from "ol/style.js";
+import map from "../../src/maps/map.js";
+import defaults from "../../src/defaults";
+import GeoJSON from "ol/format/GeoJSON.js";
+import * as oaf from "../../src/layer/oaf";
+import {featureCollection} from "./resources/oafFeatures";
+
+jest.mock("../../src/rawLayerList.js", () => {
+    const original = jest.requireActual("../../src/rawLayerList.js");
+
+    original.initializeLayerList = jest.fn();
+    return original;
+});
+
+
+describe("oaf.js", function () {
+    describe("createLayer", function () {
+        it("creates a VectorLayer without id", function () {
+            const layer = oaf.createLayer();
+
+            expect(layer).toBeInstanceOf(VectorLayer);
+            expect(layer.getSource()).toBeInstanceOf(VectorSource);
+        });
+        it("creates a VectorLayer with source", function () {
+            const attr = {
+                    "id": "id",
+                    "name": "Schulen",
+                    "url": "https://url.de",
+                    "collection": "staatliche_schulen",
+                    "typ": "OAF",
+                    "bbox": "",
+                    "bboxCrs": "",
+                    "datetime": "",
+                    "crs": ""
+                },
+                layer = oaf.createLayer(attr);
+
+            expect(layer).toBeInstanceOf(VectorLayer);
+            expect(layer.get("id")).toEqual("id");
+            expect(layer.getSource()).toBeInstanceOf(VectorSource);
+        });
+        it("creates a VectorLayer with style in rawLayer", function () {
+            function styleFunction () {
+                const icon = new Style({
+                    image: new Icon({
+                        src: "https://building.png",
+                        scale: 0.5,
+                        opacity: 1
+                    })
+                });
+
+                return [icon];
+            }
+            const layer = oaf.createLayer({id: "id", style: styleFunction});
+
+            expect(layer).toBeInstanceOf(VectorLayer);
+            expect(layer.get("id")).toEqual("id");
+            expect(layer.getSource()).toBeInstanceOf(VectorSource);
+            expect(layer.getStyleFunction()).toBeDefined();
+            expect(layer.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 = oaf.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 = oaf.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(styleFunction);
+            expect(layer.get("name")).toEqual("name");
+            expect(layer.get("layers")).toEqual("layer1, layer2");
+        });
+    });
+    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 GeoJSON VectorSource", function () {
+            global.fetch = jest.fn().mockImplementationOnce(() => {
+                return new Promise((resolve) => {
+                    resolve({
+                        ok: true,
+                        status: 200,
+                        text: () => {
+                            return {};
+                        }
+                    });
+                });
+            });
+            console.error = jest.fn();
+
+            const rawLayer = {
+                    id: "id",
+                    name: "Schulen",
+                    url: "https://url.de",
+                    collection: "staatliche_schulen",
+                    typ: "OAF",
+                    limit: 10,
+                    bbox: "",
+                    bboxCrs: "",
+                    datetime: "",
+                    crs: ""
+                },
+                layer = oaf.createLayer(rawLayer);
+
+            expect(layer.getSource().getFormat()).toBeInstanceOf(GeoJSON);
+        });
+        it("creates a VectorSource and onLoadingError is called", function () {
+            global.fetch = jest.fn().mockImplementationOnce(() => {
+                return new Promise((resolve) => {
+                    resolve({
+                        ok: false,
+                        status: 404,
+                        text: () => {
+                            return null;
+                        }
+                    });
+                });
+            });
+            // to reset show error on load in console when testing 'onLoadingError'
+            console.error = jest.fn();
+
+            const rawLayer = {
+                    id: "id",
+                    name: "Schulen",
+                    url: "https://url.de",
+                    collection: "staatliche_schulen",
+                    typ: "OAF",
+                    limit: 10,
+                    bbox: "",
+                    bboxCrs: "",
+                    datetime: "",
+                    crs: ""
+                },
+                onLoadingErrorMock = jest.fn(),
+                options = {
+                    onLoadingError: onLoadingErrorMock
+                },
+                layer = oaf.createLayer(rawLayer, {options});
+
+            // eslint-disable-next-line no-underscore-dangle
+            expect(typeof layer.getSource().loader_).toEqual("function");
+            layer.getSource().on("featuresloaderror", function () {
+                expect(onLoadingErrorMock.mock.calls.length).toBe(2);
+            });
+        });
+        it("creates a clustered VectorSource and beforeLoading, afterLoading and featuresFilter are called", function () {
+            global.fetch = jest.fn().mockImplementationOnce(() => {
+                return new Promise((resolve) => {
+                    resolve({
+                        ok: true,
+                        status: 200,
+                        json: () => {
+                            return featureCollection;
+                        }
+                    });
+                });
+            });
+            console.error = jest.fn();
+
+            const map2D = map.createMap(defaults),
+                rawLayer = {
+                    id: "id",
+                    name: "Schulen",
+                    url: "https://url.de",
+                    collection: "staatliche_schulen",
+                    typ: "OAF",
+                    limit: 10,
+                    clusterDistance: 40
+                },
+                beforeLoadingMock = jest.fn(),
+                afterLoadingMock = jest.fn(),
+                featuresFilterMock = jest.fn((features) => features),
+                clusterGeometryFunctionMock = jest.fn(),
+                options = {
+                    beforeLoading: beforeLoadingMock,
+                    afterLoading: afterLoadingMock,
+                    featuresFilter: featuresFilterMock,
+                    clusterGeometryFunction: clusterGeometryFunctionMock
+                },
+                layer = oaf.createLayer(rawLayer, {options});
+
+            layer.getSource().getSource().loadFeatures([-1000, -1000, -1000, -1000],
+                1,
+                map2D.getView().getProjection());
+
+            expect(layer.getSource()).toBeInstanceOf(Cluster);
+            expect(layer.getSource().getDistance()).toEqual(40);
+            expect(layer.getSource().getSource().getFormat()).toBeInstanceOf(GeoJSON);
+            // eslint-disable-next-line no-underscore-dangle
+            expect(typeof layer.getSource().loader_).toEqual("function");
+            expect(beforeLoadingMock.mock.calls.length).toBe(1);
+            layer.getSource().on("featuresloadend", function () {
+                expect(clusterGeometryFunctionMock.mock.calls.length).toBe(1);
+                expect(featuresFilterMock.mock.calls.length).toBe(1);
+                expect(afterLoadingMock.mock.calls.length).toBe(1);
+            });
+        });
+    });
+});

package/test/layer/resources/oafFeatures.js

@@ -0,0 +1,105 @@
+export const featureCollection = {
+    "type": "FeatureCollection",
+    "features": [
+        {
+            "type": "Feature",
+            "id": "DE.HH.UP_STAATLICHE_SCHULEN_441696",
+            "geometry": {
+                "type": "Point",
+                "coordinates": [
+                    564532,
+                    5933771
+                ]
+            },
+            "properties": {
+                "ansprechp_buero": "Karin Stelling",
+                "stadtteil": "Neustadt",
+                "schul_homepage": "http://www.fsp2.hamburg.de",
+                "is_rebbz": "false",
+                "schul_email": "BS21@hibb.hamburg.de",
+                "schulportrait": "http://hibb.hamburg.de/schulen/schulportraits/bs21",
+                "sozialindex": "n.v.",
+                "schulaufsicht": "Susanne Kallies",
+                "schulform": "Berufsfachschule|Berufsschule|Berufsvorbereitungsschule|Fachschule",
+                "fax": "+49 40 428 11-3339",
+                "rechtsform": "staatlich",
+                "schulname": "Staatliche Fachschule für Sozialpädagogik Altona",
+                "lgv_standortk_erwachsenenbildung": "No",
+                "adresse_strasse_hausnr": "Zeughausmarkt 32",
+                "kernzeitbetreuung": "",
+                "anzahl_schueler_gesamt": "1674 an 3 Standorten",
+                "schul_id": "5964-3",
+                "adresse_ort": "20459 Hamburg",
+                "schul_telefonnr": "+49 40 428 11-3313",
+                "abschluss": "Abschlusszeugnis|Abschlusszeugnis mit dem schulischen Teil der FHR|Abschlusszeugnis mit erweitertem erstem allgemeinbildenden Schulabschluss|Abschlusszeugnis mit Fachhochschulreife|Abschlusszeugnis mit mittleren Schulabschluss",
+                "bezirk": "Hamburg-Mitte",
+                "name_schulleiter": "Cornelia Averhoff",
+                "schultyp": "Zweigstelle",
+                "standort_id": "1078",
+                "name_stellv_schulleiter": "Lennart Tienken",
+                "kapitelbezeichnung": "Berufliche Schulen"
+            },
+            "srsName": "EPSG:25832"
+        }
+    ],
+    "links": [
+        {
+            "href": "https://api.hamburg.de/datasets/v1/schulen/collections/staatliche_schulen/items?offset=440&crs=EPSG%3A25832&limit=10",
+            "rel": "self",
+            "type": "application/geo+json",
+            "title": "this document as JSON"
+        },
+        {
+            "href": "https://api.hamburg.de/datasets/v1/schulen/collections/staatliche_schulen/items?offset=440&crs=EPSG%3A25832&limit=10",
+            "rel": "alternate",
+            "type": "text/html",
+            "title": "this document as HTML"
+        },
+        {
+            "href": "https://api.hamburg.de/datasets/v1/schulen/collections/staatliche_schulen/items?offset=440&crs=EPSG%3A25832&limit=10",
+            "rel": "alternate",
+            "type": "application/gml+xml",
+            "title": "this document as GML"
+        },
+        {
+            "href": "https://api.hamburg.de/datasets/v1/schulen/collections/staatliche_schulen/items?offset=440&crs=EPSG%3A25832&limit=10",
+            "rel": "alternate",
+            "type": "application/gml+xml;version=3.2",
+            "title": "this document as GML"
+        },
+        {
+            "href": "https://api.hamburg.de/datasets/v1/schulen/collections/staatliche_schulen/items?offset=440&crs=EPSG%3A25832&limit=10",
+            "rel": "alternate",
+            "type": "application/gml+xml;version=3.2;profile=\"http://www.opengis.net/def/profile/ogc/2.0/gml-sf0\"",
+            "title": "this document as GML"
+        },
+        {
+            "href": "https://api.hamburg.de/datasets/v1/schulen/collections/staatliche_schulen/items?offset=440&crs=EPSG%3A25832&limit=10",
+            "rel": "alternate",
+            "type": "application/gml+xml;version=3.2;profile=\"http://www.opengis.net/def/profile/ogc/2.0/gml-sf2\"",
+            "title": "this document as GML"
+        },
+        {
+            "href": "https://api.hamburg.de/datasets/v1/schulen/collections/staatliche_schulen",
+            "rel": "collection",
+            "type": "application/json",
+            "title": "Collection as JSON"
+        },
+        {
+            "href": "https://api.hamburg.de/datasets/v1/schulen/collections/staatliche_schulen",
+            "rel": "collection",
+            "type": "text/html",
+            "title": "Collection as HTML"
+        },
+        {
+            "href": "https://api.hamburg.de/datasets/v1/schulen/collections/staatliche_schulen",
+            "rel": "collection",
+            "type": "application/xml",
+            "title": "Collection as XML"
+        }
+    ],
+    "numberMatched": 1,
+    "numberReturned": 1,
+    "timeStamp": "2022-03-29T13:39:55.511Z",
+    "crs": "EPSG:25832"
+};

package/test/layer/resources/wfsFeatures.js

@@ -0,0 +1,26 @@
+export const featureCollection = `<?xml version='1.0' encoding='UTF-8'?>
+<wfs:FeatureCollection 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 http://www.deegree.org/app http://geodienste.hamburg.de/HH_WFS_Krankenhaeuser?SERVICE=WFS&amp;VERSION=1.1.0&amp;REQUEST=DescribeFeatureType&amp;OUTPUTFORMAT=text%2Fxml%3B+subtype%3Dgml%2F3.1.1&amp;TYPENAME=app:krankenhaeuser_hh&amp;NAMESPACE=xmlns(app=http%3A%2F%2Fwww.deegree.org%2Fapp)" xmlns:wfs="http://www.opengis.net/wfs" timeStamp="2017-08-30T12:31:07Z" xmlns:gml="http://www.opengis.net/gml">
+  <gml:featureMember>
+    <app:krankenhaeuser_hh xmlns:app="http://www.deegree.org/app" gml:id="APP_KRANKENHAEUSER_HH_9">
+      <app:kh_nummer>20</app:kh_nummer>
+      <app:name>Evangelisches Krankenhaus Alsterdorf</app:name>
+      <app:strasse>Bodelschwinghstraße 24</app:strasse>
+      <app:ort>22337  Hamburg</app:ort>
+      <app:homepage>http://www.evangelisches-krankenhaus-alsterdorf.de</app:homepage>
+      <app:krankenhausverzeichnis>www.krankenhausverzeichnis.de|www.google.com|www.hamburg.de</app:krankenhausverzeichnis>
+      <app:anzahl_planbetten>252</app:anzahl_planbetten>
+      <app:hinweiszeile></app:hinweiszeile>
+      <app:anzahl_plaetze_teilstationaer>43</app:anzahl_plaetze_teilstationaer>
+      <app:teilnahme_notversorgung>false</app:teilnahme_notversorgung>
+      <app:teilnahme_geburtsklinik>Nein</app:teilnahme_geburtsklinik>
+      <app:geburtsklinik_differenziert>Nein</app:geburtsklinik_differenziert>
+      <app:stand>01.01.2016</app:stand>
+      <app:geom>
+        <!--Inlined geometry 'APP_KRANKENHAEUSER_HH_9_APP_GEOM'-->
+        <gml:Point gml:id="APP_KRANKENHAEUSER_HH_9_APP_GEOM" srsName="EPSG:25832">
+          <gml:pos>567708.612 5941076.513</gml:pos>
+        </gml:Point>
+      </app:geom>
+    </app:krankenhaeuser_hh>
+  </gml:featureMember>
+  </wfs:FeatureCollection>`;

package/test/layer/resources/wfsFilter.js

@@ -0,0 +1,17 @@
+export const wfsFilterQuery = `<?xml version="1.0" encoding="UTF-8"?>
+<wfs:GetFeature service="WFS" version="1.1.0" xmlns:app="http://www.deegree.org/app" xmlns:wfs="http://www.opengis.net/wfs" xmlns:ogc="http://www.opengis.net/ogc">
+    <wfs:Query typeName="app:staatliche_schulen">
+        <ogc:Filter>
+            <ogc:And>
+                <ogc:PropertyIsEqualTo>
+                    <ogc:PropertyName>app:kapitelbezeichnung</ogc:PropertyName>
+                    <ogc:Literal>Grundschulen</ogc:Literal>
+                </ogc:PropertyIsEqualTo>
+                <ogc:PropertyIsGreaterThan>
+                    <ogc:PropertyName>app:zuegigkeit_kl_1</ogc:PropertyName>
+                    <ogc:Literal>0</ogc:Literal>
+                </ogc:PropertyIsGreaterThan>
+            </ogc:And>
+        </ogc:Filter>
+    </wfs:Query>
+</wfs:GetFeature>`;

package/test/layer/terrain.test.js

@@ -0,0 +1,106 @@
+import * as terrain from "../../src/layer/terrain";
+
+describe("terrain.js", function () {
+    let attr, map, cesiumTerrainProviderSpy;
+
+    beforeEach(() => {
+        global.Cesium = {};
+        global.Cesium.CesiumTerrainProvider = jest.fn();
+        global.Cesium.EllipsoidTerrainProvider = jest.fn();
+        attr = {
+            id: "12883",
+            name: "Gelaende",
+            url: "https://url/Gelaende",
+            typ: "Terrain3D",
+            cesiumTerrainProviderOptions: {
+                requestVertexNormals: true
+            }
+        };
+        map = {
+            getCesiumScene: () => {
+                return {};
+            }
+        };
+        cesiumTerrainProviderSpy = jest.spyOn(global.Cesium, "CesiumTerrainProvider");
+    });
+
+    afterEach(() => {
+        global.Cesium = null;
+        jest.clearAllMocks();
+    });
+
+    function checkAttributes (layer, attrs) {
+        expect(layer.get("name")).toEqual(attrs.name);
+        expect(layer.get("typ")).toEqual(attrs.typ);
+        expect(layer.get("id")).toEqual(attrs.id);
+    }
+
+    describe("createLayer", function () {
+        it("creates a wrapper for terrain layer without map and not selected", function () {
+            const layer = terrain.createLayer(attr);
+
+            checkAttributes(layer, attr);
+        });
+        it("creates a wrapper for terrain layer with map and not selected", function () {
+            attr.isSelected = false;
+            const layer = terrain.createLayer(attr, map);
+
+            checkAttributes(layer, attr);
+            expect(cesiumTerrainProviderSpy).toHaveBeenCalledTimes(0);
+        });
+        it("creates a wrapper for terrain layer with map and selected", function () {
+            attr.isSelected = true;
+            const layer = terrain.createLayer(attr, map);
+
+            checkAttributes(layer, attr);
+            expect(cesiumTerrainProviderSpy).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe("setVisible", function () {
+        it("calls setVisible without map shall not fail", function () {
+            const layer = terrain.createLayer(attr, map);
+
+            layer.setVisible(true, attr);
+
+            checkAttributes(layer, attr);
+            expect(cesiumTerrainProviderSpy).toHaveBeenCalledTimes(0);
+        });
+        it("calls setVisible without map and attributes shall not fail", function () {
+            const layer = terrain.createLayer(attr, map);
+
+            layer.setVisible(true);
+
+            checkAttributes(layer, attr);
+            expect(cesiumTerrainProviderSpy).toHaveBeenCalledTimes(0);
+        });
+        it("sets the terrain layer visible by creating a CesiumTerrainProvider", function () {
+            const layer = terrain.createLayer(attr, map);
+
+            layer.setVisible(true, attr, map);
+
+            checkAttributes(layer, attr);
+            expect(cesiumTerrainProviderSpy).toHaveBeenCalledTimes(1);
+        });
+        it("sets the terrain layer not visible by creating a EllipsoidTerrainProvider", function () {
+            const cesiumEllipsoidTerrainProviderSpy = jest.spyOn(global.Cesium, "EllipsoidTerrainProvider"),
+                layer = terrain.createLayer(attr, map);
+
+            layer.setVisible(false, attr, map);
+
+            checkAttributes(layer, attr);
+            expect(cesiumTerrainProviderSpy).toHaveBeenCalledTimes(0);
+            expect(cesiumEllipsoidTerrainProviderSpy).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe("get", function () {
+        it("calls get for attributes", function () {
+            const layer = terrain.createLayer(attr, map);
+
+            checkAttributes(layer, attr);
+            expect(layer.get(null)).toEqual(undefined);
+            expect(layer.get(undefined)).toEqual(undefined);
+            expect(layer.get("")).toEqual(undefined);
+        });
+    });
+});
+

package/test/layer/tileset.test.js

@@ -0,0 +1,116 @@
+import Tileset from "../../src/layer/tileset";
+
+describe("tileset.js", function () {
+    const consoleWarn = console.warn;
+    let attr, map, cesium3DTilesetSpy;
+
+    beforeEach(() => {
+        global.Cesium = {};
+        global.Cesium.Cesium3DTileset = jest.fn();
+        attr = {
+            id: "4002",
+            name: "Gebäude LoD2",
+            url: "https://geoportal-hamburg.de/gdi3d/datasource-data/LoD2",
+            typ: "TileSet3D",
+            cesium3DTilesetOptions: {
+                maximumScreenSpaceError: 6
+            }
+        };
+        map = {
+            getCesiumScene: () => {
+                return {
+                    primitives: {
+                        contains: jest.fn(),
+                        add: jest.fn(),
+                        remove: jest.fn()
+                    }
+                };
+            }
+        };
+        cesium3DTilesetSpy = jest.spyOn(global.Cesium, "Cesium3DTileset");
+        console.warn = jest.fn();
+    });
+
+    afterEach(() => {
+        global.Cesium = null;
+        jest.clearAllMocks();
+        console.warn = consoleWarn;
+    });
+
+    function checkAttributes (layer, attrs) {
+        expect(layer.get("name")).toEqual(attrs.name);
+        expect(layer.get("typ")).toEqual(attrs.typ);
+        expect(layer.get("id")).toEqual(attrs.id);
+        expect(layer.tileset.layerReferenceId).toEqual(attrs.id);
+    }
+
+    describe("createLayer", function () {
+        it("creates tileset layer without map and not selected", function () {
+            const layer = new Tileset(attr);
+
+            checkAttributes(layer, attr);
+            expect(layer.tileSet).toEqual(undefined);
+            expect(cesium3DTilesetSpy).toHaveBeenCalledTimes(1);
+        });
+        it("creates tileset layer with map and selected", function () {
+            attr.isSelected = true;
+            const layer = new Tileset(attr, map);
+
+            checkAttributes(layer, attr);
+            expect(layer.tileset.show).toEqual(true);
+            expect(cesium3DTilesetSpy).toHaveBeenCalledTimes(1);
+        });
+        it("creates 2 tileset layers  with map and selected and checks attributes", function () {
+            const attr2 = {
+                    id: "4003",
+                    name: "name",
+                    url: "https://url",
+                    typ: "TileSet3D"
+                },
+                layer = new Tileset(attr, map),
+                layer2 = new Tileset(attr2, map);
+
+            checkAttributes(layer, attr);
+            checkAttributes(layer2, attr2);
+            expect(cesium3DTilesetSpy).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe("setVisible", function () {
+        it("calls setVisible without map shall not fail", function () {
+            const layer = new Tileset(attr, map);
+
+            expect(layer.tileset.show).toEqual(undefined);
+            layer.setVisible(true);
+
+            checkAttributes(layer, attr);
+            expect(layer.tileset.show).toEqual(undefined);
+            expect(cesium3DTilesetSpy).toHaveBeenCalledTimes(1);
+        });
+        it("sets the tileset layer visible", function () {
+            const layer = new Tileset(attr, map);
+
+            layer.setVisible(true, map);
+            checkAttributes(layer, attr);
+            expect(layer.tileset.show).toEqual(true);
+            expect(cesium3DTilesetSpy).toHaveBeenCalledTimes(1);
+        });
+        it("sets the tileset layer not visible", function () {
+            const layer = new Tileset(attr, map);
+
+            layer.setVisible(false, map);
+            checkAttributes(layer, attr);
+            expect(layer.tileset.show).toEqual(false);
+            expect(cesium3DTilesetSpy).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe("get", function () {
+        it("calls get for attributes", function () {
+            const layer = new Tileset(attr, map);
+
+            checkAttributes(layer, attr);
+            expect(layer.get(null)).toEqual(undefined);
+            expect(layer.get(undefined)).toEqual(undefined);
+            expect(layer.get("")).toEqual(undefined);
+        });
+    });
+});