@wemap/osm 2.7.6 → 2.7.7

package/src/osrm/OsrmUtils.spec.js

@@ -12,16 +12,153 @@ import OsmRouter from '../network/OsmRouter';
 import OsmNetwork from '../network/OsmNetwork';
 import OsrmUtils from './OsrmUtils';
 
-import {
-    itineraryStart, itineraryEnd
-} from '../../../graph/tests/CommonTest';
 
-describe('OsrmUtils', () => {
+const load = fileName => {
+    const filePath = path.resolve(__dirname, '../../assets/' + fileName);
+    const osmXmlString = fs.readFileSync(filePath, 'utf8');
+    const model = OsmParser.parseOsmXmlString(osmXmlString);
+    const network = OsmNetwork.fromOsmModel(model);
+    const router = new OsmRouter(network);
+    return {
+        network,
+        router
+    };
+};
+
+let wemapItinerary, wemapJsonItinerary, wemapStart, wemapEnd;
+
+describe('OsrmUtils - itineraryToOsrmJson', () => {
+
+    it('With levels (Bureaux Wemap)', () => {
+
+        const {
+            network, router
+        } = load('bureaux-wemap-montpellier-network.osm');
+
+        wemapStart = new WGS84(43.6092754, 3.8842306, null, new Level(2));
+        wemapEnd = new WGS84(43.6092602, 3.8842669, null, new Level(1));
+        const itinerary = router.getShortestPath(wemapStart, wemapEnd);
+        wemapItinerary = itinerary;
+
+        const osrmJson = OsrmUtils.itineraryToOsrmJson(itinerary);
+        wemapJsonItinerary = osrmJson;
+        const itinerarySteps = itinerary.steps;
+
+        const {
+            geometry, legs
+        } = osrmJson.routes[0];
+
+        /**
+         * Verify if JSON geometry corresponds to Itinerary points
+         */
+        const { coordinates } = geometry;
+        expect(coordinates.length).equal(11);
+        for (let i = 1; i < 11; i++) {
+            expect(
+                network.getNodeByName('p' + (i + 6)).coords.equalsTo(
+                    OsrmUtils.jsonToWgs84(coordinates[i]))
+            ).true;
+        }
+
+        /**
+         * Verify location, type and modifier of each step
+         */
+        const { steps } = legs[0];
+        for (let i = 0; i < steps.length; i++) {
+            const {
+                location, type
+            } = steps[i].maneuver;
+            expect(itinerarySteps[i].node.coords.equalsTo(OsrmUtils.jsonToWgs84(location))).true;
+
+            let expectedType;
+            switch (i) {
+            case 0:
+                expectedType = 'depart';
+                break;
+            case steps.length - 1:
+                expectedType = 'arrive';
+                break;
+            default:
+                expectedType = 'turn';
+            }
+            expect(type).equals(expectedType);
+        }
+
+        // The first modifier is not mandatory by OSRM.
+        expect(steps[0].maneuver.modifier).equals('left');
+        expect(steps[0].distance).be.closeTo(2.33, 0.01);
+        expect(steps[0].maneuver.bearing_after).be.closeTo(11.90, 0.01);
+
+        expect(steps[1].maneuver.modifier).equals('right');
+        expect(steps[1].distance).be.closeTo(1.76, 0.01);
+        expect(steps[1].maneuver.bearing_after).be.closeTo(56.90, 0.01);
+
+        expect(steps[2].maneuver.modifier).equals('left');
+        expect(steps[2].distance).be.closeTo(1.15, 0.01);
+        expect(steps[2].maneuver.bearing_after).be.closeTo(11.90, 0.01);
+
+        expect(steps[3].maneuver.modifier).equals('left');
+        expect(steps[3].distance).be.closeTo(5.95, 0.01);
+        expect(steps[3].maneuver.bearing_after).be.closeTo(281.93, 0.01);
+
+        expect(steps[4].maneuver.modifier).equals('right');
+        expect(steps[4].distance).be.closeTo(10.71, 0.01);
+        expect(steps[4].maneuver.bearing_after).be.closeTo(12.22, 0.01);
+        expect(steps[4].levelChange).is.not.null;
+        expect(steps[4].levelChange.direction).equals('down');
+        expect(steps[4].levelChange.diff).equals(-1);
+
+        expect(steps[5].maneuver.modifier).equals('left');
+        expect(steps[5].distance).be.closeTo(4.23, 0.01);
+        expect(steps[5].maneuver.bearing_after).be.closeTo(102.00, 0.01);
+
+        expect(steps[6].maneuver.modifier).equals('right');
+        expect(steps[6].distance).be.closeTo(5.03, 0.01);
+        expect(steps[6].maneuver.bearing_after).be.closeTo(191.75, 0.01);
+
+        expect(steps[7].maneuver.modifier).equals('left');
+        expect(steps[7].distance).be.closeTo(0, 0.01);
+        expect(steps[7].maneuver.bearing_after).be.closeTo(0, 0.01);
+
+    });
+
+    it('Without levels', () => {
+
+        const {
+            network, router
+        } = load('network-simple.osm');
+
+        const start = network.getNodeByName('p1');
+        const end = network.getNodeByName('p3');
+
+        const itinerary = router.getShortestPath(start, end);
+        expect(() => OsrmUtils.itineraryToOsrmJson(itinerary)).not.throw(Error);
+
+    });
+
+    it('Itinerary with modifiers', () => {
+
+        const {
+            network, router
+        } = load('network-with-modifiers.osm');
+
+        const start = network.getNodeByName('start');
+        const end = network.getNodeByName('end');
+
+        const itinerary = router.getShortestPath(start, end);
+        expect(() => OsrmUtils.itineraryToOsrmJson(itinerary)).not.throw(Error);
+
+    });
+
+});
+
 
+describe('OsrmUtils - createItineraryFromJson', () => {
 
-    it('OSRM JSON to Itinerary', () => {
 
-        const filePath = path.resolve(__dirname, '../../assets/itinerary-osrm.json');
+    it('Without levels (Montpellier outdoor)', () => {
+
+        const filePath = path.resolve(__dirname, '../../assets/itinerary-montpellier-outdoor.json');
         const fileString = fs.readFileSync(filePath, 'utf8');
 
         const json = JSON.parse(fileString);
@@ -96,108 +233,33 @@ describe('OsrmUtils', () => {
         expect(itinerary._nextStepsIndexes[18]).equals(4);
     });
 
-    let osrmWemapJson, wemapItinerary;
-    it('Itinerary to OSRM JSON', () => {
-
-        const filePath = path.resolve(__dirname, '../../assets/bureaux-wemap-montpellier-network.osm');
-        const osmXmlString = fs.readFileSync(filePath, 'utf8');
-
-        const osmModel = OsmParser.parseOsmXmlString(osmXmlString);
-        const networkModel = OsmNetwork.fromOsmModel(osmModel);
-        const router = new OsmRouter(networkModel);
-
-        wemapItinerary = router.getShortestPath(itineraryStart, itineraryEnd);
-
-        osrmWemapJson = OsrmUtils.itineraryToOsrmJson(wemapItinerary);
-        const itinerarySteps = wemapItinerary.steps;
-
-        const {
-            geometry, legs
-        } = osrmWemapJson.routes[0];
-
-        const p = [];
-        for (let i = 1; i <= 16; i++) {
-            p[i] = networkModel.getNodeByName('p' + i);
-        }
-
-
-        /**
-         * Verify if JSON geometry corresponds to Itinerary points
-         */
-        const { coordinates } = geometry;
-        expect(coordinates.length).equal(11);
-        for (let i = 1; i < 11; i++) {
-            expect(p[i + 6].coords.equalsTo(OsrmUtils.jsonToWgs84(coordinates[i]))).true;
-        }
-
-        /**
-         * Verify location, type and modifier of each step
-         */
-        const { steps } = legs[0];
-        for (let i = 0; i < steps.length; i++) {
-            const {
-                location, type
-            } = steps[i].maneuver;
-            expect(itinerarySteps[i].node.coords.equalsTo(OsrmUtils.jsonToWgs84(location))).true;
-
-            let expectedType;
-            switch (i) {
-            case 0:
-                expectedType = 'depart';
-                break;
-            case steps.length - 1:
-                expectedType = 'arrive';
-                break;
-            default:
-                expectedType = 'turn';
-            }
-            expect(type).equals(expectedType);
-        }
-
-        // The first modifier is not mandatory by OSRM.
-        expect(steps[0].maneuver.modifier).equals('left');
-        expect(steps[0].distance).be.closeTo(2.33, 0.01);
-        expect(steps[0].maneuver.bearing_after).be.closeTo(11.90, 0.01);
-
-        expect(steps[1].maneuver.modifier).equals('right');
-        expect(steps[1].distance).be.closeTo(1.76, 0.01);
-        expect(steps[1].maneuver.bearing_after).be.closeTo(56.90, 0.01);
 
-        expect(steps[2].maneuver.modifier).equals('left');
-        expect(steps[2].distance).be.closeTo(1.15, 0.01);
-        expect(steps[2].maneuver.bearing_after).be.closeTo(11.90, 0.01);
+    it('Without steps (Montpellier outdoor)', () => {
 
-        expect(steps[3].maneuver.modifier).equals('left');
-        expect(steps[3].distance).be.closeTo(5.95, 0.01);
-        expect(steps[3].maneuver.bearing_after).be.closeTo(281.93, 0.01);
+        const filePath = path.resolve(__dirname,
+            '../../assets/itinerary-montpellier-outdoor-without-steps.json');
+        const fileString = fs.readFileSync(filePath, 'utf8');
 
-        expect(steps[4].maneuver.modifier).equals('right');
-        expect(steps[4].distance).be.closeTo(10.71, 0.01);
-        expect(steps[4].maneuver.bearing_after).be.closeTo(12.22, 0.01);
-        expect(steps[4].levelChange).is.not.null;
-        expect(steps[4].levelChange.direction).equals('down');
-        expect(steps[4].levelChange.diff).equals(-1);
+        const json = JSON.parse(fileString);
 
-        expect(steps[5].maneuver.modifier).equals('left');
-        expect(steps[5].distance).be.closeTo(4.23, 0.01);
-        expect(steps[5].maneuver.bearing_after).be.closeTo(102.00, 0.01);
+        const start = new WGS84(43.6007871, 3.8757218000000004);
+        const end = new WGS84(43.598877, 3.873866);
 
-        expect(steps[6].maneuver.modifier).equals('right');
-        expect(steps[6].distance).be.closeTo(5.03, 0.01);
-        expect(steps[6].maneuver.bearing_after).be.closeTo(191.75, 0.01);
+        const itinerary = OsrmUtils.createItineraryFromJson(json, start, end);
 
-        expect(steps[7].maneuver.modifier).equals('left');
-        expect(steps[7].distance).be.closeTo(0, 0.01);
-        expect(steps[7].maneuver.bearing_after).be.closeTo(0, 0.01);
+        expect(json.routes[0].geometry.coordinates.length).equal(itinerary.nodes.length);
+        expect(itinerary.nodes.length).equal(itinerary.edges.length + 1);
+        expect(itinerary.nodes.length).equal(19);
 
+        const { steps } = itinerary;
+        expect(steps.length).equal(7);
     });
 
 
-    it('Itinerary to OSRM JSON to Itinerary', () => {
-
-        const json = osrmWemapJson;
+    it('With levels (from itineraryToOsrmJson)', () => {
 
-        const itinerary = OsrmUtils.createItineraryFromJson(json, itineraryStart, itineraryEnd);
+        const itinerary = OsrmUtils.createItineraryFromJson(wemapJsonItinerary,
+            wemapStart, wemapEnd);
 
         expect(itinerary.nodes.length).equal(wemapItinerary.nodes.length);
         for (let i = 0; i < itinerary.nodes.length; i++) {
@@ -219,4 +281,29 @@ describe('OsrmUtils', () => {
 
     });
 
+    it('Errored (Montpellier outdoor)', () => {
+
+        const filePath = path.resolve(__dirname,
+            '../../assets/itinerary-montpellier-outdoor-errored.json');
+        const fileString = fs.readFileSync(filePath, 'utf8');
+
+        const json = JSON.parse(fileString);
+
+        const start = new WGS84(43.6007871, 3.8757218000000004);
+        const end = new WGS84(43.598877, 3.873866);
+
+        expect(() => OsrmUtils.createItineraryFromJson(json, start, end)).throw(Error);
+    });
+
+});
+
+describe('OsrmUtils - Output JSON', () => {
+
+    it('noRouteFoundJson', () => {
+        expect(OsrmUtils.noRouteFoundJson('foo')).deep.equals({
+            'code': 'NoRoute',
+            'message': 'foo'
+        });
+    });
+
 });