M

MLOG

Italiano

Guida completa ai test di integrazione per API con Supertest. Copre setup, best practice e tecniche avanzate per test robusti.

Test di Integrazione: Padroneggiare il Test delle API con Supertest

Nel mondo dello sviluppo software, assicurarsi che i singoli componenti funzionino correttamente in isolamento (test unitari) è fondamentale. Tuttavia, è altrettanto importante verificare che questi componenti lavorino insieme senza problemi. È qui che entra in gioco il test di integrazione. Il test di integrazione si concentra sulla validazione dell'interazione tra diversi moduli o servizi all'interno di un'applicazione. Questo articolo approfondisce il test di integrazione, concentrandosi in particolare sul test delle API con Supertest, una libreria potente e facile da usare per testare le asserzioni HTTP in Node.js.

Cos'è il Test di Integrazione?

Il test di integrazione è un tipo di test del software che combina singoli moduli software e li testa come un gruppo. Ha lo scopo di esporre i difetti nelle interazioni tra le unità integrate. A differenza dei test unitari, che si concentrano sui singoli componenti, il test di integrazione verifica il flusso di dati e il flusso di controllo tra i moduli. Gli approcci comuni al test di integrazione includono:

Nel contesto delle API, il test di integrazione implica la verifica che diverse API funzionino correttamente insieme, che i dati passati tra di esse siano coerenti e che il sistema complessivo funzioni come previsto. Ad esempio, immaginate un'applicazione di e-commerce con API separate per la gestione dei prodotti, l'autenticazione degli utenti e l'elaborazione dei pagamenti. Il test di integrazione assicurerebbe che queste API comunichino correttamente, consentendo agli utenti di sfogliare i prodotti, accedere in modo sicuro e completare gli acquisti.

Perché il Test di Integrazione delle API è Importante?

Il test di integrazione delle API è fondamentale per diverse ragioni:

Considerate una piattaforma globale di prenotazione viaggi. Il test di integrazione delle API è fondamentale per garantire una comunicazione fluida tra le API che gestiscono le prenotazioni di voli, le prenotazioni di hotel e i gateway di pagamento di vari paesi. Una mancata integrazione corretta di queste API potrebbe portare a prenotazioni errate, fallimenti nei pagamenti e una scarsa esperienza utente, con un impatto negativo sulla reputazione e sui ricavi della piattaforma.

Vi presentiamo Supertest: Uno Strumento Potente per il Test delle API

Supertest è un'astrazione di alto livello per il test delle richieste HTTP. Fornisce un'API comoda e fluente per inviare richieste alla vostra applicazione e asserire sulle risposte. Basato su Node.js, Supertest è progettato specificamente per testare i server HTTP di Node.js. Funziona eccezionalmente bene con framework di test popolari come Jest e Mocha.

Caratteristiche Principali di Supertest:

Configurazione dell'Ambiente di Test

Prima di iniziare, configuriamo un ambiente di test di base. Partiremo dal presupposto che abbiate installato Node.js e npm (o yarn). Useremo Jest come framework di test e Supertest per il test delle API.

  1. Creare un progetto Node.js:
mkdir api-testing-example
cd api-testing-example
npm init -y
  1. Installare le dipendenze:
npm install --save-dev jest supertest
npm install express  # O il vostro framework preferito per creare l'API
  1. Configurare Jest: Aggiungete quanto segue al vostro file package.json:
{
  "scripts": {
    "test": "jest"
  }
}
  1. Creare un endpoint API semplice: Create un file chiamato app.js (o simile) con il seguente codice:
const express = require('express');
const app = express();
const port = 3000;

app.get('/hello', (req, res) => {
  res.send('Hello, World!');
});

app.listen(port, () => {
  console.log(`Example app listening at http://localhost:${port}`);
});

module.exports = app; // Esporta per il testing

Scrivere il Vostro Primo Test con Supertest

Ora che abbiamo configurato il nostro ambiente, scriviamo un semplice test con Supertest per verificare il nostro endpoint API. Create un file chiamato app.test.js (o simile) nella root del vostro progetto:

const request = require('supertest');
const app = require('./app');

describe('GET /hello', () => {
  it('responds with 200 OK and returns "Hello, World!"', async () => {
    const response = await request(app).get('/hello');
    expect(response.statusCode).toBe(200);
    expect(response.text).toBe('Hello, World!');
  });
});

Spiegazione:

Per eseguire il test, lanciate il seguente comando nel vostro terminale:

npm test

Se tutto è configurato correttamente, dovreste vedere il test passare.

Tecniche Avanzate di Supertest

Supertest offre una vasta gamma di funzionalità per il test avanzato delle API. Esploriamone alcune.

1. Inviare Corpi di Richiesta

Per inviare dati nel corpo della richiesta, potete usare il metodo .send(). Ad esempio, creiamo un endpoint che accetta dati JSON:

