@wemap/routers 6.2.2 → 7.0.0

package/src/model/Leg.spec.js

@@ -0,0 +1,110 @@
+/* eslint-disable max-statements */
+import chai from 'chai';
+
+import { Coordinates } from '@wemap/geo';
+
+import Leg from './Leg.js';
+import checkLegType from './Leg.type.spec.js';
+import Constants from '../Constants.js';
+import { step1, step2, step3, step4 } from './Step.spec.js';
+
+const { expect } = chai;
+
+const leg1 = new Leg();
+leg1.mode = Constants.ROUTING_MODE.CAR;
+leg1.distance = 10;
+leg1.duration = 5;
+leg1.from = { name: null, coords: new Coordinates(0, 0) };
+leg1.to = { name: null, coords: new Coordinates(1, 0) };
+leg1.coords = [leg1.from.coords, leg1.to.coords];
+
+const leg2 = new Leg();
+leg2.mode = Constants.ROUTING_MODE.WALK;
+leg2.distance = 100;
+leg2.duration = 200;
+leg2.from = { name: null, coords: new Coordinates(1, 0) };
+leg2.to = { name: null, coords: new Coordinates(2, 0) };
+leg2.coords = [leg2.from.coords, new Coordinates(1.5, 0), leg2.to.coords];
+
+const leg3 = new Leg();
+leg3.mode = Constants.ROUTING_MODE.BUS;
+leg3.distance = 1000;
+leg3.duration = 300;
+leg3.startTime = 0;
+leg3.endTime = 10;
+leg3.from = { name: 'foo1', coords: new Coordinates(2, 0) };
+leg3.to = { name: 'foo2', coords: new Coordinates(3, 0) };
+leg3.coords = [leg3.from.coords, leg3.to.coords];
+leg3.transportInfo = {
+    name: 'foo3',
+    routeColor: '#000',
+    routeTextColor: '#fff',
+    directionName: 'foo4'
+};
+
+const leg4 = new Leg();
+leg4.mode = Constants.ROUTING_MODE.BOAT;
+leg4.distance = 10000;
+leg4.duration = 2000;
+leg4.from = { name: null, coords: new Coordinates(3, 0) };
+leg4.to = { name: null, coords: new Coordinates(4, 0) };
+leg4.coords = [leg4.from.coords, leg4.to.coords];
+leg4.steps = [step1, step2, step3, step4];
+
+const leg5 = new Leg();
+Object.assign(leg5, leg4);
+
+describe('Leg', () => {
+
+    it('checkTypes', () => {
+        checkLegType(leg1);
+        checkLegType(leg2);
+        checkLegType(leg3);
+        checkLegType(leg4);
+    });
+
+    it('isPublicTransport', () => {
+        expect(leg1.isPublicTransport()).is.false;
+        expect(leg2.isPublicTransport()).is.false;
+        expect(leg3.isPublicTransport()).is.true;
+        expect(leg4.isPublicTransport()).is.true;
+    });
+
+    it('equals', () => {
+        expect(leg1.equalsTo(leg1)).is.true;
+        expect(leg2.equalsTo(leg2)).is.true;
+        expect(leg3.equalsTo(leg3)).is.true;
+        expect(leg4.equalsTo(leg4)).is.true;
+        expect(leg4.equalsTo(leg5)).is.true;
+        expect(leg1.equalsTo(leg2)).is.false;
+        expect(leg1.equalsTo(leg3)).is.false;
+        expect(leg1.equalsTo(leg4)).is.false;
+    });
+
+    it('from / to JSON', () => {
+
+        const leg1Json = leg1.toJson();
+        expect(leg1Json).be.an('object');
+        const leg1Bis = Leg.fromJson(leg1Json);
+        expect(leg1.equalsTo(leg1Bis)).is.true;
+
+        const leg2Json = leg2.toJson();
+        expect(leg2Json).be.an('object');
+        const leg2Bis = Leg.fromJson(leg2Json);
+        expect(leg2.equalsTo(leg2Bis)).is.true;
+
+        const leg3Json = leg3.toJson();
+        expect(leg3Json).be.an('object');
+        const leg3Bis = Leg.fromJson(leg3Json);
+        expect(leg3.equalsTo(leg3Bis)).is.true;
+
+        const leg4Json = leg4.toJson();
+        expect(leg4Json).be.an('object');
+        const leg4Bis = Leg.fromJson(leg4Json);
+        expect(leg4.equalsTo(leg4Bis)).is.true;
+
+    });
+
+});
+
+export { leg1, leg2, leg3, leg4 };

