@wemap/routers 12.7.2 → 12.7.3

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/routers"
     },
     "name": "@wemap/routers",
-    "version": "12.7.2",
+    "version": "12.7.3",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -52,5 +52,5 @@
         },
         "./helpers/*": "./helpers/*"
     },
-    "gitHead": "ea4c02ed0fce8e59634b86c123464116fcd9eace"
+    "gitHead": "67ad72998468c84862793eb326649b6923b0f6ec"
 }

package/src/remote/RemoteRouterManager.spec.ts

@@ -0,0 +1,178 @@
+import chai from 'chai';
+import chaiAlmost from 'chai-almost';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fetchMock from 'fetch-mock';
+
+import { Coordinates } from '@wemap/geo';
+
+import RemoteRouterManager, { RoutingFallbackStrategy } from './RemoteRouterManager.js';
+import { RemoteRoutingError } from '../RoutingError.js';
+
+type MockAny = any;
+
+const { expect } = chai;
+chai.use(chaiAlmost(0.1));
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const assetsPath = path.resolve(__dirname, '../../assets');
+const osrmPath = path.resolve(assetsPath, 'itinerary-montpellier-outdoor.json');
+const osrmJson = JSON.parse(fs.readFileSync(osrmPath, 'utf8'));
+
+describe('RemoteRouterManager', () => {
+    afterEach(() => {
+        fetchMock.restore();
+    });
+
+    describe('getRouterByName', () => {
+        it('should return the router', () => {
+            const router = RemoteRouterManager.getRouterByName('osrm');
+            expect(router).not.null;
+        });
+
+        it('should return undefined if router is unknown', () => {
+            const router = RemoteRouterManager.getRouterByName('unknown' as MockAny);
+
+            expect(router).to.be.undefined;
+        });
+    });
+
+    describe('getItineraries', () => {
+        it('should return itineraries', async () => {
+            fetchMock.mock('*', (() => {
+                return osrmJson;
+            })())
+
+            const routerRequest = {
+                origin: new Coordinates(48.8725992, 2.343431),
+                destination: new Coordinates(48.8725694, 2.3433),
+                travelMode: 'WALK'
+            } as const;
+
+            const itineraries = await RemoteRouterManager.getItineraries('osrm', 'http://localhost:3001', routerRequest);
+            expect(itineraries).not.empty;
+        });
+
+        it('should throw an error if router is unknown', (done) => {
+            const routerRequest = {
+                origin: new Coordinates(48.8725992, 2.343431),
+                destination: new Coordinates(48.8725694, 2.3433),
+                travelMode: 'WALK'
+            } as const;
+
+            RemoteRouterManager.getItineraries('unknown' as MockAny, 'http://localhost:3001', routerRequest)
+                .then(() => done('should throw an error'))
+                .catch(() => done());
+        });
+
+        it('should throw an error on server error', (done) => {
+            fetchMock.mock('*', (() => {
+                return new Response(null, { status: 404 });
+            })())
+
+            const routerRequest = {
+                origin: new Coordinates(48.8725992, 2.343431),
+                destination: new Coordinates(48.8725694, 2.3433),
+                travelMode: 'WALK'
+            } as const;
+
+            RemoteRouterManager.getItineraries('unknown' as MockAny, 'http://localhost:3001', routerRequest)
+                .then(() => done('should throw an error'))
+                .catch(() => done());
+        });
+    });
+
+    describe('getItinerariesWithFallback', () => {
+        it('should return itineraries', async () => {
+            fetchMock.mock('*', (() => {
+                return osrmJson;
+            })())
+
+            const routerRequest = {
+                origin: new Coordinates(48.8725992, 2.343431),
+                destination: new Coordinates(48.8725694, 2.3433),
+                travelMode: 'WALK'
+            } as const;
+
+            const fallbackStrategy: RoutingFallbackStrategy = [
+                { name: 'osrm', endpointUrl: 'http://localhost:3001' }
+            ];
+
+            const itineraries = await RemoteRouterManager.getItinerariesWithFallback(routerRequest, fallbackStrategy);
+            expect(itineraries).not.empty;
+        });
+
+        it('should throw an error if all routers are unknown', (done) => {
+            const routerRequest = {
+                origin: new Coordinates(48.8725992, 2.343431),
+                destination: new Coordinates(48.8725694, 2.3433),
+                travelMode: 'WALK'
+            } as const;
+
+            const fallbackStrategy = [
+                { name: 'unknown' as MockAny, endpointUrl: 'http://localhost:3001/unknown' }
+            ];
+
+            RemoteRouterManager.getItinerariesWithFallback(routerRequest, fallbackStrategy)
+                .then(() => done('should throw an error'))
+                .catch((error) => {
+                    expect(error instanceof RemoteRoutingError).to.be.true;
+                    expect((error as RemoteRoutingError).routerName).equal('unknown');
+                    expect((error as RemoteRoutingError).message).to.contains('http://localhost:3001/unknown');
+
+                    done();
+                });
+        });
+
+        it('should throw an error if all routers are unreachable and return all errors', (done) => {
+            fetchMock.mock('*', (() => {
+                return new Response(null, { status: 404 });
+            })())
+
+            const routerRequest = {
+                origin: new Coordinates(48.8725992, 2.343431),
+                destination: new Coordinates(48.8725694, 2.3433),
+                travelMode: 'WALK'
+            } as const;
+
+            const fallbackStrategy = [
+                { name: 'osrm', endpointUrl: 'http://localhost:3001/osrm' },
+                { name: 'unknown' as MockAny, endpointUrl: 'http://localhost:3001/unknown' }
+            ];
+
+            RemoteRouterManager.getItinerariesWithFallback(routerRequest, fallbackStrategy)
+                .then(() => done('should throw an error'))
+                .catch((error) => {
+                    expect(error instanceof RemoteRoutingError).to.be.true;
+                    expect((error as RemoteRoutingError).routerName).equal('osrm, unknown');
+                    expect((error as RemoteRoutingError).message).to.contains('http://localhost:3001/osrm');
+                    expect((error as RemoteRoutingError).message).to.contains('http://localhost:3001/unknown');
+
+                    done();
+                });
+        });
+
+        it('should return itineraries and use fallback router if previous one fails', async () => {
+            fetchMock.mock('*', (() => {
+                return osrmJson;
+            })())
+
+            const routerRequest = {
+                origin: new Coordinates(48.8725992, 2.343431),
+                destination: new Coordinates(48.8725694, 2.3433),
+                travelMode: 'WALK'
+            } as const;
+
+            const fallbackStrategy = [
+                { name: 'unknown' as MockAny, endpointUrl: 'http://localhost:3001/unknown' },
+                { name: 'osrm', endpointUrl: 'http://localhost:3001/osrm' }
+            ];
+
+            const itineraries = await RemoteRouterManager.getItinerariesWithFallback(routerRequest, fallbackStrategy);
+            expect(itineraries).not.empty;
+        });
+
+    });
+
+});

