generator-jhipster 7.3.0 → 7.5.0

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

@@ -24,68 +24,66 @@ import { of, throwError } from 'rxjs';
 import { ActivateService } from './activate.service';
 import { ActivateComponent } from './activate.component';
 
-describe('Component Tests', () => {
-  describe('ActivateComponent', () => {
-    let comp: ActivateComponent;
-
-    beforeEach(
-      waitForAsync(() => {
-        TestBed.configureTestingModule({
-          imports: [HttpClientTestingModule],
-          declarations: [ActivateComponent],
-          providers: [
-            {
-              provide: ActivatedRoute,
-              useValue: { queryParams: of({ key: 'ABC123' }) },
-            },
-          ],
-        })
-          .overrideTemplate(ActivateComponent, '')
-          .compileComponents();
+describe('ActivateComponent', () => {
+  let comp: ActivateComponent;
+
+  beforeEach(
+    waitForAsync(() => {
+      TestBed.configureTestingModule({
+        imports: [HttpClientTestingModule],
+        declarations: [ActivateComponent],
+        providers: [
+          {
+            provide: ActivatedRoute,
+            useValue: { queryParams: of({ key: 'ABC123' }) },
+          },
+        ],
       })
-    );
-
-    beforeEach(() => {
-      const fixture = TestBed.createComponent(ActivateComponent);
-      comp = fixture.componentInstance;
-    });
+        .overrideTemplate(ActivateComponent, '')
+        .compileComponents();
+    })
+  );
+
+  beforeEach(() => {
+    const fixture = TestBed.createComponent(ActivateComponent);
+    comp = fixture.componentInstance;
+  });
 
-    it('calls activate.get with the key from params', inject(
-      [ActivateService],
-      fakeAsync((service: ActivateService) => {
-        jest.spyOn(service, 'get').mockReturnValue(of());
+  it('calls activate.get with the key from params', inject(
+    [ActivateService],
+    fakeAsync((service: ActivateService) => {
+      jest.spyOn(service, 'get').mockReturnValue(of());
 
-        comp.ngOnInit();
-        tick();
+      comp.ngOnInit();
+      tick();
 
-        expect(service.get).toHaveBeenCalledWith('ABC123');
-      })
-    ));
+      expect(service.get).toHaveBeenCalledWith('ABC123');
+    })
+  ));
 
-    it('should set set success to true upon successful activation', inject(
-      [ActivateService],
-      fakeAsync((service: ActivateService) => {
-        jest.spyOn(service, 'get').mockReturnValue(of({}));
+  it('should set set success to true upon successful activation', inject(
+    [ActivateService],
+    fakeAsync((service: ActivateService) => {
+      jest.spyOn(service, 'get').mockReturnValue(of({}));
 
-        comp.ngOnInit();
-        tick();
+      comp.ngOnInit();
+      tick();
 
-        expect(comp.error).toBe(false);
-        expect(comp.success).toBe(true);
-      })
-    ));
+      expect(comp.error).toBe(false);
+      expect(comp.success).toBe(true);
+    })
+  ));
 
-    it('should set set error to true upon activation failure', inject(
-      [ActivateService],
-      fakeAsync((service: ActivateService) => {
-        jest.spyOn(service, 'get').mockReturnValue(throwError('ERROR'));
+  it('should set set error to true upon activation failure', inject(
+    [ActivateService],
+    fakeAsync((service: ActivateService) => {
+      jest.spyOn(service, 'get').mockReturnValue(throwError('ERROR'));
 
-        comp.ngOnInit();
-        tick();
+      comp.ngOnInit();
+      tick();
 
-        expect(comp.error).toBe(true);
-        expect(comp.success).toBe(false);
-      })
-    ));
-  });
+      expect(comp.error).toBe(true);
+      expect(comp.success).toBe(false);
+    })
+  ));
 });

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

@@ -33,9 +33,9 @@ export class ActivateComponent implements OnInit {
   constructor(private activateService: ActivateService, private route: ActivatedRoute) {}
 
   ngOnInit(): void {
-    this.route.queryParams.pipe(mergeMap(params => this.activateService.get(params.key))).subscribe(
-      () => this.success = true,
-      () => this.error = true
-    );
+    this.route.queryParams.pipe(mergeMap(params => this.activateService.get(params.key))).subscribe({
+      next: () => this.success = true,
+      error: () => this.error = true
+    });
   }
 }

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

@@ -0,0 +1,65 @@
+<%#
+ 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 { ActivateService } from './activate.service';
+import { ApplicationConfigService } from 'app/core/config/application-config.service';
+
+describe('ActivateService Service', () => {
+  let service: ActivateService;
+  let httpMock: HttpTestingController;
+  let applicationConfigService: ApplicationConfigService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule],
+    });
+
+    service = TestBed.inject(ActivateService);
+    applicationConfigService = TestBed.inject(ApplicationConfigService);
+    httpMock = TestBed.inject(HttpTestingController);
+  });
+
+  afterEach(() => {
+    httpMock.verify();
+  });
+
+  describe('Service methods', () => {
+    it('should call api/activate endpoint with correct values', () => {
+      // GIVEN
+      let expectedResult;
+      const key = 'key';
+      const value = true;
+
+      // WHEN
+      service.get(key).subscribe(received => {
+        expectedResult = received;
+      });
+      const testRequest = httpMock.expectOne({
+        method: 'GET',
+        url: applicationConfigService.getEndpointFor(`api/activate?key=${key}`),
+      });
+      testRequest.flush(value);
+
+      // THEN
+      expect(expectedResult).toEqual(value);
+    });
+  });
+});

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

