@mshima/generator-jhipster-nodejs 0.0.0-stage → 0.0.2

package/generators/node-server/templates/server/e2e/account.e2e-spec.ts.ejs

@@ -0,0 +1,349 @@
+import { afterEach, beforeEach, describe, expect, it, type MockInstance, vi } from 'vitest';
+import { Test, TestingModule } from '@nestjs/testing';
+import request from 'supertest';
+import { AppModule } from '../src/app.module.ts';
+import { configureApp } from '../src/app.config.ts';
+import { ExecutionContext, INestApplication } from '@nestjs/common';
+import { AuthGuard } from '../src/auth/guards/auth.guard.ts';
+import { RolesGuard } from '../src/auth/guards/roles.guard.ts';
+import { <%= user.dtoClass%> } from '../src/users/dto/user.dto.ts';
+import { UserService } from '../src/users/user.service.ts';
+import { PasswordChangeDTO } from '../src/auth/dto/password-change.dto.ts';
+import { AuthService } from '../src/auth/auth.service.ts';
+import { MailService } from '../src/mail/mail.service.ts';
+
+describe('Account', () => {
+    let app: INestApplication;
+    let service: UserService;
+    let authService: AuthService;
+    let sendActivationEmail: MockInstance<MailService['sendActivationEmail']>;
+    let sendPasswordResetMail: MockInstance<MailService['sendPasswordResetMail']>;
+
+    const testUserDTO: <%= user.dtoClass%> = {
+        login: 'userTestLogin',
+        email: 'usertest@localhost.it',
+        password: 'testPassword',
+    };
+
+    // Saved before each test, with the id the database gives it: the authenticated user of the requests.
+    const testUserAuthenticated: any = {
+        login: 'userlogged',
+        email: 'userlogged@localhost.it',
+        password: 'userloggedPassword',
+        activated: true
+    };
+
+    const testPasswordChange: PasswordChangeDTO = {
+        currentPassword: testUserAuthenticated.password,
+        newPassword: 'newPassword',
+    };
+
+    let userAuthenticated: <%= user.dtoClass%>;
+
+    const authGuardMock = { canActivate: (context: ExecutionContext): any => {
+        const req = context.switchToHttp().getRequest();
+        req.user = userAuthenticated;
+        return true;
+    },
+    };
+
+    const rolesGuardMock = { canActivate: (): any => true };
+
+
+    beforeEach(async () => {
+        const moduleFixture: TestingModule = await Test.createTestingModule({
+            imports: [AppModule],
+        })
+            .overrideGuard(AuthGuard)
+            .useValue(authGuardMock)
+            .overrideGuard(RolesGuard)
+            .useValue(rolesGuardMock)
+            .compile();
+
+        app = moduleFixture.createNestApplication();
+        configureApp(app);
+        await app.init();
+        service = moduleFixture.get<UserService>(UserService);
+        authService = moduleFixture.get<AuthService>(AuthService);
+        // The mails are not sent, the tests check the users they are for.
+        const mailService = moduleFixture.get<MailService>(MailService);
+        sendActivationEmail = vi.spyOn(mailService, 'sendActivationEmail').mockResolvedValue();
+        sendPasswordResetMail = vi.spyOn(mailService, 'sendPasswordResetMail').mockResolvedValue();
+        userAuthenticated = await service.save(testUserAuthenticated, testUserAuthenticated.login, true);
+    });
+
+    it('/POST register new user', async () => {
+        const createdUser: <%= user.dtoClass%> = (
+            await request(app.getHttpServer())
+                .post('/api/register')
+                .send({ ...testUserDTO, activated: true })
+                .expect(201)
+        ).body;
+
+        // Like JHipster Spring Boot, the login in lower case, and a user not activated whatever the request.
+        expect(createdUser.login).toEqual(testUserDTO.login.toLowerCase());
+        // The activation key goes by mail only.
+        expect(createdUser.activationKey).toBeUndefined();
+        const registeredUser = (await service.findByFields({ where: { login: testUserDTO.login.toLowerCase() } }))!;
+        expect(registeredUser.activated).toBe(false);
+        expect(registeredUser.activationKey).toBeTruthy();
+        expect(sendActivationEmail).toHaveBeenCalledWith(expect.objectContaining({ login: registeredUser.login, activationKey: registeredUser.activationKey }));
+        await service.delete(registeredUser);
+    });
+
+    it('/POST register with the login of a not activated user replaces it', async () => {
+        await request(app.getHttpServer()).post('/api/register').send(testUserDTO).expect(201);
+        await request(app.getHttpServer())
+            .post('/api/register')
+            .send({ ...testUserDTO, email: 'usertest2@localhost.it' })
+            .expect(201);
+
+        const registeredUser = (await service.findByFields({ where: { login: testUserDTO.login.toLowerCase() } }))!;
+        expect(registeredUser.email).toEqual('usertest2@localhost.it');
+        await service.delete(registeredUser);
+    });
+
+    it('/POST register with a too short password is a validation error, like the ManagedUserVM of JHipster Spring Boot', async () => {
+        const problem = (
+            await request(app.getHttpServer())
+                .post('/api/register')
+                .send({ ...testUserDTO, password: 'abc' })
+                .expect(400)
+        ).body;
+
+        expect(problem).toMatchObject({
+            type: 'https://www.jhipster.tech/problem/constraint-violation',
+            fieldErrors: [expect.objectContaining({ field: 'password' })],
+        });
+        expect(await service.findByFields({ where: { login: testUserDTO.login.toLowerCase() } })).toBeFalsy();
+    });
+
+    it('/POST register with a mail of a domain without a top level domain, like the seed users', async () => {
+        await request(app.getHttpServer())
+            .post('/api/register')
+            .send({ ...testUserDTO, email: 'usertest@localhost' })
+            .expect(201);
+        const registeredUser = (await service.findByFields({ where: { login: testUserDTO.login.toLowerCase() } }))!;
+        expect(registeredUser.email).toBe('usertest@localhost');
+        await service.delete(registeredUser);
+    });
+
+    it('/POST register with an invalid login or email is a validation error', async () => {
+        const problem = (
+            await request(app.getHttpServer())
+                .post('/api/register')
+                .send({ ...testUserDTO, login: 'user name!', email: 'not an email' })
+                .expect(400)
+        ).body;
+
+        expect(problem).toMatchObject({ type: 'https://www.jhipster.tech/problem/constraint-violation' });
+        expect(problem.fieldErrors.map(({ field }: { field: string }) => field).sort()).toEqual(['email', 'login']);
+    });
+
+    it('/POST register with the login of another user is a login already used problem', async () => {
+        const problem = (
+            await request(app.getHttpServer())
+                .post('/api/register')
+                .send({ ...testUserDTO, login: testUserAuthenticated.login })
+                .expect(400)
+        ).body;
+
+        // The type the registration page of the JHipster clients reads.
+        expect(problem).toMatchObject({ type: 'https://www.jhipster.tech/problem/login-already-used', message: 'error.userexists' });
+    });
+
+    it('/POST register with the email of another user is an email already used problem', async () => {
+        const problem = (
+            await request(app.getHttpServer())
+                .post('/api/register')
+                .send({ ...testUserDTO, email: testUserAuthenticated.email })
+                .expect(400)
+        ).body;
+
+        expect(problem).toMatchObject({ type: 'https://www.jhipster.tech/problem/email-already-used', message: 'error.emailexists' });
+    });
+
+    it('/GET activate account', async () => {
+        await request(app.getHttpServer()).post('/api/register').send(testUserDTO).expect(201);
+        const { activationKey } = (await service.findByFields({ where: { login: testUserDTO.login.toLowerCase() } }))!;
+
+        await request(app.getHttpServer())
+            .get('/api/activate')
+            .query({ key: activationKey })
+            .expect(200);
+
+        const activatedUser = (await service.findByFields({ where: { login: testUserDTO.login.toLowerCase() } }))!;
+        expect(activatedUser.activated).toBe(true);
+        expect(activatedUser.activationKey).toBeFalsy();
+        await service.delete(activatedUser);
+    });
+
+    it('/GET activate account with an unknown key', async () => {
+        await request(app.getHttpServer())
+            .get('/api/activate')
+            .query({ key: 'unknownKey' })
+            .expect(500);
+    });
+
+    it('/GET activate account without key', async () => {
+        await request(app.getHttpServer())
+            .get('/api/activate')
+            .expect(500);
+    });
+
+
+    it('/GET authenticate', async () => {
+        const loginValue: any = (await request(app.getHttpServer())
+            .get('/api/authenticate')
+            .expect(200)).text;
+
+        expect(loginValue).toEqual(testUserAuthenticated.login);
+    });
+
+    it('/GET account', async () => {
+
+        const loggedUser: any = JSON.parse(( await request(app.getHttpServer())
+            .get('/api/account')
+            .expect(200)).text);
+
+        expect(String(loggedUser.id)).toEqual(String(userAuthenticated.id));
+        expect(loggedUser.login).toEqual(userAuthenticated.login);
+        expect(loggedUser.email).toEqual(userAuthenticated.email);
+
+    });
+
+    it('/POST account update settings', async () => {
+
+        const savedTestUser: <%= user.dtoClass%> = {
+            firstName: 'updateFirstName',
+            lastName: 'updateLastName',
+            ...testUserAuthenticated,
+        };
+        await request(app.getHttpServer())
+            .post('/api/account')
+            .send(savedTestUser)
+            .expect(200);
+
+        const updatedUserSettings = await service.findByFields({ where: { login: testUserAuthenticated.login } });
+        expect(updatedUserSettings?.firstName).toEqual(savedTestUser.firstName);
+        expect(updatedUserSettings?.lastName).toEqual(savedTestUser.lastName);
+
+    });
+
+    it('/POST account update settings keeps the mail in lower case, like JHipster Spring Boot', async () => {
+        await request(app.getHttpServer())
+            .post('/api/account')
+            .send({ ...testUserAuthenticated, email: 'UserLogged@LocalHost.it' })
+            .expect(200);
+
+        const updatedUserSettings = await service.findByFields({ where: { login: testUserAuthenticated.login } });
+        expect(updatedUserSettings?.email).toEqual('userlogged@localhost.it');
+    });
+
+    it('/POST account update settings with the mail of another user in another case is an email already used problem', async () => {
+        const otherUser = await service.save({ login: 'otheruser', email: 'otheruser@localhost.it', password: 'otherPassword' });
+        const problem = (
+            await request(app.getHttpServer())
+                .post('/api/account')
+                .send({ ...testUserAuthenticated, email: 'OtherUser@localhost.it' })
+                .expect(400)
+        ).body;
+
+        expect(problem).toMatchObject({ type: 'https://www.jhipster.tech/problem/email-already-used' });
+        await service.delete(otherUser);
+    });
+
+    it('/POST change password with a too short new password is an invalid password problem, like JHipster Spring Boot', async () => {
+        const problem = (
+            await request(app.getHttpServer())
+                .post('/api/account/change-password')
+                .send({ currentPassword: testUserAuthenticated.password, newPassword: 'abc' })
+                .expect(400)
+        ).body;
+
+        expect(problem).toMatchObject({ type: 'https://www.jhipster.tech/problem/invalid-password' });
+    });
+
+    it<%- databaseTypeMongodb ? '.skip' : ''%>('/POST change password', async () => {
+        await request(app.getHttpServer())
+            .post('/api/account/change-password')
+            .send(testPasswordChange)
+            .expect(200);
+
+        const successFullyLoggedInWithNewPassword = await authService
+            .authenticate(testUserAuthenticated.login, testPasswordChange.newPassword)
+            .then(() => true, () => false);
+
+        expect(successFullyLoggedInWithNewPassword).toEqual(true);
+    });
+
+    it<%- databaseTypeMongodb ? '.skip' : ''%>('logs in with the login in another case', async () => {
+        const loggedIn = await authService
+            .authenticate(testUserAuthenticated.login.toUpperCase(), testUserAuthenticated.password)
+            .then(() => true, () => false);
+        expect(loggedIn).toEqual(true);
+    });
+
+    it<%- databaseTypeMongodb ? '.skip' : ''%>('/POST change password with a wrong current password is an invalid password problem', async () => {
+        const problem = (
+            await request(app.getHttpServer())
+                .post('/api/account/change-password')
+                .send({ ...testPasswordChange, currentPassword: 'wrongPassword' })
+                .expect(400)
+        ).body;
+
+        expect(problem).toMatchObject({ type: 'https://www.jhipster.tech/problem/invalid-password', title: 'Incorrect password' });
+    });
+
+    it('/POST reset password init and finish', async () => {
+        // The mail is a text/plain body, as the JHipster clients send it.
+        await request(app.getHttpServer())
+            .post('/api/account/reset-password/init')
+            .set('Content-Type', 'text/plain')
+            .send(testUserAuthenticated.email)
+            .expect(200);
+
+        const { resetKey } = (await service.findByFields({ where: { login: testUserAuthenticated.login } }))!;
+        expect(resetKey).toBeTruthy();
+        expect(sendPasswordResetMail).toHaveBeenCalledWith(expect.objectContaining({ login: testUserAuthenticated.login, resetKey }));
+
+        await request(app.getHttpServer())
+            .post('/api/account/reset-password/finish')
+            .send({ key: resetKey, newPassword: 'resetPassword' })
+            .expect(200);
+
+        expect((await service.findByFields({ where: { login: testUserAuthenticated.login } }))?.resetKey).toBeFalsy();
+        const loggedInWithNewPassword = await authService
+            .authenticate(testUserAuthenticated.login, 'resetPassword')
+            .then(() => true, () => false);
+        expect(loggedInWithNewPassword).toEqual(true);
+    });
+
+    it('/POST reset password init of an unknown mail answers 200 too', async () => {
+        await request(app.getHttpServer())
+            .post('/api/account/reset-password/init')
+            .set('Content-Type', 'text/plain')
+            .send('unknown@localhost.it')
+            .expect(200);
+        expect(sendPasswordResetMail).not.toHaveBeenCalled();
+    });
+
+    it('/POST reset password finish with an unknown key', async () => {
+        await request(app.getHttpServer())
+            .post('/api/account/reset-password/finish')
+            .send({ key: 'unknownKey', newPassword: 'resetPassword' })
+            .expect(500);
+    });
+
+    it('/POST reset password finish with a too short password is a validation error', async () => {
+        await request(app.getHttpServer())
+            .post('/api/account/reset-password/finish')
+            .send({ key: 'unknownKey', newPassword: 'a' })
+            .expect(400);
+    });
+
+    afterEach(async () => {
+        await service.delete(userAuthenticated);
+        await app?.close();
+    });
+});

