@wemap/osm 5.8.0 → 6.2.2

package/src/routers/cityway/CitywayUtils.spec.js

@@ -1,109 +0,0 @@
-/* eslint-disable max-statements */
-import chai from 'chai';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-import { Coordinates } from '@wemap/geo';
-
-import { createRouterResponseFromJson } from './CitywayUtils.js';
-
-import { verifyRouterResponseData } from '../RouterResponse.type.spec.js';
-
-
-const { expect } = chai;
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-describe('CitywayUtils - createRouterResponseFromJson', () => {
-
-    it('RouterResponse - 1', () => {
-
-        const filePath = path.resolve(__dirname, '../../../assets/itinerary-lehavre-cityway-1.json');
-        const fileString = fs.readFileSync(filePath, 'utf8');
-        const json = JSON.parse(fileString);
-
-        const routerResponse = createRouterResponseFromJson(json);
-        verifyRouterResponseData(routerResponse);
-
-        expect(routerResponse.routerName).equal('cityway');
-        expect(routerResponse.itineraries.length).equal(3);
-        expect(routerResponse.from.equalsTo(new Coordinates(49.515093882362159, 0.093417496193663158))).true;
-        expect(routerResponse.to.equalsTo(new Coordinates(49.5067090188444, 0.16948421154178309))).true;
-
-        const itinerary1 = routerResponse.itineraries[0];
-        expect(itinerary1.distance).to.be.closeTo(6887, 1);
-        expect(itinerary1.duration).equal(2379);
-        // Do not work because of the input time format
-        // expect(itinerary1.startTime).equal(1620659156000);
-        // expect(itinerary1.endTime).equal(1620661535000);
-        expect(itinerary1.legs.length).equal(5);
-
-        const itinerary1leg1 = itinerary1.legs[0];
-        // Do not work because of the input time format
-        // expect(itinerary1leg1.startTime).equal(1620659156000);
-        // expect(itinerary1leg1.endTime).equal(1620659340000);
-        expect(itinerary1leg1.distance).to.be.closeTo(200.14, 0.1);
-        expect(itinerary1leg1.mode).equal('WALK');
-        expect(itinerary1leg1.transportInfo).is.null;
-        expect(itinerary1leg1.from.name).equal('RUE DU QUARTIER NEUF');
-        expect(itinerary1leg1.from.coords.equalsTo(new Coordinates(49.515093882362159, 0.093417496193663158))).true;
-        expect(itinerary1leg1.to.name).equal('T. Gautier');
-        expect(itinerary1leg1.to.coords.equalsTo(new Coordinates(49.5147550229, 0.0911025378))).true;
-
-        const itinerary1leg2 = itinerary1.legs[1];
-        expect(itinerary1leg2.mode).equal('BUS');
-        expect(itinerary1leg2.transportInfo).is.not.null;
-        expect(itinerary1leg2.transportInfo.name).equal('03');
-        expect(itinerary1leg2.transportInfo.routeColor).equal('3FA435');
-        expect(itinerary1leg2.transportInfo.routeTextColor).is.null;
-        expect(itinerary1leg2.transportInfo.directionName).equal('Graville');
-    });
-
-    it('RouterResponse - 2', () => {
-        const filePath = path.resolve(__dirname, '../../../assets/itinerary-lehavre-cityway-2.json');
-        const fileString = fs.readFileSync(filePath, 'utf8');
-        const json = JSON.parse(fileString);
-
-        const routerResponse = createRouterResponseFromJson(json);
-        verifyRouterResponseData(routerResponse);
-
-        expect(routerResponse.itineraries.length).equal(1);
-    });
-
-    it('RouterResponse - 3', () => {
-        const filePath = path.resolve(__dirname, '../../../assets/itinerary-lehavre-cityway-3.json');
-        const fileString = fs.readFileSync(filePath, 'utf8');
-        const json = JSON.parse(fileString);
-
-        const routerResponse = createRouterResponseFromJson(json);
-        verifyRouterResponseData(routerResponse);
-
-        expect(routerResponse.itineraries[0].legs[1].mode).equal('FUNICULAR');
-    });
-
-    it('RouterResponse - 4', () => {
-        const filePath = path.resolve(__dirname, '../../../assets/itinerary-lehavre-cityway-4.json');
-        const fileString = fs.readFileSync(filePath, 'utf8');
-        const json = JSON.parse(fileString);
-
-        const routerResponse = createRouterResponseFromJson(json);
-        verifyRouterResponseData(routerResponse);
-
-        expect(routerResponse.itineraries[0].legs[0].mode).equal('BICYCLE');
-    });
-
-    it('RouterResponse - 5', () => {
-        const filePath = path.resolve(__dirname, '../../../assets/itinerary-lehavre-cityway-5.json');
-        const fileString = fs.readFileSync(filePath, 'utf8');
-        const json = JSON.parse(fileString);
-
-        const routerResponse = createRouterResponseFromJson(json);
-        verifyRouterResponseData(routerResponse);
-
-        expect(routerResponse.itineraries[1].legs[1].mode).equal('TRAM');
-        expect(routerResponse.itineraries[1].legs[1].transportInfo.name).equal('B');
-    });
-
-});
-

