generator-jhipster 7.2.0 → 7.4.1

package/generators/client/templates/angular/src/main/webapp/app/account/password-reset/init/password-reset-init.component.spec.ts.ejs

@@ -25,59 +25,57 @@ import { of, throwError } from 'rxjs';
 import { PasswordResetInitComponent } from './password-reset-init.component';
 import { PasswordResetInitService } from './password-reset-init.service';
 
-describe('Component Tests', () => {
-  describe('PasswordResetInitComponent', () => {
-    let fixture: ComponentFixture<PasswordResetInitComponent>;
-    let comp: PasswordResetInitComponent;
+describe('PasswordResetInitComponent', () => {
+  let fixture: ComponentFixture<PasswordResetInitComponent>;
+  let comp: PasswordResetInitComponent;
 
-    beforeEach(() => {
-      fixture = TestBed.configureTestingModule({
-        imports: [HttpClientTestingModule],
-        declarations: [PasswordResetInitComponent],
-        providers: [FormBuilder],
-      })
-        .overrideTemplate(PasswordResetInitComponent, '')
-        .createComponent(PasswordResetInitComponent);
-      comp = fixture.componentInstance;
-    });
+  beforeEach(() => {
+    fixture = TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule],
+      declarations: [PasswordResetInitComponent],
+      providers: [FormBuilder],
+    })
+      .overrideTemplate(PasswordResetInitComponent, '')
+      .createComponent(PasswordResetInitComponent);
+    comp = fixture.componentInstance;
+  });
 
-    it('sets focus after the view has been initialized', () => {
-      const node = {
-        focus: jest.fn(),
-      };
-      comp.email = new ElementRef(node);
+  it('sets focus after the view has been initialized', () => {
+    const node = {
+      focus: jest.fn(),
+    };
+    comp.email = new ElementRef(node);
 
-      comp.ngAfterViewInit();
+    comp.ngAfterViewInit();
 
-      expect(node.focus).toHaveBeenCalled();
-    });
+    expect(node.focus).toHaveBeenCalled();
+  });
 
-    it('notifies of success upon successful requestReset', inject([PasswordResetInitService], (service: PasswordResetInitService) => {
-      jest.spyOn(service, 'save').mockReturnValue(of({}));
-      comp.resetRequestForm.patchValue({
-        email: 'user@domain.com',
-      });
+  it('notifies of success upon successful requestReset', inject([PasswordResetInitService], (service: PasswordResetInitService) => {
+    jest.spyOn(service, 'save').mockReturnValue(of({}));
+    comp.resetRequestForm.patchValue({
+      email: 'user@domain.com',
+    });
 
-      comp.requestReset();
+    comp.requestReset();
 
-      expect(service.save).toHaveBeenCalledWith('user@domain.com');
-      expect(comp.success).toBe(true);
-    }));
+    expect(service.save).toHaveBeenCalledWith('user@domain.com');
+    expect(comp.success).toBe(true);
+  }));
 
-    it('no notification of success upon error response', inject([PasswordResetInitService], (service: PasswordResetInitService) => {
-      jest.spyOn(service, 'save').mockReturnValue(
-        throwError({
-          status: 503,
-          data: 'something else',
-        })
-      );
-      comp.resetRequestForm.patchValue({
-        email: 'user@domain.com',
-      });
-      comp.requestReset();
+  it('no notification of success upon error response', inject([PasswordResetInitService], (service: PasswordResetInitService) => {
+    jest.spyOn(service, 'save').mockReturnValue(
+      throwError({
+        status: 503,
+        data: 'something else',
+      })
+    );
+    comp.resetRequestForm.patchValue({
+      email: 'user@domain.com',
+    });
+    comp.requestReset();
 
-      expect(service.save).toHaveBeenCalledWith('user@domain.com');
-      expect(comp.success).toBe(false);
-    }));
-  });
+    expect(service.save).toHaveBeenCalledWith('user@domain.com');
+    expect(comp.success).toBe(false);
+  }));
 });

package/generators/client/templates/angular/src/main/webapp/app/account/password-reset/init/password-reset-init.service.spec.ts.ejs

