feat: implement luigi routing config service

Author: gkrajniak

src/lib/services/luigi-config/luigi-config.service.spec.ts

@@ -3,6 +3,7 @@ import { LuigiConfigService } from './luigi-config.service';
 import { EnvConfigService } from '../env-config.service';
 import { AuthConfigService } from './auth-config.service';
 import { ClientEnvironment } from '../../model/env';
+import { RoutingConfigService } from './routing-config.service';
 import { StaticSettingsConfigService } from './static-settings-config.service';
 
 describe('LuigiConfigService', () => {
@@ -11,6 +12,7 @@ describe('LuigiConfigService', () => {
   let authConfigServiceMock: jest.Mocked<AuthConfigService>;
   let staticSettingsConfigServiceMock: jest.Mocked<StaticSettingsConfigService>;
   let communicationConfigServiceMock: jest.Mocked<CommunicationConfigService>;
+  let routingConfigServiceMock: jest.Mocked<RoutingConfigService>;
 
   beforeEach(() => {
     envConfigServiceMock = {
@@ -29,9 +31,15 @@ describe('LuigiConfigService', () => {
       getCommunicationConfig: jest.fn(),
     } as any;
 
+    routingConfigServiceMock = {
+      getInitialRoutingConfig: jest.fn(),
+      getRoutingConfig: jest.fn(),
+    } as any;
+
     service = new LuigiConfigService(
       envConfigServiceMock,
       authConfigServiceMock,
+      routingConfigServiceMock,
       staticSettingsConfigServiceMock,
       communicationConfigServiceMock
     );
@@ -60,6 +68,13 @@ describe('LuigiConfigService', () => {
         customMessagesListeners: { '43545': () => {} },
       };
 
+      const mockRoutingConfig = {
+        useHashRouting: false,
+        showModalPathInUrl: false,
+        modalPathParam: 'modalPathParamDisabled',
+        skipRoutingForUrlPatterns: [/.*/],
+      };
+
       envConfigServiceMock.getEnvConfig.mockResolvedValue(mockEnvConfig);
       authConfigServiceMock.getAuthConfig.mockReturnValue(mockAuthConfig);
       staticSettingsConfigServiceMock.getInitialStaticSettingsConfig.mockReturnValue(
@@ -68,6 +83,9 @@ describe('LuigiConfigService', () => {
       communicationConfigServiceMock.getCommunicationConfig.mockReturnValue(
         mockCommunicationConfig
       );
+      routingConfigServiceMock.getInitialRoutingConfig.mockReturnValue(
+        mockRoutingConfig
+      );
 
       const config = await service.getLuigiConfiguration();
 
@@ -82,33 +100,10 @@ describe('LuigiConfigService', () => {
 
       expect(config).toEqual({
         auth: mockAuthConfig,
-        routing: expect.any(Object),
+        routing: mockRoutingConfig,
         settings: mockStaticSettings,
         communication: mockCommunicationConfig,
       });
-
-      // Check routing config
-      expect(config.routing).toEqual({
-        useHashRouting: false,
-        showModalPathInUrl: false,
-        modalPathParam: 'modalPathParamDisabled',
-        skipRoutingForUrlPatterns: [/.*/],
-        pageNotFoundHandler: expect.any(Function),
-      });
-    });
-  });
-
-  describe('getInitialRoutingConfig', () => {
-    it('should return the correct routing configuration', () => {
-      const routingConfig = (service as any).getInitialRoutingConfig();
-
-      expect(routingConfig).toEqual({
-        useHashRouting: false,
-        showModalPathInUrl: false,
-        modalPathParam: 'modalPathParamDisabled',
-        skipRoutingForUrlPatterns: [/.*/],
-        pageNotFoundHandler: expect.any(Function),
-      });
     });
   });
 });

src/lib/services/luigi-config/luigi-config.service.ts

@@ -7,6 +7,7 @@ import { ClientEnvironment } from '../../model/env';
 import { AuthConfigService } from './auth-config.service';
 import { EnvConfigService } from '../env-config.service';
 import { CommunicationConfigService } from './communication-config.service';
+import { RoutingConfigService } from './routing-config.service';
 import { StaticSettingsConfigService } from './static-settings-config.service';
 
 @Injectable({
@@ -16,6 +17,7 @@ export class LuigiConfigService {
   constructor(
     private envConfigService: EnvConfigService,
     private authConfigService: AuthConfigService,
+    private routingConfigService: RoutingConfigService,
     @Inject(LUIGI_STATIC_SETTINGS_CONFIG_SERVICE_INJECTION_TOKEN)
     private staticSettingsConfigService: StaticSettingsConfigService,
     @Inject(LUIGI_COMMUNICATION_CONFIG_SERVICE_INJECTION_TOKEN)
@@ -30,20 +32,10 @@ export class LuigiConfigService {
         envConfig.oauthServerUrl,
         envConfig.clientId
       ),
-      routing: this.getInitialRoutingConfig(),
+      routing: this.routingConfigService.getInitialRoutingConfig(),
       communication: this.communicationConfigService.getCommunicationConfig(),
       settings:
         this.staticSettingsConfigService.getInitialStaticSettingsConfig(),
     };
   }
-
-  private getInitialRoutingConfig() {
-    return {
-      useHashRouting: false,
-      showModalPathInUrl: false,
-      modalPathParam: 'modalPathParamDisabled',
-      skipRoutingForUrlPatterns: [/.*/],
-      pageNotFoundHandler: () => {},
-    };
-  }
 }

src/lib/services/luigi-config/routing-config.service.spec.ts

@@ -0,0 +1,57 @@
+import { RoutingConfigService } from './routing-config.service';
+
+describe('RoutingConfigService', () => {
+  let service: RoutingConfigService;
+
+  beforeEach(() => {
+    service = new RoutingConfigService();
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  describe('getInitialRoutingConfig', () => {
+    it('should return the correct initial configuration', () => {
+      const config = service.getInitialRoutingConfig();
+
+      expect(config).toEqual({
+        useHashRouting: false,
+        showModalPathInUrl: false,
+        modalPathParam: 'modalPathParamDisabled',
+        skipRoutingForUrlPatterns: expect.arrayContaining([expect.any(RegExp)]),
+        pageNotFoundHandler: expect.any(Function),
+      });
+    });
+
+    it('should have a skipRoutingForUrlPatterns that matches any string', () => {
+      const config = service.getInitialRoutingConfig();
+      expect(
+        config.skipRoutingForUrlPatterns[0].test('any string')
+      ).toBeTruthy();
+    });
+  });
+
+  describe('getRoutingConfig', () => {
+    it('should return the correct routing configuration', () => {
+      const config = service.getRoutingConfig();
+
+      expect(config).toEqual({
+        useHashRouting: false,
+        showModalPathInUrl: true,
+        modalPathParam: 'modal',
+        pageNotFoundHandler: expect.any(Function),
+      });
+    });
+
+    it('pageNotFoundHandler should return the correct object', () => {
+      const config = service.getRoutingConfig();
+      const result = config.pageNotFoundHandler('some/path', true);
+
+      expect(result).toEqual({
+        redirectTo: 'error/404',
+        keepURL: true,
+      });
+    });
+  });
+});

src/lib/services/luigi-config/routing-config.service.ts

@@ -0,0 +1,31 @@
+import { Injectable } from '@angular/core';
+
+@Injectable({ providedIn: 'root' })
+export class RoutingConfigService {
+  getInitialRoutingConfig(): any {
+    return {
+      useHashRouting: false,
+      showModalPathInUrl: false,
+      modalPathParam: 'modalPathParamDisabled',
+      skipRoutingForUrlPatterns: [/.*/],
+      pageNotFoundHandler: () => {},
+    };
+  }
+
+  getRoutingConfig(): any {
+    return {
+      useHashRouting: false,
+      showModalPathInUrl: true,
+      modalPathParam: 'modal',
+      pageNotFoundHandler: (
+        notFoundPath: string,
+        isAnyPathMatched: boolean
+      ) => {
+        return {
+          redirectTo: 'error/404',
+          keepURL: true,
+        };
+      },
+    };
+  }
+}