generator-jhipster 7.3.0 → 7.5.0

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

@@ -16,16 +16,12 @@
  See the License for the specific language governing permissions and
  limitations under the License.
 -%>
-<%_ if (enableTranslation) { _%>
-jest.mock('@ngx-translate/core');
-<%_ } _%>
-
 import { ComponentFixture, TestBed, waitForAsync, inject, tick, fakeAsync } from '@angular/core/testing';
 import { HttpClientTestingModule } from '@angular/common/http/testing';
 import { FormBuilder } from '@angular/forms';
 import { of, throwError } from 'rxjs';
 <%_ if (enableTranslation) { _%>
-import { TranslateService } from '@ngx-translate/core';
+import { TranslateModule, TranslateService } from '@ngx-translate/core';
 <%_ } _%>
 
 import { EMAIL_ALREADY_USED_TYPE, LOGIN_ALREADY_USED_TYPE } from 'app/config/error.constants';
@@ -33,133 +29,136 @@ 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: [
+<%_ if (enableTranslation) { _%>
+          TranslateModule.forRoot(),
+<%_ } _%>
+          HttpClientTestingModule
+        ],
+        declarations: [RegisterComponent],
+        providers: [FormBuilder],
       })
-    );
+        .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) { %>, mockTranslateService: TranslateService<% } %>) => {
+      jest.spyOn(service, 'save').mockReturnValue(of({}));
+<%_ if (enableTranslation) { _%>
+      mockTranslateService.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.component.ts.ejs

@@ -75,7 +75,7 @@ export class RegisterComponent implements AfterViewInit {
       const email = this.registerForm.get(['email'])!.value;
       this.registerService
         .save({ login, email, password, langKey: <% if (enableTranslation) { %>this.translateService.currentLang<% } else { %>'en'<% } %> })
-        .subscribe(() => (this.success = true), response => this.processError(response));
+        .subscribe({ next: () => (this.success = true), error: response => this.processError(response)});
     }
   }
 

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);
+    })
+  ));
 });