@wemap/routers 12.10.8 → 12.11.0

package/src/wemap-multi/WemapMultiRouter.spec.ts

@@ -1,138 +0,0 @@
-import chai from 'chai';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import fetchMock from 'fetch-mock';
-
-import { Coordinates } from '@wemap/geo';
-
-import CustomGraphMap from './CustomGraphMap.js';
-import WemapMultiRouter from './WemapMultiRouter.js';
-import OsrmRemoteRouter from '../remote/osrm/OsrmRemoteRouter.js';
-import { type RouterRequest } from '../model/RouterRequest.js';
-import { type RoutingFallbackStrategy } from '../remote/RemoteRouterManager.js';
-
-const { expect } = chai;
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const assetsPath = path.resolve(__dirname, '../../assets');
-
-function mockFetchWithJsonAsset(assetName: string) {
-    fetchMock.restore();
-    fetchMock.mock('*', (() => {
-        const filePath = path.resolve(assetsPath, assetName);
-        const fileString = fs.readFileSync(filePath, 'utf8');
-        return JSON.parse(fileString);
-    })(),)
-}
-
-function createIOMapFromAsset(assetName: string) {
-    const filePath = path.resolve(__dirname, '../../assets/' + assetName);
-    const osmXmlString = fs.readFileSync(filePath, 'utf8');
-    const mapName = path.parse(assetName).name;
-    return CustomGraphMap.fromOsmXml(osmXmlString, mapName)!;
-}
-
-describe('WemapMultiRouter', () => {
-
-
-    let router: WemapMultiRouter;
-    let garedelestMap: CustomGraphMap, biocbonMap: CustomGraphMap;
-    const travelMode = 'WALK';
-    const fallbackStrategy: RoutingFallbackStrategy = [{
-        name: OsrmRemoteRouter.rname,
-        endpointUrl: 'https://routing-orsm.getwemap.com'
-    }]
-
-    before(async () => {
-
-        router = new WemapMultiRouter();
-
-        biocbonMap = createIOMapFromAsset('biocbon-bergere-rdc-network.osm');
-        router.addIOMap(biocbonMap);
-        garedelestMap = createIOMapFromAsset('gare-de-lest-network-pp-bounds.osm');
-        router.addIOMap(garedelestMap);
-    });
-
-    after(() => {
-        fetchMock.restore();
-    });
-
-
-    it('indoor to indoor', async () => {
-
-        const request: RouterRequest = {
-            origin: new Coordinates(48.8725992, 2.343431),
-            destination: new Coordinates(48.8725694, 2.3433),
-            travelMode
-        };
-
-        const itineraries = await router.getItineraries(request, fallbackStrategy, [biocbonMap]);
-
-        const osrmResponse = OsrmRemoteRouter.itineraryToOsrmJson(itineraries[0]);
-        expect(osrmResponse).is.not.null;
-        const routes = osrmResponse.routes!;
-        expect(routes.length).equals(1);
-        expect(routes[0].geometry.coordinates.length).equals(6);
-        expect(routes[0].legs).not.empty;
-    });
-
-    it('outdoor to outdoor', async () => {
-
-        const request: RouterRequest = {
-            origin: new Coordinates(48.8726513, 2.343449),
-            destination: new Coordinates(48.8726397, 2.3431657),
-            travelMode
-        };
-        mockFetchWithJsonAsset('rr-wemap-multi-outdoor-outdoor.json');
-
-        const itineraries = await router.getItineraries(request, fallbackStrategy, [biocbonMap]);
-
-        const osrmResponse = OsrmRemoteRouter.itineraryToOsrmJson(itineraries[0]);
-        expect(osrmResponse.routes![0].geometry.coordinates.length).equals(4);
-    });
-
-    it('outdoor to indoor', async () => {
-        const request: RouterRequest = {
-            origin: new Coordinates(48.8726085, 2.3434289),
-            destination: new Coordinates(48.8725694, 2.3433),
-            travelMode
-        };
-        mockFetchWithJsonAsset('rr-wemap-multi-outdoor-indoor.json');
-
-        const itineraries = await router.getItineraries(request, fallbackStrategy, [biocbonMap]);
-
-        const osrmResponse = OsrmRemoteRouter.itineraryToOsrmJson(itineraries[0]);
-        expect(osrmResponse.routes![0].geometry.coordinates.length).equals(6);
-    });
-
-    it('indoor to outdoor', async () => {
-        const request: RouterRequest = {
-            origin: new Coordinates(48.8725992, 2.343431),
-            destination: new Coordinates(48.8726513, 2.343449),
-            travelMode
-        };
-        mockFetchWithJsonAsset('rr-wemap-multi-indoor-outdoor.json');
-
-        const itineraries = await router.getItineraries(request, fallbackStrategy, [biocbonMap]);
-
-        const osrmResponse = OsrmRemoteRouter.itineraryToOsrmJson(itineraries[0]);
-        expect(osrmResponse.routes![0].geometry.coordinates.length).equals(6);
-    });
-
-    it('indoor to outdoor to indoor', async () => {
-
-        const request: RouterRequest = {
-            origin: new Coordinates(48.8725992, 2.343431),
-            destination: new Coordinates(48.8772962, 2.3584458, null, 0),
-            travelMode
-        };
-        mockFetchWithJsonAsset('rr-wemap-multi-indoor-outdoor-indoor.json');
-
-        const itineraries = await router.getItineraries(request, fallbackStrategy, [biocbonMap, garedelestMap]);
-
-        const osrmResponse = OsrmRemoteRouter.itineraryToOsrmJson(itineraries[0]);
-        expect(osrmResponse.routes![0].geometry.coordinates.length).equals(77);
-    });
-
-});

