Création de tests dans une base de données réelle avec NestJS, TypeORM et PostgreSQL

Intro
Que vous soyez ou non en mode de développement piloté par les tests, l'écriture de tests présente quelques avantages utiles :
Ils fournissent un filet de sécurité qui permet aux développeurs d'apporter des modifications en toute confiance, d'ajouter de nouvelles fonctionnalités et de refactoriser le code en sachant que les tests vérifieront que la fonctionnalité reste intacte.

La douleur
Certains d'entre nous ne disposent pas de processeurs haut de gamme, et cela ne peut pas être particulièrement frustrant lorsqu'il s'agit de projets énormes.
Récemment, je travaillais dans une énorme application NestJS et je voulais juste tester quelques requêtes TypeORM et chaque fois que je modifiais, je devais charger l'intégralité du projet. Pensez à un visage frustré, c'était moi.

Solution
Écrire des tests est une bonne pratique, non ? Et si je pouvais développer plus rapidement et créer indirectement des tests tout en évitant d'avoir à créer des simulations et des stubs ? C'est à ce moment-là que j'ai pensé : les tests ne sont pas effectués avec la vraie base de données.

Code

Voici les tests :

import * as dotenv from 'dotenv';
import { Test, TestingModule } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm'; 
dotenv.config();
describe('Queryes only test', () => {
    let app: INestApplication;
    let foodRepo: FoodRepository;

    beforeAll(async () => {
        const moduleFixture: TestingModule = await Test.createTestingModule({
            imports: [
                TypeOrmModule.forRootAsync({
                    useFactory: (configService: any) => ({
                        type: 'postgres',

                        host: process.env.TYPEORM_HOST,
                        port: Number(process.env.TYPEORM_PORT),
                        username: process.env.TYPEORM_USERNAME,
                        password: process.env.TYPEORM_PASSWORD,
                        database: process.env.TYPEORM_DATABASE,

                        entities: ['src/app/**/entities/*.entity.*'],
                        synchronize: false,
                        logging: true /* That will make the sql queryes appear in the console */
                    })
                }),
                TypeOrmModule.forFeature([FoodRepository])
            ]
        }).compile();

        app = moduleFixture.createNestApplication();
        await app.init();

        foodRepo = moduleFixture.get<FoodRepository>(FoodRepository);
    });

    jest.setTimeout(30000);

    it('Must find foods from regular customers', async () => {
        const foodsFromRegularCustomers = await foodRepo.findFoodsFromRegularCustomers().getMany();
        expect(Array.isArray(foodsFromRegularCustomers)).toBeTruthy();
    });

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

et c'est mon référentiel :

async findFoodsFromRegularCustomers() {
  const currentDate = new Date();
  const startOfWeek = new Date(currentDate.setDate(currentDate.getDate() - currentDate.getDay()));

  return this.createQueryBuilder('food')
    .innerJoin('food.customer', 'customer')
    .innerJoin('customer.orders', 'orders')
    .select([
      'customer.id', 
      'customer.name', 
      'customer.cpf', 
      'customer.address'
    ])
    .where('orders.createdAt >= :startOfWeek', { startOfWeek })
    .groupBy('customer.id')
    .having('COUNT(orders.id) > :minOrders', { minOrders: 10 })  
}

---

Ce test ne doit pas être la perfection, mais je vous assure :
Cela aidera l'équipe de développeurs à éviter d'envoyer des requêtes interrompues.

Si un attribut ou une relation d'entité cesse d'exister, comme customer.address, le générateur de requêtes ne s'interrompra pas au moment de la construction. Mais les tests le feront.?

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!