@@ -0,0 +1,61 @@
+<%#
+ Copyright 2013-2021 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+import { TestBed } from '@angular/core/testing';
+import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
+
+import { PasswordResetInitService } from './password-reset-init.service';
+import { ApplicationConfigService } from 'app/core/config/application-config.service';
+
+describe('PasswordResetInit Service', () => {
+  let service: PasswordResetInitService;
+  let httpMock: HttpTestingController;
+  let applicationConfigService: ApplicationConfigService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule],
+    });
+
+    service = TestBed.inject(PasswordResetInitService);
+    applicationConfigService = TestBed.inject(ApplicationConfigService);
+    httpMock = TestBed.inject(HttpTestingController);
+  });
+
+  afterEach(() => {
+    httpMock.verify();
+  });
+
+  describe('Service methods', () => {
+    it('should call reset-password/init endpoint with correct values', () => {
+      // GIVEN
+      const mail = 'test@test.com';
+
+      // WHEN
+      service.save(mail).subscribe();
+
+      const testRequest = httpMock.expectOne({
+        method: 'POST',
+        url: applicationConfigService.getEndpointFor('api/account/reset-password/init'),
+      });
+
+      // THEN
+      expect(testRequest.request.body).toEqual(mail);
+    });
+  });
+});

package/generators/client/templates/angular/src/main/webapp/app/account/register/register.component.spec.ts.ejs

@@ -33,133 +33,131 @@ import { EMAIL_ALREADY_USED_TYPE, LOGIN_ALREADY_USED_TYPE } from 'app/config/err
 import { RegisterService } from './register.service';
 import { RegisterComponent } from './register.component';
 