package/src/remote/RemoteRouterManager.ts

@@ -40,15 +40,30 @@ class RemoteRouterManager {
 
     async getItinerariesWithFallback(routerRequest: RouterRequest, fallbackStrategy: RoutingFallbackStrategy) {
         let itineraries;
+        const errors = [];
         for (const { name, endpointUrl } of fallbackStrategy) {
-            itineraries = await this.getItineraries(name, endpointUrl, routerRequest);
-            if (itineraries.length) {
-                return itineraries;
+            try {
+                itineraries = await this.getItineraries(name, endpointUrl, routerRequest);
+                if (itineraries.length) {
+                    return itineraries;
+                }
+            } catch (error) {
+                if (error instanceof RemoteRoutingError) {
+                    errors.push({
+                        name,
+                        endpointUrl,
+                        error
+                    });
+                } else {
+                    throw error;
+                }
             }
         }
 
-        const routersNames = fallbackStrategy.map(({ name }) => name).join(',');
-        throw RemoteRoutingError.notFound(routersNames, `Could not find an itinerary with any of following servers: ${routersNames}`)
+        const routersNames = fallbackStrategy.map(({ name }) => name).join(', ');
+        const errorsMessages = errors.map(routerError => `(${routerError.name}) Could not find an itinerary on endpoint: ${routerError.endpointUrl}. Details: ${routerError.error.message}`).join('\n');
+
+        throw RemoteRoutingError.notFound(routersNames, errorsMessages)
     }
 }