package/src/routers/custom/OsmNetworkUtils.js

@@ -1,199 +0,0 @@
-import { Level, GraphEdge, GraphNode, Network } from '@wemap/geo';
-
-import OsmElement from '../../model/OsmElement.js';
-import OsmModel from '../../model/OsmModel.js';
-import OsmNode from '../../model/OsmNode.js';
-import OsmWay from '../../model/OsmWay.js';
-
-
-export const HIGHWAYS_PEDESTRIANS = ['footway', 'steps', 'pedestrian', 'living_street', 'path', 'track', 'sidewalk'];
-
-export const DEFAULT_WAY_SELECTOR = way => {
-    return HIGHWAYS_PEDESTRIANS.includes(way.tags.highway)
-        || way.tags.footway === 'sidewalk'
-        || way.tags.public_transport === 'platform'
-        || way.tags.railway === 'platform';
-};
-
-/**
- * @param {Network<OsmElement>} network
- * @param {string} name
- */
-export function getNodeByName(network, name) {
-    return network.nodes.find(({ builtFrom }) => builtFrom.tags.name === name);
-}
-
-/**
- * @param {Network<OsmElement>} network
- * @param {string} name
- */
-export function getEdgeByName(network, name) {
-    return network.edges.find(({ builtFrom }) => builtFrom.tags.name === name);
-}
-
-/**
- * @param {GraphEdge<OsmElement>} edge
- * @param {OsmWay} way
- * @returns {boolean}
- */
-function manageOneWay(edge, way) {
-
-    const { highway, oneway, conveying } = way.tags;
-
-    edge.isOneway = Boolean((oneway === 'yes' || oneway === 'true' || oneway === '1')
-        || (conveying && highway && ['yes', 'forward', 'backward'].includes(conveying)));
-
-    if (edge.isOneway && conveying === 'backward') {
-        const tmpNode = edge.node1;
-        edge.node1 = edge.node2;
-        edge.node2 = tmpNode;
-    }
-}
-
-/**
- * @param {Network} networkModel
- * @param {GraphNode} node
- */
-function createNodesAndEdgesFromElevator(networkModel, node) {
-
-    /** @type {GraphNode[]} */
-    const createdNodes = [];
-    const getOrCreateLevelNode = (level, builtFrom) => {
-        let levelNode = createdNodes.find(({ coords }) => Level.equalsTo(level, coords.level));
-        if (!levelNode) {
-            levelNode = new GraphNode(node.coords.clone(), builtFrom);
-            levelNode.coords.level = level;
-            createdNodes.push(levelNode);
-            networkModel.nodes.push(levelNode);
-        }
-        return levelNode;
-    };
-
-    // Create nodes from node.edges
-    node.edges.forEach(edge => {
-        if (edge.level.isRange) {
-            throw new Error('Cannot handle this elevator edge due to ambiguity');
-        }
-
-        const levelNode = getOrCreateLevelNode(edge.level, node.builtFrom);
-        if (edge.node1 === node) {
-            edge.node1 = levelNode;
-        } else {
-            edge.node2 = levelNode;
-        }
-        levelNode.edges.push(edge);
-    });
-
-    // Create edges from createdNodes
-    for (let i = 0; i < createdNodes.length; i++) {
-        for (let j = i + 1; j < createdNodes.length; j++) {
-
-            const createdNode1 = createdNodes[i];
-            const createdNode2 = createdNodes[j];
-
-            const newEdge = new GraphEdge(
-                createdNode1,
-                createdNode2,
-                new Level(createdNode1.coords.level.val, createdNode2.coords.level.val),
-                node.builtFrom
-            );
-            networkModel.edges.push(newEdge);
-        }
-    }
-
-    // Remove the historical elevator node from the network
-    networkModel.nodes = networkModel.nodes.filter(_node => _node !== node);
-}
-
-
-/**
- * @param {OsmModel} osmModel
- * @param {function} _waySelectionFilter
- * @returns {Network<OsmElement>}
- */
-export function createNetworkFromOsmModel(
-    osmModel,
-    waySelectionFilter = DEFAULT_WAY_SELECTOR
-) {
-
-    const networkModel = new Network();
-
-    const nodesCreated = {};
-    const elevatorNodes = [];
-
-    /**
-     * @param {OsmNode} osmNode
-     */
-    const getOrCreateNode = osmNode => {
-        let node = nodesCreated[osmNode.id];
-        if (!node) {
-            node = new GraphNode(osmNode.coords, osmNode);
-            nodesCreated[osmNode.id] = node;
-            networkModel.nodes.push(node);
-
-            if (osmNode.tags.highway === 'elevator') {
-                elevatorNodes.push(node);
-            }
-        }
-        return node;
-    };
-
-    osmModel.ways.forEach(way => {
-        if (!waySelectionFilter(way)) {
-            return;
-        }
-
-        let firstNode = getOrCreateNode(way.nodes[0]);
-        for (let i = 1; i < way.nodes.length; i++) {
-            const secondNode = getOrCreateNode(way.nodes[i]);
-
-            const edge = new GraphEdge(firstNode, secondNode, way.level, way);
-            manageOneWay(edge, way);
-            networkModel.edges.push(edge);
-            firstNode = secondNode;
-        }
-
-    });
-
-    elevatorNodes.forEach(node => {
-        // We have to clone this node for each connected edge
-        createNodesAndEdgesFromElevator(networkModel, node);
-    });
-
-    GraphNode.generateNodesLevels(networkModel.nodes);
-
-    return networkModel;
-}
-
-
-// /**
-//  * @param {GraphNode} node
-//  * @param {object} tags
-//  */
-// static _applyNodePropertiesFromTags(node, tags) {
-//     node.name = tags.name || null;
-//     node.subwayEntrance = tags.railway === 'subway_entrance';
-//     if (node.subwayEntrance && tags.ref) {
-//         node.subwayEntranceRef = tags.ref;
-//     }
-// }
-
-// /**
-//  * @param {GraphEdge} edge
-//  * @param {object} tags
-//  */
-// static _applyEdgePropertiesFromTags(edge, tags) {
-//     const { highway, oneway, conveying, name } = tags;
-//     edge.name = name || null;
-//     edge.isStairs = highway === 'steps';
-//     edge.isConveying = 'conveying' in tags;
-//     edge.isOneway = Boolean((oneway === 'yes' || oneway === 'true' || oneway === '1')
-//         || (conveying && highway && ['yes', 'forward', 'backward'].includes(conveying)));
-
-//     if (conveying === 'backward') {
-//         const tmpNode = edge.node1;
-//         edge.node1 = edge.node2;
-//         edge.node2 = tmpNode;
-//     }
-
-// }

