generator-jhipster 7.1.0 → 7.4.0

package/generators/client/templates/angular/src/main/webapp/app/core/auth/account.service.spec.ts.ejs

@@ -58,248 +58,255 @@ function accountWithAuthorities(authorities: string[]): Account {
   };
 }
 
-describe('Service Tests', () => {
-  describe('Account Service', () => {
-    let service: AccountService;
+describe('Account Service', () => {
+  let service: AccountService;
 <%_ if (!skipUserManagement) { _%>
-    let applicationConfigService: ApplicationConfigService;
+  let applicationConfigService: ApplicationConfigService;
 <%_ } _%>
-    let httpMock: HttpTestingController;
-    let mockStorageService: StateStorageService;
-    let mockRouter: Router;
+  let httpMock: HttpTestingController;
+  let mockStorageService: StateStorageService;
+  let mockRouter: Router;
 <%_ if (communicationSpringWebsocket) { _%>
-    let mockTrackerService: TrackerService;
+  let mockTrackerService: TrackerService;
 <%_ } _%>
 <%_ if (enableTranslation) { _%>
-    let mockTranslateService: TranslateService;
-    let sessionStorageService: SessionStorageService;
+  let mockTranslateService: TranslateService;
+  let sessionStorageService: SessionStorageService;
 <%_ } _%>
 
-    beforeEach(() => {
-      TestBed.configureTestingModule({
-        imports: [HttpClientTestingModule, NgxWebstorageModule.forRoot()],
-        providers: [
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule, NgxWebstorageModule.forRoot()],
+      providers: [
 <%_ if (enableTranslation) { _%>
-          TranslateService,
+        TranslateService,
 <%_ } _%>
 <%_ if (communicationSpringWebsocket) { _%>
-          TrackerService,
+        TrackerService,
 <%_ } _%>
-          StateStorageService,
-          Router,
-        ],
-      });
+        StateStorageService,
+        Router,
+      ],
+    });
 
-      service = TestBed.inject(AccountService);
+    service = TestBed.inject(AccountService);
 <%_ if (!skipUserManagement) { _%>
-      applicationConfigService = TestBed.inject(ApplicationConfigService);
+    applicationConfigService = TestBed.inject(ApplicationConfigService);
 <%_ } _%>
-      httpMock = TestBed.inject(HttpTestingController);
-      mockStorageService = TestBed.inject(StateStorageService);
-      mockRouter = TestBed.inject(Router);
+    httpMock = TestBed.inject(HttpTestingController);
+    mockStorageService = TestBed.inject(StateStorageService);
+    mockRouter = TestBed.inject(Router);
 <%_ if (communicationSpringWebsocket) { _%>
-      mockTrackerService = TestBed.inject(TrackerService);
+    mockTrackerService = TestBed.inject(TrackerService);
 <%_ } _%>
 <%_ if (enableTranslation) { _%>
-      mockTranslateService = TestBed.inject(TranslateService);
-      sessionStorageService = TestBed.inject(SessionStorageService);
+    mockTranslateService = TestBed.inject(TranslateService);
+    sessionStorageService = TestBed.inject(SessionStorageService);
 <%_ } _%>
-    });
+  });
 
-    afterEach(() => {
-      httpMock.verify();
-    });
+  afterEach(() => {
+    httpMock.verify();
+  });
 
 <%_ if (!skipUserManagement) { _%>
-  describe('save', () => {
-    it('should call account saving endpoint with correct values', () => {
+describe('save', () => {
+  it('should call account saving endpoint with correct values', () => {
+    // GIVEN
+    const account = accountWithAuthorities([]);
+
+    // WHEN
+    service.save(account).subscribe();
+    const testRequest = httpMock.expectOne({ method: 'POST', url: applicationConfigService.getEndpointFor('api/account') });
+    testRequest.flush({});
+
+    // THEN
+    expect(testRequest.request.body).toEqual(account);
+  });
+});
+
+<%_ } _%>
+  describe('authenticate', () => {
+    it('authenticationState should emit null if input is null', () => {
       // GIVEN
-      const account = accountWithAuthorities([]);
+      let userIdentity: Account | null = accountWithAuthorities([]);
+      service.getAuthenticationState().subscribe(account => (userIdentity = account));
 
       // WHEN
-      service.save(account).subscribe();
-      const testRequest = httpMock.expectOne({ method: 'POST', url: applicationConfigService.getEndpointFor('api/account') });
-      testRequest.flush({});
+      service.authenticate(null);
 
       // THEN
-      expect(testRequest.request.body).toEqual(account);
+      expect(userIdentity).toBeNull();
+      expect(service.isAuthenticated()).toBe(false);
+<%_ if (communicationSpringWebsocket) { _%>
+      expect(mockTrackerService.disconnect).toHaveBeenCalled();
+      expect(mockTrackerService.connect).not.toHaveBeenCalled();
+<%_ } _%>
     });
-  });
 
+    it('authenticationState should emit the same account as was in input parameter', () => {
+      // GIVEN
+      const expectedResult = accountWithAuthorities([]);
+      let userIdentity: Account | null = null;
+      service.getAuthenticationState().subscribe(account => (userIdentity = account));
+
+      // WHEN
+      service.authenticate(expectedResult);
+
+      // THEN
+      expect(userIdentity).toEqual(expectedResult);
+      expect(service.isAuthenticated()).toBe(true);
+<%_ if (communicationSpringWebsocket) { _%>
+      expect(mockTrackerService.connect).toHaveBeenCalled();
+      expect(mockTrackerService.disconnect).not.toHaveBeenCalled();
 <%_ } _%>
-    describe('authenticate', () => {
-      it('authenticationState should emit null if input is null', () => {
+    });
+  });
+
+  describe('identity', () => {
+    it('should call /account only once if last call have not returned', () => {
+      // When I call
+      service.identity().subscribe();
+      // Once more
+      service.identity().subscribe();
+      // Then there is only request
+      httpMock.expectOne({ method: 'GET' });
+    });
+
+    it('should call /account only once if not logged out after first authentication and should call /account again if user has logged out', () => {
+      // Given the user is authenticated
+      service.identity().subscribe();
+      httpMock.expectOne({ method: 'GET' }).flush({});
+
+      // When I call
+      service.identity().subscribe();
+
+      // Then there is no second request
+      httpMock.expectNone({ method: 'GET' });
+
+      // When I log out
+      service.authenticate(null);
+      // and then call
+      service.identity().subscribe();
+
+      // Then there is a new request
+      httpMock.expectOne({ method: 'GET' });
+    });
+
+<%_ if (enableTranslation) { _%>
+    describe('should change the language on authentication if necessary', () => {
+      it('should change language if user has not changed language manually', () => {
         // GIVEN
-        let userIdentity: Account | null = accountWithAuthorities([]);
-        service.getAuthenticationState().subscribe(account => (userIdentity = account));
+        sessionStorageService.retrieve = jest.fn(key => (key === 'locale' ? undefined : 'otherSessionStorageValue'));
 
         // WHEN
-        service.authenticate(null);
+        service.identity().subscribe();
+        httpMock.expectOne({ method: 'GET' }).flush({ ...accountWithAuthorities([]), langKey: 'accountLang' });
 
         // THEN
-        expect(userIdentity).toBeNull();
-        expect(service.isAuthenticated()).toBe(false);
-<%_ if (communicationSpringWebsocket) { _%>
-        expect(mockTrackerService.disconnect).toHaveBeenCalled();
-        expect(mockTrackerService.connect).not.toHaveBeenCalled();
-<%_ } _%>
+        expect(mockTranslateService.use).toHaveBeenCalledWith('accountLang');
       });
 
-      it('authenticationState should emit the same account as was in input parameter', () => {
+      it('should not change language if user has changed language manually', () => {
         // GIVEN
-        const expectedResult = accountWithAuthorities([]);
-        let userIdentity: Account | null = null;
-        service.getAuthenticationState().subscribe(account => (userIdentity = account));
+        sessionStorageService.retrieve = jest.fn(key => (key === 'locale' ? 'sessionLang' : undefined));
 
         // WHEN
-        service.authenticate(expectedResult);
+        service.identity().subscribe();
+        httpMock.expectOne({ method: 'GET' }).flush({ ...accountWithAuthorities([]), langKey: 'accountLang' });
 
         // THEN
-        expect(userIdentity).toEqual(expectedResult);
-        expect(service.isAuthenticated()).toBe(true);
-<%_ if (communicationSpringWebsocket) { _%>
-        expect(mockTrackerService.connect).toHaveBeenCalled();
-        expect(mockTrackerService.disconnect).not.toHaveBeenCalled();
-<%_ } _%>
+        expect(mockTranslateService.use).not.toHaveBeenCalled();
       });
     });
 
-    describe('identity', () => {
-      it('should call /account only once if not logged out after first authentication and should call /account again if user has logged out', () => {
-        // Given the user is authenticated
-        service.identity().subscribe();
-        httpMock.expectOne({ method: 'GET' }).flush({});
+<%_ } _%>
+    describe('navigateToStoredUrl', () => {
+      it('should navigate to the previous stored url post successful authentication', () => {
+        // GIVEN
+        mockStorageService.getUrl = jest.fn(() => 'admin/users?page=0');
 
-        // When I call
+        // WHEN
         service.identity().subscribe();
+        httpMock.expectOne({ method: 'GET' }).flush({});
 
-        // Then there is no second request
-        httpMock.expectNone({ method: 'GET' });
+        // THEN
+        expect(mockStorageService.getUrl).toHaveBeenCalledTimes(1);
+        expect(mockStorageService.clearUrl).toHaveBeenCalledTimes(1);
+        expect(mockRouter.navigateByUrl).toHaveBeenCalledWith('admin/users?page=0');
+      });
 
-        // When I log out
-        service.authenticate(null);
-        // and then call
+      it('should not navigate to the previous stored url when authentication fails', () => {
+        // WHEN
         service.identity().subscribe();
+        httpMock.expectOne({ method: 'GET' }).error(new ErrorEvent(''));
 
-        // Then there is a new request
-        httpMock.expectOne({ method: 'GET' });
+        // THEN
+        expect(mockStorageService.getUrl).not.toHaveBeenCalled();
+        expect(mockStorageService.clearUrl).not.toHaveBeenCalled();
+        expect(mockRouter.navigateByUrl).not.toHaveBeenCalled();
       });
 
-<%_ if (enableTranslation) { _%>
-      describe('should change the language on authentication if necessary', () => {
-        it('should change language if user has not changed language manually', () => {
-          // GIVEN
-          sessionStorageService.retrieve = jest.fn(key => (key === 'locale' ? undefined : 'otherSessionStorageValue'));
-
-          // WHEN
-          service.identity().subscribe();
-          httpMock.expectOne({ method: 'GET' }).flush({ ...accountWithAuthorities([]), langKey: 'accountLang' });
-
-          // THEN
-          expect(mockTranslateService.use).toHaveBeenCalledWith('accountLang');
-        });
-
-        it('should not change language if user has changed language manually', () => {
-          // GIVEN
-          sessionStorageService.retrieve = jest.fn(key => (key === 'locale' ? 'sessionLang' : undefined));
-
-          // WHEN
-          service.identity().subscribe();
-          httpMock.expectOne({ method: 'GET' }).flush({ ...accountWithAuthorities([]), langKey: 'accountLang' });
-
-          // THEN
-          expect(mockTranslateService.use).not.toHaveBeenCalled();
-        });
-      });
+      it('should not navigate to the previous stored url when no such url exists post successful authentication', () => {
+        // GIVEN
+        mockStorageService.getUrl = jest.fn(() => null);
 
-<%_ } _%>
-      describe('navigateToStoredUrl', () => {
-        it('should navigate to the previous stored url post successful authentication', () => {
-          // GIVEN
-          mockStorageService.getUrl = jest.fn(() => 'admin/users?page=0');
-
-          // WHEN
-          service.identity().subscribe();
-          httpMock.expectOne({ method: 'GET' }).flush({});
-
-          // THEN
-          expect(mockStorageService.getUrl).toHaveBeenCalledTimes(1);
-          expect(mockStorageService.clearUrl).toHaveBeenCalledTimes(1);
-          expect(mockRouter.navigateByUrl).toHaveBeenCalledWith('admin/users?page=0');
-        });
-
-        it('should not navigate to the previous stored url when authentication fails', () => {
-          // WHEN
-          service.identity().subscribe();
-          httpMock.expectOne({ method: 'GET' }).error(new ErrorEvent(''));
-
-          // THEN
-          expect(mockStorageService.getUrl).not.toHaveBeenCalled();
-          expect(mockStorageService.clearUrl).not.toHaveBeenCalled();
-          expect(mockRouter.navigateByUrl).not.toHaveBeenCalled();
-        });
-
-        it('should not navigate to the previous stored url when no such url exists post successful authentication', () => {
-          // GIVEN
-          mockStorageService.getUrl = jest.fn(() => null);
-
-          // WHEN
-          service.identity().subscribe();
-          httpMock.expectOne({ method: 'GET' }).flush({});
-
-          // THEN
-          expect(mockStorageService.getUrl).toHaveBeenCalledTimes(1);
-          expect(mockStorageService.clearUrl).not.toHaveBeenCalled();
-          expect(mockRouter.navigateByUrl).not.toHaveBeenCalled();
-        });
+        // WHEN
+        service.identity().subscribe();
+        httpMock.expectOne({ method: 'GET' }).flush({});
+
+        // THEN
+        expect(mockStorageService.getUrl).toHaveBeenCalledTimes(1);
+        expect(mockStorageService.clearUrl).not.toHaveBeenCalled();
+        expect(mockRouter.navigateByUrl).not.toHaveBeenCalled();
       });
     });
+  });
 
-    describe('hasAnyAuthority', () => {
-      describe('hasAnyAuthority string parameter', () => {
-        it('should return false if user is not logged', () => {
-          const hasAuthority = service.hasAnyAuthority(Authority.USER);
-          expect(hasAuthority).toBe(false);
-        });
+  describe('hasAnyAuthority', () => {
+    describe('hasAnyAuthority string parameter', () => {
+      it('should return false if user is not logged', () => {
+        const hasAuthority = service.hasAnyAuthority(Authority.USER);
+        expect(hasAuthority).toBe(false);
+      });
 
-        it('should return false if user is logged and has not authority', () => {
-          service.authenticate(accountWithAuthorities([Authority.USER]));
+      it('should return false if user is logged and has not authority', () => {
+        service.authenticate(accountWithAuthorities([Authority.USER]));
 
-          const hasAuthority = service.hasAnyAuthority(Authority.ADMIN);
+        const hasAuthority = service.hasAnyAuthority(Authority.ADMIN);
 
-          expect(hasAuthority).toBe(false);
-        });
+        expect(hasAuthority).toBe(false);
+      });
 
-        it('should return true if user is logged and has authority', () => {
-          service.authenticate(accountWithAuthorities([Authority.USER]));
+      it('should return true if user is logged and has authority', () => {
+        service.authenticate(accountWithAuthorities([Authority.USER]));
 
-          const hasAuthority = service.hasAnyAuthority(Authority.USER);
+        const hasAuthority = service.hasAnyAuthority(Authority.USER);
 
-          expect(hasAuthority).toBe(true);
-        });
+        expect(hasAuthority).toBe(true);
       });
+    });
 
-      describe('hasAnyAuthority array parameter', () => {
-        it('should return false if user is not logged', () => {
-          const hasAuthority = service.hasAnyAuthority([Authority.USER]);
-          expect(hasAuthority).toBeFalsy();
-        });
+    describe('hasAnyAuthority array parameter', () => {
+      it('should return false if user is not logged', () => {
+        const hasAuthority = service.hasAnyAuthority([Authority.USER]);
+        expect(hasAuthority).toBeFalsy();
+      });
 
-        it('should return false if user is logged and has not authority', () => {
-          service.authenticate(accountWithAuthorities([Authority.USER]));
+      it('should return false if user is logged and has not authority', () => {
+        service.authenticate(accountWithAuthorities([Authority.USER]));
 
-          const hasAuthority = service.hasAnyAuthority([Authority.ADMIN]);
+        const hasAuthority = service.hasAnyAuthority([Authority.ADMIN]);
 
-          expect(hasAuthority).toBe(false);
-        });
+        expect(hasAuthority).toBe(false);
+      });
 
-        it('should return true if user is logged and has authority', () => {
-          service.authenticate(accountWithAuthorities([Authority.USER]));
+      it('should return true if user is logged and has authority', () => {
+        service.authenticate(accountWithAuthorities([Authority.USER]));
 
-          const hasAuthority = service.hasAnyAuthority([Authority.USER, Authority.ADMIN]);
+        const hasAuthority = service.hasAnyAuthority([Authority.USER, Authority.ADMIN]);
 
-          expect(hasAuthority).toBe(true);
-        });
+        expect(hasAuthority).toBe(true);
       });
     });
   });

package/generators/client/templates/angular/src/main/webapp/app/core/auth/account.service.ts.ejs

@@ -37,7 +37,7 @@ import { TrackerService } from '../tracker/tracker.service';
 export class AccountService {
   private userIdentity: Account | null = null;
   private authenticationState = new ReplaySubject<Account | null>(1);
-  private accountCache$?: Observable<Account | null>;
+  private accountCache$?: Observable<Account> | null;
 
   constructor(
 <%_ if (enableTranslation) { _%>
@@ -62,6 +62,9 @@ export class AccountService {
   authenticate(identity: Account | null): void {
     this.userIdentity = identity;
     this.authenticationState.next(this.userIdentity);
+    if (!identity) {
+      this.accountCache$ = null;
+    }
 <%_ if (communicationSpringWebsocket) { _%>
     if (identity) {
       this.trackerService.connect();
@@ -82,29 +85,26 @@ export class AccountService {
   }
 
   identity(force?: boolean): Observable<Account | null> {
-    if (!this.accountCache$ || force || !this.isAuthenticated()) {
+    if (!this.accountCache$ || force) {
       this.accountCache$ = this.fetch().pipe(
-        catchError(() => of(null)),
-        tap((account: Account | null) => {
+        tap((account: Account) => {
           this.authenticate(account);
 
 <%_ if (enableTranslation) { _%>
           // After retrieve the account info, the language will be changed to
           // the user's preferred language configured in the account setting
           // unless user have choosed other language in the current session
-          if (!this.sessionStorageService.retrieve('locale') && account) {
+          if (!this.sessionStorageService.retrieve('locale')) {
             this.translateService.use(account.langKey);
           }
 <%_ } _%>
 
-          if (account) {
-            this.navigateToStoredUrl();
-          }
+          this.navigateToStoredUrl();
         }),
         shareReplay()
       );
     }
-    return this.accountCache$;
+    return this.accountCache$.pipe(catchError(() => of(null)));
   }
 
   isAuthenticated(): boolean {

package/generators/client/templates/angular/src/main/webapp/app/core/config/application-config.service.ts.ejs

@@ -23,11 +23,20 @@ import { Injectable } from '@angular/core';
 })
 export class ApplicationConfigService {
   private endpointPrefix = '';
+  private microfrontend = false;
 
   setEndpointPrefix(endpointPrefix: string): void {
     this.endpointPrefix = endpointPrefix;
   }
 
+  setMicrofrontend(microfrontend = true): void {
+    this.microfrontend = microfrontend;
+  }
+
+  isMicrofrontend(): boolean {
+    return this.microfrontend;
+  }
+
   getEndpointFor(api: string, microservice?: string): string {
     if (microservice) {
       return `${this.endpointPrefix}services/${microservice}/${api}`;

package/generators/client/templates/angular/src/main/webapp/app/core/util/data-util.service.spec.ts.ejs

@@ -41,11 +41,12 @@ describe('Data Utils Service Test', () => {
       const newWindow = { ...window };
       newWindow.document.write = jest.fn();
       window.open = jest.fn(() => newWindow);
+      window.URL.createObjectURL = jest.fn();
       // 'JHipster' in base64 is 'SkhpcHN0ZXI='
       const data = 'SkhpcHN0ZXI=';
       const contentType = 'text/plain';
       service.openFile(data, contentType);
-      expect(newWindow.document.write).toHaveBeenCalledWith(expect.stringContaining('src="data:text/plain;base64,SkhpcHN0ZXI="'));
+      expect(window.open).toHaveBeenCalledTimes(1);
     });
   });
 });

package/generators/client/templates/angular/src/main/webapp/app/core/util/data-util.service.ts.ejs

@@ -47,28 +47,20 @@ export class DataUtils {
    */
   openFile(data: string, contentType: string | null | undefined): void {
     contentType = contentType ?? '';
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    if (window.navigator.msSaveOrOpenBlob) {
-      // To support IE
-      const byteCharacters = atob(data);
-      const byteNumbers = new Array(byteCharacters.length);
-      for (let i = 0; i < byteCharacters.length; i++) {
-        byteNumbers[i] = byteCharacters.charCodeAt(i);
-      }
-      const byteArray = new Uint8Array(byteNumbers);
-      const blob = new Blob([byteArray], {
-        type: contentType,
-      });
-      window.navigator.msSaveOrOpenBlob(blob);
-    } else {
-      // Other browsers
-      const fileURL = `data:${contentType};base64,${data}`;
-      const win = window.open();
-      win?.document.write(
-        '<iframe src="' +
-          fileURL +
-          '" frameborder="0" style="border:0; top:0; left:0; bottom:0; right:0; width:100%; height:100%;" allowfullscreen></iframe>'
-      );
+    
+    const byteCharacters = atob(data);
+    const byteNumbers = new Array(byteCharacters.length);
+    for (let i = 0; i < byteCharacters.length; i++) {
+      byteNumbers[i] = byteCharacters.charCodeAt(i);
+    }
+    const byteArray = new Uint8Array(byteNumbers);
+    const blob = new Blob([byteArray], {
+      type: contentType,
+    });
+    const fileURL = window.URL.createObjectURL(blob);
+    const win = window.open(fileURL);
+    win!.onload = function() {
+        URL.revokeObjectURL(fileURL);
     }
   }