package/src/model/Leg.type.spec.js

@@ -0,0 +1,48 @@
+import chai from 'chai';
+
+import { Coordinates } from '@wemap/geo';
+
+import checkStepType from './Step.type.spec.js';
+import Leg from './Leg.js';
+import Constants from '../Constants.js';
+
+const { expect } = chai;
+
+const isNullOrNumber = val => val === null || typeof val === 'number';
+const isNullOrString = val => val === null || typeof val === 'string';
+const isNullOrObject = val => val === null || typeof val === 'object';
+const isNullOrArray = val => val === null || Array.isArray(val);
+
+/**
+ * @param {Leg} leg
+ */
+export default function checkLegType(leg) {
+
+    expect(leg).instanceOf(Leg);
+    expect(leg.mode).be.a('string');
+    expect(leg.mode).satisfies(str => Object.values(Constants.ROUTING_MODE).includes(str));
+    expect(leg.distance).be.a('number');
+    expect(leg.duration).be.a('number');
+    expect(leg.startTime).satisfies(isNullOrNumber);
+    expect(leg.endTime).satisfies(isNullOrNumber);
+    expect(leg.from).be.an('object');
+    expect(leg.from.name).satisfies(isNullOrString);
+    expect(leg.from.coords).instanceOf(Coordinates);
+    expect(leg.to).be.an('object');
+    expect(leg.to.name).satisfies(isNullOrString);
+    expect(leg.to.coords).instanceOf(Coordinates);
+    expect(leg.coords).be.an('array');
+    leg.coords.forEach(coords => expect(coords).instanceOf(Coordinates));
+
+    expect(leg.transportInfo).satisfies(isNullOrObject);
+    if (leg.transportInfo !== null) {
+        expect(leg.transportInfo.name).be.a('string');
+        expect(leg.transportInfo.routeColor).satisfies(isNullOrString);
+        expect(leg.transportInfo.routeTextColor).satisfies(isNullOrString);
+        expect(leg.transportInfo.directionName).satisfies(isNullOrString);
+    }
+    expect(leg.steps).satisfies(isNullOrArray);
+    if (leg.steps !== null) {
+        leg.steps.forEach(checkStepType);
+    }
+}

package/src/model/LevelChange.js