package/generators/node-server/templates/server/e2e/app.e2e-spec.ts.ejs

@@ -0,0 +1,188 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { Test, TestingModule } from '@nestjs/testing';
+import request from 'supertest';
+import { AppModule } from '../src/app.module.ts';
+import { configureApp } from '../src/app.config.ts';
+import { INestApplication } from '@nestjs/common';
+<%_ if (authenticationType === 'jwt') { _%>
+import { JwtService } from '@nestjs/jwt';
+<%_ } _%>
+<%_ if (authenticationType === 'jwt' && generateUserManagement) { _%>
+import { UserLoginDTO } from '../src/auth/dto/user-login.dto.ts';
+<%_ } else if (authenticationType === 'jwt') { _%>
+import { ConfigService } from '@nestjs/config';
+import { JWT_ALGORITHM, jwtSecretKey } from '../src/auth/jwt.config.ts';
+<%_ } else if (authenticationType === 'oauth2' && generateBuiltInUserEntity) { _%>
+import { oidcUserOfClaims } from '../src/auth/oauth2.authorities.ts';
+import { AuthService } from '../src/auth/auth.service.ts';
+import { UserService } from '../src/users/user.service.ts';
+<%_ } _%>
+
+describe('App', () => {
+    let app: INestApplication;
+
+    // The test profile and the profiles of its group (application.yml).
+    const infoService = {
+        activeProfiles: ['test', 'secret-samples'],
+        'display-ribbon-on-profiles': 'dev',
+    };
+<%_  if (authenticationType === 'jwt' && generateUserManagement) { _%>
+    const testUserLogin: UserLoginDTO = {
+        username: 'admin',
+        password: 'admin',
+        rememberMe: true
+    };
+<%_ } else if (authenticationType === 'oauth2') { _%>
+
+    const testRequest: any = {};
+<%_ }_%>
+
+    beforeEach(async () => {
+        const moduleFixture: TestingModule = await Test.createTestingModule({
+            imports: [AppModule],
+        }).compile();
+
+        app = moduleFixture.createNestApplication();
+        configureApp(app);
+        await app.init();
+    });
+
+    it('/GET up running info OK', () => request(app.getHttpServer())
+        .get('/management/info')
+        .expect(200)
+        .expect(infoService));
+
+    it('/GET the headers of the responses, like JHipster Spring Boot', async () => {
+        const response = await request(app.getHttpServer())
+            .get('/management/info')
+            .expect(200)
+            .expect('Cache-Control', 'no-cache, no-store, max-age=0, must-revalidate')
+            .expect('Pragma', 'no-cache')
+            .expect('Expires', '0')
+            .expect('X-Content-Type-Options', 'nosniff')
+            .expect('X-XSS-Protection', '0')
+<%_ if (skipClient) { _%>
+            .expect('X-Frame-Options', 'DENY');
+<%_ } else { _%>
+            .expect('X-Frame-Options', 'SAMEORIGIN')
+            .expect('Referrer-Policy', 'strict-origin-when-cross-origin')
+            .expect('Content-Security-Policy', /^default-src 'self';/)
+            .expect('Permissions-Policy', /camera=\(\)/);
+<%_ } _%>
+        expect(response.headers['x-powered-by']).toBeUndefined();
+        // Only on HTTPS requests.
+        expect(response.headers['strict-transport-security']).toBeUndefined();
+    });
+
+    it('/GET the API is not cached whatever the case of its path, like Express routes it', () => request(app.getHttpServer())
+        .get('/MANAGEMENT/info')
+        .expect(200)
+        .expect('Cache-Control', 'no-cache, no-store, max-age=0, must-revalidate'));
+
+    it('/GET an unknown path of the API is not found, not the client', () => request(app.getHttpServer())
+        .get('/api/unknown-resource')
+        .expect(404));
+
+    it('/GET health is UP without authentication', () => request(app.getHttpServer())
+        .get('/management/health')
+        .expect(200)
+        .expect({ status: 'UP', components: { db: { status: 'UP' } } }));
+
+    it('/GET the liveness and readiness probes are UP without authentication', async () => {
+        await request(app.getHttpServer()).get('/management/health/liveness').expect(200).expect({ status: 'UP' });
+        await request(app.getHttpServer()).get('/management/health/readiness').expect(200).expect({ status: 'UP' });
+    });
+
+<%_ if (generateUserManagement) { _%>
+    it('/GET the authorities without authentication is unauthorized, like JHipster Spring Boot', () => request(app.getHttpServer())
+        .get('/api/authorities')
+        .expect(401));
+
+    it('/GET public users without authentication is unauthorized, like JHipster Spring Boot', () => request(app.getHttpServer())
+        .get('/api/users')
+        .expect(401));
+<%_ } _%>
+
+    <%_ if (authenticationType === 'jwt' && generateUserManagement) { _%>
+    it<%- databaseTypeMongodb ? '.skip' : ''%>('/POST authenticate get jwt authenticate OK', () => request(app.getHttpServer())
+        .post('/api/authenticate')
+        .send(testUserLogin)
+        .expect(200));
+
+    it('/POST authenticate without credentials is a validation error', () => request(app.getHttpServer())
+        .post('/api/authenticate')
+        .send({})
+        .expect(400)
+        .expect(response => expect(response.body).toMatchObject({ message: 'error.validation', fieldErrors: expect.arrayContaining([expect.objectContaining({ field: 'username' })]) })));
+
+    it('/GET account with an expired jwt is unauthorized', () => {
+        const expiredToken = app.get(JwtService).sign({ sub: 'admin', auth: '' }, { expiresIn: -10 });
+        return request(app.getHttpServer())
+            .get('/api/account')
+            .set('Authorization', `Bearer ${expiredToken}`)
+            .expect(401);
+    });
+    <%_ } else if (authenticationType === 'jwt') { _%>
+    describe('with a token of the gateway', () => {
+        // Signed like a JHipster Spring Boot gateway: HS512 with the base64 decoded secret, login as subject, authorities in auth.
+        const gatewayJwtService = (): JwtService =>
+            new JwtService({ secret: jwtSecretKey(app.get(ConfigService)), signOptions: { algorithm: JWT_ALGORITHM } });
+
+        it('/GET account is the user of the token', () => {
+            const token = gatewayJwtService().sign({ sub: 'gateway-user', auth: 'ROLE_USER ROLE_ADMIN', userId: 1 });
+            return request(app.getHttpServer())
+                .get('/api/account')
+                .set('Authorization', `Bearer ${token}`)
+                .expect(200)
+                .expect(res => expect(res.body).toMatchObject({ login: 'gateway-user', authorities: ['ROLE_USER', 'ROLE_ADMIN'] }));
+        });
+
+        it('/GET account without a token is unauthorized', () => request(app.getHttpServer())
+            .get('/api/account')
+            .expect(401));
+
+        it('/GET account with an expired token is unauthorized', () => {
+            const expiredToken = gatewayJwtService().sign({ sub: 'gateway-user', auth: '' }, { expiresIn: -10 });
+            return request(app.getHttpServer())
+                .get('/api/account')
+                .set('Authorization', `Bearer ${expiredToken}`)
+                .expect(401);
+        });
+
+        it('/GET account with a token signed with the encoded secret is unauthorized', () => {
+            const encodedSecret = app.get(ConfigService).getOrThrow<string>('jhipster.security.authentication.jwt.base64-secret');
+            const token = new JwtService({ secret: encodedSecret }).sign({ sub: 'gateway-user', auth: 'ROLE_USER' });
+            return request(app.getHttpServer())
+                .get('/api/account')
+                .set('Authorization', `Bearer ${token}`)
+                .expect(401);
+        });
+    });
+    <%_ } else if (authenticationType === 'oauth2') { _%>
+    it('/POST security oauth2 does not perform logout', () => request(app.getHttpServer())
+        .post('/api/logout')
+        .send(testRequest)
+        .expect({})
+        .expect(201));
+
+    it('/GET account not logged', () => request(app.getHttpServer())
+        .get('/api/account')
+        // Like JHipster Spring Boot, the clients take a 401 for not logged.
+        .expect(401));
+    <%_ if (generateBuiltInUserEntity) { _%>
+
+    it('saves the user of the identity provider at its logins, without a password, like JHipster Spring Boot', async () => {
+        const authService = app.get(AuthService);
+        await authService.findUserOrSave(oidcUserOfClaims({ sub: 'idp-user', preferred_username: 'IdP-User', groups: ['ROLE_USER'] }));
+        await authService.findUserOrSave(oidcUserOfClaims({ sub: 'idp-user', preferred_username: 'idp-user', given_name: 'Updated', groups: ['ROLE_USER'] }));
+
+        const saved = await app.get(UserService).findByFields({ where: { login: 'idp-user' } });
+        expect(saved).toMatchObject({ login: 'idp-user', firstName: 'Updated', email: 'idp-user@localhost', activated: true });
+    });
+    <%_ } _%>
+    <%_ } _%>
+
+    afterEach(async () => {
+        await app?.close();
+    });
+});