package/src/routers/custom/OsmNetworkUtils.spec.js

@@ -1,109 +0,0 @@
-/* eslint-disable max-statements */
-import chai from 'chai';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-import { Network } from '@wemap/geo';
-import { verifyCoherence } from '@wemap/geo/tests/CommonTest.js';
-
-import OsmParser from '../../model/OsmParser.js';
-import OsmModel from '../../model/OsmModel.js';
-import { createNetworkFromOsmModel, getNodeByName, getEdgeByName } from './OsmNetworkUtils.js';
-
-const { expect } = chai;
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-
-const loadFile = fileName => {
-    const filePath = path.resolve(__dirname, '../../../assets/' + fileName);
-    return fs.readFileSync(filePath, 'utf8');
-};
-
-describe('OsmNetwork - simple', () => {
-
-    /** @type {OsmModel} */
-    let osmModel;
-
-    /** @type {Network} */
-    let network;
-    const osmXmlString = loadFile('network-simple.osm');
-
-    it('Network creation', () => {
-
-        osmModel = OsmParser.parseOsmXmlString(osmXmlString);
-        network = createNetworkFromOsmModel(osmModel);
-
-        verifyCoherence(network);
-        expect(network.nodes.length).equals(3);
-        expect(network.edges.length).equals(2);
-    });
-
-
-    it('Network creation - waySelectionFilter', () => {
-
-        const selectionNetwork = createNetworkFromOsmModel(osmModel, () => true);
-
-        verifyCoherence(selectionNetwork);
-        expect(selectionNetwork.nodes.length).equals(4);
-        expect(selectionNetwork.edges.length).equals(3);
-    });
-
-    it('Network creation - elevator', () => {
-
-        const elevatorModel = OsmParser.parseOsmXmlString(loadFile('network-elevator.osm'));
-        const elevatorNetwork = createNetworkFromOsmModel(elevatorModel);
-
-        verifyCoherence(elevatorNetwork);
-        expect(elevatorNetwork.nodes.length).equals(7);
-        expect(elevatorNetwork.edges.length).equals(7);
-
-
-        const osmModel2 = 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(() => createNetworkFromOsmModel(osmModel2)).throw(Error);
-    });
-
-    it('getNodeByName', () => {
-        let node = getNodeByName(network, 'p1');
-        expect(node).not.undefined;
-
-        node = getNodeByName(network, 'p5');
-        expect(node).is.undefined;
-    });
-});
-
-
-describe('OsmNetwork - with stairs', () => {
-
-    /** @type {OsmModel} */
-    let osmModel;
-
-    /** @type {Network} */
-    let network;
-    const osmXmlString = loadFile('bureaux-wemap-montpellier-network.osm');
-
-    it('Network creation', () => {
-
-        osmModel = OsmParser.parseOsmXmlString(osmXmlString);
-        network = createNetworkFromOsmModel(osmModel);
-
-        verifyCoherence(network);
-
-        expect(getEdgeByName(network, 'w6').builtFrom.tags.highway).equal('steps');
-    });
-
-});

