test.e2e-spec.ts

import { Test, TestingModule } from '@nestjs/testing';
import { HttpStatus, INestApplication, ValidationPipe } from '@nestjs/common';
import * as request from 'supertest';
import { AppModule } from '../../src/app.module';
import { TestUtils } from '@test/test-utils';
import { CreateTravelDto } from '@modules/travel/dtos/create-travel.dto';
import { UpdateTravelDto } from '@modules/travel/dtos/update-travel.dto';
import { TravelRepository } from '@modules/travel/repositories/travel.repository';
import { getCustomRepository, In } from 'typeorm';
import { CreateTravelResponseDto } from '@modules/travel/dtos/create-travel-response.dto';
import { UserRepository } from '@modules/user/repositories/user.repository';
import { extractIds } from '@utils/extractors';

const userDto = {
    email: 'test@gmail.com',
    firstName: 'test',
    password: '123456',
};

describe('TravelResolver (e2e)', () => {
    let app: INestApplication;
    let testUtils: TestUtils;
    let token: string;
    let travelRepository: TravelRepository;
    let userRepository: UserRepository;

    beforeEach(async () => {
        const moduleFixture: TestingModule = await Test.createTestingModule({
            imports: [AppModule],
            providers: [TestUtils],
        }).compile();

        app = moduleFixture.createNestApplication();
        app.useGlobalPipes(new ValidationPipe());
        await app.init();

        testUtils = moduleFixture.get<TestUtils>(TestUtils);

        await testUtils.loadDataBaseMocks();

        travelRepository = getCustomRepository(TravelRepository);
        userRepository = getCustomRepository(UserRepository);

        const loginDto = testUtils.convertObjectToJson({
            email: userDto.email,
            password: userDto.password,
        });

        const loginQuery = /* GraphQL */ `
                mutation {
                    login(data: ${loginDto}) {
                        access_token
                    }
                }
            `;

        await request(app.getHttpServer())
            .post(testUtils.gqlPath)
            .send(testUtils.getQueryObj(loginQuery))
            .expect(HttpStatus.OK)
            .then(({ body }: request.Response) => {
                const { access_token } = body.data.login;

                token = access_token;
            });
    });

    afterEach(async () => {
        await testUtils.cleanDataBase();
        await testUtils.closeDbConnection();
    });

    afterAll(async () => {
        await app.close();
    });

    it('should delete travel', async (done) => {
        const userTravels = await travelRepository.findAllByUserId(1);

        expect(userTravels).toHaveLength(3);

        const deleteTravelQuery = /* GraphQL */ `
            mutation {
                deleteTravel(travelId: 1) {
                    success
                    deletedItems
                }
            }
        `;

        return request(app.getHttpServer())
            .post(testUtils.gqlPath)
            .set('Authorization', `Bearer ${token}`)
            .send(testUtils.getQueryObj(deleteTravelQuery))
            .expect(HttpStatus.OK)
            .then(async ({ body }: request.Response) => {
                const deleteResult = body.data.deleteTravel;

                const { success, deletedItems } = deleteResult;

                expect(success).toBeTruthy();
                expect(deletedItems).toBe(1);

                const userTravels = await travelRepository.findAllByUserId(1);

                expect(userTravels).toHaveLength(2);

                done();
            });
    });
});