fix random test failing part 2 (#3395)

* fix random failing test core search/comment/auth/user

* fix node delete directive

* fix lint issues

* node restore fix

* fix comment test

* remove fdescribe

* fix tests and tslint

* fix upload test

* unsubscribe success event task test

* copy comment object during test

* use the data pipe performance improvement and standard usage

* uncomment random test

* fix comment date random failing test

* disposable unsubscribe

* fix start process

* remove fdescribe

* change start process test and remove commented code

* fix error event check double click

* clone object form test

* refactor date time test

* fix service mock

* fix test dropdown and context

* git hook lint

* fix language test

* unsubscribe documentlist event test

* fix disposable error

* fix console log service error document list

* unusbscribe search test

* clear input field

* remove wrong test

lib/core/services/alfresco-api.service.ts

@@ -105,6 +105,9 @@ export class AlfrescoApiService {
     }
 
     async reset() {
+        if (this.alfrescoApi) {
+            this.alfrescoApi = null;
+        }
         this.initAlfrescoApi();
     }
 

lib/core/services/auth-guard.service.spec.ts

@@ -61,6 +61,7 @@ describe('AuthGuardService', () => {
 
     it('should set redirect url', async(() => {
         state.url = 'some-url';
+        appConfigService.config.loginRoute = 'login';
 
         spyOn(router, 'navigate');
         spyOn(authService, 'setRedirect');
@@ -75,6 +76,7 @@ describe('AuthGuardService', () => {
 
     it('should set redirect url with query params', async(() => {
         state.url = 'some-url;q=query';
+        appConfigService.config.loginRoute = 'login';
 
         spyOn(router, 'navigate');
         spyOn(authService, 'setRedirect');

lib/core/services/authentication.service.spec.ts

@@ -64,38 +64,43 @@ describe('AuthenticationService', () => {
         });
 
         it('[ECM] should save the remember me cookie as a session cookie after successful login', (done) => {
-            authService.login('fake-username', 'fake-password', false).subscribe(() => {
+            let disposableLogin = authService.login('fake-username', 'fake-password', false).subscribe(() => {
                 expect(cookie['ALFRESCO_REMEMBER_ME']).not.toBeUndefined();
                 expect(cookie['ALFRESCO_REMEMBER_ME'].expiration).toBeNull();
+                disposableLogin.unsubscribe();
                 done();
             });
 
             jasmine.Ajax.requests.mostRecent().respondWith({
                 'status': 201,
                 contentType: 'application/json',
-                responseText: JSON.stringify({'entry': {'id': 'fake-post-ticket', 'userId': 'admin'}})
+                responseText: JSON.stringify({ 'entry': { 'id': 'fake-post-ticket', 'userId': 'admin' } })
             });
         });
 
         it('[ECM] should save the remember me cookie as a persistent cookie after successful login', (done) => {
-            authService.login('fake-username', 'fake-password', true).subscribe(() => {
+            let disposableLogin = authService.login('fake-username', 'fake-password', true).subscribe(() => {
                 expect(cookie['ALFRESCO_REMEMBER_ME']).not.toBeUndefined();
                 expect(cookie['ALFRESCO_REMEMBER_ME'].expiration).not.toBeNull();
+                disposableLogin.unsubscribe();
+
                 done();
             });
 
             jasmine.Ajax.requests.mostRecent().respondWith({
                 'status': 201,
                 contentType: 'application/json',
-                responseText: JSON.stringify({'entry': {'id': 'fake-post-ticket', 'userId': 'admin'}})
+                responseText: JSON.stringify({ 'entry': { 'id': 'fake-post-ticket', 'userId': 'admin' } })
             });
         });
 
         it('[ECM] should not save the remember me cookie after failed login', (done) => {
-            authService.login('fake-username', 'fake-password').subscribe(
-                (res) => {},
+            let disposableLogin = authService.login('fake-username', 'fake-password').subscribe(
+                (res) => {
+                },
                 (err: any) => {
                     expect(cookie['ALFRESCO_REMEMBER_ME']).toBeUndefined();
+                    disposableLogin.unsubscribe();
                     done();
                 });
 
@@ -140,43 +145,46 @@ describe('AuthenticationService', () => {
         });
 
         it('[ECM] should return an ECM ticket after the login done', (done) => {
-            authService.login('fake-username', 'fake-password').subscribe(() => {
+            let disposableLogin = authService.login('fake-username', 'fake-password').subscribe(() => {
                 expect(authService.isLoggedIn()).toBe(true);
                 expect(authService.getTicketEcm()).toEqual('fake-post-ticket');
                 expect(authService.isEcmLoggedIn()).toBe(true);
+                disposableLogin.unsubscribe();
                 done();
             });
 
             jasmine.Ajax.requests.mostRecent().respondWith({
                 'status': 201,
                 contentType: 'application/json',
-                responseText: JSON.stringify({'entry': {'id': 'fake-post-ticket', 'userId': 'admin'}})
+                responseText: JSON.stringify({ 'entry': { 'id': 'fake-post-ticket', 'userId': 'admin' } })
             });
         });
 
         it('[ECM] should save only ECM ticket on localStorage', (done) => {
-            authService.login('fake-username', 'fake-password').subscribe(() => {
+            let disposableLogin = authService.login('fake-username', 'fake-password').subscribe(() => {
                 expect(authService.isLoggedIn()).toBe(true);
                 expect(authService.getTicketBpm()).toBeNull();
                 expect(apiService.getInstance().bpmAuth.isLoggedIn()).toBeFalsy();
+                disposableLogin.unsubscribe();
                 done();
             });
 
             jasmine.Ajax.requests.mostRecent().respondWith({
                 'status': 201,
                 contentType: 'application/json',
-                responseText: JSON.stringify({'entry': {'id': 'fake-post-ticket', 'userId': 'admin'}})
+                responseText: JSON.stringify({ 'entry': { 'id': 'fake-post-ticket', 'userId': 'admin' } })
             });
         });
 
         it('[ECM] should return ticket undefined when the credentials are wrong', (done) => {
-            authService.login('fake-wrong-username', 'fake-wrong-password').subscribe(
+            let disposableLogin = authService.login('fake-wrong-username', 'fake-wrong-password').subscribe(
                 (res) => {
                 },
                 (err: any) => {
                     expect(authService.isLoggedIn()).toBe(false);
                     expect(authService.getTicketEcm()).toBe(null);
                     expect(authService.isEcmLoggedIn()).toBe(false);
+                    disposableLogin.unsubscribe();
                     done();
                 });
 
@@ -196,23 +204,26 @@ describe('AuthenticationService', () => {
         });
 
         it('[ECM] should login in the ECM if no provider are defined calling the login', (done) => {
-            authService.login('fake-username', 'fake-password').subscribe(() => {
+            let disposableLogin = authService.login('fake-username', 'fake-password').subscribe(() => {
+                disposableLogin.unsubscribe();
                 done();
             });
 
             jasmine.Ajax.requests.mostRecent().respondWith({
                 'status': 201,
                 contentType: 'application/json',
-                responseText: JSON.stringify({'entry': {'id': 'fake-post-ticket', 'userId': 'admin'}})
+                responseText: JSON.stringify({ 'entry': { 'id': 'fake-post-ticket', 'userId': 'admin' } })
             });
         });
 
         it('[ECM] should return a ticket undefined after logout', (done) => {
-            authService.login('fake-username', 'fake-password').subscribe(() => {
-                authService.logout().subscribe(() => {
+            let disposableLogin = authService.login('fake-username', 'fake-password').subscribe(() => {
+                let disposableLogout = authService.logout().subscribe(() => {
                     expect(authService.isLoggedIn()).toBe(false);
                     expect(authService.getTicketEcm()).toBe(null);
                     expect(authService.isEcmLoggedIn()).toBe(false);
+                    disposableLogin.unsubscribe();
+                    disposableLogout.unsubscribe();
                     done();
                 });
 
@@ -224,13 +235,12 @@ describe('AuthenticationService', () => {
             jasmine.Ajax.requests.mostRecent().respondWith({
                 'status': 201,
                 contentType: 'application/json',
-                responseText: JSON.stringify({'entry': {'id': 'fake-post-ticket', 'userId': 'admin'}})
+                responseText: JSON.stringify({ 'entry': { 'id': 'fake-post-ticket', 'userId': 'admin' } })
             });
         });
 
         it('[ECM] ticket should be deleted only after logout request is accepted', (done) => {
-
-            authService.login('fake-username', 'fake-password').subscribe(() => {
+            let disposableLogin = authService.login('fake-username', 'fake-password').subscribe(() => {
                 let logoutPromise = authService.logout();
 
                 expect(authService.getTicketEcm()).toBe('fake-post-ticket');
@@ -239,9 +249,11 @@ describe('AuthenticationService', () => {
                     'status': 204
                 });
 
-                logoutPromise.subscribe(() => {
+                let disposableLogout = logoutPromise.subscribe(() => {
                     expect(authService.isLoggedIn()).toBe(false);
                     expect(authService.isEcmLoggedIn()).toBe(false);
+                    disposableLogin.unsubscribe();
+                    disposableLogout.unsubscribe();
                     done();
                 });
 
@@ -250,7 +262,7 @@ describe('AuthenticationService', () => {
             jasmine.Ajax.requests.mostRecent().respondWith({
                 'status': 201,
                 contentType: 'application/json',
-                responseText: JSON.stringify({'entry': {'id': 'fake-post-ticket', 'userId': 'admin'}})
+                responseText: JSON.stringify({ 'entry': { 'id': 'fake-post-ticket', 'userId': 'admin' } })
             });
         });
 
@@ -260,19 +272,19 @@ describe('AuthenticationService', () => {
         });
 
         it('[ECM] should set/get redirectUrl when provider is ECM', () => {
-            authService.setRedirect({provider: 'ECM', navigation: ['some-url'] } );
+            authService.setRedirect({ provider: 'ECM', navigation: ['some-url'] });
 
             expect(authService.getRedirect(preferences.authType)).toEqual(['some-url']);
         });
 
         it('[ECM] should set/get redirectUrl when provider is BPM', () => {
-            authService.setRedirect({provider: 'BPM', navigation: ['some-url'] } );
+            authService.setRedirect({ provider: 'BPM', navigation: ['some-url'] });
 
             expect(authService.getRedirect(preferences.authType)).toBeNull();
         });
 
         it('[ECM] should return null as redirectUrl when redirectUrl field is not set', () => {
-            authService.setRedirect( null );
+            authService.setRedirect(null);
 
             expect(authService.getRedirect(preferences.authType)).toBeNull();
         });
@@ -303,41 +315,45 @@ describe('AuthenticationService', () => {
         });
 
         it('[BPM] should return an BPM ticket after the login done', (done) => {
-            authService.login('fake-username', 'fake-password').subscribe(() => {
+            let disposableLogin = authService.login('fake-username', 'fake-password').subscribe((response) => {
                 expect(authService.isLoggedIn()).toBe(true);
                 expect(authService.getTicketBpm()).toEqual('Basic ZmFrZS11c2VybmFtZTpmYWtlLXBhc3N3b3Jk');
                 expect(authService.isBpmLoggedIn()).toBe(true);
+                disposableLogin.unsubscribe();
                 done();
             });
 
             jasmine.Ajax.requests.mostRecent().respondWith({
-                'status': 200
+                'status': 200,
+                contentType: 'application/json'
             });
         });
 
         it('[BPM] should save only BPM ticket on localStorage', (done) => {
-            authService.login('fake-username', 'fake-password').subscribe(() => {
+            let disposableLogin = authService.login('fake-username', 'fake-password').subscribe(() => {
                 expect(authService.isLoggedIn()).toBe(true);
                 expect(authService.getTicketEcm()).toBeNull();
                 expect(apiService.getInstance().ecmAuth.isLoggedIn()).toBeFalsy();
+                disposableLogin.unsubscribe();
                 done();
             });
 
             jasmine.Ajax.requests.mostRecent().respondWith({
                 'status': 201,
                 contentType: 'application/json',
-                responseText: JSON.stringify({'entry': {'id': 'fake-post-ticket', 'userId': 'admin'}})
+                responseText: JSON.stringify({ 'entry': { 'id': 'fake-post-ticket', 'userId': 'admin' } })
             });
         });
 
         it('[BPM] should return ticket undefined when the credentials are wrong', (done) => {
-            authService.login('fake-wrong-username', 'fake-wrong-password').subscribe(
+            let disposableLogin = authService.login('fake-wrong-username', 'fake-wrong-password').subscribe(
                 (res) => {
                 },
                 (err: any) => {
                     expect(authService.isLoggedIn()).toBe(false, 'isLoggedIn');
                     expect(authService.getTicketBpm()).toBe(null, 'getTicketBpm');
                     expect(authService.isBpmLoggedIn()).toBe(false, 'isBpmLoggedIn');
+                    disposableLogin.unsubscribe();
                     done();
                 });
 
@@ -347,8 +363,7 @@ describe('AuthenticationService', () => {
         });
 
         it('[BPM] ticket should be deleted only after logout request is accepted', (done) => {
-
-            authService.login('fake-username', 'fake-password').subscribe(() => {
+            let disposableLogin = authService.login('fake-username', 'fake-password').subscribe(() => {
                 let logoutPromise = authService.logout();
 
                 expect(authService.getTicketBpm()).toBe('Basic ZmFrZS11c2VybmFtZTpmYWtlLXBhc3N3b3Jk');
@@ -357,9 +372,11 @@ describe('AuthenticationService', () => {
                     'status': 200
                 });
 
-                logoutPromise.subscribe(() => {
+                let disposableLogout = logoutPromise.subscribe(() => {
                     expect(authService.isLoggedIn()).toBe(false);
                     expect(authService.isBpmLoggedIn()).toBe(false);
+                    disposableLogout.unsubscribe();
+                    disposableLogin.unsubscribe();
                     done();
                 });
 
@@ -371,11 +388,13 @@ describe('AuthenticationService', () => {
         });
 
         it('[BPM] should return a ticket undefined after logout', (done) => {
-            authService.login('fake-username', 'fake-password').subscribe(() => {
-                authService.logout().subscribe(() => {
+            let disposableLogin = authService.login('fake-username', 'fake-password').subscribe(() => {
+                let disposableLogout = authService.logout().subscribe(() => {
                     expect(authService.isLoggedIn()).toBe(false);
                     expect(authService.getTicketBpm()).toBe(null);
                     expect(authService.isBpmLoggedIn()).toBe(false);
+                    disposableLogout.unsubscribe();
+                    disposableLogin.unsubscribe();
                     done();
                 });
 
@@ -405,19 +424,19 @@ describe('AuthenticationService', () => {
         });
 
         it('[BPM] should set/get redirectUrl when provider is BPM', () => {
-            authService.setRedirect({provider: 'BPM', navigation: ['some-url'] } );
+            authService.setRedirect({ provider: 'BPM', navigation: ['some-url'] });
 
             expect(authService.getRedirect(preferences.authType)).toEqual(['some-url']);
         });
 
         it('[BPM] should set/get redirectUrl when provider is ECM', () => {
-            authService.setRedirect({provider: 'ECM', navigation: ['some-url'] } );
+            authService.setRedirect({ provider: 'ECM', navigation: ['some-url'] });
 
             expect(authService.getRedirect(preferences.authType)).toBeNull();
         });
 
         it('[BPM] should return null as redirectUrl when redirectUrl field is not set', () => {
-            authService.setRedirect( null );
+            authService.setRedirect(null);
 
             expect(authService.getRedirect(preferences.authType)).toBeNull();
         });
@@ -430,19 +449,20 @@ describe('AuthenticationService', () => {
         });
 
         it('[ALL] should return both ECM and BPM tickets after the login done', (done) => {
-            authService.login('fake-username', 'fake-password').subscribe(() => {
+            let disposableLogin = authService.login('fake-username', 'fake-password').subscribe(() => {
                 expect(authService.isLoggedIn()).toBe(true);
                 expect(authService.getTicketEcm()).toEqual('fake-post-ticket');
                 expect(authService.getTicketBpm()).toEqual('Basic ZmFrZS11c2VybmFtZTpmYWtlLXBhc3N3b3Jk');
                 expect(authService.isBpmLoggedIn()).toBe(true);
                 expect(authService.isEcmLoggedIn()).toBe(true);
+                disposableLogin.unsubscribe();
                 done();
             });
 
             jasmine.Ajax.requests.at(0).respondWith({
                 'status': 201,
                 contentType: 'application/json',
-                responseText: JSON.stringify({'entry': {'id': 'fake-post-ticket', 'userId': 'admin'}})
+                responseText: JSON.stringify({ 'entry': { 'id': 'fake-post-ticket', 'userId': 'admin' } })
             });
 
             jasmine.Ajax.requests.at(1).respondWith({
@@ -451,7 +471,7 @@ describe('AuthenticationService', () => {
         });
 
         it('[ALL] should return login fail if only ECM call fail', (done) => {
-            authService.login('fake-username', 'fake-password').subscribe(
+            let disposableLogin = authService.login('fake-username', 'fake-password').subscribe(
                 (res) => {
                 },
                 (err: any) => {
@@ -459,6 +479,7 @@ describe('AuthenticationService', () => {
                     expect(authService.getTicketEcm()).toBe(null, 'getTicketEcm');
                     expect(authService.getTicketBpm()).toBe(null, 'getTicketBpm');
                     expect(authService.isEcmLoggedIn()).toBe(false, 'isEcmLoggedIn');
+                    disposableLogin.unsubscribe();
                     done();
                 });
 
@@ -472,7 +493,7 @@ describe('AuthenticationService', () => {
         });
 
         it('[ALL] should return login fail if only BPM call fail', (done) => {
-            authService.login('fake-username', 'fake-password').subscribe(
+            let disposableLogin = authService.login('fake-username', 'fake-password').subscribe(
                 (res) => {
                 },
                 (err: any) => {
@@ -480,13 +501,14 @@ describe('AuthenticationService', () => {
                     expect(authService.getTicketEcm()).toBe(null);
                     expect(authService.getTicketBpm()).toBe(null);
                     expect(authService.isBpmLoggedIn()).toBe(false);
+                    disposableLogin.unsubscribe();
                     done();
                 });
 
             jasmine.Ajax.requests.at(0).respondWith({
                 'status': 201,
                 contentType: 'application/json',
-                responseText: JSON.stringify({'entry': {'id': 'fake-post-ticket', 'userId': 'admin'}})
+                responseText: JSON.stringify({ 'entry': { 'id': 'fake-post-ticket', 'userId': 'admin' } })
             });
 
             jasmine.Ajax.requests.at(1).respondWith({
@@ -495,7 +517,7 @@ describe('AuthenticationService', () => {
         });
 
         it('[ALL] should return ticket undefined when the credentials are wrong', (done) => {
-            authService.login('fake-username', 'fake-password').subscribe(
+            let disposableLogin = authService.login('fake-username', 'fake-password').subscribe(
                 (res) => {
                 },
                 (err: any) => {
@@ -504,6 +526,7 @@ describe('AuthenticationService', () => {
                     expect(authService.getTicketBpm()).toBe(null);
                     expect(authService.isBpmLoggedIn()).toBe(false);
                     expect(authService.isEcmLoggedIn()).toBe(false);
+                    disposableLogin.unsubscribe();
                     done();
                 });
 
@@ -517,25 +540,25 @@ describe('AuthenticationService', () => {
         });
 
         it('[ALL] should set/get redirectUrl when provider is ALL', () => {
-            authService.setRedirect({provider: 'ALL', navigation: ['some-url'] } );
+            authService.setRedirect({ provider: 'ALL', navigation: ['some-url'] });
 
             expect(authService.getRedirect(preferences.authType)).toEqual(['some-url']);
         });
 
         it('[ALL] should set/get redirectUrl when provider is BPM', () => {
-            authService.setRedirect({provider: 'BPM', navigation: ['some-url'] } );
+            authService.setRedirect({ provider: 'BPM', navigation: ['some-url'] });
 
             expect(authService.getRedirect(preferences.authType)).toEqual(['some-url']);
         });
 
         it('[ALL] should set/get redirectUrl when provider is ECM', () => {
-            authService.setRedirect({provider: 'ECM', navigation: ['some-url'] } );
+            authService.setRedirect({ provider: 'ECM', navigation: ['some-url'] });
 
             expect(authService.getRedirect(preferences.authType)).toEqual(['some-url']);
         });
 
         it('[ALL] should return null as redirectUrl when redirectUrl field is not set', () => {
-            authService.setRedirect( null );
+            authService.setRedirect(null);
 
             expect(authService.getRedirect(preferences.authType)).toBeNull();
         });

lib/core/services/user-preferences.service.spec.ts

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-import { async, TestBed } from '@angular/core/testing';
+import { TestBed } from '@angular/core/testing';
 import { TranslateService } from '@ngx-translate/core';
 import { AppConfigService } from '../app-config/app-config.service';
 import { StorageService } from './storage.service';
@@ -32,6 +32,7 @@ describe('UserPreferencesService', () => {
     let storage: StorageService;
     let appConfig: AppConfigService;
     let translate: TranslateService;
+    let changeDisposable: any;
 
     setupTestBed({
         imports: [CoreTestingModule]
@@ -50,6 +51,12 @@ describe('UserPreferencesService', () => {
         translate = TestBed.get(TranslateService);
     });
 
+    afterEach(() => {
+        if (changeDisposable) {
+            changeDisposable.unsubscribe();
+        }
+    });
+
     it('should get default pagination from app config', () => {
         appConfig.config.pagination.size = 0;
         expect(preferences.defaults.paginationSize).toBe(defaultPaginationSize);
@@ -132,25 +139,28 @@ describe('UserPreferencesService', () => {
         expect(preferences.locale).toBe('fake-store-locate');
     });
 
-    it('should stream the page size value when is set', async(() => {
+    it('should stream the page size value when is set', (done) => {
         preferences.paginationSize = 5;
-        preferences.onChange.subscribe((userPreferenceStatus) => {
+        changeDisposable = preferences.onChange.subscribe((userPreferenceStatus) => {
             expect(userPreferenceStatus.PAGINATION_SIZE).toBe(5);
+            done();
         });
-    }));
+    });
 
-    it('should stream the user preference status when changed', async(() => {
+    it('should stream the user preference status when changed', (done) => {
         preferences.set('propertyA', 'valueA');
-        preferences.onChange.subscribe((userPreferenceStatus) => {
+        changeDisposable = preferences.onChange.subscribe((userPreferenceStatus) => {
             expect(userPreferenceStatus.propertyA).toBe('valueA');
+            done();
         });
-    }));
+    });
 
-    it('should stream only the selected attribute changes when using select', async(() => {
+    it('should stream only the selected attribute changes when using select', (done) => {
         preferences.disableCSRF = true;
         preferences.select(UserPreferenceValues.DisableCSRF).subscribe((disableCSRFFlag) => {
             expect(disableCSRFFlag).toBeTruthy();
+            done();
         });
-    }));
+    });
 
 });