refactor: replace TSLint with ESLint

2026-01-21 09:03:02 +00:00 · 2021-06-30 13:53:44 +02:00
parent 67fb4a43c9
commit d696215d08
147 changed files with 5471 additions and 2704 deletions
--- a/src/app/modules/config/config.module.ts
+++ b/src/app/modules/config/config.module.ts
@@ -21,12 +21,7 @@ import {ConfigProvider} from './config.provider';
 * TODO
 */
@NgModule({
-  imports: [
-    StorageModule,
-    DataModule,
-  ],
-  providers: [
-    ConfigProvider,
-  ],
+  imports: [StorageModule, DataModule],
+  providers: [ConfigProvider],
 })
 export class ConfigModule {}
--- a/src/app/modules/config/config.provider.spec.ts
+++ b/src/app/modules/config/config.provider.spec.ts
@@ -13,12 +13,22 @@
 * this program. If not, see <https://www.gnu.org/licenses/>.
 */
 import {TestBed} from '@angular/core/testing';
-import {SCIndexResponse, SCThingOriginType, SCThingType, SCSettingInputType} from '@openstapps/core';
+import {
+  SCIndexResponse,
+  SCThingOriginType,
+  SCThingType,
+  SCSettingInputType,
+} from '@openstapps/core';
 import {StAppsWebHttpClient} from '../data/stapps-web-http-client.provider';
 import {StorageProvider} from '../storage/storage.provider';
 import {ConfigProvider, STORAGE_KEY_CONFIG} from './config.provider';
