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

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