test: adjust tests to config init changes

src/app/_helpers/data/sample-configuration.ts

@@ -89,3 +89,31 @@ export const sampleAuthConfiguration: {
       },
     },
   };
+
+export const sampleDefaultPolygon = {
+  "coordinates": [
+    [
+      [
+        8.660432999690723,
+        50.123027017044436
+      ],
+      [
+        8.675496285518358,
+        50.123027017044436
+      ],
+      [
+        8.675496285518358,
+        50.13066176448642
+      ],
+      [
+        8.660432999690723,
+        50.13066176448642
+      ],
+      [
+        8.660432999690723,
+        50.123027017044436
+      ]
+    ]
+  ],
+  "type": "Polygon"
+}

src/app/modules/config/config.provider.spec.ts

@@ -35,6 +35,7 @@ import packageJson from '../../../../package.json';
 describe('ConfigProvider', () => {
   let configProvider: ConfigProvider;
   let storageProviderSpy: jasmine.SpyObj<StorageProvider>;
+  let ngxLogger: jasmine.SpyObj<NGXLogger>;
 
   beforeEach(() => {
     const storageProviderMethodSpy = jasmine.createSpyObj('StorageProvider', [
@@ -46,10 +47,7 @@ describe('ConfigProvider', () => {
     const webHttpClientMethodSpy = jasmine.createSpyObj('StAppsWebHttpClient', [
       'request',
     ]);
-    const ngxLogger: jasmine.SpyObj<NGXLogger> = jasmine.createSpyObj(
+    ngxLogger = jasmine.createSpyObj('NGXLogger', ['log', 'error', 'warn']);
-      'NGXLogger',
-      ['log', 'error', 'warn'],
-    );
 
     TestBed.configureTestingModule({
       imports: [],
@@ -112,27 +110,6 @@ describe('ConfigProvider', () => {
     );
   });
 
-  it('should init from storage when remote fails', async () => {
-    storageProviderSpy.has.and.returnValue(Promise.resolve(true));
-    storageProviderSpy.get.and.returnValue(
-      Promise.resolve(sampleIndexResponse),
-    );
-    spyOn(configProvider.client, 'handshake').and.throwError('');
-    // eslint-disable-next-line unicorn/error-message
-    let error = new Error('');
-    try {
-      await configProvider.init();
-    } catch (error_) {
-      error = error_;
-    }
-    expect(error).toEqual(new ConfigFetchError());
-    expect(storageProviderSpy.has).toHaveBeenCalled();
-    expect(storageProviderSpy.get).toHaveBeenCalled();
-    expect(await configProvider.getValue('name')).toEqual(
-      sampleIndexResponse.app.name,
-    );
-  });
-
   it('should throw error on failed initialisation', async () => {
     storageProviderSpy.has.and.returnValue(Promise.resolve(false));
     spyOn(configProvider.client, 'handshake').and.throwError('');
@@ -154,14 +131,14 @@ describe('ConfigProvider', () => {
     spyOn(configProvider.client, 'handshake').and.returnValue(
       Promise.resolve(sampleIndexResponse),
     );
-    // eslint-disable-next-line unicorn/no-null
+    await configProvider.init();
-    let error = null;
+
-    try {
+    expect(ngxLogger.warn).toHaveBeenCalledWith(
-      await configProvider.init();
+      new WrongConfigVersionInStorage(
-    } catch (error_) {
+        configProvider.scVersion,
-      error = error_;
+        wrongConfig.backend.SCVersion,
-    }
+      ),
-    expect(error).toEqual(new WrongConfigVersionInStorage(scVersion, '0.1.0'));
+    );
   });
 
   it('should throw error on saved app configuration not available', async () => {
@@ -203,13 +180,15 @@ describe('ConfigProvider', () => {
     );
   });
 
-  it('should return app configuration value if only saved config is available and fetch fails', async () => {
+  it('should init from storage when remote fails', async () => {
     storageProviderSpy.has.and.returnValue(Promise.resolve(true));
     storageProviderSpy.get.and.returnValue(
       Promise.resolve(sampleIndexResponse),
     );
     spyOn(configProvider.client, 'handshake').and.throwError('');
-    expect(await configProvider.getValue('name')).toEqual(
+    await configProvider.init();
+
+    expect(configProvider.getValue('name')).toEqual(
       sampleIndexResponse.app.name,
     );
   });

src/app/modules/config/config.provider.ts

@@ -133,7 +133,6 @@ export class ConfigProvider {
           this.scVersion,
           this.config.backend.SCVersion,
         );
-        this.logger.warn(loadError);
       }
     } catch (error) {
       loadError = error;
@@ -154,7 +153,7 @@ export class ConfigProvider {
       this.logger.warn(loadError);
     }
     if (typeof fetchError !== 'undefined') {
-      throw fetchError;
+      this.logger.warn(fetchError);
     }
   }
 

src/app/modules/hebis/daia-data.provider.ts

@@ -69,9 +69,9 @@ export class DaiaDataProvider {
   async getAvailability(id: string): Promise<SCDaiaHoldings[] | undefined> {
     if (typeof this.daiaServiceUrl === 'undefined') {
       try {
-        const features = (await this.configProvider.getValue(
+        const features = this.configProvider.getValue(
           'features',
-        )) as SCFeatureConfiguration;
+        ) as SCFeatureConfiguration;
         if (features.extern?.daia?.url) {
           this.daiaServiceUrl = features.extern?.daia?.url;
         } else {

src/app/modules/map/map.provider.spec.ts

@@ -23,14 +23,22 @@ import {StorageProvider} from '../storage/storage.provider';
 import {MapModule} from './map.module';
 import {StorageModule} from '../storage/storage.module';
 import {LoggerConfig, LoggerModule, NGXLogger} from 'ngx-logger';
+import {ConfigProvider} from '../config/config.provider';
+import {sampleDefaultPolygon} from '../../_helpers/data/sample-configuration';
 
 describe('MapProvider', () => {
   let provider: MapProvider;
+  let configProvider: jasmine.SpyObj<ConfigProvider>;
 
   beforeEach(() => {
+    configProvider = jasmine.createSpyObj('ConfigProvider', ['getValue']);
     TestBed.configureTestingModule({
       imports: [MapModule, HttpClientModule, StorageModule, LoggerModule],
       providers: [
+        {
+          provide: ConfigProvider,
+          useValue: configProvider,
+        },
         Geolocation,
         Diagnostic,
         StAppsWebHttpClient,
@@ -39,6 +47,10 @@ describe('MapProvider', () => {
         LoggerConfig,
       ],
     });
+
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    configProvider.getValue.and.returnValue(sampleDefaultPolygon);
     provider = TestBed.inject(MapProvider);
   });
 

src/app/modules/menu/navigation/navigation.service.ts

@@ -15,9 +15,9 @@ export class NavigationService {
   async getMenu() {
     let menu: SCAppConfigurationMenuCategory[] = [];
     try {
-      menu = (await this.configProvider.getValue(
+      menu = this.configProvider.getValue(
         'menus',
-      )) as SCAppConfigurationMenuCategory[];
+      ) as SCAppConfigurationMenuCategory[];
     } catch (error) {
       this.logger.error(`error from loading menu entries: ${error}`);
     }

src/app/modules/settings/settings.provider.spec.ts

@@ -69,9 +69,7 @@ describe('SettingsProvider', () => {
     });
     configProviderSpy = TestBed.get(ConfigProvider);
     // set settings returned from config
-    configProviderSpy.getValue.and.returnValue(
+    configProviderSpy.getValue.and.returnValue(CONFIG_SETTINGS_MOCK);
-      Promise.resolve(CONFIG_SETTINGS_MOCK),
-    );
     settingsProvider = TestBed.get(SettingsProvider);
     storageProviderSpy = TestBed.get(StorageProvider);
     storageProviderMethodSpy.has.and.returnValue(false);
@@ -126,7 +124,7 @@ describe('SettingsProvider', () => {
 
   it('should keep persisted setting values from settings that are not contained in loaded config', async () => {
     const settings = [CONFIG_SETTINGS_MOCK[4], CONFIG_SETTINGS_MOCK[5]];
-    configProviderSpy.getValue.and.returnValue(Promise.resolve(settings));
+    configProviderSpy.getValue.and.returnValue(settings);
     storageProviderSpy.has.and.returnValue(Promise.resolve(true));
     storageProviderSpy.get.and.returnValue(
       Promise.resolve(SETTING_VALUES_MOCK),