generator-jhipster 7.2.0 → 7.4.1

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}`;

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

@@ -29,105 +29,103 @@ import { User, IUser } from './user.model';
 
 import { UserService } from './user.service';
 
-describe('Service Tests', () => {
-  describe('User Service', () => {
-    let service: UserService;
-    let httpMock: HttpTestingController;
-    let expectedResult: IUser | IUser[] | boolean | number | null;
-
-    beforeEach(() => {
-      TestBed.configureTestingModule({
-        imports: [HttpClientTestingModule],
+describe('User Service', () => {
+  let service: UserService;
+  let httpMock: HttpTestingController;
+  let expectedResult: IUser | IUser[] | boolean | number | null;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule],
+    });
+    expectedResult = null;
+    service = TestBed.inject(UserService);
+    httpMock = TestBed.inject(HttpTestingController);
+  });
+
+  afterEach(() => {
+    httpMock.verify();
+  });
+
+  describe('Service methods', () => {
+    it('should return Users', () => {
+      service.query().subscribe(received => {
+        expectedResult = received.body;
       });
-      expectedResult = null;
-      service = TestBed.inject(UserService);
-      httpMock = TestBed.inject(HttpTestingController);
+
+      const req = httpMock.expectOne({ method: 'GET' });
+      req.flush([new User(<%- tsKeyId %>, 'user')]);
+      expect(expectedResult).toEqual([{ id: <%- tsKeyId %>, login: 'user' }]);
     });
 
-    afterEach(() => {
-      httpMock.verify();
+    it('should propagate not found response', () => {
+      service.query().subscribe({
+        error: (error: HttpErrorResponse) => expectedResult = error.status
+      });
+
+      const req = httpMock.expectOne({ method: 'GET' });
+      req.flush('Internal Server Error', {
+        status: 500,
+        statusText: 'Inernal Server Error',
+      });
+      expect(expectedResult).toEqual(500);
     });
 
-    describe('Service methods', () => {
-      it('should return Users', () => {
-        service.query().subscribe(received => {
-          expectedResult = received.body;
-        });
+    describe('addUserToCollectionIfMissing', () => {
+      it('should add a User to an empty array', () => {
+        const user: IUser = <%- testEntityPrimaryKey0 %>;
+        expectedResult = service.addUserToCollectionIfMissing([], user);
+        expect(expectedResult).toHaveLength(1);
+        expect(expectedResult).toContain(user);
+      });
+
+      it('should not add a User to an array that contains it', () => {
+        const user: IUser = <%- testEntityPrimaryKey0 %>;
+        const userCollection: IUser[] = [
+          {
+            ...user,
+          },
+          <%- testEntityPrimaryKey1 %>,
+        ];
+        expectedResult = service.addUserToCollectionIfMissing(userCollection, user);
+        expect(expectedResult).toHaveLength(2);
+      });
+
+      it("should add a User to an array that doesn't contain it", () => {
+        const user: IUser = <%- testEntityPrimaryKey0 %>;
+        const userCollection: IUser[] = [<%- testEntityPrimaryKey1 %>];
+        expectedResult = service.addUserToCollectionIfMissing(userCollection, user);
+        expect(expectedResult).toHaveLength(2);
+        expect(expectedResult).toContain(user);
+      });
+
+      it('should add only unique User to an array', () => {
+        const userArray: IUser[] = [<%- testEntityPrimaryKey0 %>, <%- testEntityPrimaryKey1 %>, <%- generateTestEntityPrimaryKey(user.primaryKey) %>];
+        const userCollection: IUser[] = [<%- testEntityPrimaryKey1 %>];
+        expectedResult = service.addUserToCollectionIfMissing(userCollection, ...userArray);
+        expect(expectedResult).toHaveLength(3);
+      });
 
-        const req = httpMock.expectOne({ method: 'GET' });
-        req.flush([new User(<%- tsKeyId %>, 'user')]);
-        expect(expectedResult).toEqual([{ id: <%- tsKeyId %>, login: 'user' }]);
+      it("should accept varargs", () => {
+        const user: IUser = <%- testEntityPrimaryKey0 %>;
+        const user2: IUser = <%- testEntityPrimaryKey1 %>;
+        expectedResult = service.addUserToCollectionIfMissing([], user, user2);
+        expect(expectedResult).toHaveLength(2);
+        expect(expectedResult).toContain(user);
+        expect(expectedResult).toContain(user2);
       });
 
-      it('should propagate not found response', () => {
-        service.query().subscribe({
-          error: (error: HttpErrorResponse) => expectedResult = error.status
-        });
-
-        const req = httpMock.expectOne({ method: 'GET' });
-        req.flush('Internal Server Error', {
-          status: 500,
-          statusText: 'Inernal Server Error',
-        });
-        expect(expectedResult).toEqual(500);
+      it("should accept null and undefined values", () => {
+        const user: IUser = <%- testEntityPrimaryKey0 %>;
+        expectedResult = service.addUserToCollectionIfMissing([], null, user, undefined);
+        expect(expectedResult).toHaveLength(1);
+        expect(expectedResult).toContain(user);
       });
 
-      describe('addUserToCollectionIfMissing', () => {
-        it('should add a User to an empty array', () => {
-          const user: IUser = <%- testEntityPrimaryKey0 %>;
-          expectedResult = service.addUserToCollectionIfMissing([], user);
-          expect(expectedResult).toHaveLength(1);
-          expect(expectedResult).toContain(user);
-        });
-
-        it('should not add a User to an array that contains it', () => {
-          const user: IUser = <%- testEntityPrimaryKey0 %>;
-          const userCollection: IUser[] = [
-            {
-              ...user,
-            },
-            <%- testEntityPrimaryKey1 %>,
-          ];
-          expectedResult = service.addUserToCollectionIfMissing(userCollection, user);
-          expect(expectedResult).toHaveLength(2);
-        });
-
-        it("should add a User to an array that doesn't contain it", () => {
-          const user: IUser = <%- testEntityPrimaryKey0 %>;
-          const userCollection: IUser[] = [<%- testEntityPrimaryKey1 %>];
-          expectedResult = service.addUserToCollectionIfMissing(userCollection, user);
-          expect(expectedResult).toHaveLength(2);
-          expect(expectedResult).toContain(user);
-        });
-
-        it('should add only unique User to an array', () => {
-          const userArray: IUser[] = [<%- testEntityPrimaryKey0 %>, <%- testEntityPrimaryKey1 %>, <%- generateTestEntityPrimaryKey(user.primaryKey) %>];
-          const userCollection: IUser[] = [<%- testEntityPrimaryKey1 %>];
-          expectedResult = service.addUserToCollectionIfMissing(userCollection, ...userArray);
-          expect(expectedResult).toHaveLength(3);
-        });
-
-        it("should accept varargs", () => {
-          const user: IUser = <%- testEntityPrimaryKey0 %>;
-          const user2: IUser = <%- testEntityPrimaryKey1 %>;
-          expectedResult = service.addUserToCollectionIfMissing([], user, user2);
-          expect(expectedResult).toHaveLength(2);
-          expect(expectedResult).toContain(user);
-          expect(expectedResult).toContain(user2);
-        });
-
-        it("should accept null and undefined values", () => {
-          const user: IUser = <%- testEntityPrimaryKey0 %>;
-          expectedResult = service.addUserToCollectionIfMissing([], null, user, undefined);
-          expect(expectedResult).toHaveLength(1);
-          expect(expectedResult).toContain(user);
-        });
-
-        it('should return initial array if no users is added', () => {
-          const userCollection: IUser[] = [<%- testEntityPrimaryKey1 %>];
-          expectedResult = service.addUserToCollectionIfMissing(userCollection, null, undefined);
-          expect(expectedResult).toEqual(userCollection);
-        });
+      it('should return initial array if no users is added', () => {
+        const userCollection: IUser[] = [<%- testEntityPrimaryKey1 %>];
+        expectedResult = service.addUserToCollectionIfMissing(userCollection, null, undefined);
+        expect(expectedResult).toEqual(userCollection);
       });
     });
   });