package/src/routers/custom/OsmRouter.js

@@ -1,27 +0,0 @@
-import { Coordinates, GraphItinerary, GraphRouter, Network } from '@wemap/geo';
-
-import OsmRouterOptions from './OsmRouterOptions.js';
-import OsmElement from '../../model/OsmElement.js';
-
-class OsmRouter extends GraphRouter {
-
-    /**
-     * @param {!Network<OsmElement>} network
-     */
-    constructor(network) {
-        super(network);
-    }
-
-    /**
-     * @param {Coordinates} start
-     * @param {Coordinates} end
-     * @param {OsmRouterOptions} options
-     * @returns {GraphItinerary<OsmElement>}
-     */
-    getShortestPath(start, end, options = new OsmRouterOptions()) {
-        return super.getShortestPath(start, end, options);
-    }
-
-}
-
-export default OsmRouter;

package/src/routers/custom/OsmRouter.spec.js

@@ -1,222 +0,0 @@
-/* eslint-disable max-statements */
-import chai from 'chai';
-import chaiAlmost from 'chai-almost';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-import {
-    Level, Coordinates, GraphNode, Network, GraphItinerary
-} from '@wemap/geo';
-
-import OsmParser from '../../model/OsmParser.js';
-import OsmElement from '../../model/OsmElement.js';
-
-import OsmRouter from './OsmRouter.js';
-import OsmRouterOptions from './OsmRouterOptions.js';
-import StepsGeneration from './StepsGeneration.js';
-import { createNetworkFromOsmModel, getNodeByName } from './OsmNetworkUtils.js';
-
-import LevelChange from '../LevelChange.js';
-
-const { expect } = chai;
-chai.use(chaiAlmost(0.01));
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-
-/**
- * @param {GraphItinerary<OsmElement>} _itinerary
- * @returns {string[]}
- */
-const getNodesNames = _itinerary => {
-    return _itinerary.nodes.map(({ builtFrom }) => builtFrom.tags.name || null);
-};
-
-
-const itineraryStart = new Coordinates(43.6092754, 3.8842306, null, new Level(2));
-const itineraryEnd = new Coordinates(43.6092602, 3.8842669, null, new Level(1));
-
-
-/**
- * @param {string} fileName
- * @returns {Network}
- */
-const loadNetwork = fileName => {
-    const filePath = path.resolve(__dirname, '../../../assets/' + fileName);
-    const osmXmlString = fs.readFileSync(filePath, 'utf8');
-    const osmModel = OsmParser.parseOsmXmlString(osmXmlString);
-    return createNetworkFromOsmModel(osmModel);
-};
-
-const generateNodeNames = (start, end) =>
-    new Array(end - start + 1).fill().map((_, idx) => 'p' + (idx + start));
-
-describe('OsmRouter - Multi-level itinerary', () => {
-
-    const networkModel = loadNetwork('bureaux-wemap-montpellier-network.osm');
-    const router = new OsmRouter(networkModel);
-
-    const itinerary = router.getShortestPath(itineraryStart, itineraryEnd);
-
-    /** @type {GraphNode<OsmElement>[]} */
-    const p = [];
-
-    it('Search for nodes', () => {
-        for (let i = 1; i <= 16; i++) {
-            p[i] = getNodeByName(networkModel, 'p' + i);
-            expect(p[i]).instanceOf(GraphNode);
-        }
-    });
-
-    it('Router return shortest path', () => {
-        expect(getNodesNames(itinerary)).deep.equals(
-            ['w2', ...generateNodeNames(7, 16)]
-        );
-    });
-
-    it('Verify steps', () => {
-
-        const steps = StepsGeneration.fromGraphItinerary(itinerary);
-        expect(steps.length).equal(8);
-
-        expect(steps[0].coords.equalsTo(itineraryStart.getSegmentProjection(p[6].coords, p[7].coords))).true;
-        expect(steps[0].name).equals('w2');
-        expect(steps[0].number).equals(1);
-        expect(steps[0].angle).almost.equals(-1.57);
-        expect(steps[0].previousBearing).almost.equals(1.778);
-        expect(steps[0].nextBearing).almost.equals(0.207);
-        expect(steps[0].distance).almost.equals(2.328);
-        expect(steps[0].duration).almost.equals(1.676);
-        expect(steps[0].firstStep).true;
-        expect(steps[0].lastStep).false;
-        expect(steps[0].levelChange).is.null;
-        expect(steps[0].extras).is.empty;
-
-        expect(steps[1].coords.equalsTo(p[8].coords)).true;
-        expect(steps[1].name).equals('w3');
-        expect(steps[1].number).equals(2);
-        expect(steps[1].distance).almost.equals(1.764);
-        expect(steps[1].firstStep).false;
-        expect(steps[1].lastStep).false;
-
-        expect(steps[2].coords.equalsTo(p[9].coords)).true;
-        expect(steps[2].name).equals('w3');
-
-        expect(steps[3].coords.equalsTo(p[10].coords)).true;
-        expect(steps[3].name).equals('w5');
-
-        expect(steps[4].coords.equalsTo(p[11].coords)).true;
-        expect(steps[4].name).equals('w6');
-        expect(steps[4].levelChange).instanceOf(LevelChange);
-        expect(steps[4].levelChange.difference).equals(-1);
-        expect(steps[4].levelChange.direction).equals('down');
-        expect(steps[4].levelChange.type).equals('stairs');
-
-        expect(steps[5].coords.equalsTo(p[14].coords)).true;
-        expect(steps[5].name).equals('w7');
-
-        expect(steps[6].coords.equalsTo(p[15].coords)).true;
-        expect(steps[6].name).equals('w9');
-
-        expect(steps[7].coords.equalsTo(p[16].coords)).true;
-        expect(steps[7].name).is.null;
-        expect(steps[7].lastStep).true;
-    });
-
-
-    it('router returns shortest path 2', () => {
-
-        const start = new Coordinates(43.609219, 3.8841743, null, new Level(2));
-        const end = new Coordinates(43.60917216742, 3.8842355275, null, new Level(2));
-        const itinerary2 = router.getShortestPath(start, end);
-
-        expect(getNodesNames(itinerary2)).deep.equals(['w1', 'p6', 'p5']);
-    });
-
-    it('do not use stairs', () => {
-
-        const itineraryWithoutStairs = router.getShortestPath(
-            itineraryStart, itineraryEnd,
-            OsmRouterOptions.WITHOUT_STAIRS
-        );
-        expect(itineraryWithoutStairs.nodes.length).equal(11);
-        itineraryWithoutStairs.edges.forEach((edge) => {
-            expect(edge.builtFrom.tags.highway).is.not.equal('steps');
-        });
-    });
-
-    // it('toCompressedJson / fromCompressedJson', () => {
-    //     const json = itinerary.toCompressedJson();
-    //     expect(() => JSON.stringify(json)).not.throw(Error);
-
-    //     const itineraryBis = Itinerary.fromCompressedJson(json);
-    //     verifyCoherence(itineraryBis);
-    //     expect(itineraryBis.nodes.length).equal(11);
-    //     verifyNodesOrder(itineraryBis.nodes, ['w2', ...generateNodeNames(7, 16)]);
-    // });
-
-});
-
-describe('OsmRouter - One Way itinerary', () => {
-
-    const networkModel = loadNetwork('one-way.osm');
-    const router = new OsmRouter(networkModel);
-
-    it('do not use oneway', () => {
-
-        const start = new Coordinates(43.6094542, 3.8842072);
-        const end = new Coordinates(43.6093792, 3.8841889);
-
-        const itinerary = router.getShortestPath(start, end);
-        expect(itinerary).is.not.undefined;
-        expect(getNodesNames(itinerary)).deep.equals(['p0', 'p1', 'p2', 'p3']);
-
-        const itineraryOtherWay = router.getShortestPath(end, start);
-        expect(itineraryOtherWay).is.not.undefined;
-        expect(getNodesNames(itineraryOtherWay)).deep.equals(['p3', 'p2', 'p5', 'p4', 'p1', 'p0']);
-    });
-});
-
-
-describe('OsmRouter - Conveying', () => {
-
-    const networkModel = loadNetwork('gare-de-lyon-extract.osm');
-    const router = new OsmRouter(networkModel);
-
-    it('do not use oneway conveying', () => {
-
-        const start = new Coordinates(48.8445715, 2.3718927, null, new Level(0));
-        const end = new Coordinates(48.84443728652394, 2.3721685669363524, null, new Level(-1));
-
-        const itinerary = router.getShortestPath(start, end);
-        expect(itinerary).is.not.undefined;
-        expect(getNodesNames(itinerary)).deep.equals(['p11', 'p12', 'p9', 'p8', 'p6', null]);
-
-        const itineraryOtherWay = router.getShortestPath(end, start);
-        expect(itineraryOtherWay).is.not.undefined;
-        expect(getNodesNames(itineraryOtherWay)).deep.equals([null, 'p6', 'p7', 'p10', 'p11']);
-    });
-});
-
-
-describe('OsmRouter - Conveying - backward', () => {
-
-    const networkModel = loadNetwork('network-conveying-backward.osm');
-    const router = new OsmRouter(networkModel);
-
-    it('do not use oneway conveying', () => {
-
-        const start = getNodeByName(networkModel, 'p6');
-        const end = getNodeByName(networkModel, 'p13');
-
-        const itinerary = router.getShortestPath(start, end);
-        expect(itinerary).is.not.undefined;
-        expect(getNodesNames(itinerary)).deep.equals(['p6', 'p7', 'p10', 'p11', 'p12', 'p13']);
-
-        const itineraryOtherWay = router.getShortestPath(end, start);
-        expect(itineraryOtherWay).is.not.undefined;
-        expect(getNodesNames(itineraryOtherWay)).deep.equals(['p13', 'p12', 'p9', 'p8', 'p6']);
-    });
-});
-
-