[ACS-6190] prefer-promise-reject-errors rule and fixes (#9021)

* fix promise rejections

* fix promise errors

* promise error fixes

* fix promise rejections

* [ci:force] fix formatting

* test fixes

* [ci:force] fix tests

* [ci:force] fix tests

* fix incorrect return types

* meaningful errors

* remove useless pipe

* fix accessing private members in the test

lib/process-services/src/lib/process-list/components/process-filters.component.spec.ts

@@ -160,9 +160,7 @@ describe('ProcessFiltersComponent', () => {
     });
 
     it('should emit an error with a bad response of getProcessFilters', async () => {
-        const mockErrorFilterPromise = Promise.reject({
-            error: 'wrong request'
-        });
+        const mockErrorFilterPromise = Promise.reject(new Error('wrong request'));
         spyOn(processFilterService, 'getProcessFilters').and.returnValue(from(mockErrorFilterPromise));
 
         const appId = '1';
@@ -177,9 +175,7 @@ describe('ProcessFiltersComponent', () => {
     });
 
     it('should emit an error with a bad response of getDeployedApplicationsByName', async () => {
-        const mockErrorFilterPromise = Promise.reject({
-            error: 'wrong request'
-        });
+        const mockErrorFilterPromise = Promise.reject(new Error('wrong request'));
         spyOn(appsProcessService, 'getDeployedApplicationsByName').and.returnValue(from(mockErrorFilterPromise));
 
         const appId = 'fake-app';

lib/process-services/src/lib/process-list/services/process-filter.service.spec.ts

@@ -47,7 +47,7 @@ describe('Process filter', () => {
         let createFilter: jasmine.Spy;
 
         beforeEach(() => {
-            getFilters = spyOn(service['userFiltersApi'], 'getUserProcessInstanceFilters').and.returnValue(
+            getFilters = spyOn(service.userFiltersApi, 'getUserProcessInstanceFilters').and.returnValue(
                 Promise.resolve(fakeProcessFiltersResponse)
             );
 
@@ -70,7 +70,7 @@ describe('Process filter', () => {
             });
 
             it('should return the task filter by id', (done) => {
-                service.getProcessFilterById(333).subscribe((processFilter: FilterProcessRepresentationModel) => {
+                service.getProcessFilterById(333).subscribe((processFilter) => {
                     expect(processFilter).toBeDefined();
                     expect(processFilter.id).toEqual(333);
                     expect(processFilter.name).toEqual('Running');
@@ -81,7 +81,7 @@ describe('Process filter', () => {
             });
 
             it('should return the task filter by name', (done) => {
-                service.getProcessFilterByName('Running').subscribe((res: FilterProcessRepresentationModel) => {
+                service.getProcessFilterByName('Running').subscribe((res) => {
                     expect(res).toBeDefined();
                     expect(res.id).toEqual(333);
                     expect(res.name).toEqual('Running');
@@ -211,7 +211,7 @@ describe('Process filter', () => {
 
         describe('add filter', () => {
             beforeEach(() => {
-                createFilter = spyOn(service['userFiltersApi'], 'createUserProcessInstanceFilter').and.callFake(
+                createFilter = spyOn(service.userFiltersApi, 'createUserProcessInstanceFilter').and.callFake(
                     (processFilter) => Promise.resolve(processFilter)
                 );
             });
@@ -243,11 +243,11 @@ describe('Process filter', () => {
             });
 
             it('should return a default error if no data is returned by the API', (done) => {
-                createFilter = createFilter.and.returnValue(Promise.reject(null));
+                createFilter = createFilter.and.returnValue(Promise.reject(new Error('Server error')));
                 service.addProcessFilter(filter).subscribe(
                     () => {},
-                    (res) => {
-                        expect(res).toBe('Server error');
+                    (err) => {
+                        expect(err.message).toBe('Server error');
                         done();
                     }
                 );
@@ -307,8 +307,8 @@ describe('Process filter', () => {
                 const duplicateRunningObservable = of(duplicateRunningFilter);
 
                 spyOn(service, 'getRunningFilterInstance').and.returnValue(runningFilter);
-                spyOn<any>(service, 'getCompletedFilterInstance').and.returnValue(completedFilter);
-                spyOn<any>(service, 'getAllFilterInstance').and.returnValue(allFilter);
+                spyOn(service, 'getCompletedFilterInstance').and.returnValue(completedFilter);
+                spyOn(service, 'getAllFilterInstance').and.returnValue(allFilter);
 
                 spyOn(service, 'addProcessFilter').and.returnValues(
                     runningObservable,

lib/process-services/src/lib/process-list/services/process-filter.service.ts

@@ -17,12 +17,13 @@
 
 import { AlfrescoApiService } from '@alfresco/adf-core';
 import { Injectable } from '@angular/core';
-import { Observable, from, forkJoin, throwError } from 'rxjs';
+import { Observable, from, forkJoin } from 'rxjs';
 import { FilterProcessRepresentationModel } from '../models/filter-process.model';
-import { map, catchError } from 'rxjs/operators';
+import { map } from 'rxjs/operators';
 import {
     ResultListDataRepresentationUserProcessInstanceFilterRepresentation,
-    UserFiltersApi
+    UserFiltersApi,
+    UserProcessInstanceFilterRepresentation
 } from '@alfresco/js-api';
 
 @Injectable({
@@ -57,8 +58,7 @@ export class ProcessFilterService {
                         }
                     });
                     return filters;
-                }),
-                catchError((err) => this.handleProcessError(err))
+                })
             );
     }
 
@@ -69,11 +69,10 @@ export class ProcessFilterService {
      * @param appId ID of the target app
      * @returns Details of the filter
      */
-    getProcessFilterById(filterId: number, appId?: number): Observable<FilterProcessRepresentationModel> {
+    getProcessFilterById(filterId: number, appId?: number): Observable<UserProcessInstanceFilterRepresentation> {
         return from(this.callApiProcessFilters(appId))
             .pipe(
-                map((response: any) => response.data.find((filter) => filter.id === filterId)),
-                catchError((err) => this.handleProcessError(err))
+                map((response) => response.data.find((filter) => filter.id === filterId))
             );
     }
 
@@ -84,11 +83,10 @@ export class ProcessFilterService {
      * @param appId ID of the target app
      * @returns Details of the filter
      */
-    getProcessFilterByName(filterName: string, appId?: number): Observable<FilterProcessRepresentationModel> {
+    getProcessFilterByName(filterName: string, appId?: number): Observable<UserProcessInstanceFilterRepresentation> {
         return from(this.callApiProcessFilters(appId))
             .pipe(
-                map((response: any) => response.data.find((filter) => filter.name === filterName)),
-                catchError((err) => this.handleProcessError(err))
+                map((response) => response.data.find((filter) => filter.name === filterName))
             );
     }
 
@@ -130,9 +128,6 @@ export class ProcessFilterService {
                     });
                     observer.next(filters);
                     observer.complete();
-                },
-                (err: any) => {
-                    this.handleProcessError(err);
                 });
         });
     }
@@ -172,12 +167,8 @@ export class ProcessFilterService {
      * @param filter The filter to add
      * @returns The filter just added
      */
-    addProcessFilter(filter: FilterProcessRepresentationModel): Observable<FilterProcessRepresentationModel> {
-        return from(this.userFiltersApi.createUserProcessInstanceFilter(filter))
-            .pipe(
-                map((response: FilterProcessRepresentationModel) => response),
-                catchError((err) => this.handleProcessError(err))
-            );
+    addProcessFilter(filter: FilterProcessRepresentationModel): Observable<UserProcessInstanceFilterRepresentation> {
+        return from(this.userFiltersApi.createUserProcessInstanceFilter(filter));
     }
 
     /**
@@ -194,7 +185,7 @@ export class ProcessFilterService {
         }
     }
 
-    private getCompletedFilterInstance(appId: number, index?: number): FilterProcessRepresentationModel {
+    getCompletedFilterInstance(appId: number, index?: number): FilterProcessRepresentationModel {
         return new FilterProcessRepresentationModel({
             name: 'Completed',
             appId,
@@ -205,7 +196,7 @@ export class ProcessFilterService {
         });
     }
 
-    private getAllFilterInstance(appId: number, index?: number): FilterProcessRepresentationModel {
+    getAllFilterInstance(appId: number, index?: number): FilterProcessRepresentationModel {
         return new FilterProcessRepresentationModel({
             name: 'All',
             appId,
@@ -215,8 +206,4 @@ export class ProcessFilterService {
             index
         });
     }
-
-    private handleProcessError(error: any) {
-        return throwError(error || 'Server error');
-    }
 }

lib/process-services/src/lib/process-list/services/process.service.spec.ts

@@ -46,7 +46,7 @@ describe('ProcessService', () => {
         });
 
         beforeEach(() => {
-            spyOn(service['processInstancesApi'], 'getProcessInstances')
+            spyOn(service.processInstancesApi, 'getProcessInstances')
                 .and
                 .returnValue(Promise.resolve({ data: [exampleProcess] }));
         });
@@ -74,7 +74,7 @@ describe('ProcessService', () => {
         const processId = 'test';
 
         beforeEach(() => {
-            spyOn(service['processInstancesApi'], 'getProcessInstance')
+            spyOn(service.processInstancesApi, 'getProcessInstance')
                 .and
                 .returnValue(Promise.resolve(exampleProcess));
         });
@@ -95,7 +95,7 @@ describe('ProcessService', () => {
         let startNewProcessInstance: jasmine.Spy;
 
         beforeEach(() => {
-            startNewProcessInstance = spyOn(service['processInstancesApi'], 'startNewProcessInstance')
+            startNewProcessInstance = spyOn(service.processInstancesApi, 'startNewProcessInstance')
                 .and
                 .returnValue(Promise.resolve(exampleProcess));
         });
@@ -145,12 +145,12 @@ describe('ProcessService', () => {
         });
 
         it('should return a default error if no data is returned by the API', (done) => {
-            startNewProcessInstance = startNewProcessInstance.and.returnValue(Promise.reject(null));
+            startNewProcessInstance = startNewProcessInstance.and.returnValue(Promise.reject(new Error('Server error')));
             service.startProcess(processDefId, processName).subscribe(
                 () => {
                 },
-                (res) => {
-                    expect(res).toBe('Server error');
+                (err) => {
+                    expect(err.message).toBe('Server error');
                     done();
                 }
             );
@@ -163,7 +163,7 @@ describe('ProcessService', () => {
         let deleteProcessInstance: jasmine.Spy;
 
         beforeEach(() => {
-            deleteProcessInstance = spyOn(service['processInstancesApi'], 'deleteProcessInstance')
+            deleteProcessInstance = spyOn(service.processInstancesApi, 'deleteProcessInstance')
                 .and
                 .returnValue(Promise.resolve());
         });
@@ -191,12 +191,12 @@ describe('ProcessService', () => {
         });
 
         it('should return a default error if no data is returned by the API', (done) => {
-            deleteProcessInstance = deleteProcessInstance.and.returnValue(Promise.reject(null));
+            deleteProcessInstance = deleteProcessInstance.and.returnValue(Promise.reject(new Error('Server error')));
             service.cancelProcess(null).subscribe(
                 () => {
                 },
-                (res) => {
-                    expect(res).toBe('Server error');
+                (err) => {
+                    expect(err.message).toBe('Server error');
                     done();
                 }
             );
@@ -208,7 +208,7 @@ describe('ProcessService', () => {
         let getProcessDefinitions: jasmine.Spy;
 
         beforeEach(() => {
-            getProcessDefinitions = spyOn(service['processDefinitionsApi'], 'getProcessDefinitions')
+            getProcessDefinitions = spyOn(service.processDefinitionsApi, 'getProcessDefinitions')
                 .and
                 .returnValue(Promise.resolve({ data: [fakeProcessDef, fakeProcessDef] }));
         });
@@ -251,12 +251,12 @@ describe('ProcessService', () => {
         });
 
         it('should return a default error if no data is returned by the API', (done) => {
-            getProcessDefinitions = getProcessDefinitions.and.returnValue(Promise.reject(null));
+            getProcessDefinitions = getProcessDefinitions.and.returnValue(Promise.reject(new Error('Server error')));
             service.getProcessDefinitions().subscribe(
                 () => {
                 },
-                (res) => {
-                    expect(res).toBe('Server error');
+                (err) => {
+                    expect(err.message).toBe('Server error');
                     done();
                 }
             );
@@ -269,7 +269,7 @@ describe('ProcessService', () => {
         let listTasks: jasmine.Spy;
 
         beforeEach(() => {
-            listTasks = spyOn(service['tasksApi'], 'listTasks')
+            listTasks = spyOn(service.tasksApi, 'listTasks')
                 .and
                 .returnValue(Promise.resolve(fakeTasksList));
         });
@@ -325,12 +325,12 @@ describe('ProcessService', () => {
         });
 
         it('should return a default error if no data is returned by the API', (done) => {
-            listTasks = listTasks.and.returnValue(Promise.reject(null));
+            listTasks = listTasks.and.returnValue(Promise.reject(new Error('Server error')));
             service.getProcessTasks(processId).subscribe(
                 () => {
                 },
-                (res) => {
-                    expect(res).toBe('Server error');
+                (err) => {
+                    expect(err.message).toBe('Server error');
                     done();
                 }
             );
@@ -344,7 +344,7 @@ describe('ProcessService', () => {
         let deleteProcessInstanceVariableSpy: jasmine.Spy;
 
         beforeEach(() => {
-            getVariablesSpy = spyOn(service['processInstanceVariablesApi'], 'getProcessInstanceVariables').and.returnValue(Promise.resolve([{
+            getVariablesSpy = spyOn(service.processInstanceVariablesApi, 'getProcessInstanceVariables').and.returnValue(Promise.resolve([{
                 name: 'var1',
                 value: 'Test1'
             }, {
@@ -352,10 +352,10 @@ describe('ProcessService', () => {
                 value: 'Test3'
             }]));
 
-            createOrUpdateProcessInstanceVariablesSpy = spyOn(service['processInstanceVariablesApi'],
+            createOrUpdateProcessInstanceVariablesSpy = spyOn(service.processInstanceVariablesApi,
                 'createOrUpdateProcessInstanceVariables').and.returnValue(Promise.resolve({} as any));
 
-            deleteProcessInstanceVariableSpy = spyOn(service['processInstanceVariablesApi'],
+            deleteProcessInstanceVariableSpy = spyOn(service.processInstanceVariablesApi,
                 'deleteProcessInstanceVariable').and.returnValue(Promise.resolve());
         });
 
@@ -379,12 +379,12 @@ describe('ProcessService', () => {
             });
 
             it('should return a default error if no data is returned by the API', (done) => {
-                getVariablesSpy = getVariablesSpy.and.returnValue(Promise.reject(null));
+                getVariablesSpy = getVariablesSpy.and.returnValue(Promise.reject(new Error('Server error')));
                 service.getProcessInstanceVariables(null).subscribe(
                     () => {
                     },
-                    (res) => {
-                        expect(res).toBe('Server error');
+                    (err) => {
+                        expect(err.message).toBe('Server error');
                         done();
                     }
                 );
@@ -410,20 +410,20 @@ describe('ProcessService', () => {
                 service.createOrUpdateProcessInstanceVariables('123', updatedVariables).subscribe(
                     () => {
                     },
-                    (res) => {
-                        expect(res).toBe(mockError);
+                    (err) => {
+                        expect(err).toBe(mockError);
                         done();
                     }
                 );
             });
 
             it('should return a default error if no data is returned by the API', (done) => {
-                createOrUpdateProcessInstanceVariablesSpy = createOrUpdateProcessInstanceVariablesSpy.and.returnValue(Promise.reject(null));
+                createOrUpdateProcessInstanceVariablesSpy = createOrUpdateProcessInstanceVariablesSpy.and.returnValue(Promise.reject(new Error('Server error')));
                 service.createOrUpdateProcessInstanceVariables('123', updatedVariables).subscribe(
                     () => {
                     },
-                    (res) => {
-                        expect(res).toBe('Server error');
+                    (err) => {
+                        expect(err.message).toBe('Server error');
                         done();
                     }
                 );
@@ -444,12 +444,12 @@ describe('ProcessService', () => {
             });
 
             it('should return a default error if no data is returned by the API', (done) => {
-                deleteProcessInstanceVariableSpy = deleteProcessInstanceVariableSpy.and.returnValue(Promise.reject(null));
+                deleteProcessInstanceVariableSpy = deleteProcessInstanceVariableSpy.and.returnValue(Promise.reject(new Error('Server error')));
                 service.deleteProcessInstanceVariable('123', 'myVar').subscribe(
                     () => {
                     },
-                    (res) => {
-                        expect(res).toBe('Server error');
+                    (err) => {
+                        expect(err.message).toBe('Server error');
                         done();
                     }
                 );