generator-jhipster 7.2.0 → 7.4.1

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

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

@@ -26,93 +26,91 @@ import { of, throwError } from 'rxjs';
 import { PasswordResetFinishComponent } from './password-reset-finish.component';
 import { PasswordResetFinishService } from './password-reset-finish.service';
 
-describe('Component Tests', () => {
-  describe('PasswordResetFinishComponent', () => {
-    let fixture: ComponentFixture<PasswordResetFinishComponent>;
-    let comp: PasswordResetFinishComponent;
-
-    beforeEach(() => {
-      fixture = TestBed.configureTestingModule({
-        imports: [HttpClientTestingModule],
-        declarations: [PasswordResetFinishComponent],
-        providers: [
-          FormBuilder,
-          {
-            provide: ActivatedRoute,
-            useValue: { queryParams: of({ key: 'XYZPDQ' }) },
-          },
-        ],
-      })
-        .overrideTemplate(PasswordResetFinishComponent, '')
-        .createComponent(PasswordResetFinishComponent);
-    });
+describe('PasswordResetFinishComponent', () => {
+  let fixture: ComponentFixture<PasswordResetFinishComponent>;
+  let comp: PasswordResetFinishComponent;
+
+  beforeEach(() => {
+    fixture = TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule],
+      declarations: [PasswordResetFinishComponent],
+      providers: [
+        FormBuilder,
+        {
+          provide: ActivatedRoute,
+          useValue: { queryParams: of({ key: 'XYZPDQ' }) },
+        },
+      ],
+    })
+      .overrideTemplate(PasswordResetFinishComponent, '')
+      .createComponent(PasswordResetFinishComponent);
+  });
 
-    beforeEach(() => {
-      fixture = TestBed.createComponent(PasswordResetFinishComponent);
-      comp = fixture.componentInstance;
-      comp.ngOnInit();
-    });
+  beforeEach(() => {
+    fixture = TestBed.createComponent(PasswordResetFinishComponent);
+    comp = fixture.componentInstance;
+    comp.ngOnInit();
+  });
 
-    it('should define its initial state', () => {
-      expect(comp.initialized).toBe(true);
-      expect(comp.key).toEqual('XYZPDQ');
-    });
+  it('should define its initial state', () => {
+    expect(comp.initialized).toBe(true);
+    expect(comp.key).toEqual('XYZPDQ');
+  });
+
+  it('sets focus after the view has been initialized', () => {
+    const node = {
+      focus: jest.fn(),
+    };
+    comp.newPassword = new ElementRef(node);
 
-    it('sets focus after the view has been initialized', () => {
-      const node = {
-        focus: jest.fn(),
-      };
-      comp.newPassword = new ElementRef(node);
+    comp.ngAfterViewInit();
 
-      comp.ngAfterViewInit();
+    expect(node.focus).toHaveBeenCalled();
+  });
 
-      expect(node.focus).toHaveBeenCalled();
+  it('should ensure the two passwords entered match', () => {
+    comp.passwordForm.patchValue({
+      newPassword: 'password',
+      confirmPassword: 'non-matching',
     });
 
-    it('should ensure the two passwords entered match', () => {
+    comp.finishReset();
+
+    expect(comp.doNotMatch).toBe(true);
+  });
+
+  it('should update success to true after resetting password', inject(
+    [PasswordResetFinishService],
+    fakeAsync((service: PasswordResetFinishService) => {
+      jest.spyOn(service, 'save').mockReturnValue(of({}));
       comp.passwordForm.patchValue({
         newPassword: 'password',
-        confirmPassword: 'non-matching',
+        confirmPassword: 'password',
       });
 
       comp.finishReset();
+      tick();
 
-      expect(comp.doNotMatch).toBe(true);
-    });
+      expect(service.save).toHaveBeenCalledWith('XYZPDQ', 'password');
+      expect(comp.success).toBe(true);
+    })
+  ));
 
-    it('should update success to true after resetting password', inject(
-      [PasswordResetFinishService],
-      fakeAsync((service: PasswordResetFinishService) => {
-        jest.spyOn(service, 'save').mockReturnValue(of({}));
-        comp.passwordForm.patchValue({
-          newPassword: 'password',
-          confirmPassword: 'password',
-        });
-
-        comp.finishReset();
-        tick();
-
-        expect(service.save).toHaveBeenCalledWith('XYZPDQ', 'password');
-        expect(comp.success).toBe(true);
-      })
-    ));
-
-    it('should notify of generic error', inject(
-      [PasswordResetFinishService],
-      fakeAsync((service: PasswordResetFinishService) => {
-        jest.spyOn(service, 'save').mockReturnValue(throwError('ERROR'));
-        comp.passwordForm.patchValue({
-          newPassword: 'password',
-          confirmPassword: 'password',
-        });
-
-        comp.finishReset();
-        tick();
-
-        expect(service.save).toHaveBeenCalledWith('XYZPDQ', 'password');
-        expect(comp.success).toBe(false);
-        expect(comp.error).toBe(true);
-      })
-    ));
-  });
+  it('should notify of generic error', inject(
+    [PasswordResetFinishService],
+    fakeAsync((service: PasswordResetFinishService) => {
+      jest.spyOn(service, 'save').mockReturnValue(throwError('ERROR'));
+      comp.passwordForm.patchValue({
+        newPassword: 'password',
+        confirmPassword: 'password',
+      });
+
+      comp.finishReset();
+      tick();
+
+      expect(service.save).toHaveBeenCalledWith('XYZPDQ', 'password');
+      expect(comp.success).toBe(false);
+      expect(comp.error).toBe(true);
+    })
+  ));
 });

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

@@ -0,0 +1,62 @@
+<%#
+ 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 { PasswordResetFinishService } from './password-reset-finish.service';
+import { ApplicationConfigService } from 'app/core/config/application-config.service';
+
+describe('PasswordResetFinish Service', () => {
+  let service: PasswordResetFinishService;
+  let httpMock: HttpTestingController;
+  let applicationConfigService: ApplicationConfigService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule],
+    });
+
+    service = TestBed.inject(PasswordResetFinishService);
+    applicationConfigService = TestBed.inject(ApplicationConfigService);
+    httpMock = TestBed.inject(HttpTestingController);
+  });
+
+  afterEach(() => {
+    httpMock.verify();
+  });
+
+  describe('Service methods', () => {
+    it('should call reset-password/finish endpoint with correct values', () => {
+      // GIVEN
+      const key = 'abc';
+      const newPassword = 'password';
+
+      // WHEN
+      service.save(key, newPassword).subscribe();
+
+      const testRequest = httpMock.expectOne({
+        method: 'POST',
+        url: applicationConfigService.getEndpointFor('api/account/reset-password/finish'),
+      });
+
+      // THEN
+      expect(testRequest.request.body).toEqual({ key, newPassword });
+    });
+  });
+});