-describe('Component Tests', () => {
-  describe('RegisterComponent', () => {
-    let fixture: ComponentFixture<RegisterComponent>;
-    let comp: RegisterComponent;
-
-    beforeEach(
-      waitForAsync(() => {
-        TestBed.configureTestingModule({
-          imports: [HttpClientTestingModule],
-          declarations: [RegisterComponent],
-          providers: [FormBuilder<% if (enableTranslation) { %>, TranslateService<% } %>],
-        })
-          .overrideTemplate(RegisterComponent, '')
-          .compileComponents();
+describe('RegisterComponent', () => {
+  let fixture: ComponentFixture<RegisterComponent>;
+  let comp: RegisterComponent;
+
+  beforeEach(
+    waitForAsync(() => {
+      TestBed.configureTestingModule({
+        imports: [HttpClientTestingModule],
+        declarations: [RegisterComponent],
+        providers: [FormBuilder<% if (enableTranslation) { %>, TranslateService<% } %>],
       })
-    );
+        .overrideTemplate(RegisterComponent, '')
+        .compileComponents();
+    })
+  );
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(RegisterComponent);
+    comp = fixture.componentInstance;
+  });
 
-    beforeEach(() => {
-      fixture = TestBed.createComponent(RegisterComponent);
-      comp = fixture.componentInstance;
+  it('should ensure the two passwords entered match', () => {
+    comp.registerForm.patchValue({
+      password: 'password',
+      confirmPassword: 'non-matching',
     });
 
-    it('should ensure the two passwords entered match', () => {
+    comp.register();
+
+    expect(comp.doNotMatch).toBe(true);
+  });
+
+  it('should update success to true after creating an account', inject(
+    [RegisterService<% if (enableTranslation) { %>, TranslateService<% } %>],
+    fakeAsync((service: RegisterService<% if (enableTranslation) { %>, mockLanguageService: TranslateService<% } %>) => {
+      jest.spyOn(service, 'save').mockReturnValue(of({}));
+<%_ if (enableTranslation) { _%>
+      mockLanguageService.currentLang = '<%= nativeLanguage %>';
+<%_ } _%>
       comp.registerForm.patchValue({
         password: 'password',
-        confirmPassword: 'non-matching',
+        confirmPassword: 'password',
       });
 
       comp.register();
+      tick();
 
-      expect(comp.doNotMatch).toBe(true);
-    });
+      expect(service.save).toHaveBeenCalledWith({
+        email: '',
+        password: 'password',
+        login: '',
+        langKey: '<%= nativeLanguage %>',
+      });
+      expect(comp.success).toBe(true);
+      expect(comp.errorUserExists).toBe(false);
+      expect(comp.errorEmailExists).toBe(false);
+      expect(comp.error).toBe(false);
+    })
+  ));
+
+  it('should notify of user existence upon 400/login already in use', inject(
+    [RegisterService],
+    fakeAsync((service: RegisterService) => {
+      jest.spyOn(service, 'save').mockReturnValue(
+        throwError({
+          status: 400,
+          error: { type: LOGIN_ALREADY_USED_TYPE },
+        })
+      );
+      comp.registerForm.patchValue({
+        password: 'password',
+        confirmPassword: 'password',
+      });
 
-    it('should update success to true after creating an account', inject(
-      [RegisterService<% if (enableTranslation) { %>, TranslateService<% } %>],
-      fakeAsync((service: RegisterService<% if (enableTranslation) { %>, mockLanguageService: TranslateService<% } %>) => {
-        jest.spyOn(service, 'save').mockReturnValue(of({}));
-        <%_ if (enableTranslation) { _%>
-        mockLanguageService.currentLang = '<%= nativeLanguage %>';
-        <%_ } _%>
-        comp.registerForm.patchValue({
-          password: 'password',
-          confirmPassword: 'password',
-        });
-
-        comp.register();
-        tick();
-
-        expect(service.save).toHaveBeenCalledWith({
-          email: '',
-          password: 'password',
-          login: '',
-          langKey: '<%= nativeLanguage %>',
-        });
-        expect(comp.success).toBe(true);
-        expect(comp.errorUserExists).toBe(false);
-        expect(comp.errorEmailExists).toBe(false);
-        expect(comp.error).toBe(false);
-      })
-    ));
-
-    it('should notify of user existence upon 400/login already in use', inject(
-      [RegisterService],
-      fakeAsync((service: RegisterService) => {
-        jest.spyOn(service, 'save').mockReturnValue(
-          throwError({
-            status: 400,
-            error: { type: LOGIN_ALREADY_USED_TYPE },
-          })
-        );
-        comp.registerForm.patchValue({
-          password: 'password',
-          confirmPassword: 'password',
-        });
-
-        comp.register();
-        tick();
-
-        expect(comp.errorUserExists).toBe(true);
-        expect(comp.errorEmailExists).toBe(false);
-        expect(comp.error).toBe(false);
-      })
-    ));
-
-    it('should notify of email existence upon 400/email address already in use', inject(
-      [RegisterService],
-      fakeAsync((service: RegisterService) => {
-        jest.spyOn(service, 'save').mockReturnValue(
-          throwError({
-            status: 400,
-            error: { type: EMAIL_ALREADY_USED_TYPE },
-          })
-        );
-        comp.registerForm.patchValue({
-          password: 'password',
-          confirmPassword: 'password',
-        });
-
-        comp.register();
-        tick();
-
-        expect(comp.errorEmailExists).toBe(true);
-        expect(comp.errorUserExists).toBe(false);
-        expect(comp.error).toBe(false);
-      })
-    ));
-
-    it('should notify of generic error', inject(
-      [RegisterService],
-      fakeAsync((service: RegisterService) => {
-        jest.spyOn(service, 'save').mockReturnValue(
-          throwError({
-            status: 503,
-          })
-        );
-        comp.registerForm.patchValue({
-          password: 'password',
-          confirmPassword: 'password',
-        });
-
-        comp.register();
-        tick();
-
-        expect(comp.errorUserExists).toBe(false);
-        expect(comp.errorEmailExists).toBe(false);
-        expect(comp.error).toBe(true);
-      })
-    ));
-  });
+      comp.register();
+      tick();
+
+      expect(comp.errorUserExists).toBe(true);
+      expect(comp.errorEmailExists).toBe(false);
+      expect(comp.error).toBe(false);
+    })
+  ));
+
+  it('should notify of email existence upon 400/email address already in use', inject(
+    [RegisterService],
+    fakeAsync((service: RegisterService) => {
+      jest.spyOn(service, 'save').mockReturnValue(
+        throwError({
+          status: 400,
+          error: { type: EMAIL_ALREADY_USED_TYPE },
+        })
+      );
+      comp.registerForm.patchValue({
+        password: 'password',
+        confirmPassword: 'password',
+      });
+
+      comp.register();
+      tick();
+
+      expect(comp.errorEmailExists).toBe(true);
+      expect(comp.errorUserExists).toBe(false);
+      expect(comp.error).toBe(false);
+    })
+  ));
+
+  it('should notify of generic error', inject(
+    [RegisterService],
+    fakeAsync((service: RegisterService) => {
+      jest.spyOn(service, 'save').mockReturnValue(
+        throwError({
+          status: 503,
+        })
+      );
+      comp.registerForm.patchValue({
+        password: 'password',
+        confirmPassword: 'password',
+      });
+
+      comp.register();
+      tick();
+
+      expect(comp.errorUserExists).toBe(false);
+      expect(comp.errorEmailExists).toBe(false);
+      expect(comp.error).toBe(true);
+    })
+  ));
 });

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

@@ -0,0 +1,66 @@
+<%#
+ Copyright 2013-2021 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+import { TestBed } from '@angular/core/testing';
+import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
+
+import { RegisterService } from './register.service';
+import { ApplicationConfigService } from 'app/core/config/application-config.service';
+import { Registration } from './register.model';
+
+describe('RegisterService Service', () => {
+  let service: RegisterService;
+  let httpMock: HttpTestingController;
+  let applicationConfigService: ApplicationConfigService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule],
+    });
+
+    service = TestBed.inject(RegisterService);
+    applicationConfigService = TestBed.inject(ApplicationConfigService);
+    httpMock = TestBed.inject(HttpTestingController);
+  });
+
+  afterEach(() => {
+    httpMock.verify();
+  });
+
+  describe('Service methods', () => {
+    it('should call register endpoint with correct values', () => {
+      // GIVEN
+      const login = 'abc';
+      const email = 'test@test.com';
+      const password = 'pass';
+      const langKey = 'FR';
+      const registration = new Registration(login, email, password, langKey);
+
+      // WHEN
+      service.save(registration).subscribe();
+
+      const testRequest = httpMock.expectOne({
+        method: 'POST',
+        url: applicationConfigService.getEndpointFor('api/register'),
+      });
+
+      // THEN
+      expect(testRequest.request.body).toEqual({ email, langKey, login, password });
+    });
+  });
+});