-import {ConfigFetchError, ConfigInitError, SavedConfigNotAvailable, WrongConfigVersionInStorage,} from './errors';
-import {NGXLogger} from "ngx-logger";
+import {
+  ConfigFetchError,
+  ConfigInitError,
+  SavedConfigNotAvailable,
+  WrongConfigVersionInStorage,
+} from './errors';
+import {NGXLogger} from 'ngx-logger';
 import {dependencies} from '../../../../package.json';

 describe('ConfigProvider', () => {
@@ -26,22 +36,35 @@ describe('ConfigProvider', () => {
  let storageProviderSpy: jasmine.SpyObj<StorageProvider>;

  beforeEach(() => {
-    const storageProviderMethodSpy = jasmine.createSpyObj('StorageProvider', ['init', 'get', 'has', 'put']);
-    const webHttpClientMethodSpy = jasmine.createSpyObj('StAppsWebHttpClient', ['request']);
-    const ngxLogger: jasmine.SpyObj<NGXLogger> = jasmine.createSpyObj('NGXLogger', ['log', 'error', 'warn']);
+    const storageProviderMethodSpy = jasmine.createSpyObj('StorageProvider', [
+      'init',
+      'get',
+      'has',
+      'put',
+    ]);
+    const webHttpClientMethodSpy = jasmine.createSpyObj('StAppsWebHttpClient', [
+      'request',
+    ]);
+    const ngxLogger: jasmine.SpyObj<NGXLogger> = jasmine.createSpyObj(
+      'NGXLogger',
+      ['log', 'error', 'warn'],
+    );

    TestBed.configureTestingModule({
      imports: [],
      providers: [
        ConfigProvider,
        {
-          provide: StorageProvider, useValue: storageProviderMethodSpy,
+          provide: StorageProvider,
+          useValue: storageProviderMethodSpy,
        },
        {
-          provide: StAppsWebHttpClient, useValue: webHttpClientMethodSpy,
+          provide: StAppsWebHttpClient,
+          useValue: webHttpClientMethodSpy,
        },
        {
-          provide: NGXLogger, useValue: ngxLogger,
+          provide: NGXLogger,
+          useValue: ngxLogger,
        },
      ],
    });
@@ -51,25 +74,30 @@ describe('ConfigProvider', () => {
  });

  it('should fetch app configuration', async () => {
-    spyOn(configProvider.client, 'handshake').and.returnValue(Promise.resolve(sampleIndexResponse));
+    spyOn(configProvider.client, 'handshake').and.returnValue(
+      Promise.resolve(sampleIndexResponse),
+    );
    const result = await configProvider.fetch();
    expect(result).toEqual(sampleIndexResponse);
  });

  it('should throw error on fetch with error response', async () => {
    spyOn(configProvider.client, 'handshake').and.throwError('');
+    // eslint-disable-next-line unicorn/error-message
    let error = new Error('');
    try {
      await configProvider.fetch();
-    } catch (err) {
-      error = err;
+    } catch (error_) {
+      error = error_;
    }
    expect(error).toEqual(new ConfigFetchError());
  });

  it('should init from remote and saved config not available', async () => {
    storageProviderSpy.has.and.returnValue(Promise.resolve(false));
-    spyOn(configProvider.client, 'handshake').and.returnValue(Promise.resolve(sampleIndexResponse));
+    spyOn(configProvider.client, 'handshake').and.returnValue(
+      Promise.resolve(sampleIndexResponse),
+    );
    try {
      await configProvider.init();
    } catch (error) {
@@ -79,34 +107,42 @@ describe('ConfigProvider', () => {
    expect(storageProviderSpy.get).toHaveBeenCalledTimes(0);
    expect(configProvider.client.handshake).toHaveBeenCalled();
    expect(configProvider.initialised).toBe(true);
-    expect(await configProvider.getValue('name')).toEqual(sampleIndexResponse.app.name);
+    expect(await configProvider.getValue('name')).toEqual(
+      sampleIndexResponse.app.name,
+    );
  });

  it('should init from storage when remote fails', async () => {
    storageProviderSpy.has.and.returnValue(Promise.resolve(true));
-    storageProviderSpy.get.and.returnValue(Promise.resolve(sampleIndexResponse));
+    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 (err) {
-      error = err;
+    } catch (error_) {
+      error = error_;
    }
    expect(error).toEqual(new ConfigFetchError());
    expect(storageProviderSpy.has).toHaveBeenCalled();
    expect(storageProviderSpy.get).toHaveBeenCalled();
    expect(configProvider.initialised).toBe(true);
-    expect(await configProvider.getValue('name')).toEqual(sampleIndexResponse.app.name);
+    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('');
+    // eslint-disable-next-line unicorn/no-null
    let error = null;
    try {
      await configProvider.init();
-    } catch (err) {
-      error = err;
+    } catch (error_) {
+      error = error_;
    }
    expect(error).toEqual(new ConfigInitError());
  });
@@ -116,30 +152,37 @@ describe('ConfigProvider', () => {
    const wrongConfig = JSON.parse(JSON.stringify(sampleIndexResponse));
    wrongConfig.backend.SCVersion = '0.1.0';
    storageProviderSpy.get.and.returnValue(wrongConfig);
-    spyOn(configProvider.client, 'handshake').and.returnValue(Promise.resolve(sampleIndexResponse));
+    spyOn(configProvider.client, 'handshake').and.returnValue(
+      Promise.resolve(sampleIndexResponse),
+    );
+    // eslint-disable-next-line unicorn/no-null
    let error = null;
    try {
      await configProvider.init();
-    } catch (err) {
-      error = err;
+    } catch (error_) {
+      error = error_;
    }
    expect(error).toEqual(new WrongConfigVersionInStorage(scVersion, '0.1.0'));
  });

  it('should throw error on saved app configuration not available', async () => {
    storageProviderSpy.has.and.returnValue(Promise.resolve(false));
+    // eslint-disable-next-line unicorn/error-message
    let error = new Error('');
    try {
      await configProvider.loadLocal();
-    } catch (err) {
-      error = err;
+    } catch (error_) {
+      error = error_;
    }
    expect(error).toEqual(new SavedConfigNotAvailable());
  });

  it('should save app configuration', async () => {
    await configProvider.save(sampleIndexResponse);
-    expect(storageProviderSpy.put).toHaveBeenCalledWith(STORAGE_KEY_CONFIG, sampleIndexResponse);
+    expect(storageProviderSpy.put).toHaveBeenCalledWith(
+      STORAGE_KEY_CONFIG,
+      sampleIndexResponse,
+    );
  });

  it('should set app configuration', async () => {
@@ -149,21 +192,31 @@ describe('ConfigProvider', () => {

  it('should return app configuration value', async () => {
    storageProviderSpy.has.and.returnValue(Promise.resolve(true));
-    storageProviderSpy.get.and.returnValue(Promise.resolve(sampleIndexResponse));
-    spyOn(configProvider.client, 'handshake').and.returnValue(Promise.resolve(sampleIndexResponse));
+    storageProviderSpy.get.and.returnValue(
+      Promise.resolve(sampleIndexResponse),
+    );
+    spyOn(configProvider.client, 'handshake').and.returnValue(
+      Promise.resolve(sampleIndexResponse),
+    );
    await configProvider.init();
-    expect(await configProvider.getValue('name')).toEqual(sampleIndexResponse.app.name);
+    expect(await configProvider.getValue('name')).toEqual(
+      sampleIndexResponse.app.name,
+    );
  });

  it('should return app configuration value if only saved config is available and fetch fails', async () => {
    storageProviderSpy.has.and.returnValue(Promise.resolve(true));
-    storageProviderSpy.get.and.returnValue(Promise.resolve(sampleIndexResponse));
+    storageProviderSpy.get.and.returnValue(
+      Promise.resolve(sampleIndexResponse),
+    );
    spyOn(configProvider.client, 'handshake').and.throwError('');
-    expect(await configProvider.getValue('name')).toEqual(sampleIndexResponse.app.name);
+    expect(await configProvider.getValue('name')).toEqual(
+      sampleIndexResponse.app.name,
+    );
  });
 });

-const scVersion = dependencies["@openstapps/core"];
+const scVersion = dependencies['@openstapps/core'];

 const sampleIndexResponse: SCIndexResponse = {
  app: {
@@ -192,7 +245,6 @@ const sampleIndexResponse: SCIndexResponse = {
              },
            },
          },
-
        ],
        name: 'main',
        translations: {
@@ -235,11 +287,7 @@ const sampleIndexResponse: SCIndexResponse = {
  backend: {
    SCVersion: scVersion,
    externalRequestTimeout: 5000,
-    hiddenTypes: [
-      SCThingType.DateSeries,
-      SCThingType.Diff,
-      SCThingType.Floor,
-    ],
+    hiddenTypes: [SCThingType.DateSeries, SCThingType.Diff, SCThingType.Floor],
    mappingIgnoredTags: [],
    maxMultiSearchRouteQueries: 5,
    maxRequestBodySize: 512 * 1024,
@@ -299,9 +347,7 @@ const sampleIndexResponse: SCIndexResponse = {
      },
      {
        fieldName: 'offers',
-        onlyOnTypes: [
-          SCThingType.Dish,
-        ],
+        onlyOnTypes: [SCThingType.Dish],
        sortTypes: ['price'],
      },
    ],
--- a/src/app/modules/config/config.provider.ts
+++ b/src/app/modules/config/config.provider.ts
@@ -31,7 +31,7 @@ import {
 /**
 * Key to store config in storage module
 *
- * @TODO: Issue #41 centralise storage keys
+ * TODO: Issue #41 centralise storage keys
 */
 export const STORAGE_KEY_CONFIG = 'stapps.config';

@@ -44,18 +44,22 @@ export class ConfigProvider {
   * Api client
   */
  client: Client;
+
  /**
   * App configuration as IndexResponse
   */
  config: SCIndexResponse;
+
  /**
   * First session indicator
   */
  firstSession = true;
+
  /**
   * Initialised status flag of config provider
   */
  initialised = false;
+
  /**
   * Version of the @openstapps/core package that app is using
   */
@@ -68,10 +72,16 @@ export class ConfigProvider {
   * @param swHttpClient Api client
   * @param logger An angular logger
   */
-  constructor(private readonly storageProvider: StorageProvider,
-              swHttpClient: StAppsWebHttpClient,
-              private readonly logger: NGXLogger) {
-    this.client = new Client(swHttpClient, environment.backend_url, environment.backend_version);
+  constructor(
+    private readonly storageProvider: StorageProvider,
+    swHttpClient: StAppsWebHttpClient,
+    private readonly logger: NGXLogger,
+  ) {
+    this.client = new Client(
+      swHttpClient,
+      environment.backend_url,
+      environment.backend_version,
+    );
  }

  /**
@@ -80,7 +90,7 @@ export class ConfigProvider {
  async fetch(): Promise<SCIndexResponse> {
    try {
      return await this.client.handshake(this.scVersion);
-    } catch (error) {
+    } catch {
      throw new ConfigFetchError();
    }
  }
@@ -124,7 +134,10 @@ export class ConfigProvider {
      this.initialised = true;
      this.logger.log(`initialised configuration from storage`);
      if (this.config.backend.SCVersion !== this.scVersion) {
-        loadError = new WrongConfigVersionInStorage(this.scVersion, this.config.backend.SCVersion);
+        loadError = new WrongConfigVersionInStorage(
+          this.scVersion,
+          this.config.backend.SCVersion,
+        );
        this.logger.warn(loadError);
      }
    } catch (error) {
--- a/src/app/modules/config/errors.ts
+++ b/src/app/modules/config/errors.ts
@@ -13,7 +13,7 @@
 * this program. If not, see <https://www.gnu.org/licenses/>.
 */

-import {AppError} from './../../_helpers/errors';
+import {AppError} from '../../_helpers/errors';

 /**
 * Error that is thrown when fetching from backend fails
@@ -38,7 +38,10 @@ export class ConfigInitError extends AppError {
 */
 export class ConfigValueNotAvailable extends AppError {
  constructor(valueKey: string) {
-    super('ConfigValueNotAvailable', `No attribute "${valueKey}" in config available!`);
+    super(
+      'ConfigValueNotAvailable',
+      `No attribute "${valueKey}" in config available!`,
+    );
  }
 }

@@ -56,7 +59,10 @@ export class SavedConfigNotAvailable extends AppError {
 */
 export class WrongConfigVersionInStorage extends AppError {
  constructor(correctVersion: string, savedVersion: string) {
-    super('WrongConfigVersionInStorage', `The saved configs backend version ${savedVersion} ` +
-      `does not equal the configured backend version ${correctVersion} of the app.`);
+    super(
+      'WrongConfigVersionInStorage',
+      `The saved configs backend version ${savedVersion} ` +
+        `does not equal the configured backend version ${correctVersion} of the app.`,
+    );
  }
 }