package/src/wemap-multi/WemapMultiRouter.ts

@@ -1,329 +0,0 @@
-/* eslint-disable complexity */
-/* eslint-disable max-statements */
-
-import CustomGraphMap from './CustomGraphMap.js';
-import RemoteRouterManager, { type RoutingFallbackStrategy } from '../remote/RemoteRouterManager.js';
-import Itinerary from '../model/Itinerary.js';
-import WemapMultiRemoteRouter from '../remote/wemap-multi/WemapMultiRemoteRouter.js';
-import GraphRoute from '../graph/GraphRoute.js';
-import GraphRouterOptionsBuilder from '../graph/GraphRouterOptionsBuilder.js';
-import { type RouterRequest } from '../model/RouterRequest.js';
-import { RemoteRoutingError, WemapMultiRoutingError } from '../RoutingError.js';
-
-
-class WemapMultiRouter {
-
-    maps: CustomGraphMap[] = [];
-
-    get rname() {
-        return 'wemap-multi';
-    }
-
-    addIOMap(customGraphMap: CustomGraphMap) {
-        this.maps.push(customGraphMap);
-    }
-
-    removeIOMap(customGraphMap: CustomGraphMap) {
-        this.maps = this.maps.filter(map => map !== customGraphMap);
-    }
-
-    removeAllMaps() {
-        this.maps = [];
-    }
-
-    getMapByName(mapId: string) {
-        return this.maps.find(map => map.name === mapId);
-    }
-
-    async getItineraries(routerRequest: RouterRequest, fallbackStrategy: RoutingFallbackStrategy = [], targetMaps = this.maps): Promise<Itinerary[]> {
-
-        const { origin, destination } = routerRequest;
-
-        /*
-         * Here, we try to get the shortest path using io maps networks and a remote router server.
-         */
-
-        /**
-         * ----- 1 -----
-         * Parse function params
-         * -------------
-         */
-
-        // Avoid cycles on remoteRouters
-        fallbackStrategy = fallbackStrategy.filter(({ name }) => name !== WemapMultiRemoteRouter.rname) || [];
-
-        /*
-         * ----- 2 -----
-         * Retrieve the IO maps to consider for this itinerary
-         * -------------
-         *
-         * By default, all maps in this.maps are considered
-         * If options.targetMaps is defined, only use this subset
-         */
-        // const ioMapsToTest = this.getIoMapsFromOptions(options);
-        // TODO: map it with Wemap backend
-        const ioMapsToTest = targetMaps;
-
-        /*
-         * If there is no local map to test, use remote router directly.
-         * This should happen:
-         * 1 - this.maps is empty
-         * 2 - options.targetMaps is defined but empty
-         * 3 - intersection of this.maps and options.targetMaps is empty
-         */
-        if (!ioMapsToTest.length) {
-            return await RemoteRouterManager.getItinerariesWithFallback(routerRequest, fallbackStrategy);
-        }
-
-
-        /**
-         * ----- 3 -----
-         * Run the IO Maps - Remote Routers logic
-         * -------------
-         *
-         * For this purpose we have to consider 5 use cases
-         *
-         */
-
-        let ioMapRoute: GraphRoute | null;
-        let ioMapItinerary: Itinerary;
-
-        // Find the first map where the "origin" is inside.
-        const mapWithOrigin = ioMapsToTest.find(map => map.isPointInside(origin));
-
-
-        // Create GraphRouterOptions from request
-        const routerOptions = GraphRouterOptionsBuilder.fromJson(routerRequest.itineraryModifiers || {});
-
-        /*
-         * Case 1
-         *
-         * If "origin" and "destination" are in the same map, use the local router.
-         */
-        if (mapWithOrigin && mapWithOrigin.isPointInside(destination)) {
-
-            ioMapRoute = mapWithOrigin.getRouteInsideMap(origin, destination, routerOptions);
-            if (!ioMapRoute) {
-                throw WemapMultiRoutingError.notFound(mapWithOrigin.name || "")
-            }
-
-            return [Itinerary.fromGraphRoute(ioMapRoute)];
-        }
-
-        // Find the first map where the "destination" is inside.
-        // Note: At this step, mapWithDestination is necessarily different from mapWithOrigin
-        const mapWithDestination = ioMapsToTest.find(map => map.isPointInside(destination));
-
-
-        let remoteRouterItineraries: Itinerary[];
-
-        /*
-         * Case 2
-         *
-         * If no io map have been found for "origin" and "destination", therefore use remote router.
-         */
-        if (!mapWithOrigin && !mapWithDestination) {
-            return await RemoteRouterManager.getItinerariesWithFallback(routerRequest, fallbackStrategy);
-        }
-
-        /**
-         * Case 3
-         *
-         * If a map has been found for the "origin"  but not for the "destination", so:
-         * - A first itinerary (firstRoute) is calculated from "origin" to an "entrypoint"
-         *  of the IO map network using the wemap router.
-         * - A second itinerary (secondRoute) is calculated from an "entrypoint" to the
-         * "destination" using remote routers.
-         * Itinerary returned is the concatenation of the both itineraries.
-         *
-         * Note: Check the mapWithDestination.getBestItineraryFromEntryPointsToDestination to understand
-         * which "entrypoint" is chosen by the algorithm
-         */
-        if (mapWithOrigin && !mapWithDestination) {
-
-            if (!mapWithOrigin.entryPoints.length) {
-                throw WemapMultiRoutingError.notFound(mapWithOrigin.name || '',
-                    `A map including the "origin" but the "destination" has been 
-                    found (${mapWithOrigin.name}), however, no "entrypoints" have been found to go out`
-                )
-            }
-
-            const customError = (details: string) => 'Tried to calculate an itinerary from "origin" '
-                + `to "entrypoints" using wemap router on local map "${mapWithOrigin.name}" and `
-                + 'an itinerary from  "entrypoints" to "destination" using remote routers '
-                + `(${fallbackStrategy.map(r => r.name).join(', ')}), but failed. `
-                + `Details: ${details}.`;
-
-            ioMapRoute = mapWithOrigin.getBestRouteFromOriginToEntryPoints(origin, destination, routerOptions);
-            if (!ioMapRoute) {
-                const details = `No route found from ${origin.toString()} to entry points in map: ${mapWithOrigin.name}`;
-                throw WemapMultiRoutingError.notFound(mapWithOrigin.name || "", customError(details))
-            }
-
-            const newRouterRequest: RouterRequest = {
-                ...routerRequest,
-                origin: ioMapRoute.end,
-                destination,
-                waypoints: []
-            };
-            try {
-                remoteRouterItineraries = await RemoteRouterManager.getItinerariesWithFallback(newRouterRequest, fallbackStrategy);
-            } catch (e) {
-                if (e instanceof RemoteRoutingError) {
-                    e.message = customError(e.message);
-                }
-                throw e;
-            }
-
-            // Concat the the IO map itinerary with the remote router response (for each itinerary)
-            ioMapItinerary = Itinerary.fromGraphRoute(ioMapRoute);
-            return remoteRouterItineraries.map(
-                remoteRouterItinerary => Itinerary.fromItineraries(ioMapItinerary, remoteRouterItinerary)
-            );
-        }
-
-        /*
-         * Case 4
-         *
-         * If a map has been found for the "destination" but not for the "origin", so:
-         * - A first itinerary (remoteRouterResponse) is calculated from "origin" to an "entrypoint"
-         *  of the IO map network using remote routers.
-         * - A second itinerary (ioMapItinerary) is calculated from an "entrypoint" to the
-         *  "destination" using the wemap router.
-         * Itinerary returned is the concatenation of the both itineraries.
-         *
-         * Note: Check the mapWithDestination.getBestItineraryFromEntryPointsToDestination to understand
-         * which "entrypoint" is chosen by the algorithm
-         */
-        if (!mapWithOrigin && mapWithDestination) {
-
-            if (!mapWithDestination.entryPoints.length) {
-                throw WemapMultiRoutingError.notFound(mapWithDestination.name || '',
-                    `A map including the "destination" but the "origin" has been 
-                found (${mapWithDestination.name}), however, no "entrypoints" have been found to go in`
-                )
-            }
-
-            const customError = (details: string) => 'Tried to calculate an itinerary from "origin" to "entrypoints" '
-                + `using remote routers (${fallbackStrategy.map(r => r.name).join(', ')}) and an `
-                + 'itinerary from "entrypoints" to "destination" using wemap router on local map '
-                + `"${mapWithDestination.name}", but failed. `
-                + `Details: ${details}.`
-
-            /*
-             * ioMapItinerary is computed before the remoteRouterResponse because it is less expensive to
-             * calculate all the routes to entrypoints using local router than all the routes with the
-             * remote router.
-             */
-            ioMapRoute = mapWithDestination.getBestRouteFromEntryPointsToDestination(origin, destination, routerOptions);
-            if (!ioMapRoute) {
-                const details = `No route found from entry points to ${destination.toString()} in map: ${mapWithDestination.name}`;
-                throw WemapMultiRoutingError.notFound(mapWithDestination.name || "", customError(details))
-            }
-
-            const newRouterRequest: RouterRequest = {
-                ...routerRequest,
-                origin,
-                destination: ioMapRoute.start,
-                waypoints: []
-            };
-            try {
-                remoteRouterItineraries = await RemoteRouterManager.getItinerariesWithFallback(newRouterRequest, fallbackStrategy);
-            } catch (e) {
-                if (e instanceof RemoteRoutingError) {
-                    e.message = customError(e.message);
-                }
-                throw e;
-            }
-
-            // Concat the remote router response (for each itinerary) with the IO map itinerary
-            ioMapItinerary = Itinerary.fromGraphRoute(ioMapRoute);
-            return remoteRouterItineraries.map(
-                remoteRouterItinerary => Itinerary.fromItineraries(remoteRouterItinerary, ioMapItinerary)
-            );
-        }
-
-        /**
-         * Case 5
-         *
-         * If maps have been found for the "origin" and the "destination" but they are different, so:
-         * - A first itinerary (ioMapItinerary1) is calculated from "origin" to an "entrypoint" of
-         *  the mapWithOrigin using the wemap router.
-         * - A second itinerary (remoteRouterResponse) is calculated from an "entrypoint" of the
-         *  mapWithOrigin to an "entrypoint" of the destinationWithMap using remote routers.
-         * - A third itinerary (ioMapItinerary2) is calculated from an "entrypoint" of the mapWithDestination
-         *  to the "destination" using the wemap router.
-         * Itinerary returned is the concatenation of the three itineraries.
-         */
-        if (mapWithOrigin && mapWithDestination) {
-
-            if (!mapWithOrigin.entryPoints.length) {
-                throw WemapMultiRoutingError.notFound(mapWithOrigin.name || '',
-                    `One map including the "origin" (${mapWithOrigin.name}) and another 
-                    including the "destination" (${mapWithDestination.name}) has been found, however, no "entrypoints" have 
-                    been found to go out of the origin map`
-                );
-            }
-
-            if (!mapWithDestination.entryPoints.length) {
-                throw WemapMultiRoutingError.notFound(mapWithDestination.name || '',
-                    `One map including the "origin" (${mapWithOrigin.name}) and another 
-                    including the "destination" (${mapWithDestination.name}) has been found, however, no "entrypoints" have 
-                    been found to go in the second map`
-                );
-            }
-
-            const customError = (details: string) => 'Tried to calculate an itinerary from "origin" to "entrypoints1" '
-                + `using wemap router on local map  "${mapWithOrigin.name}", an itinerary from `
-                + '"entrypoints1" to "entrypoints2" using remote routers '
-                + `(${fallbackStrategy.map(r => r.name).join(', ')}) and an itinerary from "entrypoints2" `
-                + `to "destination" using wemap router on local map "${mapWithDestination.name}", but failed. `
-                + `Details: ${details}.`;
-
-
-            const ioMapRoute1 = mapWithOrigin.getBestRouteFromOriginToEntryPoints(origin, destination, routerOptions);
-            if (!ioMapRoute1) {
-                const details = `No route found from ${origin.toString()} to entry points in map: ${mapWithOrigin.name}`;
-                throw WemapMultiRoutingError.notFound(mapWithOrigin.name || "", customError(details))
-            }
-
-            const ioMapRoute2 = mapWithDestination.getBestRouteFromEntryPointsToDestination(origin, destination, routerOptions);
-            if (!ioMapRoute2) {
-                const details = `No route found from entry points to ${destination.toString()} in map: ${mapWithDestination.name}`;
-                throw WemapMultiRoutingError.notFound(mapWithDestination.name || "", customError(details))
-            }
-
-            const newRouterRequest: RouterRequest = {
-                ...routerRequest,
-                origin: ioMapRoute1.end,
-                destination: ioMapRoute2.start,
-                waypoints: []
-            };
-            try {
-                remoteRouterItineraries = await RemoteRouterManager.getItinerariesWithFallback(newRouterRequest, fallbackStrategy);
-            } catch (e) {
-                if (e instanceof RemoteRoutingError) {
-                    e.message = customError(e.message);
-                }
-                throw e;
-            }
-
-
-            // Concat the IO map itinerary 2 with the remote router response (for each itinerary)
-            // and the IO map itinerary 2
-            return remoteRouterItineraries.map(remoteRouterItinerary =>
-                Itinerary.fromItineraries(
-                    Itinerary.fromGraphRoute(ioMapRoute1),
-                    remoteRouterItinerary,
-                    Itinerary.fromGraphRoute(ioMapRoute2)
-                )
-            );
-
-        }
-
-        throw new Error('Should never happen');
-    }
-
-}
-
-export default WemapMultiRouter;

