generator-jhipster 7.2.0 → 7.3.0

package/generators/client/templates/angular/src/main/webapp/app/admin/user-management/service/user-management.service.spec.ts.ejs

@@ -30,65 +30,63 @@ import { User } from '../user-management.model';
 
 import { UserManagementService } from './user-management.service';
 
-describe('Service Tests', () => {
-  describe('User Service', () => {
-    let service: UserManagementService;
-    let httpMock: HttpTestingController;
-
-    beforeEach(() => {
-      TestBed.configureTestingModule({
-        imports: [HttpClientTestingModule],
-      });
+describe('User Service', () => {
+  let service: UserManagementService;
+  let httpMock: HttpTestingController;
 
-      service = TestBed.inject(UserManagementService);
-      httpMock = TestBed.inject(HttpTestingController);
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule],
     });
 
-    afterEach(() => {
-      httpMock.verify();
-    });
+    service = TestBed.inject(UserManagementService);
+    httpMock = TestBed.inject(HttpTestingController);
+  });
 
-    describe('Service methods', () => {
-      it('should return User', () => {
-        let expectedResult: string | undefined;
+  afterEach(() => {
+    httpMock.verify();
+  });
 
-        service.find('user').subscribe(received => {
-          expectedResult = received.login;
-        });
+  describe('Service methods', () => {
+    it('should return User', () => {
+      let expectedResult: string | undefined;
 
-        const req = httpMock.expectOne({ method: 'GET' });
-        req.flush(new User(<%- tsKeyId %>, 'user'));
-        expect(expectedResult).toEqual('user');
+      service.find('user').subscribe(received => {
+        expectedResult = received.login;
       });
 
-<%_ if (databaseTypeSql || databaseTypeMongodb || databaseTypeCouchbase) { _%>
-      it('should return Authorities', () => {
-        let expectedResult: string[] = [];
+      const req = httpMock.expectOne({ method: 'GET' });
+      req.flush(new User(<%- tsKeyId %>, 'user'));
+      expect(expectedResult).toEqual('user');
+    });
 
-        service.authorities().subscribe(authorities => {
-          expectedResult = authorities;
-        });
-        const req = httpMock.expectOne({ method: 'GET' });
+<%_ if (databaseTypeSql || databaseTypeMongodb || databaseTypeCouchbase) { _%>
+    it('should return Authorities', () => {
+      let expectedResult: string[] = [];
 
-        req.flush([Authority.USER, Authority.ADMIN]);
-        expect(expectedResult).toEqual([Authority.USER, Authority.ADMIN]);
+      service.authorities().subscribe(authorities => {
+        expectedResult = authorities;
       });
+      const req = httpMock.expectOne({ method: 'GET' });
+
+      req.flush([Authority.USER, Authority.ADMIN]);
+      expect(expectedResult).toEqual([Authority.USER, Authority.ADMIN]);
+    });
 <%_ } _%>
 
-      it('should propagate not found response', () => {
-        let expectedResult = 0;
+    it('should propagate not found response', () => {
+      let expectedResult = 0;
 
-        service.find('user').subscribe({
-          error: (error: HttpErrorResponse) => expectedResult = error.status
-        });
+      service.find('user').subscribe({
+        error: (error: HttpErrorResponse) => expectedResult = error.status
+      });
 
-        const req = httpMock.expectOne({ method: 'GET' });
-        req.flush('Invalid request parameters', {
-          status: 404,
-          statusText: 'Bad Request',
-        });
-        expect(expectedResult).toEqual(404);
+      const req = httpMock.expectOne({ method: 'GET' });
+      req.flush('Invalid request parameters', {
+        status: 404,
+        statusText: 'Bad Request',
       });
+      expect(expectedResult).toEqual(404);
     });
   });
 });

package/generators/client/templates/angular/src/main/webapp/app/app.module.ts.ejs

@@ -113,6 +113,9 @@ import { ErrorComponent } from './layouts/error/error.component';
 })
 export class AppModule {
   constructor(applicationConfigService: ApplicationConfigService, iconLibrary: FaIconLibrary, dpConfig: NgbDatepickerConfig<% if (enableTranslation) { %>, translateService: TranslateService, sessionStorageService: SessionStorageService<% } %>) {
+<%_ if (applicationTypeMicroservice) { _%>
+    applicationConfigService.setMicrofrontend();
+<%_ } _%>
     applicationConfigService.setEndpointPrefix(SERVER_API_URL);
     registerLocaleData(locale);
     iconLibrary.addIcons(...fontAwesomeIcons);

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

@@ -58,257 +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 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' });
-      });
+<%_ } _%>
+    describe('navigateToStoredUrl', () => {
+      it('should navigate to the previous stored url post successful authentication', () => {
+        // GIVEN
+        mockStorageService.getUrl = jest.fn(() => 'admin/users?page=0');
 
-      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
+        // WHEN
         service.identity().subscribe();
         httpMock.expectOne({ method: 'GET' }).flush({});
 
-        // When I call
-        service.identity().subscribe();
-
-        // 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/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}`;