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

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

@@ -0,0 +1,192 @@
+<%_
+// The values of the fields as the API exchanges them, reproducible: the faker of the entity is seeded for this test.
+resetFakerSeed('nodejs-database-e2e');
+const created = nodejsApiFakeEntity();
+const updated = nodejsApiFakeEntity();
+const approximateFields = created.approximateFields;
+// The relationships of the entity with a join column or a join table (the persistableRelationships of JHipster): stored
+// by the id of the related record.
+const storedRelationships = databaseTypeSql ? persistableRelationships : [];
+const anyUserRelationship = storedRelationships.some(relationship => relationship.otherEntity.builtInUser);
+// The relationships the other entity stores (nodejsMappedByRelationships), with another entity of the application.
+const inverseRelationships = databaseTypeSql
+  ? nodejsMappedByRelationships.filter(relationship => !relationship.otherEntity.builtIn && relationship.otherRelationship?.propertyName)
+  : [];
+const literal = value => JSON.stringify(value);
+_%>
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { INestApplication } from '@nestjs/common';
+import { Test, TestingModule } from '@nestjs/testing';
+import request from 'supertest';
+<%_ if (anyUserRelationship) { _%>
+import { DataSource } from 'typeorm';
+<%_ } _%>
+
+import { AppModule } from '../src/app.module.ts';
+import { configureApp } from '../src/app.config.ts';
+<%_ if (anyUserRelationship) { _%>
+import { <%= user.persistClass %> } from '../src/users/user.entity.ts';
+<%_ } _%>
+import { AuthGuard } from '../src/auth/guards/auth.guard.ts';
+import { RolesGuard } from '../src/auth/guards/roles.guard.ts';
+
+/**
+ * <%= entityClass %> stored in the database and read back through the REST API, like the resource tests of JHipster
+ * Spring Boot: the values of every field as the API exchanges them<% if (storedRelationships.length > 0) { %>, and the relationships stored by the id of the related
+ * record, without changing it<% } %>.
+ */
+describe('<%= entityClass %> on the database', () => {
+  let app: INestApplication;
+
+  // The values of the fields, of a creation then of an update.
+  const createdValues: Record<string, any> = {
+<%_ for (const [name, value] of Object.entries(created.values)) { _%>
+    <%= name %>: <%- literal(value) %>,
+<%_ } _%>
+  };
+  const updatedValues: Record<string, any> = {
+<%_ for (const [name, value] of Object.entries(updated.values)) { _%>
+    <%= name %>: <%- literal(value) %>,
+<%_ } _%>
+  };
+
+  /** The values read back: a Float is approximate on the databases keeping it in single precision. */
+  const expected = (values: Record<string, any>): Record<string, any> => ({
+    ...values,
+<%_ for (const name of approximateFields) { _%>
+    <%= name %>: expect.closeTo(values.<%= name %>, 1),
+<%_ } _%>
+  });
+
+  beforeAll(async () => {
+    const moduleFixture: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    })
+      .overrideGuard(AuthGuard)
+      .useValue({ canActivate: () => true })
+      .overrideGuard(RolesGuard)
+      .useValue({ canActivate: () => true })
+      .compile();
+
+    app = moduleFixture.createNestApplication();
+    configureApp(app);
+    await app.init();
+  });
+
+  afterAll(async () => {
+    await app?.close();
+  });
+
+  it('should store every field and read it back, then update and delete it', async () => {
+    const server = app.getHttpServer();
+    const { body: stored } = await request(server).post('/api/<%= entityApiUrl %>').send(createdValues).expect(201);
+    const { body: read } = await request(server).get(`/api/<%= entityApiUrl %>/${stored.<%= primaryKey.name %>}`).expect(200);
+    expect(read).toMatchObject(expected(createdValues));
+
+    await request(server)
+      .put(`/api/<%= entityApiUrl %>/${stored.<%= primaryKey.name %>}`)
+      .send({ ...updatedValues, <%= primaryKey.name %>: stored.<%= primaryKey.name %> })
+      .expect(200);
+    const { body: readUpdated } = await request(server).get(`/api/<%= entityApiUrl %>/${stored.<%= primaryKey.name %>}`).expect(200);
+    expect(readUpdated).toMatchObject(expected(updatedValues));
+
+    await request(server).delete(`/api/<%= entityApiUrl %>/${stored.<%= primaryKey.name %>}`).expect(204);
+    await request(server).get(`/api/<%= entityApiUrl %>/${stored.<%= primaryKey.name %>}`).expect(404);
+  });
+<%_ for (const relationship of storedRelationships) {
+    const otherEntity = relationship.otherEntity;
+    const otherId = otherEntity.primaryKey.name;
+    const collection = relationship.relationshipType === 'many-to-many';
+    const property = relationship.propertyName;
+    const otherValues = relationship.nodejsRelatedValues;
+    // A text field of the related record, sent changed with its id: the relationship does not store it (no cascade).
+    const otherTextField = otherValues && otherEntity.fields.find(field => !field.id && field.fieldType === 'String' && field.fieldName in otherValues);
+_%>
+
+  it('should store the <%= property %> relationship by the id of the related record, without changing it', async () => {
+    const server = app.getHttpServer();
+<%_ if (otherEntity.builtInUser) { _%>
+    // A user of this test: the applications without seed users (OAuth2) have none.
+    const users = app.get(DataSource).getRepository(<%= user.persistClass %>);
+    const related = await users.save(
+      users.create({
+        login: '<%= entityInstance.toLowerCase() %>-<%= property.toLowerCase() %>-e2e',
+        email: '<%= entityInstance.toLowerCase() %>-<%= property.toLowerCase() %>-e2e@localhost',
+        password: '',
+        activationKey: 'e2e-activation-key',
+        resetKey: 'e2e-reset-key',
+      }),
+    );
+<%_ } else { _%>
+    const relatedValues: Record<string, any> = <%- literal(otherValues) %>;
+    const { body: related } = await request(server).post('/api/<%= otherEntity.entityApiUrl %>').send(relatedValues).expect(201);
+<%_ } _%>
+<%_ if (otherTextField) { _%>
+    const reference = { <%= otherId %>: related.<%= otherId %>, <%= otherTextField.fieldName %>: 'not stored through the relationship' };
+<%_ } else { _%>
+    const reference = { <%= otherId %>: related.<%= otherId %> };
+<%_ } _%>
+    const { body: stored } = await request(server)
+      .post('/api/<%= entityApiUrl %>')
+      .send({ ...createdValues, <%= property %>: <%- collection ? '[reference]' : 'reference' %> })
+      .expect(201);
+
+    const { body: read } = await request(server).get(`/api/<%= entityApiUrl %>/${stored.<%= primaryKey.name %>}`).expect(200);
+<%_ if (collection) { _%>
+    expect(read.<%= property %>).toEqual([expect.objectContaining({ <%= otherId %>: related.<%= otherId %> })]);
+<%_ } else { _%>
+    expect(read.<%= property %>).toMatchObject({ <%= otherId %>: related.<%= otherId %> });
+<%_ } _%>
+<%_ if (otherEntity.builtInUser) { _%>
+    // The keys of the user never in a response, like the @JsonIgnore keys of JHipster Spring Boot.
+    expect(JSON.stringify(read.<%= property %>)).not.toMatch(/e2e-(activation|reset)-key/);
+<%_ } _%>
+<%_ if (otherTextField) { _%>
+    const { body: relatedRead } = await request(server).get(`/api/<%= otherEntity.entityApiUrl %>/${related.<%= otherId %>}`).expect(200);
+    expect(relatedRead.<%= otherTextField.fieldName %>).toBe(relatedValues.<%= otherTextField.fieldName %>);
+<%_ } _%>
+
+    await request(server).delete(`/api/<%= entityApiUrl %>/${stored.<%= primaryKey.name %>}`).expect(204);
+<%_ if (otherEntity.builtInUser) { _%>
+    await users.remove(related);
+<%_ } else if (!otherEntity.builtIn) { _%>
+    await request(server).delete(`/api/<%= otherEntity.entityApiUrl %>/${related.<%= otherId %>}`).expect(204);
+<%_ } _%>
+  });
+<%_ } _%>
+<%_ for (const relationship of inverseRelationships) {
+    const otherEntity = relationship.otherEntity;
+    const otherId = otherEntity.primaryKey.name;
+    const property = relationship.propertyName;
+    const collection = relationship.relationshipType !== 'one-to-one';
+    const otherProperty = relationship.otherRelationship.propertyName;
+    const otherCollection = relationship.relationshipType === 'many-to-many';
+    const otherValues = relationship.nodejsRelatedValues;
+_%>
+
+  it('should not store the <%= property %> relationship from this side, like the mappedBy side of JHipster Spring Boot', async () => {
+    const server = app.getHttpServer();
+    const { body: stored } = await request(server).post('/api/<%= entityApiUrl %>').send(createdValues).expect(201);
+    const reference = { <%= primaryKey.name %>: stored.<%= primaryKey.name %> };
+    const { body: related } = await request(server)
+      .post('/api/<%= otherEntity.entityApiUrl %>')
+      .send({ ...<%- literal(otherValues) %>, <%= otherProperty %>: <%- otherCollection ? '[reference]' : 'reference' %> })
+      .expect(201);
+
+    await request(server)
+      .put(`/api/<%= entityApiUrl %>/${stored.<%= primaryKey.name %>}`)
+      .send({ ...stored, <%= property %>: <%- collection ? '[]' : 'null' %> })
+      .expect(200);
+
+    const { body: relatedRead } = await request(server).get(`/api/<%= otherEntity.entityApiUrl %>/${related.<%= otherId %>}`).expect(200);
+<%_ if (otherCollection) { _%>
+    expect(relatedRead.<%= otherProperty %>).toEqual([expect.objectContaining(reference)]);
+<%_ } else { _%>
+    expect(relatedRead.<%= otherProperty %>).toMatchObject(reference);
+<%_ } _%>
+
+    await request(server).delete(`/api/<%= otherEntity.entityApiUrl %>/${related.<%= otherId %>}`).expect(204);
+    await request(server).delete(`/api/<%= entityApiUrl %>/${stored.<%= primaryKey.name %>}`).expect(204);
+  });
+<%_ } _%>
+});

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