@@ -1,7 +1,3 @@
-import { Level, GraphNode, GraphUtils } from '@wemap/geo';
-
-import { OsmElement } from '@wemap/osm';
-
 class LevelChange {
 
     /** @type {!string} [up|down] */
@@ -14,28 +10,22 @@ class LevelChange {
     type = null;
 
     /**
-     * @param {GraphNode<OsmElement>} firstNode
-     * @param {GraphNode<OsmElement>} secondNode
-     * @returns {LevelChange}
+     * @param {LevelChange} obj1
+     * @param {LevelChange} obj2
+     * @returns {Boolean}
      */
-    static fromTwoNodes(firstNode, secondNode) {
-
-        const levelChange = new LevelChange();
-
-        const edge = GraphUtils.getEdgeByNodes(firstNode.edges, firstNode, secondNode);
-
-        if (edge.builtFrom.isElevator) {
-            levelChange.type = 'elevator';
-        } else if (edge.builtFrom.isConveying) {
-            levelChange.type = 'conveyor';
-        } else if (edge.builtFrom.areStairs) {
-            levelChange.type = 'stairs';
-        }
-
-        levelChange.difference = Level.diff(firstNode.coords.level, secondNode.coords.level);
-        levelChange.direction = levelChange.difference > 0 ? 'up' : 'down';
+    static equalsTo(obj1, obj2) {
+        return obj1.difference === obj2.difference
+            && obj1.direction === obj2.direction
+            && obj1.type === obj2.type;
+    }
 
-        return levelChange;
+    /**
+     * @param {LevelChange} obj
+     * @returns {Boolean}
+     */
+    equalsTo(obj) {
+        return LevelChange.equalsTo(this, obj);
     }
 
     /**

package/src/model/LevelChange.spec.js

@@ -0,0 +1,78 @@
+import chai from 'chai';
+
+import LevelChange from './LevelChange.js';
+import checkLevelChangeType from './LevelChange.type.spec.js';
+
+const { expect } = chai;
+
+const levelChange1 = new LevelChange();
+levelChange1.direction = 'up';
+levelChange1.difference = 1;
+levelChange1.type = 'stairs';
+
+const levelChange2 = new LevelChange();
+levelChange2.direction = 'down';
+levelChange2.difference = -1;
+levelChange2.type = 'elevator';
+
+const levelChange3 = new LevelChange();
+levelChange3.direction = 'up';
+levelChange3.difference = 3;
+levelChange3.type = 'conveyor';
+
+const levelChange4 = new LevelChange();
+levelChange4.direction = 'up';
+levelChange4.difference = 1;
+
+const levelChange5 = new LevelChange();
+levelChange5.direction = 'up';
+levelChange5.difference = 1;
+
+describe('LevelChange', () => {
+
+    it('checkTypes', () => {
+        checkLevelChangeType(levelChange1);
+        checkLevelChangeType(levelChange2);
+        checkLevelChangeType(levelChange3);
+        checkLevelChangeType(levelChange4);
+        checkLevelChangeType(levelChange5);
+    });
+
+    it('equals', () => {
+        expect(levelChange1.equalsTo(levelChange1)).is.true;
+        expect(levelChange2.equalsTo(levelChange2)).is.true;
+        expect(levelChange3.equalsTo(levelChange3)).is.true;
+        expect(levelChange4.equalsTo(levelChange4)).is.true;
+        expect(levelChange4.equalsTo(levelChange5)).is.true;
+        expect(levelChange1.equalsTo(levelChange2)).is.false;
+        expect(levelChange1.equalsTo(levelChange3)).is.false;
+        expect(levelChange1.equalsTo(levelChange4)).is.false;
+    });
+
+    it('from / to JSON', () => {
+
+        const levelChange1Json = levelChange1.toJson();
+        expect(levelChange1Json).be.an('object');
+        const levelChange1Bis = LevelChange.fromJson(levelChange1Json);
+        expect(levelChange1.equalsTo(levelChange1Bis)).is.true;
+
+        const levelChange2Json = levelChange2.toJson();
+        expect(levelChange2Json).be.an('object');
+        const levelChange2Bis = LevelChange.fromJson(levelChange2Json);
+        expect(levelChange2.equalsTo(levelChange2Bis)).is.true;
+
+        const levelChange3Json = levelChange3.toJson();
+        expect(levelChange3Json).be.an('object');
+        const levelChange3Bis = LevelChange.fromJson(levelChange3Json);
+        expect(levelChange3.equalsTo(levelChange3Bis)).is.true;
+
+        const levelChange4Json = levelChange4.toJson();
+        expect(levelChange4Json).be.an('object');
+        const levelChange4Bis = LevelChange.fromJson(levelChange4Json);
+        expect(levelChange4.equalsTo(levelChange4Bis)).is.true;
+
+    });
+
+});
+
+export { levelChange1, levelChange2, levelChange3, levelChange4 };

package/src/model/LevelChange.type.spec.js

@@ -0,0 +1,26 @@
+import chai from 'chai';
+
+import LevelChange from './LevelChange.js';
+
+const { expect } = chai;
+
+const isNullOrString = val => val === null || typeof val === 'string';
+
+/**
+ * @param {LevelChange} levelChange
+ */
+export default function checkLevelChangeType(levelChange) {
+
+    expect(levelChange).instanceOf(LevelChange);
+
+    const { direction, difference, type } = levelChange;
+
+    expect(direction).satisfies(str => ['up', 'down'].includes(str));
+    expect(difference).be.a('number');
+    expect(difference !== 0).is.true;
+    expect(difference < 0 ? direction === 'down' : direction === 'up').is.true;
+    expect(type).satisfies(isNullOrString);
+    if (type) {
+        expect(type).satisfies(str => ['elevator', 'conveyor', 'stairs'].includes(str));
+    }
+}

package/src/model/RouterResponse.js

@@ -1,9 +1,10 @@
 import { Coordinates } from '@wemap/geo';
 
 import Itinerary from './Itinerary.js';
+
 class RouterResponse {
 
-    /** @type {!string} */
+    /** @type {!string|Array<string>} */
     routerName;
 
     /** @type {!Coordinates} */
@@ -14,6 +15,74 @@ class RouterResponse {
 
     /** @type {!(Itinerary[])} */
     itineraries = [];
+
+    /** @type {?object} */
+    error = null;
+
+    /**
+     * @param {RouterResponse} obj1
+     * @param {RouterResponse} obj2
+     * @returns {Boolean}
+     */
+    static equalsTo(obj1, obj2) {
+        const intermediate = obj1.routerName === obj2.routerName
+            && obj1.from.equalsTo(obj2.from)
+            && obj1.to.equalsTo(obj2.to)
+            && obj1.itineraries.length === obj2.itineraries.length;
+
+        if (!intermediate) {
+            return false;
+        }
+
+        for (let i = 0; i < obj1.itineraries.length; i++) {
+            if (!obj1.itineraries[i].equalsTo(obj2.itineraries[i])) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * @param {RouterResponse} obj
+     * @returns {Boolean}
+     */
+    equalsTo(obj) {
+        return RouterResponse.equalsTo(this, obj);
+    }
+
+
+    /**
+     * @returns {object}
+     */
+    toJson() {
+        const json = {
+            routerName: this.routerName,
+            from: this.from.toCompressedJson(),
+            to: this.to.toCompressedJson(),
+            itineraries: this.itineraries.map(itinerary => itinerary.toJson())
+        };
+        if (this.error) {
+            json.error = this.error;
+        }
+        return json;
+    }
+
+    /**
+     * @param {object} json
+     * @returns {RouterResponse}
+     */
+    static fromJson(json) {
+        const routerResponse = new RouterResponse();
+        routerResponse.routerName = json.routerName;
+        routerResponse.from = Coordinates.fromCompressedJson(json.from);
+        routerResponse.to = Coordinates.fromCompressedJson(json.to);
+        routerResponse.itineraries = json.itineraries.map(Itinerary.fromJson);
+        if (json.error) {
+            routerResponse.error = json.error;
+        }
+        return routerResponse;
+    }
 }
 
 export default RouterResponse;

package/src/model/RouterResponse.spec.js

@@ -0,0 +1,85 @@
+/* eslint-disable max-statements */
+import chai from 'chai';
+
+import { Coordinates } from '@wemap/geo';
+
+import RouterResponse from './RouterResponse.js';
+import checkRouterResponseType from './RouterResponse.type.spec.js';
+import { itinerary1, itinerary2, itinerary3, itinerary4 } from './Itinerary.spec.js';
+
+const { expect } = chai;
+
+const routerResponse1 = new RouterResponse();
+routerResponse1.routerName = 'foo1';
+routerResponse1.from = new Coordinates(0, 0);
+routerResponse1.to = new Coordinates(1, 0);
+routerResponse1.itineraries = [itinerary1];
+
+const routerResponse2 = new RouterResponse();
+routerResponse2.routerName = 'foo2';
+routerResponse2.from = new Coordinates(0, 0);
+routerResponse2.to = new Coordinates(1, 0);
+routerResponse2.itineraries = [itinerary1, itinerary2];
+
+const routerResponse3 = new RouterResponse();
+routerResponse3.routerName = 'foo3';
+routerResponse3.from = new Coordinates(0, 0);
+routerResponse3.to = new Coordinates(2, 0);
+routerResponse3.itineraries = [itinerary1, itinerary2, itinerary3, itinerary4];
+
+const routerResponse4 = new RouterResponse();
+routerResponse4.routerName = 'foo4';
+routerResponse4.from = new Coordinates(1, 0);
+routerResponse4.to = new Coordinates(4, 0);
+routerResponse4.itineraries = [itinerary1];
+
+const routerResponse5 = new RouterResponse();
+Object.assign(routerResponse5, routerResponse4);
+
+describe('RouterResponse', () => {
+
+    it('checkTypes', () => {
+        checkRouterResponseType(routerResponse1);
+        checkRouterResponseType(routerResponse2);
+        checkRouterResponseType(routerResponse3);
+        checkRouterResponseType(routerResponse4);
+    });
+
+    it('equals', () => {
+        expect(routerResponse1.equalsTo(routerResponse1)).is.true;
+        expect(routerResponse2.equalsTo(routerResponse2)).is.true;
+        expect(routerResponse3.equalsTo(routerResponse3)).is.true;
+        expect(routerResponse4.equalsTo(routerResponse4)).is.true;
+        expect(routerResponse4.equalsTo(routerResponse5)).is.true;
+        expect(routerResponse1.equalsTo(routerResponse2)).is.false;
+        expect(routerResponse1.equalsTo(routerResponse3)).is.false;
+        expect(routerResponse1.equalsTo(routerResponse4)).is.false;
+    });
+
+    it('from / to JSON', () => {
+
+        const routerResponse1Json = routerResponse1.toJson();
+        expect(routerResponse1Json).be.an('object');
+        const routerResponse1Bis = RouterResponse.fromJson(routerResponse1Json);
+        expect(routerResponse1.equalsTo(routerResponse1Bis)).is.true;
+
+        const routerResponse2Json = routerResponse2.toJson();
+        expect(routerResponse2Json).be.an('object');
+        const routerResponse2Bis = RouterResponse.fromJson(routerResponse2Json);
+        expect(routerResponse2.equalsTo(routerResponse2Bis)).is.true;
+
+        const routerResponse3Json = routerResponse3.toJson();
+        expect(routerResponse3Json).be.an('object');
+        const routerResponse3Bis = RouterResponse.fromJson(routerResponse3Json);
+        expect(routerResponse3.equalsTo(routerResponse3Bis)).is.true;
+
+        const routerResponse4Json = routerResponse4.toJson();
+        expect(routerResponse4Json).be.an('object');
+        const routerResponse4Bis = RouterResponse.fromJson(routerResponse4Json);
+        expect(routerResponse4.equalsTo(routerResponse4Bis)).is.true;
+
+    });
+
+});
+
+export { routerResponse1, routerResponse2, routerResponse3, routerResponse4 };

package/src/model/RouterResponse.type.spec.js

@@ -4,21 +4,24 @@ import { Coordinates } from '@wemap/geo';
 
 import RouterResponse from './RouterResponse.js';
 
-import { verifyItineraryData } from './Itinerary.type.spec.js';
+import checkItineraryType from './Itinerary.type.spec.js';
 
 const { expect } = chai;
 
 /**
  * @param {RouterResponse} routerResponse
  */
-export function verifyRouterResponseData(routerResponse) {
+export default function checkRouterResponseType(routerResponse) {
 
     expect(routerResponse).instanceOf(RouterResponse);
-    expect(routerResponse.routerName).be.a('string');
+    expect(routerResponse.routerName).satisfy(val => {
+        return typeof val === 'string'
+            || Array.isArray(val) && val.every(val2 => typeof val2 === 'string');
+    });
     expect(routerResponse.from).instanceOf(Coordinates);
     expect(routerResponse.to).instanceOf(Coordinates);
     expect(routerResponse.itineraries).be.an('array');
-    routerResponse.itineraries.forEach(verifyItineraryData);
+    routerResponse.itineraries.forEach(checkItineraryType);
 
 }
 

package/src/model/Step.js

@@ -46,6 +46,45 @@ class Step {
     /** @type {!number} */
     _idCoordsInLeg = null;
 
+    /**
+     * @param {Step} obj1
+     * @param {Step} obj2
+     * @returns {Boolean}
+     */
+    static equalsTo(obj1, obj2) {
+        return obj1.firstStep === obj2.firstStep
+            && obj1.lastStep === obj2.lastStep
+            && obj1.number === obj2.number
+            && obj1.coords.equalsTo(obj2.coords)
+            && obj1.angle === obj2.angle
+            && obj1.previousBearing === obj2.previousBearing
+            && obj1.nextBearing === obj2.nextBearing
+            && obj1.distance === obj2.distance
+            && obj1.duration === obj2.duration
+            && obj1.name === obj2.name
+            && (
+                obj1.levelChange === obj2.levelChange
+                || obj1.levelChange !== null && obj1.levelChange.equalsTo(obj2.levelChange)
+            )
+            && (
+                obj1.extras === obj2.extras
+                || (
+                    obj1.extras !== null
+                    && obj1.extras.subwayEntrance === obj2.extras.subwayEntrance
+                    && obj1.extras.subwayEntranceRef === obj2.extras.subwayEntranceRef
+                )
+            )
+            && obj1._idCoordsInLeg === obj2._idCoordsInLeg;
+    }
+
+    /**
+     * @param {Step} obj
+     * @returns {Boolean}
+     */
+    equalsTo(obj) {
+        return Step.equalsTo(this, obj);
+    }
+
     /**
      * @returns {object}
      */
@@ -93,22 +132,22 @@ class Step {
         step.nextBearing = json.nextBearing;
         step.distance = json.distance;
         step._idCoordsInLeg = json._idCoordsInLeg;
-        if (json.firstStep) {
+        if (typeof json.firstStep === 'boolean') {
             step.firstStep = json.firstStep;
         }
-        if (json.lastStep) {
+        if (typeof json.lastStep === 'boolean') {
             step.lastStep = json.lastStep;
         }
-        if (json.duration) {
+        if (typeof json.duration === 'number') {
             step.duration = json.duration;
         }
-        if (json.name) {
+        if (typeof json.name === 'string') {
             step.name = json.name;
         }
-        if (json.levelChange) {
+        if (typeof json.levelChange === 'object') {
             step.levelChange = LevelChange.fromJson(json.levelChange);
         }
-        if (json.extras) {
+        if (typeof json.extras === 'object') {
             step.extras = json.extras;
         }
         return step;

package/src/model/Step.spec.js

@@ -0,0 +1,100 @@
+/* eslint-disable max-statements */
+import { Coordinates } from '@wemap/geo';
+import chai from 'chai';
+
+import Step from './Step.js';
+import checkStepType from './Step.type.spec.js';
+import { levelChange1 } from './LevelChange.spec.js';
+
+const { expect } = chai;
+
+const step1 = new Step();
+step1.firstStep = true;
+step1.lastStep = false;
+step1.number = 1;
+step1.coords = new Coordinates(0, 0);
+step1.angle = 0;
+step1.previousBearing = 0;
+step1.nextBearing = 0;
+step1.distance = 10;
+step1._idCoordsInLeg = 0;
+
+const step2 = new Step();
+Object.assign(step2, step1);
+step2.firstStep = false;
+step2.number = 2;
+step2.coords = new Coordinates(1, 0);
+step2.distance = step1.coords.distanceTo(step2.coords);
+step2.extras = { subwayEntrance: true, subwayEntranceRef: 'toto' };
+step2._idCoordsInLeg = 1;
+
+const step3 = new Step();
+Object.assign(step3, step2);
+step3.number = 3;
+step3.coords = new Coordinates(2, 0, null);
+step3.distance = step2.coords.distanceTo(step3.coords);
+step3.duration = step3.distance * 2;
+step3.levelChange = levelChange1;
+step3.extras = { subwayEntrance: false };
+step3._idCoordsInLeg = 2;
+
+const step4 = new Step();
+Object.assign(step4, step3);
+step4.lastStep = true;
+step4.number = 4;
+step4.coords = new Coordinates(3, 0);
+step4.distance = step3.coords.distanceTo(step4.coords);
+step4.name = 'end';
+step4.extras = {};
+step4._idCoordsInLeg = 3;
+
+const step5 = new Step();
+Object.assign(step5, step4);
+
+describe('Step', () => {
+
+    it('checkTypes', () => {
+        checkStepType(step1);
+        checkStepType(step2);
+        checkStepType(step3);
+        checkStepType(step4);
+    });
+
+    it('equals', () => {
+        expect(step1.equalsTo(step1)).is.true;
+        expect(step2.equalsTo(step2)).is.true;
+        expect(step3.equalsTo(step3)).is.true;
+        expect(step4.equalsTo(step4)).is.true;
+        expect(step4.equalsTo(step5)).is.true;
+        expect(step1.equalsTo(step2)).is.false;
+        expect(step1.equalsTo(step3)).is.false;
+        expect(step1.equalsTo(step4)).is.false;
+    });
+
+    it('from / to JSON', () => {
+
+        const step1Json = step1.toJson();
+        expect(step1Json).be.an('object');
+        const step1Bis = Step.fromJson(step1Json);
+        expect(step1.equalsTo(step1Bis)).is.true;
+
+        const step2Json = step2.toJson();
+        expect(step2Json).be.an('object');
+        const step2Bis = Step.fromJson(step2Json);
+        expect(step2.equalsTo(step2Bis)).is.true;
+
+        const step3Json = step3.toJson();
+        expect(step3Json).be.an('object');
+        const step3Bis = Step.fromJson(step3Json);
+        expect(step3.equalsTo(step3Bis)).is.true;
+
+        const step4Json = step4.toJson();
+        expect(step4Json).be.an('object');
+        const step4Bis = Step.fromJson(step4Json);
+        expect(step4.equalsTo(step4Bis)).is.true;
+
+    });
+
+});
+
+export { step1, step2, step3, step4 };