app.post('/users', express.json(), (req, res) => {
  const { name, email } = req.body;
  // Simula la creazione di un utente in un database
  const user = { id: Date.now(), name, email };
  res.status(201).json(user);
});

Ecco come potete testare questo endpoint usando Supertest:

describe('POST /users', () => {
  it('creates a new user', async () => {
    const userData = {
      name: 'John Doe',
      email: 'john.doe@example.com',
    };

    const response = await request(app)
      .post('/users')
      .send(userData)
      .expect(201);

    expect(response.body).toHaveProperty('id');
    expect(response.body.name).toBe(userData.name);
    expect(response.body.email).toBe(userData.email);
  });
});

Spiegazione:

2. Impostare gli Header

Per impostare header personalizzati nelle vostre richieste, potete usare il metodo .set(). Questo è utile per impostare token di autenticazione, tipi di contenuto o altri header personalizzati.

describe('GET /protected', () => {
  it('requires authentication', async () => {
    const response = await request(app).get('/protected').expect(401);
  });

  it('returns 200 OK with a valid token', async () => {
    // Simula l'ottenimento di un token valido
    const token = 'valid-token';

    const response = await request(app)
      .get('/protected')
      .set('Authorization', `Bearer ${token}`)
      .expect(200);

    expect(response.text).toBe('Protected Resource');
  });
});

Spiegazione:

3. Gestione dei Cookie

Supertest può anche gestire i cookie. Potete impostare i cookie usando il metodo .set('Cookie', ...), oppure potete usare la proprietà .cookies per accedere e modificare i cookie.

4. Testare l'Upload di File

Supertest può essere usato per testare endpoint API che gestiscono l'upload di file. Potete usare il metodo .attach() per allegare file alla richiesta.

5. Usare Librerie di Asserzioni (Chai)

Sebbene la libreria di asserzioni integrata di Jest sia sufficiente per molti casi, potete anche usare librerie di asserzioni più potenti come Chai con Supertest. Chai fornisce una sintassi di asserzione più espressiva e flessibile. Per usare Chai, dovrete installarlo:

npm install --save-dev chai

Poi, potete importare Chai nel vostro file di test e usare le sue asserzioni:

const request = require('supertest');
const app = require('./app');
const chai = require('chai');
const expect = chai.expect;

describe('GET /hello', () => {
  it('responds with 200 OK and returns "Hello, World!"', async () => {
    const response = await request(app).get('/hello');
    expect(response.statusCode).to.equal(200);
    expect(response.text).to.equal('Hello, World!');
  });
});

Nota: Potrebbe essere necessario configurare Jest per funzionare correttamente con Chai. Questo spesso comporta l'aggiunta di un file di setup che importa Chai e lo configura per funzionare con l'expect globale di Jest.

6. Riutilizzare gli Agenti

Per i test che richiedono la configurazione di un ambiente specifico (es. autenticazione), è spesso vantaggioso riutilizzare un agente Supertest. Ciò evita codice di setup ridondante in ogni caso di test.

describe('Authenticated API Tests', () => {
  let agent;

  beforeAll(() => {
    agent = request.agent(app); // Crea un agente persistente
    // Simula l'autenticazione
    return agent
      .post('/login')
      .send({ username: 'testuser', password: 'password123' });
  });

  it('can access a protected resource', async () => {
    const response = await agent.get('/protected').expect(200);
    expect(response.text).toBe('Protected Resource');
  });

  it('can perform other actions that require authentication', async () => {
    // Esegui qui altre azioni che richiedono autenticazione
  });
});

In questo esempio, creiamo un agente Supertest nell'hook beforeAll e autentichiamo l'agente. I test successivi all'interno del blocco describe possono quindi riutilizzare questo agente autenticato senza doversi ri-autenticare per ogni test.

Best Practice per il Test di Integrazione delle API con Supertest

Per garantire un test di integrazione delle API efficace, considerate le seguenti best practice:

Errori Comuni da Evitare

Conclusione

Il test di integrazione delle API è una parte essenziale del processo di sviluppo del software. Utilizzando Supertest, potete scrivere facilmente test di integrazione API completi e affidabili che aiutano a garantire la qualità e la stabilità della vostra applicazione. Ricordate di concentrarvi sul testare i flussi di lavoro end-to-end, usando dati realistici, isolando i vostri test e automatizzando il processo di testing. Seguendo queste best practice, potete ridurre significativamente il rischio di problemi di integrazione e fornire un prodotto più robusto e affidabile.

Mentre le API continuano a guidare le applicazioni moderne e le architetture a microservizi, l'importanza di test API robusti, e in particolare dei test di integrazione, non farà che crescere. Supertest fornisce un set di strumenti potente e accessibile per gli sviluppatori di tutto il mondo per garantire l'affidabilità e la qualità delle loro interazioni API.