Testen einer GraphQL-Anwendung mit Jest und SuperTest

In diesem Blogbeitrag untersuchen wir die Herausforderungen und Lösungen beim Testen einer GraphQL-API mit Jest und SuperTest. Die Reise begann mit der Notwendigkeit, Header, insbesondere für die tokenbasierte Authentifizierung, in Jest-Tests zu simulieren.

Die Herausforderung: Header im Scherz simulieren

Bei der Entwicklung des Todo Backend GraphQL-Projekts für die Woovi-Challenge bin ich auf eine erhebliche Hürde gestoßen. Ich musste die Authentifizierung der GraphQL-API testen, die auf JSON Web Tokens (JWT) basiert, die in den HTTP-Headern übergeben werden. Anfangs hatte ich Mühe, eine einfache Möglichkeit zu finden, diese Header in Jest zu simulieren. Das Standard-Jest-Setup reichte nicht aus, da es HTTP-Anfragen und -Antworten nicht direkt auf die gleiche Weise verarbeitete wie ein echter Server.

Die Lösung: SuperTest entdecken

Nach mehreren Versuchen und Irrtümern bin ich auf SuperTest gestoßen, eine Bibliothek für HTTP-Assertionen. SuperTest erweitert die Funktionalität von Jest, indem es Ihnen ermöglicht, HTTP-Server zu testen, als wären sie echte Clients. Diese Funktion ermöglichte die Simulation von Headern, einschließlich der für die Authentifizierung meiner API erforderlichen Autorisierungstoken.

Einrichten der Testumgebung

Bevor wir in die Tests eintauchen, richten wir die Umgebung ein.

1. Abhängigkeiten installieren Stellen Sie zunächst sicher, dass Jest, SuperTest und Faker installiert sind:

   npm install --save-dev jest supertest faker

1. Jest konfigurieren Erstellen Sie eine jest.config.js-Datei:

   module.exports = {
     preset: 'ts-jest',
     testEnvironment: 'node',
   };

1. Testfälle schreiben Wenn die Umgebung bereit ist, können wir jetzt Testfälle schreiben.

Schreiben von Tests mit SuperTest

SuperTest wurde in diesem Szenario zum Game-Changer. So habe ich es verwendet, um die CRUD-Operationen und die Authentifizierung der API zu testen.

Testen von CRUD-Operationen mit SuperTest

1. Auf- und Abbau Verwenden Sie die beforeAll- und afterAll-Hooks von Jest zum Auf- und Abbau:

   import { connect, disconnectDatabase } from './mongooseConnection';
   import supertest from 'supertest';
   import app from './../index';

   beforeAll(async () => {
     await connect();
   });

   afterAll(async () => {
     await disconnectDatabase();
   });

1. Authentifizierung und Token-Nutzung testen Erstellen Sie eine Hilfsfunktion, um einen Benutzer zu registrieren und das Token abzurufen:

   import { faker } from '@faker-js/faker';
   import { graphql } from 'graphql';
   import { schema } from '../schema';

   async function authUserTest() {
     const userTest = {
       name: faker.name.firstName(),
       email: faker.internet.email(),
       password: faker.internet.password(),
     };
     const source = `
       mutation {
         register(name: "${userTest.name}", email: "${userTest.email}", password: "${userTest.password}") {
           token
           user {
             name
             email
           }
         }
       }
     `;
     const result = await graphql({ schema, source });
     const data = result.data?.register;
     return data.token;
   }

1. Testaufgaben CRUD-Operationen

   • Erstellen Sie eine neue Aufgabe

    it('should create a new task', async () => {
      const todo = {
        task: faker.lorem.words(),
        status: faker.helpers.arrayElement(['pending', 'complete', 'in progress']),
      };
      const query = `
        mutation {
          todo(task: "${todo.task}", status: "${todo.status}") {
            task
            status
          }
        }
      `;
      const { body } = await supertest(app)
        .post('/graphql')
        .send({ query })
        .set('Accept', 'application/json')
        .set('Authorization', `Bearer ${await authUserTest()}`);
      expect(body.data.todo).toMatchObject(todo);
    });
   

• Alle Aufgaben abrufen
  

   it('should retrieve all tasks', async () => {
     const query = `
       query {
         todos {
           _id
           task
           status
         }
       }
     `;
     const { body } = await supertest(app)
       .post('/graphql')
       .send({ query })
       .set('Accept', 'application/json')
       .set('Authorization', `Bearer ${await authUserTest()}`);
     expect(body.data.todos).toBeInstanceOf(Array);
   });
  

• Eine Aufgabe aktualisieren
  

   it('should update a task', async () => {
     const todos = await Todo.find();
     const randomTodo = todos[Math.floor(Math.random() * todos.length)];
     const updatedTask = faker.lorem.words();
     const updatedStatus = faker.helpers.arrayElement(['pending', 'complete', 'in progress']);
     const query = `
       mutation {
         updateTodo(_id: "${randomTodo._id}", task: "${updatedTask}", status: "${updatedStatus}") {
           task
           status
         }
       }
     `;
     const { body } = await supertest(app)
       .post('/graphql')
       .send({ query })
       .set('Accept', 'application/json')
       .set('Authorization', `Bearer ${await authUserTest()}`);
     expect(body.data.updateTodo.task).toBe(updatedTask);
     expect(body.data.updateTodo.status).toBe(updatedStatus);
   });
  

• Eine Aufgabe löschen
  

   it('should delete a task', async () => {
     const todos = await Todo.find();
     const randomTodo = todos[Math.floor(Math.random() * todos.length)];
     const query = `
       mutation {
         deleteTodo(_id: "${randomTodo._id}") {
           _id
         }
       }
     `;
     const { body } = await supertest(app)
       .post('/graphql')
       .send({ query })
       .set('Accept', 'application/json')
       .set('Authorization', `Bearer ${await authUserTest()}`);
     expect(body.data.deleteTodo._id).toBe(randomTodo._id);
   });
  

Ausführen der Tests

Führen Sie Ihre Tests mit Jest durch:

npm test

Dieser Befehl führt alle Testdateien aus und liefert einen detaillierten Bericht der Ergebnisse.

Abschluss

Die Schwierigkeit, Header in Jest zu simulieren, führte zur Entdeckung von SuperTest, was den Prozess erheblich vereinfachte. Durch die Nutzung von SuperTest zusammen mit Jest konnte ich die Authentifizierungs- und CRUD-Vorgänge der GraphQL-API effektiv testen und so die Sicherheit und Funktionalität der Anwendung gewährleisten. Das Teilen dieses Lernprozesses unterstreicht die Kraft des öffentlichen Lernens und der gemeinschaftsgesteuerten Problemlösung.

Das obige ist der detaillierte Inhalt vonTesten einer GraphQL-Anwendung mit Jest und SuperTest. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!