package/generators/client/templates/angular/src/main/webapp/app/account/sessions/sessions.component.spec.ts.ejs

@@ -29,7 +29,7 @@ import { Session } from './session.model';
 import { SessionsComponent } from './sessions.component';
 import { SessionsService } from './sessions.service';
 
-describe('Component Tests', () => {
+describe('SessionsComponent', () => {
   let fixture: ComponentFixture<SessionsComponent>;
   let comp: SessionsComponent;
   const sessions: Session[] = [new Session('xxxxxx==', new Date(2015, 10, 15), '0:0:0:0:0:0:0:1', 'Mozilla/5.0')];
@@ -44,81 +44,79 @@ describe('Component Tests', () => {
     imageUrl: '',
   };
 
-  describe('SessionsComponent', () => {
-    beforeEach(() => {
-      fixture = TestBed.configureTestingModule({
-        imports: [HttpClientTestingModule],
-        declarations: [SessionsComponent],
-        providers: [AccountService],
-      })
-        .overrideTemplate(SessionsComponent, '')
-        .createComponent(SessionsComponent);
-      comp = fixture.componentInstance;
-    });
-
-    it('should define its initial state', inject(
-      [AccountService, SessionsService],
-      fakeAsync((mockAccountService: AccountService, service: SessionsService) => {
-        mockAccountService.identity = jest.fn(() => of(account));
-        jest.spyOn(service, 'findAll').mockReturnValue(of(sessions));
-
-        comp.ngOnInit();
-        tick();
-
-        expect(mockAccountService.identity).toHaveBeenCalled();
-        expect(service.findAll).toHaveBeenCalled();
-        expect(comp.success).toBe(false);
-        expect(comp.error).toBe(false);
-        expect(comp.account).toEqual(account);
-        expect(comp.sessions).toEqual(sessions);
-      })
-    ));
-
-    it('should call delete on Sessions to invalidate a session', inject(
-      [AccountService, SessionsService],
-      fakeAsync((mockAccountService: AccountService, service: SessionsService) => {
-        mockAccountService.identity = jest.fn(() => of(account));
-        jest.spyOn(service, 'findAll').mockReturnValue(of(sessions));
-        jest.spyOn(service, 'delete').mockReturnValue(of({}));
-
-        comp.ngOnInit();
-        comp.invalidate('xyz');
-        tick();
-
-        expect(service.delete).toHaveBeenCalledWith('xyz');
-      })
-    ));
-
-    it('should call delete on Sessions and notify of error', inject(
-      [AccountService, SessionsService],
-      fakeAsync((mockAccountService: AccountService, service: SessionsService) => {
-        mockAccountService.identity = jest.fn(() => of(account));
-        jest.spyOn(service, 'findAll').mockReturnValue(of(sessions));
-        jest.spyOn(service, 'delete').mockReturnValue(throwError({}));
-
-        comp.ngOnInit();
-        comp.invalidate('xyz');
-        tick();
-
-        expect(comp.success).toBe(false);
-        expect(comp.error).toBe(true);
-      })
-    ));
-
-    it('should call notify of success upon session invalidation', inject(
-      [AccountService, SessionsService],
-      fakeAsync((mockAccountService: AccountService, service: SessionsService) => {
-        mockAccountService.identity = jest.fn(() => of(account));
-        jest.spyOn(service, 'findAll').mockReturnValue(of(sessions));
-        jest.spyOn(service, 'delete').mockReturnValue(of({}));
-
-        comp.ngOnInit();
-        comp.invalidate('xyz');
-        tick();
-
-        expect(comp.error).toBe(false);
-        expect(comp.success).toBe(true);
-      })
-    ));
+  beforeEach(() => {
+    fixture = TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule],
+      declarations: [SessionsComponent],
+      providers: [AccountService],
+    })
+      .overrideTemplate(SessionsComponent, '')
+      .createComponent(SessionsComponent);
+    comp = fixture.componentInstance;
   });
+
+  it('should define its initial state', inject(
+    [AccountService, SessionsService],
+    fakeAsync((mockAccountService: AccountService, service: SessionsService) => {
+      mockAccountService.identity = jest.fn(() => of(account));
+      jest.spyOn(service, 'findAll').mockReturnValue(of(sessions));
+
+      comp.ngOnInit();
+      tick();
+
+      expect(mockAccountService.identity).toHaveBeenCalled();
+      expect(service.findAll).toHaveBeenCalled();
+      expect(comp.success).toBe(false);
+      expect(comp.error).toBe(false);
+      expect(comp.account).toEqual(account);
+      expect(comp.sessions).toEqual(sessions);
+    })
+  ));
+
+  it('should call delete on Sessions to invalidate a session', inject(
+    [AccountService, SessionsService],
+    fakeAsync((mockAccountService: AccountService, service: SessionsService) => {
+      mockAccountService.identity = jest.fn(() => of(account));
+      jest.spyOn(service, 'findAll').mockReturnValue(of(sessions));
+      jest.spyOn(service, 'delete').mockReturnValue(of({}));
+
+      comp.ngOnInit();
+      comp.invalidate('xyz');
+      tick();
+
+      expect(service.delete).toHaveBeenCalledWith('xyz');
+    })
+  ));
+
+  it('should call delete on Sessions and notify of error', inject(
+    [AccountService, SessionsService],
+    fakeAsync((mockAccountService: AccountService, service: SessionsService) => {
+      mockAccountService.identity = jest.fn(() => of(account));
+      jest.spyOn(service, 'findAll').mockReturnValue(of(sessions));
+      jest.spyOn(service, 'delete').mockReturnValue(throwError({}));
+
+      comp.ngOnInit();
+      comp.invalidate('xyz');
+      tick();
+
+      expect(comp.success).toBe(false);
+      expect(comp.error).toBe(true);
+    })
+  ));
+
+  it('should call notify of success upon session invalidation', inject(
+    [AccountService, SessionsService],
+    fakeAsync((mockAccountService: AccountService, service: SessionsService) => {
+      mockAccountService.identity = jest.fn(() => of(account));
+      jest.spyOn(service, 'findAll').mockReturnValue(of(sessions));
+      jest.spyOn(service, 'delete').mockReturnValue(of({}));
+
+      comp.ngOnInit();
+      comp.invalidate('xyz');
+      tick();
+
+      expect(comp.error).toBe(false);
+      expect(comp.success).toBe(true);
+    })
+  ));
 });