@masterportal/masterportalapi 2.46.0 → 2.48.0

package/CHANGELOG.md

@@ -3,21 +3,29 @@
 
  The [Semantic Versioning](https://semver.org/spec/v2.0.0.html) is used.
 
-## Unreleased - in development
+## 2.48.0 - 2025-04-01
 
-### __Breaking Changes__
+### Fixed
+- olcsMap: fixed function setCameraParameter.
 
-### Added
+---
 
-### Changed
+## 2.47.0 - 2025-03-20
 
-### Deprecated
+### Added
+- An interface to OGC API Processes has been added.
 
-### Removed
+### Changed
+- The following package has been updated:
+    - peerDependencies:
+        - cesium/engine: 13.0.0 to 15.0.0
 
 ### Fixed
+- Reset the depthTestAgainstTerrain parameter to true due to problems with the height of the terrain model.
+- WMS-Layer: fixed setting of projection for olcs.
 
 ---
+
 ## 2.46.0 - 2025-03-10
 
 ### Changed

package/example/config/services.json

@@ -44,6 +44,17 @@
     "version": "1.1.0",
     "featureNS": "http://www.deegree.org/app"
   },
+  {
+    "id": "2426",
+    "name": "Bezirke",
+    "url": "https://geodienste.hamburg.de/HH_WMS_Verwaltungsgrenzen",
+    "typ": "WMS",
+    "layers": "bezirke",
+    "version": "1.3.0",
+    "singleTile": true,
+    "transparent": true,
+    "transparency": 0
+  },
   {
     "id": "4001",
     "name": "Gelaende",

package/example/index.js

@@ -132,7 +132,7 @@ services.find(({id}) => id === "5001").style = styleOaf;
 map2D = mapsAPI.map.createMap(config, "2D", {errorCallback});
 window.mpapi.map = map2D;
 
-["2001", "2002", "1002", "3001", "5001"].forEach(id => window.mpapi.map.addLayer(id, {errorCallback}));
+["2001", "2002", "1002", "3001", "5001", "2426"].forEach(id => window.mpapi.map.addLayer(id, {errorCallback}));
 
 // ping all layers
 services
@@ -231,8 +231,36 @@ window.mpapi.search("Mümmelmannsberg 72", {
     searchAddress: true
 }).then(x => console.log(x)).catch(e => console.error(e));
 
-//*/
+// */
+
+/* OGC API - PROCESSES EXAMPLE */
+/*
+// Enter the URL to an OGC API - Processes service here.
+const ogcApiProcessUrl = ""; // eslint-disable-line
+
+async function testOgcApiProcesses (processUrl) {
+    const processList = await window.mpapi.ogcApiProcesses.processList(processUrl),
+        processDescription = await window.mpapi.ogcApiProcesses.processDescription(processUrl, processList[0].id),
+        jobList = await window.mpapi.ogcApiProcesses.jobList(processUrl),
+        data = {};
+
+    console.log("### OGC API - PROCESSES EXAMPLE ###"); // eslint-disable-line
+    console.log("Process list:", processList); // eslint-disable-line
+    console.log("Process Description:", processDescription); // eslint-disable-line
+
+    // create example data from process input schema
+    Object.keys(processDescription.inputs).forEach(key => data[key] = `Example ${key}`); // eslint-disable-line
+    console.log("Execute Process:", await window.mpapi.ogcApiProcesses.executeProcess(processUrl, processList[0].id, data)); // eslint-disable-line
+
+    console.log("Job List:", jobList); // eslint-disable-line
+    console.log("Job Status of last job:", await window.mpapi.ogcApiProcesses.jobStatus(processUrl, jobList.at(-1).jobID)); // eslint-disable-line
+    console.log("Job Results of last job:", await window.mpapi.ogcApiProcesses.jobResults(processUrl, jobList.at(-1).jobID)); // eslint-disable-line
+    console.log("Cancle the last Job:", await window.mpapi.ogcApiProcesses.cancelJob(processUrl, jobList.at(-1).jobID)); // eslint-disable-line
+    console.log("Job list:", await window.mpapi.ogcApiProcesses.jobList(processUrl)); // eslint-disable-line
+}
 
+testOgcApiProcesses(ogcApiProcessUrl);
+// */
 
 // Add 3D functionality to the example:
 // ---------------------------------------

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@masterportal/masterportalapi",
   "author": "Implementierungspartnerschaft Masterportal <info@masterportal.org> (https://www.masterportal.org)",
-  "version": "2.46.0",
+  "version": "2.48.0",
   "license": "MIT",
   "description": "Basic functions of the Masterportal as api",
   "repository": {
@@ -56,7 +56,7 @@
     "util": "^0.12.5"
   },
   "peerDependencies": {
-    "@cesium/engine": "^13.0.0"
+    "@cesium/engine": "^15.0.0"
   },
   "engines": {
     "node": "^16.13.2 || ^18.12.0 || ^20.12.2",

package/src/api/ogcApiProcesses.js

@@ -0,0 +1,205 @@
+/**
+ * This is an implementation of the interface to OGC API - Processes - Part 1: Core.
+ * @module api/ogcApiProcesses
+ * @see {@link https://ogcapi.ogc.org/processes|OGC API - Processes} for further information
+ */
+
+/**
+ * Returns the url params for a DELETE request.
+ * @returns {object} The url params for DELETE request.
+ */
+function fetchDeleteParams () {
+    return {
+        method: "DELETE"
+    };
+}
+
+/**
+ * Returns the url params for a GET request.
+ * @returns {object} The url params for GET request.
+ */
+function fetchGetParams () {
+    return {
+        method: "GET"
+    };
+}
+
+/**
+ * Returns the url params for a POST request.
+ * @param {object} body The request body.
+ * @returns {object} The url params for poPOSTst request.
+ */
+function fetchPostParams (body) {
+    return {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+    };
+}
+
+/**
+ * Returns the fetch params by request method.
+ * @param {string} method The fetch method.
+ * @param {object} body The request body.
+ * @returns {object} The fetch params.
+ */
+function fetchParams (method, body) {
+    const fetchParamsByMethod = {
+        DELETE: fetchDeleteParams,
+        GET: fetchGetParams,
+        POST: fetchPostParams
+    };
+
+    return fetchParamsByMethod[method](body);
+}
+/**
+ * Fetch the url with fetch api and catch errors.
+ * @param {string} processUrl The process url.
+ * @param {string} [method=GET] The fetch method.
+ * @param {object} [body={}] The request body, only used if request-method is POST.
+ * @returns {object} The response object.
+ */
+function fetchUrl (processUrl, method = "GET", body = {}) {
+    return new Promise((resolve, reject) => {
+        fetch(processUrl, fetchParams(method, body))
+            .then(response => {
+                const errorMessage = `Status code: ${response.status}.`;
+
+                if (response.ok) {
+                    return response.json();
+                }
+                else if (response.status === "400") {
+                    throw new Error(`${errorMessage} The URL: ${response.url} is an bad request! Perhaps the status of the process or job is failure!`);
+                }
+                else if (response.status === "404") {
+                    throw new Error(`${errorMessage} The URL: ${response.url} was not found!`);
+                }
+
+                throw new Error(`${errorMessage} The response of the URL: ${response.url} has an error occured!`);
+            })
+            .then(responseJson => resolve(responseJson))
+            .catch(error => {
+                reject(error);
+            });
+    });
+}
+
+/**
+ * Retrieve the list of available processes.
+ * @param {string} processUrl The process url.
+ * @param {boolean} [nextLink=false] If processurl is a nextLink.
+ * @returns {object[]} The process list.
+ */
+async function processList (processUrl, nextLink = false) {
+    const url = nextLink ? processUrl : `${processUrl}/processes`,
+        responseJson = await fetchUrl(url),
+        nextLinkObject = responseJson?.links?.find(link => link.rel === "next");
+    let processes = responseJson.processes;
+
+    if (typeof nextLinkObject !== "undefined") {
+        processes = processes.concat(await processList(nextLinkObject.href, true));
+    }
+
+    return processes;
+}
+
+/**
+ * Retrieve the description of a process.
+ * @param {string} processUrl The process url.
+ * @param {string} processId The process id.
+ * @returns {object} The process description.
+ */
+async function processDescription (processUrl, processId) {
+    const url = `${processUrl}/processes/${processId}`,
+        responseJson = await fetchUrl(url);
+
+    return responseJson;
+}
+
+/**
+ * Execute a process.
+ * @param {string} processUrl The process url.
+ * @param {string} processId The process id.
+ * @param {object} data The data.
+ * @returns {object} The response data.
+ */
+async function executeProcess (processUrl, processId, data) {
+    const url = `${processUrl}/processes/${processId}/execution`,
+        body = {
+            inputs: data
+        },
+        responseJson = await fetchUrl(url, "POST", body);
+
+    return responseJson;
+}
+
+/**
+ * Retrieve the list of jobs.
+ * @param {string} processUrl The process url.
+ * @param {boolean} [nextLink=false] If processurl is a nextLink.
+ * @returns {object[]} The job list.
+ */
+async function jobList (processUrl, nextLink = false) {
+    const url = nextLink ? processUrl : `${processUrl}/jobs`,
+        responseJson = await fetchUrl(url),
+        nextLinkObject = responseJson?.links?.find(link => link.rel === "next");
+    let jobs = responseJson.jobs;
+
+    if (typeof nextLinkObject !== "undefined") {
+        jobs = jobs.concat(await jobList(nextLinkObject.href, true));
+    }
+
+    return jobs;
+}
+
+/**
+ * Retrieve the status of a job.
+ * @param {string} processUrl The process url.
+ * @param {string} jobId The job id.
+ * @returns {object} The job status.
+ */
+async function jobStatus (processUrl, jobId) {
+    const url = `${processUrl}/jobs/${jobId}`,
+        responseJson = await fetchUrl(url);
+
+    return responseJson;
+}
+
+/**
+ * Cancel a job execution, remove a finished job.
+ * @param {string} processUrl The process url.
+ * @param {string} jobId The job id.
+ * @returns {object} The canceled job status.
+ */
+async function cancelJob (processUrl, jobId) {
+    const url = `${processUrl}/jobs/${jobId}`,
+        responseJson = await fetchUrl(url, "DELETE");
+
+    return responseJson;
+}
+
+/**
+ * Retrieve the result(s) of a job.
+ * @param {string} processUrl The process url.
+ * @param {string} jobId The job id.
+ * @param {string} [format=json] The result format can be `html` or `json`.
+ * @returns {object} The job dismissed status.
+ */
+async function jobResults (processUrl, jobId, format = "json") {
+    const url = `${processUrl}/jobs/${jobId}/results?f=${format}`,
+        responseJson = await fetchUrl(url);
+
+    return responseJson;
+}
+
+export default {
+    processList,
+    processDescription,
+    executeProcess,
+    jobList,
+    cancelJob,
+    jobStatus,
+    jobResults
+};

package/src/defaults.js

@@ -40,7 +40,7 @@ export default {
             enableTerrainAdjustmentWhenLoading: true
         },
         globe: {
-            depthTestAgainstTerrain: false
+            depthTestAgainstTerrain: true // is necessary for scene.pickedPosition and correct height of the terrain. @see {https://github.com/CesiumGS/cesium/issues/5676}
         },
         highDynamicRange: false,
         pickTranslucentDepth: true,

package/src/index.js

@@ -15,6 +15,7 @@ import * as layerLib from "./layer/lib";
 import {search, setGazetteerUrl} from "./searchAddress";
 import setBackgroundImage from "./lib/setBackgroundImage";
 import ping from "./lib/ping";
+import ogcApiProcesses from "./api/ogcApiProcesses";
 
 export {
     createMapView,
@@ -34,5 +35,6 @@ export {
     ping,
     search,
     crs,
-    webgl
+    webgl,
+    ogcApiProcesses
 };

package/src/layer/wms.js

@@ -164,7 +164,7 @@ export function createLayer (rawLayer, layerParams = {}, options) {
     const source = createLayerSource(rawLayer, options),
         Layer = rawLayer.singleTile ? ImageLayer : TileLayer;
 
-    source.set("olcs.projection", getProjection(OLCS_DEFAULT_OLCS_PROJECTION_CRS));
+    source.set("olcs_projection", getProjection(OLCS_DEFAULT_OLCS_PROJECTION_CRS));
 
     return new Layer(Object.assign({
         source,

package/src/maps/olcs/olcsMap.js

@@ -9,91 +9,84 @@ import defaults from "../../defaults";
 let mapIdCounter = 0;
 
 /**
- * Recursive function.
- * Sets the cesium default scene params.
- * @param {Cesium.scene} scene The cesium scene.
- * @param {Object} params Optional configuration parameters.
+ * Recursively sets parameters on the Cesium scene.
+ *
+ * Certain keys are excluded from being set directly on the scene object:
+ * - "0", "1", "2": These is placeholder keys or indices from certain configurations that should not be interpreted as scene properties.
+ * - "heading", "tilt", "altitude": These are camera-related properties and should be handled separately via specific camera functions.
+ *
+ * @param {Cesium.Scene} scene - The Cesium scene instance.
+ * @param {Object} params - Configuration parameters.
  * @returns {void}
  */
 export function setCesiumSceneParams (scene, params) {
-    Object.keys(params).forEach(paramKey => {
-        const paramValue = params[paramKey];
-
-        if (typeof paramValue === "object") {
-            Object.keys(paramValue).forEach(paramSubKey => {
-                if (paramSubKey !== "heading" && paramSubKey !== "tilt" && paramSubKey !== "altitude") {
-                    setCesiumSceneParams(scene[paramKey], paramValue);
-                }
-            });
+    if (!scene || !params || typeof params !== "object") {
+        console.warn("setCesiumSceneParams: Invalid scene or params.");
+        return;
+    }
+
+    Object.entries(params).forEach(([key, value]) => {
+        if (["0", "1", "2", "heading", "tilt", "altitude"].includes(key)) {
+            return;
+        }
+
+        if (typeof value === "object" && scene[key]) {
+            setCesiumSceneParams(scene[key], value);
         }
         else {
-            scene[paramKey] = paramValue;
+            scene[key] = value;
         }
     });
 }
 /**
  * Sets the camera parameters either from config or from an trigger.
- * @param {Object} params Params.
- * @param {Object} map3D olcs map.
- * @param {Cesium} cesium cesium.
+ * @param {Object} params - Parameters for setting the camera.
+ * @param {Object} map3D - olcs map instance.
+ * @param {Cesium} cesium - Cesium instance.
  * @returns {void}
  */
 export function setCameraParameter (params, map3D, cesium) {
-    let camera,
-        destination,
-        orientation,
-        heading;
-
-    if (params && map3D) {
-        if (typeof params.heading !== "undefined") {
-            heading = parseFloat(params.heading);
-        }
-        else if (typeof params.camera?.heading !== "undefined") {
-            heading = parseFloat(params.camera?.heading);
-        }
-        // if the cameraPosition is given, directly set the cesium camera position, otherwise use olcesium Camera
-        if (params.cameraPosition) {
-            camera = map3D.getCesiumScene().camera;
-            destination = cesium.Cartesian3.fromDegrees(params.cameraPosition[0], params.cameraPosition[1], params.cameraPosition[2]);
+    if (!params || !map3D) {
+        console.warn("setCameraParameter: Missing parameters or map3D instance.");
+        return;
+    }
+
+    let camera = map3D.getCesiumScene()?.camera;
+    const heading = parseFloat(params.heading ?? params.camera?.heading ?? 0),
+        pitch = parseFloat(params.pitch ?? params.camera?.pitch ?? 0),
+        roll = parseFloat(params.roll ?? 0),
+        tilt = parseFloat(params.tilt ?? params.camera?.tilt ?? 0),
+        altitude = parseFloat(params.altitude ?? params.camera?.altitude ?? 0);
+
+    if (params.cameraPosition || params.camera?.cameraPosition) {
+        const cameraPosition = params.cameraPosition ?? params.camera.cameraPosition,
+            destination = cesium.Cartesian3.fromDegrees(cameraPosition[0], cameraPosition[1], cameraPosition[2]),
             orientation = {
                 heading: cesium.Math.toRadians(heading),
-                pitch: cesium.Math.toRadians(parseFloat(params.pitch)),
-                roll: cesium.Math.toRadians(parseFloat(params.roll))
+                pitch: cesium.Math.toRadians(pitch),
+                roll: cesium.Math.toRadians(roll)
             };
 
-            camera.setView({
-                destination,
-                orientation
-            });
+        if (params.cameraPosition) {
+            camera.setView({destination, orientation});
         }
         else {
-            let tilt,
-                altitude;
+            camera.flyTo({destination, orientation});
+        }
 
-            if (typeof params.tilt !== "undefined") {
-                tilt = parseFloat(params.tilt);
-            }
-            else if (typeof params.camera?.tilt !== "undefined") {
-                tilt = parseFloat(params.camera?.tilt);
-            }
-            if (typeof params.altitude !== "undefined") {
-                altitude = parseFloat(params.altitude);
-            }
-            else if (typeof params.camera?.altitude !== "undefined") {
-                altitude = parseFloat(params.camera?.altitude);
-            }
-            camera = map3D.getCamera();
+        return;
+    }
 
-            if (tilt) {
-                camera.setTilt(tilt);
-            }
-            if (heading) {
-                camera.setHeading(heading);
-            }
-            if (altitude) {
-                camera.setAltitude(altitude);
-            }
-        }
+    camera = map3D.getCamera();
+
+    if (tilt) {
+        camera.setTilt(tilt);
+    }
+    if (heading) {
+        camera.setHeading(heading);
+    }
+    if (altitude) {
+        camera.setAltitude(altitude);
     }
 }
 

package/test/api/ogcApiProcesses.test.js

@@ -0,0 +1,113 @@
+import ogcApiProcesses from "../../src/api/ogcApiProcesses";
+
+describe("ogcApiProcesses.js", () => {
+    const processUrl = "https://example.de",
+        processId = "process-id",
+        jobId = "job-id";
+
+    beforeEach(() => {
+        if (global.fetch) {
+            fetch.mockClear();
+        }
+
+        global.fetch = jest.fn().mockImplementationOnce(() => {
+            return new Promise((resolve) => {
+                resolve({
+                    ok: true,
+                    status: 200,
+                    json: () => {
+                        return {};
+                    }
+                });
+            });
+        });
+    });
+
+    describe("processList", () => {
+        it("should return a process list", async () => {
+            await ogcApiProcesses.processList(processUrl);
+
+            expect(fetch).toHaveBeenCalledWith(`${processUrl}/processes`, {method: "GET"});
+        });
+
+        it("should return a process list with next link", async () => {
+            const offsetProcessUrl = `${processUrl}/processes?offset=30`;
+
+            await ogcApiProcesses.processList(offsetProcessUrl, true);
+
+            expect(fetch).toHaveBeenCalledWith(offsetProcessUrl, {method: "GET"});
+        });
+    });
+
+    describe("processDescription", () => {
+        it("should return a process description", async () => {
+            await ogcApiProcesses.processDescription(processUrl, processId);
+
+            expect(fetch).toHaveBeenCalledWith(`${processUrl}/processes/${processId}`, {method: "GET"});
+        });
+    });
+
+    describe("executeProcess", () => {
+        it("should execute a process", async () => {
+            const data = {
+                attr: "test-attribute"
+            };
+
+            await ogcApiProcesses.executeProcess(processUrl, processId, data);
+
+            expect(fetch).toHaveBeenCalledWith(`${processUrl}/processes/${processId}/execution`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json"
+                },
+                body: "{\"inputs\":{\"attr\":\"test-attribute\"}}"
+            });
+        });
+    });
+
+    describe("jobList", () => {
+        it("should return a job list", async () => {
+            await ogcApiProcesses.jobList(processUrl);
+
+            expect(fetch).toHaveBeenCalledWith(`${processUrl}/jobs`, {method: "GET"});
+        });
+
+        it("should return a job list with next link", async () => {
+            const offsetProcessUrl = `${processUrl}/jobs?offset=20`;
+
+            await ogcApiProcesses.processList(offsetProcessUrl, true);
+
+            expect(fetch).toHaveBeenCalledWith(offsetProcessUrl, {method: "GET"});
+        });
+    });
+
+    describe("jobStatus", () => {
+        it("should return a job status", async () => {
+            await ogcApiProcesses.jobStatus(processUrl, jobId);
+
+            expect(fetch).toHaveBeenCalledWith(`${processUrl}/jobs/${jobId}`, {method: "GET"});
+        });
+    });
+
+    describe("cancelJob", () => {
+        it("should cancle a job", async () => {
+            await ogcApiProcesses.cancelJob(processUrl, jobId);
+
+            expect(fetch).toHaveBeenCalledWith(`${processUrl}/jobs/${jobId}`, {method: "DELETE"});
+        });
+    });
+
+    describe("jobResults", () => {
+        it("should return job results in json format", async () => {
+            await ogcApiProcesses.jobResults(processUrl, jobId);
+
+            expect(fetch).toHaveBeenCalledWith(`${processUrl}/jobs/${jobId}/results?f=json`, {method: "GET"});
+        });
+
+        it("should return job results in html format", async () => {
+            await ogcApiProcesses.jobResults(processUrl, jobId, "html");
+
+            expect(fetch).toHaveBeenCalledWith(`${processUrl}/jobs/${jobId}/results?f=html`, {method: "GET"});
+        });
+    });
+});

package/test/map.test.js

@@ -72,7 +72,7 @@ describe("map.js", function () {
                         };
                     }
                 },
-                cesiumLib: "https://lib.virtualcitymap.de/v3.6.x/lib/Cesium/Cesium.js"
+                cesiumLib: "https://geoportal-hamburg.de/mastercode/cesium/latest/Cesium.js"
             };
 
             load3DScriptModule.load3DScript(config.cesiumLib, function Loaded3DCallback () {
@@ -165,7 +165,7 @@ describe("map.js", function () {
                     heading: -0.30858728378862876,
                     tilt: 0.9321791580603296
                 },
-                cesiumLib: "https://lib.virtualcitymap.de/v3.6.x/lib/Cesium/Cesium.js"
+                cesiumLib: "https://geoportal-hamburg.de/mastercode/cesium/latest/Cesium.js"
             };
 
             load3DScriptModule.load3DScript(config.cesiumLib, function Loaded3DCallback () {
@@ -200,7 +200,7 @@ describe("map.js", function () {
                         tilt: 0.9321791580603296
                     }
                 },
-                cesiumLib: "https://lib.virtualcitymap.de/v3.6.x/lib/Cesium/Cesium.js"
+                cesiumLib: "https://geoportal-hamburg.de/mastercode/cesium/latest/Cesium.js"
             };
 
             load3DScriptModule.load3DScript(config.cesiumLib, function Loaded3DCallback () {
@@ -213,48 +213,108 @@ describe("map.js", function () {
             });
         });
         it("set the camera from viewpoint parameter", function () {
-            const config = {
-                map2D: {
-                    getView: () => {
-                        return {
-                            getProjection: () => {
-                                return {getCode: () => "code"};
-                            }
-                        };
+            const mockFlyTo = jest.fn(),
+                config = {
+                    map2D: {
+                        getView: () => {
+                            return {
+                                getProjection: () => {
+                                    return {getCode: () => "code"};
+                                }
+                            };
+                        },
+                        getViewport: () => {
+                            return {
+                                appendChild: jest.fn()
+                            };
+                        }
                     },
-                    getViewport: () => {
-                        return {
-                            appendChild: jest.fn()
-                        };
-                    }
-                },
-                viewpoint: [{"distance": 1660.0290142521517,
-                    "cameraPosition": [
-                        9.982163927085617,
-                        53.532817572762475,
-                        1180.9805498821436
-                    ],
-                    "groundPosition": [
-                        9.983171185370468,
-                        53.54328139366739,
-                        -0.00449886760542777
-                    ],
-                    "heading": 3.281512334248587,
-                    "pitch": -45.35612834848329,
-                    "roll": 0.015054499334397243,
-                    "animate": false,
-                    "duration": 6.006336273348537
-                }],
-                cesiumLib: "https://lib.virtualcitymap.de/v3.6.x/lib/Cesium/Cesium.js"
-            };
+                    viewpoint: [{
+                        "distance": 1660.0290142521517,
+                        "cameraPosition": [
+                            9.982163927085617,
+                            53.532817572762475,
+                            1180.9805498821436
+                        ],
+                        "heading": 3.281512334248587,
+                        "pitch": -45.35612834848329,
+                        "roll": 0.015054499334397243
+                    }],
+                    cesiumLib: "https://geoportal-hamburg.de/mastercode/cesium/latest/Cesium.js"
+                };
 
             load3DScriptModule.load3DScript(config.cesiumLib, function Loaded3DCallback () {
-                const map3D = map.createMap(config, "3D");
+                const mockMap3D = {
+                    mapMode: "3D",
+                    getCesiumScene: () => ({
+                        camera: {
+                            flyTo: mockFlyTo
+                        }
+                    })
+                };
 
-                expect(map3D.mapMode).toBe("3D");
-                map.setCameraParameter(config.viewpoint, map3D, config.cesiumLib);
+                map.setCameraParameter(config.viewpoint, mockMap3D, config.cesiumLib);
 
-                // missing test, if the passed parameters are also in the 3D map
+                expect(mockFlyTo).toHaveBeenCalledWith(expect.objectContaining({
+                    destination: expect.any(Object),
+                    orientation: {
+                        heading: expect.any(Number),
+                        pitch: expect.any(Number),
+                        roll: expect.any(Number)
+                    },
+                    duration: config.viewpoint[0].duration
+                }));
+            });
+        });
+
+        it("sets the camera parameters when cameraPosition is not provided", function () {
+            const mockFlyTo = jest.fn(),
+                config = {
+                    map2D: {
+                        getView: () => {
+                            return {
+                                getProjection: () => {
+                                    return {getCode: () => "code"};
+                                }
+                            };
+                        },
+                        getViewport: () => {
+                            return {
+                                appendChild: jest.fn()
+                            };
+                        }
+                    },
+                    viewpoint: [{
+                        "distance": 1660.0290142521517,
+                        "heading": 3.281512334248587,
+                        "pitch": -45.35612834848329,
+                        "roll": 0.015054499334397243,
+                        "tilt": 10,
+                        "altitude": 1500
+                    }],
+                    cesiumLib: "https://geoportal-hamburg.de/mastercode/cesium/latest/Cesium.js"
+                };
+
+            load3DScriptModule.load3DScript(config.cesiumLib, function Loaded3DCallback () {
+                const mockMap3D = {
+                    mapMode: "3D",
+                    getCesiumScene: () => ({
+                        camera: {
+                            flyTo: mockFlyTo,
+                            setTilt: jest.fn(),
+                            setHeading: jest.fn(),
+                            setAltitude: jest.fn()
+                        }
+                    })
+                };
+
+                map.setCameraParameter(config.viewpoint[0], mockMap3D, config.cesiumLib);
+
+                expect(mockFlyTo).not.toHaveBeenCalled();
+
+                expect(mockMap3D.getCesiumScene().camera.setTilt).toHaveBeenCalledWith(10);
+                expect(mockMap3D.getCesiumScene().camera.setHeading).toHaveBeenCalledWith(3.281512334248587);
+                expect(mockMap3D.getCesiumScene().camera.setAltitude).toHaveBeenCalledWith(1500);
             });
         });
     });
@@ -281,7 +341,7 @@ describe("map.js", function () {
                     heading: -0.30858728378862876,
                     tilt: 0.9321791580603296
                 },
-                cesiumLib: "https://lib.virtualcitymap.de/v3.6.x/lib/Cesium/Cesium.js"
+                cesiumLib: "https://geoportal-hamburg.de/mastercode/cesium/latest/Cesium.js"
             };
 
             load3DScriptModule.load3DScript(config.cesiumLib, function Loaded3DCallback () {
@@ -339,7 +399,7 @@ describe("map.js", function () {
                         undergroundColor: undefined
                     }
                 },
-                cesiumLib: "https://lib.virtualcitymap.de/v3.6.x/lib/Cesium/Cesium.js"
+                cesiumLib: "https://geoportal-hamburg.de/mastercode/cesium/latest/Cesium.js"
             };
 
             load3DScriptModule.load3DScript(config.cesiumLib, function Loaded3DCallback () {
@@ -355,5 +415,4 @@ describe("map.js", function () {
             });
         });
     });
-
 });