@@ -0,0 +1,402 @@
+<%_
+// The fake data of this test, whatever the templates rendered before: the faker of the entity is seeded for it.
+resetFakerSeed('nodejs-e2e-mock');
+const numericId = primaryKey.tsType === 'number';
+// The fake data of the fields, reproducible (the faker of the entity is seeded): distinct ids of the type of the primary
+// key, as TypeScript literals, and a value for each field of the entity, as the API exchanges it.
+const idField = primaryKey.fields[0];
+const [entityId, unknownId, anotherId] = [idField.generateFakeData('ts'), idField.generateFakeData('ts'), idField.generateFakeData('ts')];
+const fakeFields = fields
+  .filter(field => !field.id && !field.transient && !field.collection)
+  .map(field => [field.propertyName, field.nodejsApiFakeValue()])
+  .filter(([, value]) => value !== undefined && value !== null);
+// An id the pipe of the path rejects: neither a number nor a UUID.
+const invalidId = faker.lorem.word({ length: { min: 5, max: 10 } });
+_%>
+import { afterEach, beforeEach, describe, expect, it, 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 { INestApplication } from '@nestjs/common';
+import { AuthGuard } from '../src/auth/guards/auth.guard.ts';
+import { RolesGuard } from '../src/auth/guards/roles.guard.ts';
+import { <%= dtoClass %> } from '../src/entities/<%= entityFileName %>/dto/<%= entityFileName %>.dto.ts';
+import { <%= entityClass %>Service } from '../src/entities/<%= entityFileName %>/<%= entityFileName %>.service.ts';
+import { DataSource, EntityMetadata } from 'typeorm';
+import { <%= entityClass %> } from '../src/entities/<%= entityFileName %>/<%= entityFileName %>.entity.ts';
+
+// The alert headers the JHipster clients read, named after jhipster.clientApp.name.
+const alertHeader = (headers: Record<string, unknown>, suffix: string): unknown => headers[`x-<%= frontendAppName.toLowerCase() %>${suffix}`];
+
+describe('<%= entityClass %> Controller', () => {
+    let app: INestApplication;
+
+    const authGuardMock = { canActivate: (): any => true };
+    const rolesGuardMock = { canActivate: (): any => true };
+    const entityMock: any = {
+        id: <%- entityId %>,
+<%_ for (const [propertyName, value] of fakeFields) { _%>
+        <%- propertyName %>: <%- JSON.stringify(value) %>,
+<%_ } _%>
+    }
+    const unknownId = <%- unknownId %>;
+    const anotherId = <%- anotherId %>;
+<%_
+// The global ValidationPipe of configureApp validates the requests: a body with valid values of the validated fields.
+resetFakerSeed('nodejs-e2e');
+const validatedFields = fields.filter(field => !field.id && field.fieldValidate && field.fieldType !== 'byte[]');
+const validValues = Object.fromEntries(
+    validatedFields
+        .map(field => [field.fieldName, field.nodejsApiFakeValue()])
+        .filter(([, value]) => value !== undefined && value !== null),
+);
+const requiredField = validatedFields.find(field => field.fieldValidationRequired);
+const enumField = fields.find(field => !field.id && field.fieldIsEnum);
+_%>
+    const validEntity: any = {
+        ...entityMock,
+<%_ for (const [fieldName, value] of Object.entries(validValues)) { _%>
+        <%= fieldName %>: <%- JSON.stringify(value) %>,
+<%_ } _%>
+    };
+
+    const serviceMock: { metadata?: EntityMetadata, [method: string]: unknown } = {
+        findById: (id: any): any => (id === entityMock.id ? { ...entityMock } : undefined),
+        findAndCount: (): any => [entityMock, 0],
+        save: (): any => entityMock,
+        update: (dto: any): any => dto,
+        deleteById: (): any => entityMock
+    };
+
+
+    beforeEach(async () => {
+        const moduleFixture: TestingModule = await Test.createTestingModule({
+            imports: [AppModule],
+        }).overrideGuard(AuthGuard)
+        .useValue(authGuardMock)
+        .overrideGuard(RolesGuard)
+        .useValue(rolesGuardMock)
+        .overrideProvider(<%= entityClass %>Service)
+        .useValue(serviceMock)
+        .compile();
+        // The sort is validated with the TypeORM metadata of the entity.
+        serviceMock.metadata = moduleFixture.get(DataSource).getMetadata(<%= entityClass %>);
+
+        app = moduleFixture.createNestApplication();
+        configureApp(app);
+        await app.init();
+    });
+
+    it('/GET all <%= entityApiUrl %> ', async () => {
+
+        const getEntities: <%= dtoClass %>[] = (await request(app.getHttpServer())
+        .get('/api/<%= entityApiUrl %>')
+        .expect(200)).body;
+
+        expect(getEntities).toEqual(entityMock);
+
+    }
+    );
+
+<%_
+const sortField = fields.find(field => !field.id && !field.transient);
+const sortRelationship = relationships.find(relationship => relationship.ownerSide && !relationship.collection);
+_%>
+
+    it('/GET all <%= entityApiUrl %> sorted on a property of the entity', async () => {
+        await request(app.getHttpServer())
+            .get('/api/<%= entityApiUrl %>?sort=<%= sortField ? sortField.fieldName : primaryKey.name %>,desc')
+            .expect(200);
+    });
+<%_ if (sortRelationship) { _%>
+
+    it('/GET all <%= entityApiUrl %> sorted on the id and the label of a relationship', async () => {
+        await request(app.getHttpServer())
+            .get('/api/<%= entityApiUrl %>?sort=<%= sortRelationship.propertyName %>.id,asc')
+            .expect(200);
+        await request(app.getHttpServer())
+            .get('/api/<%= entityApiUrl %>?sort=<%= sortRelationship.propertyName %>.<%= sortRelationship.otherEntityField %>,desc')
+            .expect(200);
+    });
+
+    it('/GET all <%= entityApiUrl %> sorted on a deeper property of a relationship', async () => {
+        await request(app.getHttpServer())
+            .get('/api/<%= entityApiUrl %>?sort=<%= sortRelationship.propertyName %>.id.unknown,asc')
+            .expect(400);
+    });
+<%_ } _%>
+
+    it('/GET all <%= entityApiUrl %> sorted on an unknown property', async () => {
+        const response = await request(app.getHttpServer())
+            .get('/api/<%= entityApiUrl %>?sort=unknownProperty,asc')
+            .expect(400);
+
+        expect(response.body.detail).toBe('Invalid sort property: unknownProperty');
+    });
+
+<%_ if (pagination === 'no') { _%>
+    it('/GET all <%= entityApiUrl %> without pagination, like JHipster Spring Boot', async () => {
+        const { findAndCount } = serviceMock;
+        const options: any[] = [];
+        (serviceMock as any).findAndCount = (findOptions: any): any => {
+            options.push(findOptions);
+            return [[entityMock], 45];
+        };
+        try {
+            const response = await request(app.getHttpServer())
+                .get('/api/<%= entityApiUrl %>')
+                .expect(200);
+
+            expect(options[0].take).toBeUndefined();
+            expect(response.headers['x-total-count']).toBeUndefined();
+            expect(response.headers.link).toBeUndefined();
+        } finally {
+            serviceMock.findAndCount = findAndCount;
+        }
+    });
+
+<%_ } else { _%>
+    it('/GET all <%= entityApiUrl %> with the links of the pages', async () => {
+        const { findAndCount } = serviceMock;
+        // 45 records, 3 pages of 20.
+        serviceMock.findAndCount = (): any => [[entityMock], 45];
+        try {
+            const response = await request(app.getHttpServer())
+                .get('/api/<%= entityApiUrl %>?page=1&size=20')
+                .expect(200);
+
+            expect(response.headers['x-total-count']).toBe('45');
+            expect(response.headers.link.split(',')).toEqual([
+                '</api/<%= entityApiUrl %>?page=2&size=20>; rel="next"',
+                '</api/<%= entityApiUrl %>?page=0&size=20>; rel="prev"',
+                '</api/<%= entityApiUrl %>?page=2&size=20>; rel="last"',
+                '</api/<%= entityApiUrl %>?page=0&size=20>; rel="first"',
+            ]);
+        } finally {
+            serviceMock.findAndCount = findAndCount;
+        }
+    });
+
+    it('/GET all <%= entityApiUrl %> without records links the first page as the last one', async () => {
+        const response = await request(app.getHttpServer())
+            .get('/api/<%= entityApiUrl %>')
+            .expect(200);
+
+        expect(response.headers.link).toContain('page=0&size=20>; rel="last"');
+        expect(response.headers.link).not.toContain('rel="next"');
+    });
+
+<%_ } _%>
+    it('/GET <%= entityApiUrl %> by id', async () => {
+
+
+        const getEntity: <%= dtoClass %> = (await request(app.getHttpServer())
+            .get(`/api/<%= entityApiUrl %>/${entityMock.id}`)
+            .expect(200)).body;
+
+        expect(getEntity).toEqual(entityMock);
+
+    }
+    );
+
+    it('/GET <%= entityApiUrl %> by an unknown id', async () => {
+        await request(app.getHttpServer())
+            .get(`/api/<%= entityApiUrl %>/${unknownId}`)
+            .expect(404);
+    });
+<%_ if (numericId || primaryKey.typeUUID) { _%>
+
+    it('/GET <%= entityApiUrl %> by an invalid id', async () => {
+        await request(app.getHttpServer())
+            .get('/api/<%= entityApiUrl %>/<%= invalidId %>')
+            .expect(400);
+    });
+<%_ } _%>
+
+    it('/POST create <%= entityApiUrl %>', async () => {
+        const { id: _id, ...newEntity } = validEntity;
+        const response = await request(app.getHttpServer())
+            .post('/api/<%= entityApiUrl %>')
+            .send(newEntity)
+            .expect(201);
+
+        expect(response.body).toEqual(entityMock);
+        expect(response.headers.location).toBe(`/api/<%= entityApiUrl %>/${entityMock.id}`);
+        expect(alertHeader(response.headers, '-alert')).toMatch(<%- enableTranslation ? `/^${frontendAppName}\\.${entityAlertName}\\.created$/` : `/^A new ${entityAlertName} is created with identifier /` %>);
+    });
+
+    it('/POST create <%= entityApiUrl %> ignores the properties its DTO does not declare', async () => {
+        // Like JHipster Spring Boot, which ignores the unknown properties of a request: the service gets the declared ones.
+        const { id: _id, ...newEntity } = validEntity;
+        const save = vi.spyOn(serviceMock as any, 'save');
+        try {
+            await request(app.getHttpServer())
+                .post('/api/<%= entityApiUrl %>')
+                .send({ ...newEntity, unknownProperty: 'unknown' })
+                .expect(201);
+
+            const [dto] = save.mock.calls[0];
+            expect(dto).not.toHaveProperty('unknownProperty');
+            expect(Object.keys(dto as object)).toEqual(expect.arrayContaining(Object.keys(JSON.parse(JSON.stringify(newEntity)))));
+        } finally {
+            save.mockRestore();
+        }
+    });
+
+    it('/POST create <%= entityApiUrl %> with an id', async () => {
+        const response = await request(app.getHttpServer())
+            .post('/api/<%= entityApiUrl %>')
+            .send(validEntity)
+            .expect(400);
+
+        expect(alertHeader(response.headers, '-error')).toBe('error.idexists');
+        expect(response.body).toMatchObject({ message: 'error.idexists', params: '<%= entityAlertName %>' });
+        expect(alertHeader(response.headers, '-params')).toBe('<%= entityAlertName %>');
+    });
+
+<%_ if (requiredField) { _%>
+    it('/POST create <%= entityApiUrl %> without <%= requiredField.fieldName %> is a validation error', async () => {
+        const { <%= requiredField.fieldName %>: _<%= requiredField.fieldName %>, ...invalidEntity } = validEntity;
+
+        const error = (await request(app.getHttpServer())
+            .post('/api/<%= entityApiUrl %>')
+            .send(invalidEntity)
+            .expect(400)).body;
+
+        expect(error).toMatchObject({
+            type: 'https://www.jhipster.tech/problem/constraint-violation',
+            message: 'error.validation',
+            fieldErrors: [{ objectName: '<%= entityInstance %>', field: '<%= requiredField.fieldName %>', message: expect.any(String) }],
+        });
+    });
+
+<%_ } _%>
+<%_ if (enumField) { _%>
+    it('/POST create <%= entityApiUrl %> with a <%= enumField.fieldName %> out of its enum is a validation error', async () => {
+        const error = (await request(app.getHttpServer())
+            .post('/api/<%= entityApiUrl %>')
+            .send({ ...validEntity, <%= enumField.fieldName %>: 'NOT_A_<%= enumField.fieldType.toUpperCase() %>' })
+            .expect(400)).body;
+
+        expect(error).toMatchObject({ message: 'error.validation', fieldErrors: [expect.objectContaining({ field: '<%= enumField.fieldName %>' })] });
+    });
+
+<%_ } _%>
+    it('/PUT update <%= entityApiUrl %> from id', async () => {
+        const response = await request(app.getHttpServer())
+            .put(`/api/<%= entityApiUrl %>/${entityMock.id}`)
+            .send(validEntity)
+            .expect(200);
+
+        expect(response.body).toEqual(validEntity);
+        expect(alertHeader(response.headers, '-alert')).toMatch(<%- enableTranslation ? `/^${frontendAppName}\\.${entityAlertName}\\.updated$/` : `/^A ${entityAlertName} is updated with identifier /` %>);
+        expect(alertHeader(response.headers, '-params')).toBe(String(entityMock.id));
+    }
+    );
+
+    it('/PUT update <%= entityApiUrl %> from another id', async () => {
+        const response = await request(app.getHttpServer())
+            .put(`/api/<%= entityApiUrl %>/${anotherId}`)
+            .send(validEntity)
+            .expect(400);
+
+        expect(alertHeader(response.headers, '-error')).toBe('error.idinvalid');
+        expect(response.body).toMatchObject({ message: 'error.idinvalid', params: '<%= entityAlertName %>' });
+    });
+
+    it('/PUT update <%= entityApiUrl %> without id', async () => {
+        const response = await request(app.getHttpServer())
+            .put(`/api/<%= entityApiUrl %>/${entityMock.id}`)
+            .send({ ...validEntity, id: undefined })
+            .expect(400);
+
+        expect(alertHeader(response.headers, '-error')).toBe('error.idnull');
+        expect(response.body).toMatchObject({ message: 'error.idnull', params: '<%= entityAlertName %>' });
+    });
+
+    it('/PUT update an unknown <%= entityApiUrl %>', async () => {
+        const response = await request(app.getHttpServer())
+            .put(`/api/<%= entityApiUrl %>/${unknownId}`)
+            .send({ ...validEntity, id: unknownId })
+            .expect(400);
+
+        expect(alertHeader(response.headers, '-error')).toBe('error.idnotfound');
+        expect(response.body).toMatchObject({ message: 'error.idnotfound', params: '<%= entityAlertName %>' });
+    });
+
+    it('/DELETE <%= entityApiUrl %>', async () => {
+
+
+        const deletedEntity: <%= dtoClass %> = (await request(app.getHttpServer())
+            .delete(`/api/<%= entityApiUrl %>/${entityMock.id}`)
+            .expect(204)).body;
+
+            expect(deletedEntity).toEqual({});
+    }
+    );
+
+    afterEach(async () => {
+        await app?.close();
+    });
+<%_ if (nodejsReadRoles) { _%>
+
+    describe('with the roles of <%= entityClass %>, like the @PreAuthorize of JHipster Spring Boot', () => {
+        let rolesApp: INestApplication;
+
+        /** The application with its RolesGuard, for a user of these roles. */
+        const appOfUser = async (authorities: string[]): Promise<INestApplication> => {
+            const moduleFixture: TestingModule = await Test.createTestingModule({
+                imports: [AppModule],
+            }).overrideGuard(AuthGuard)
+            .useValue({ canActivate: (context: any): boolean => {
+                context.switchToHttp().getRequest().user = { login: 'user', authorities };
+                return true;
+            } })
+            .overrideProvider(<%= entityClass %>Service)
+            .useValue(serviceMock)
+            .compile();
+            serviceMock.metadata = moduleFixture.get(DataSource).getMetadata(<%= entityClass %>);
+            const rolesNestApp = moduleFixture.createNestApplication();
+            configureApp(rolesNestApp);
+            await rolesNestApp.init();
+            return rolesNestApp;
+        };
+
+        afterEach(async () => {
+            await rolesApp?.close();
+        });
+
+        it('refuses a user without its roles with 403', async () => {
+            rolesApp = await appOfUser(['ROLE_OTHER']);
+            await request(rolesApp.getHttpServer()).get('/api/<%= entityApiUrl %>').expect(403);
+            await request(rolesApp.getHttpServer()).get(`/api/<%= entityApiUrl %>/${entityMock.id}`).expect(403);
+<%_ if (nodejsWriteRoles) { _%>
+            const { id: _id, ...newEntity } = validEntity;
+            await request(rolesApp.getHttpServer()).post('/api/<%= entityApiUrl %>').send(newEntity).expect(403);
+            await request(rolesApp.getHttpServer()).delete(`/api/<%= entityApiUrl %>/${entityMock.id}`).expect(403);
+<%_ } _%>
+        });
+<%_ if (nodejsWriteRoles) { _%>
+
+        it('allows a user of its roles to read and to write', async () => {
+            rolesApp = await appOfUser([<%- nodejsWriteRoles %>]);
+            await request(rolesApp.getHttpServer()).get('/api/<%= entityApiUrl %>').expect(200);
+            const { id: _id, ...newEntity } = validEntity;
+            await request(rolesApp.getHttpServer()).post('/api/<%= entityApiUrl %>').send(newEntity).expect(201);
+        });
+<%_ } _%>
+<%_ if (nodejsReadOnlyRoles) { _%>
+
+        it('allows a user of its read roles to read only', async () => {
+            rolesApp = await appOfUser([<%- nodejsReadOnlyRoles %>]);
+            await request(rolesApp.getHttpServer()).get('/api/<%= entityApiUrl %>').expect(200);
+<%_ if (nodejsWriteRoles) { _%>
+            const { id: _id, ...newEntity } = validEntity;
+            await request(rolesApp.getHttpServer()).post('/api/<%= entityApiUrl %>').send(newEntity).expect(403);
+<%_ } _%>
+        });
+<%_ } _%>
+    });
+<%_ } _%>
+});