package/generators/node-server/templates/server/e2e/authority.e2e-spec.ts.ejs

@@ -0,0 +1,50 @@
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { INestApplication } from '@nestjs/common';
+import { Test, TestingModule } from '@nestjs/testing';
+import request from 'supertest';
+
+import { configureApp } from '../src/app.config.ts';
+import { AppModule } from '../src/app.module.ts';
+import { AuthGuard } from '../src/auth/guards/auth.guard.ts';
+import { RolesGuard } from '../src/auth/guards/roles.guard.ts';
+
+describe('Authority Controller', () => {
+    let app: INestApplication;
+
+    beforeAll(async () => {
+        const moduleFixture: TestingModule = await Test.createTestingModule({
+            imports: [AppModule],
+        })
+            .overrideGuard(AuthGuard)
+            .useValue({ canActivate: (): any => true })
+            .overrideGuard(RolesGuard)
+            .useValue({ canActivate: (): any => true })
+            .compile();
+
+        app = moduleFixture.createNestApplication();
+        configureApp(app);
+        await app.init();
+    });
+
+    afterAll(async () => {
+        await app?.close();
+    });
+
+    it('/GET the authorities the user management assigns, like JHipster Spring Boot', async () => {
+        const authorities = (await request(app.getHttpServer()).get('/api/authorities').expect(200)).body;
+        expect(authorities).toEqual(expect.arrayContaining([{ name: 'ROLE_ADMIN' }, { name: 'ROLE_USER' }]));
+    });
+
+    it('/POST, /GET and /DELETE an authority, like JHipster Spring Boot', async () => {
+        const created = await request(app.getHttpServer()).post('/api/authorities').send({ name: 'ROLE_E2E' }).expect(201);
+        expect(created.body).toEqual({ name: 'ROLE_E2E' });
+        expect(created.headers.location).toBe('/api/authorities/ROLE_E2E');
+
+        const problem = (await request(app.getHttpServer()).post('/api/authorities').send({ name: 'ROLE_E2E' }).expect(400)).body;
+        expect(problem).toMatchObject({ message: 'error.idexists' });
+
+        await request(app.getHttpServer()).get('/api/authorities/ROLE_E2E').expect(200).expect({ name: 'ROLE_E2E' });
+        await request(app.getHttpServer()).delete('/api/authorities/ROLE_E2E').expect(204);
+        await request(app.getHttpServer()).get('/api/authorities/ROLE_E2E').expect(404);
+    });
+});