@@ -20,49 +20,47 @@ import { ComponentFixture, TestBed, waitForAsync } from '@angular/core/testing';
 
 import { PasswordStrengthBarComponent } from './password-strength-bar.component';
 
-describe('Component Tests', () => {
-  describe('PasswordStrengthBarComponent', () => {
-    let comp: PasswordStrengthBarComponent;
-    let fixture: ComponentFixture<PasswordStrengthBarComponent>;
+describe('PasswordStrengthBarComponent', () => {
+  let comp: PasswordStrengthBarComponent;
+  let fixture: ComponentFixture<PasswordStrengthBarComponent>;
 
-    beforeEach(
-      waitForAsync(() => {
-        TestBed.configureTestingModule({
-          declarations: [PasswordStrengthBarComponent],
-        })
-          .overrideTemplate(PasswordStrengthBarComponent, '')
-          .compileComponents();
+  beforeEach(
+    waitForAsync(() => {
+      TestBed.configureTestingModule({
+        declarations: [PasswordStrengthBarComponent],
       })
-    );
+        .overrideTemplate(PasswordStrengthBarComponent, '')
+        .compileComponents();
+    })
+  );
 
-    beforeEach(() => {
-      fixture = TestBed.createComponent(PasswordStrengthBarComponent);
-      comp = fixture.componentInstance;
-    });
+  beforeEach(() => {
+    fixture = TestBed.createComponent(PasswordStrengthBarComponent);
+    comp = fixture.componentInstance;
+  });
 
-    describe('PasswordStrengthBarComponents', () => {
-      it('should initialize with default values', () => {
-        expect(comp.measureStrength('')).toBe(0);
-        expect(comp.colors).toEqual(['#F00', '#F90', '#FF0', '#9F0', '#0F0']);
-        expect(comp.getColor(0).idx).toBe(1);
-        expect(comp.getColor(0).color).toBe(comp.colors[0]);
-      });
+  describe('PasswordStrengthBarComponents', () => {
+    it('should initialize with default values', () => {
+      expect(comp.measureStrength('')).toBe(0);
+      expect(comp.colors).toEqual(['#F00', '#F90', '#FF0', '#9F0', '#0F0']);
+      expect(comp.getColor(0).idx).toBe(1);
+      expect(comp.getColor(0).color).toBe(comp.colors[0]);
+    });
 
-      it('should increase strength upon password value change', () => {
-        expect(comp.measureStrength('')).toBe(0);
-        expect(comp.measureStrength('aa')).toBeGreaterThanOrEqual(comp.measureStrength(''));
-        expect(comp.measureStrength('aa^6')).toBeGreaterThanOrEqual(comp.measureStrength('aa'));
-        expect(comp.measureStrength('Aa090(**)')).toBeGreaterThanOrEqual(comp.measureStrength('aa^6'));
-        expect(comp.measureStrength('Aa090(**)+-07365')).toBeGreaterThanOrEqual(comp.measureStrength('Aa090(**)'));
-      });
+    it('should increase strength upon password value change', () => {
+      expect(comp.measureStrength('')).toBe(0);
+      expect(comp.measureStrength('aa')).toBeGreaterThanOrEqual(comp.measureStrength(''));
+      expect(comp.measureStrength('aa^6')).toBeGreaterThanOrEqual(comp.measureStrength('aa'));
+      expect(comp.measureStrength('Aa090(**)')).toBeGreaterThanOrEqual(comp.measureStrength('aa^6'));
+      expect(comp.measureStrength('Aa090(**)+-07365')).toBeGreaterThanOrEqual(comp.measureStrength('Aa090(**)'));
+    });
 
-      it('should change the color based on strength', () => {
-        expect(comp.getColor(0).color).toBe(comp.colors[0]);
-        expect(comp.getColor(11).color).toBe(comp.colors[1]);
-        expect(comp.getColor(22).color).toBe(comp.colors[2]);
-        expect(comp.getColor(33).color).toBe(comp.colors[3]);
-        expect(comp.getColor(44).color).toBe(comp.colors[4]);
-      });
+    it('should change the color based on strength', () => {
+      expect(comp.getColor(0).color).toBe(comp.colors[0]);
+      expect(comp.getColor(11).color).toBe(comp.colors[1]);
+      expect(comp.getColor(22).color).toBe(comp.colors[2]);
+      expect(comp.getColor(33).color).toBe(comp.colors[3]);
+      expect(comp.getColor(44).color).toBe(comp.colors[4]);
     });
   });
 });

package/generators/client/templates/angular/src/main/webapp/app/account/password/password-strength-bar/password-strength-bar.component.ts.ejs

@@ -33,7 +33,7 @@ export class PasswordStrengthBarComponent {
     const regex = /[$-/:-?{-~!"^_`[\]]/g; // "
     const lowerLetters = /[a-z]+/.test(p);
     const upperLetters = /[A-Z]+/.test(p);
-    const numbers = /[0-9]+/.test(p);
+    const numbers = /\d+/.test(p);
     const symbols = regex.test(p);
 
     const flags = [lowerLetters, upperLetters, numbers, symbols];

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

@@ -29,98 +29,96 @@ import { AccountService } from 'app/core/auth/account.service';
 import { PasswordComponent } from './password.component';
 import { PasswordService } from './password.service';
 
-describe('Component Tests', () => {
-  describe('PasswordComponent', () => {
-    let comp: PasswordComponent;
-    let fixture: ComponentFixture<PasswordComponent>;
-    let service: PasswordService;
-
-    beforeEach(
-      waitForAsync(() => {
-        TestBed.configureTestingModule({
-          imports: [HttpClientTestingModule],
-          declarations: [PasswordComponent],
-          providers: [FormBuilder, AccountService],
-        })
-          .overrideTemplate(PasswordComponent, '')
-          .compileComponents();
+describe('PasswordComponent', () => {
+  let comp: PasswordComponent;
+  let fixture: ComponentFixture<PasswordComponent>;
+  let service: PasswordService;
+
+  beforeEach(
+    waitForAsync(() => {
+      TestBed.configureTestingModule({
+        imports: [HttpClientTestingModule],
+        declarations: [PasswordComponent],
+        providers: [FormBuilder, AccountService],
       })
-    );
+        .overrideTemplate(PasswordComponent, '')
+        .compileComponents();
+    })
+  );
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(PasswordComponent);
+    comp = fixture.componentInstance;
+    service = TestBed.inject(PasswordService);
+  });
 
-    beforeEach(() => {
-      fixture = TestBed.createComponent(PasswordComponent);
-      comp = fixture.componentInstance;
-      service = TestBed.inject(PasswordService);
+  it('should show error if passwords do not match', () => {
+    // GIVEN
+    comp.passwordForm.patchValue({
+      newPassword: 'password1',
+      confirmPassword: 'password2',
     });
+    // WHEN
+    comp.changePassword();
+    // THEN
+    expect(comp.doNotMatch).toBe(true);
+    expect(comp.error).toBe(false);
+    expect(comp.success).toBe(false);
+  });
 
-    it('should show error if passwords do not match', () => {
-      // GIVEN
-      comp.passwordForm.patchValue({
-        newPassword: 'password1',
-        confirmPassword: 'password2',
-      });
-      // WHEN
-      comp.changePassword();
-      // THEN
-      expect(comp.doNotMatch).toBe(true);
-      expect(comp.error).toBe(false);
-      expect(comp.success).toBe(false);
-    });
+  it('should call Auth.changePassword when passwords match', () => {
+    // GIVEN
+    const passwordValues = {
+      currentPassword: 'oldPassword',
+      newPassword: 'myPassword',
+    };
 
-    it('should call Auth.changePassword when passwords match', () => {
-      // GIVEN
-      const passwordValues = {
-        currentPassword: 'oldPassword',
-        newPassword: 'myPassword',
-      };
+    jest.spyOn(service, 'save').mockReturnValue(of(new HttpResponse({ body: true })));
 
-      jest.spyOn(service, 'save').mockReturnValue(of(new HttpResponse({ body: true })));
+    comp.passwordForm.patchValue({
+      currentPassword: passwordValues.currentPassword,
+      newPassword: passwordValues.newPassword,
+      confirmPassword: passwordValues.newPassword,
+    });
 
-      comp.passwordForm.patchValue({
-        currentPassword: passwordValues.currentPassword,
-        newPassword: passwordValues.newPassword,
-        confirmPassword: passwordValues.newPassword,
-      });
+    // WHEN
+    comp.changePassword();
 
-      // WHEN
-      comp.changePassword();
+    // THEN
+    expect(service.save).toHaveBeenCalledWith(passwordValues.newPassword, passwordValues.currentPassword);
+  });
 
-      // THEN
-      expect(service.save).toHaveBeenCalledWith(passwordValues.newPassword, passwordValues.currentPassword);
+  it('should set success to true upon success', () => {
+    // GIVEN
+    jest.spyOn(service, 'save').mockReturnValue(of(new HttpResponse({ body: true })));
+    comp.passwordForm.patchValue({
+      newPassword: 'myPassword',
+      confirmPassword: 'myPassword',
     });
 
-    it('should set success to true upon success', () => {
-      // GIVEN
-      jest.spyOn(service, 'save').mockReturnValue(of(new HttpResponse({ body: true })));
-      comp.passwordForm.patchValue({
-        newPassword: 'myPassword',
-        confirmPassword: 'myPassword',
-      });
-
-      // WHEN
-      comp.changePassword();
-
-      // THEN
-      expect(comp.doNotMatch).toBe(false);
-      expect(comp.error).toBe(false);
-      expect(comp.success).toBe(true);
-    });
+    // WHEN
+    comp.changePassword();
+
+    // THEN
+    expect(comp.doNotMatch).toBe(false);
+    expect(comp.error).toBe(false);
+    expect(comp.success).toBe(true);
+  });
 
-    it('should notify of error if change password fails', () => {
-      // GIVEN
-      jest.spyOn(service, 'save').mockReturnValue(throwError('ERROR'));
-      comp.passwordForm.patchValue({
-        newPassword: 'myPassword',
-        confirmPassword: 'myPassword',
-      });
-
-      // WHEN
-      comp.changePassword();
-
-      // THEN
-      expect(comp.doNotMatch).toBe(false);
-      expect(comp.success).toBe(false);
-      expect(comp.error).toBe(true);
+  it('should notify of error if change password fails', () => {
+    // GIVEN
+    jest.spyOn(service, 'save').mockReturnValue(throwError('ERROR'));
+    comp.passwordForm.patchValue({
+      newPassword: 'myPassword',
+      confirmPassword: 'myPassword',
     });
+
+    // WHEN
+    comp.changePassword();
+
+    // THEN
+    expect(comp.doNotMatch).toBe(false);
+    expect(comp.success).toBe(false);
+    expect(comp.error).toBe(true);
   });
 });

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

@@ -54,10 +54,10 @@ export class PasswordComponent implements OnInit {
     if (newPassword !== this.passwordForm.get(['confirmPassword'])!.value) {
       this.doNotMatch = true;
     } else {
-      this.passwordService.save(newPassword, this.passwordForm.get(['currentPassword'])!.value).subscribe(
-        () => this.success = true,
-        () => this.error = true
-      );
+      this.passwordService.save(newPassword, this.passwordForm.get(['currentPassword'])!.value).subscribe({
+        next: () => this.success = true,
+        error: () => this.error = true
+      });
     }
   }
 }

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

@@ -0,0 +1,41 @@
+import { TestBed } from '@angular/core/testing';
+import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
+
+import { PasswordService } from './password.service';
+import { ApplicationConfigService } from 'app/core/config/application-config.service';
+
+describe('Password Service', () => {
+  let service: PasswordService;
+  let httpMock: HttpTestingController;
+  let applicationConfigService: ApplicationConfigService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule],
+    });
+
+    service = TestBed.inject(PasswordService);
+    applicationConfigService = TestBed.inject(ApplicationConfigService);
+    httpMock = TestBed.inject(HttpTestingController);
+  });
+
+  afterEach(() => {
+    httpMock.verify();
+  });
+
+  describe('Service methods', () => {
+    it('should call change-password endpoint with correct values', () => {
+      // GIVEN
+      const password1 = 'password1';
+      const password2 = 'password2';
+
+      // WHEN
+      service.save(password2, password1).subscribe();
+
+      const testRequest = httpMock.expectOne({ method: 'POST', url: applicationConfigService.getEndpointFor('api/account/change-password') });
+
+      // THEN
+      expect(testRequest.request.body).toEqual({ currentPassword: password1, newPassword: password2 });
+    });
+  });
+});