package/src/wemap-osm/OsmGraphUtils.spec.ts

@@ -1,165 +0,0 @@
-import chai from 'chai';
-import fs from 'fs';
-import { describe, it } from 'mocha';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-import { OsmParser } from '@wemap/osm';
-import { Level } from '@wemap/geo';
-
-import { verifyCoherence } from '../../tests/CommonTest.js';
-import OsmGraphUtils from './OsmGraphUtils.js';
-
-const { expect } = chai;
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-const loadFile = (fileName: string) => {
-    const filePath = path.resolve(__dirname, '../../assets/' + fileName);
-    return fs.readFileSync(filePath, 'utf8');
-};
-
-describe('OsmGraph - simple', () => {
-
-    const osmXmlString = loadFile('network-simple.osm');
-    const osmModel = OsmParser.parseOsmXmlString(osmXmlString);
-
-    it('OsmGraph creation', () => {
-
-        const graph = OsmGraphUtils.createGraphFromOsmModel(osmModel);
-
-        verifyCoherence(graph);
-        expect(graph.vertices.length).equals(3);
-        expect(graph.edges.length).equals(2);
-    });
-
-
-    it('OsmGraph creation - waySelectionFilter', () => {
-
-        const selectionGraph = OsmGraphUtils.createGraphFromOsmModel(osmModel, () => true);
-
-        verifyCoherence(selectionGraph);
-        expect(selectionGraph.vertices.length).equals(4);
-        expect(selectionGraph.edges.length).equals(3);
-    });
-
-    it('OsmGraph creation - elevator', () => {
-
-        const elevatorModel = OsmParser.parseOsmXmlString(loadFile('network-elevator.osm'));
-        const elevatorGraph = OsmGraphUtils.createGraphFromOsmModel(elevatorModel);
-
-        verifyCoherence(elevatorGraph);
-        expect(elevatorGraph.vertices.length).equals(7);
-        expect(elevatorGraph.edges.length).equals(7);
-
-
-        // const osmModel = OsmParser.parseOsmXmlString(`
-        // <osm>
-        //     <node id='1' lat='43' lon='4'>
-        //         <tag k='highway' v='elevator' />
-        //         <tag k='level' v='0;1' />
-        //     </node>
-        //     <node id='2' lat='43' lon='3' />
-        //     <way id='3'>
-        //         <nd ref='1' />
-        //         <nd ref='2' />
-        //         <tag k='highway' v='footway' />
-        //         <tag k='level' v='0;1' />
-        //     </way>
-        // </osm>
-        // `);
-        // expect(() => OsmGraphUtils.createGraphFromOsmModel(osmModel)).throw(Error);
-    });
-
-    it('getVertexByName', () => {
-        const graph = OsmGraphUtils.createGraphFromOsmModel(osmModel);
-
-        let vertex = graph.getVertexByName('p1');
-        expect(vertex).not.undefined;
-
-        vertex = graph.getVertexByName('p5');
-        expect(vertex).is.undefined;
-    });
-});
-
-
-describe('OsmGraph - complex', () => {
-
-
-    it('with stairs', () => {
-
-        const osmXmlString = loadFile('bureaux-wemap-montpellier-network.osm');
-        const osmModel = OsmParser.parseOsmXmlString(osmXmlString);
-        const graph = OsmGraphUtils.createGraphFromOsmModel(osmModel);
-
-        verifyCoherence(graph);
-
-        expect(graph.getEdgeByName('w6')?.properties.areStairs).is.true;
-    });
-
-    it('exits', () => {
-
-        const osmXmlString = loadFile('exit-graph.osm');
-        const osmModel = OsmParser.parseOsmXmlString(osmXmlString);
-        const graph = OsmGraphUtils.createGraphFromOsmModel(osmModel);
-
-        verifyCoherence(graph);
-
-        expect(Level.equals(graph.getEdgeByName('e1')!.level, 0));
-        expect(Level.equals(graph.getEdgeByName('e2')!.level, null));
-        expect(Level.equals(graph.getVertexByName('p1')!.coords.level, 0));
-        expect(Level.equals(graph.getVertexByName('p2')!.coords.level, 0));
-        expect(Level.equals(graph.getVertexByName('p3')!.coords.level, null));
-
-        expect(graph.exitVertices.size).equals(1);
-        expect(graph.exitVertices.has(graph.getVertexByName('p2')!)).is.true;
-
-    });
-
-    it('stairs & exit', () => {
-
-        const osmXmlString = loadFile('stairs-and-exit.osm');
-        const osmModel = OsmParser.parseOsmXmlString(osmXmlString);
-        const graph = OsmGraphUtils.createGraphFromOsmModel(osmModel);
-
-        verifyCoherence(graph);
-
-        expect(Level.equals(graph.getEdgeByName('e1')!.level, [0, 1]));
-        expect(Level.equals(graph.getEdgeByName('e2')!.level, 0));
-        expect(Level.equals(graph.getEdgeByName('e3')!.level, null));
-        expect(Level.equals(graph.getVertexByName('p1')!.coords.level, 1));
-        expect(Level.equals(graph.getVertexByName('p2')!.coords.level, 0));
-        expect(Level.equals(graph.getVertexByName('p3')!.coords.level, 0));
-        expect(Level.equals(graph.getVertexByName('p4')!.coords.level, null));
-
-        expect(graph.exitVertices.size).equals(1);
-        expect(graph.exitVertices.has(graph.getVertexByName('p3')!)).is.true;
-
-    });
-
-    it('escalators', () => {
-
-        const osmXmlString = loadFile('network-escalators.osm');
-        const osmModel = OsmParser.parseOsmXmlString(osmXmlString);
-        const graph = OsmGraphUtils.createGraphFromOsmModel(osmModel);
-
-        verifyCoherence(graph);
-
-        expect(graph.vertices.length).equals(4);
-        expect(graph.edges.length).equals(3);
-        graph.vertices.forEach(v => expect(v.coords.level).be.a("number"));
-
-    });
-
-    it('horizontal elevator', () => {
-
-        const osmXmlString = loadFile('horizontal-elevator.osm');
-        const osmModel = OsmParser.parseOsmXmlString(osmXmlString);
-        const graph = OsmGraphUtils.createGraphFromOsmModel(osmModel);
-
-        verifyCoherence(graph);
-
-        expect(graph.vertices.length).equals(2);
-        expect(graph.edges.length).equals(1);
-    });
-
-});