El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Proves unitàries de resolvers

Següent ►
►

Les proves unitàries són una part essencial del desenvolupament de programari, ja que asseguren que cada unitat de codi funcioni correctament de manera aïllada. En el context de GraphQL, els resolvers són una part crítica de l'esquema, ja que s'encarreguen de recuperar les dades sol·licitades per les consultes. En aquesta secció, aprendrem com escriure proves unitàries per als resolvers de GraphQL.

Objectius d'aprenentatge

  • Entendre la importància de les proves unitàries per als resolvers.
  • Configurar un entorn de proves per a resolvers de GraphQL.
  • Escriure proves unitàries per a resolvers utilitzant eines com Jest.
  • Gestionar mocks i dades simulades per a les proves.

  1. Importància de les proves unitàries per als resolvers

Les proves unitàries per als resolvers són importants per diverses raons:

  • Fiabilitat: Asseguren que els resolvers funcionin correctament i retornin les dades esperades.
  • Mantenibilitat: Faciliten la detecció de regressions quan es fan canvis en el codi.
  • Documentació: Les proves poden servir com a documentació viva del comportament esperat dels resolvers.

  1. Configuració de l'entorn de proves

Instal·lació de Jest

Jest és una eina popular per a les proves unitàries en JavaScript. Per començar, instal·lem Jest en el nostre projecte:

npm install --save-dev jest

Configuració de Jest

Afegim una configuració bàsica de Jest al nostre package.json:

{
  "scripts": {
    "test": "jest"
  },
  "jest": {
    "testEnvironment": "node"
  }
}

  1. Escriure proves unitàries per a resolvers

Exemple de resolver

Suposem que tenim el següent resolver per a una consulta getUser:

const resolvers = {
  Query: {
    getUser: async (_, { id }, { dataSources }) => {
      return dataSources.userAPI.getUserById(id);
    },
  },
};

module.exports = resolvers;

Prova unitària per al resolver getUser

Creem un fitxer de prova resolvers.test.js:

const resolvers = require('./resolvers');

describe('Resolvers', () => {
  describe('Query.getUser', () => {
    it('hauria de retornar un usuari per ID', async () => {
      // Mock del dataSource
      const mockDataSource = {
        userAPI: {
          getUserById: jest.fn().mockResolvedValue({ id: '1', name: 'John Doe' }),
        },
      };

      // Executar el resolver
      const result = await resolvers.Query.getUser(null, { id: '1' }, { dataSources: mockDataSource });

      // Comprovar el resultat
      expect(result).toEqual({ id: '1', name: 'John Doe' });
      expect(mockDataSource.userAPI.getUserById).toHaveBeenCalledWith('1');
    });
  });
});

Explicació del codi

  1. Importació del resolver: Importem el resolver que volem provar.
  2. Descripció de la prova: Utilitzem describe per agrupar les proves relacionades amb els resolvers.
  3. Mock del dataSource: Creem un mock del dataSource que el resolver utilitza per obtenir les dades.
  4. Execució del resolver: Cridem el resolver amb els paràmetres necessaris.
  5. Comprovació del resultat: Utilitzem expect per verificar que el resultat sigui el que esperem i que el mètode del dataSource s'hagi cridat amb els paràmetres correctes.

  1. Mocks i dades simulades

Utilització de mocks

Els mocks són essencials per aïllar el codi que estem provant. En el cas dels resolvers, podem utilitzar mocks per simular les respostes dels dataSources o altres dependències.

Exemple avançat amb més mocks

Suposem que el nostre resolver getUser també fa una crida a un altre servei per obtenir informació addicional:

const resolvers = {
  Query: {
    getUser: async (_, { id }, { dataSources }) => {
      const user = await dataSources.userAPI.getUserById(id);
      const additionalInfo = await dataSources.infoAPI.getAdditionalInfo(user.id);
      return { ...user, ...additionalInfo };
    },
  },
};

module.exports = resolvers;

La prova unitària per a aquest resolver seria:

const resolvers = require('./resolvers');

describe('Resolvers', () => {
  describe('Query.getUser', () => {
    it('hauria de retornar un usuari amb informació addicional', async () => {
      // Mock dels dataSources
      const mockDataSource = {
        userAPI: {
          getUserById: jest.fn().mockResolvedValue({ id: '1', name: 'John Doe' }),
        },
        infoAPI: {
          getAdditionalInfo: jest.fn().mockResolvedValue({ age: 30, email: '[email protected]' }),
        },
      };

      // Executar el resolver
      const result = await resolvers.Query.getUser(null, { id: '1' }, { dataSources: mockDataSource });

      // Comprovar el resultat
      expect(result).toEqual({ id: '1', name: 'John Doe', age: 30, email: '[email protected]' });
      expect(mockDataSource.userAPI.getUserById).toHaveBeenCalledWith('1');
      expect(mockDataSource.infoAPI.getAdditionalInfo).toHaveBeenCalledWith('1');
    });
  });
});

Resum

En aquesta secció, hem après la importància de les proves unitàries per als resolvers de GraphQL i com configurar un entorn de proves utilitzant Jest. Hem vist exemples pràctics de com escriure proves unitàries per a resolvers, incloent-hi la gestió de mocks i dades simulades. Les proves unitàries són una eina poderosa per assegurar la qualitat i fiabilitat del nostre codi, i són especialment importants en aplicacions de GraphQL on els resolvers juguen un paper crucial en la recuperació de dades.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats