M

MLOG

Norsk

En omfattende guide til integrasjonstesting med fokus på API-testing ved hjelp av Supertest, som dekker oppsett, beste praksis og avanserte teknikker for robust applikasjonstesting.

Integrasjonstesting: Mestring av API-testing med Supertest

Innen programvareutvikling er det avgjørende å sikre at individuelle komponenter fungerer korrekt isolert (enhetstesting). Det er imidlertid like viktig å verifisere at disse komponentene fungerer sømløst sammen. Det er her integrasjonstesting kommer inn i bildet. Integrasjonstesting fokuserer på å validere samspillet mellom forskjellige moduler eller tjenester i en applikasjon. Denne artikkelen dykker dypt ned i integrasjonstesting, med spesifikt fokus på API-testing med Supertest, et kraftig og brukervennlig bibliotek for testing av HTTP-påstander i Node.js.

Hva er integrasjonstesting?

Integrasjonstesting er en type programvaretesting som kombinerer individuelle programvaremoduler og tester dem som en gruppe. Målet er å avdekke feil i interaksjonene mellom integrerte enheter. I motsetning til enhetstesting, som fokuserer på individuelle komponenter, verifiserer integrasjonstesting dataflyten og kontrollflyten mellom moduler. Vanlige tilnærminger til integrasjonstesting inkluderer:

I konteksten av API-er innebærer integrasjonstesting å verifisere at forskjellige API-er fungerer korrekt sammen, at dataene som sendes mellom dem er konsistente, og at det overordnede systemet fungerer som forventet. Tenk deg for eksempel en e-handelsapplikasjon med separate API-er for produktadministrasjon, brukerautentisering og betalingsbehandling. Integrasjonstesting vil sikre at disse API-ene kommuniserer korrekt, slik at brukere kan bla gjennom produkter, logge seg trygt inn og fullføre kjøp.

Hvorfor er API-integrasjonstesting viktig?

API-integrasjonstesting er kritisk av flere grunner:

Tenk på en global reisebestillingsplattform. API-integrasjonstesting er avgjørende for å sikre smidig kommunikasjon mellom API-er som håndterer flyreservasjoner, hotellbestillinger og betalingsløsninger fra forskjellige land. Unnlatelse av å integrere disse API-ene riktig kan føre til feilaktige bestillinger, betalingsfeil og en dårlig brukeropplevelse, noe som påvirker plattformens omdømme og inntekter negativt.

Introduksjon til Supertest: Et kraftig verktøy for API-testing

Supertest er en høynivå-abstraksjon for testing av HTTP-forespørsler. Det gir et praktisk og flytende API for å sende forespørsler til applikasjonen din og gjøre påstander om responsene. Supertest er bygget på toppen av Node.js og er spesielt designet for testing av Node.js HTTP-servere. Det fungerer usedvanlig godt med populære testrammeverk som Jest og Mocha.

Nøkkelfunksjoner i Supertest:

Sette opp testmiljøet ditt

Før vi begynner, la oss sette opp et grunnleggende testmiljø. Vi antar at du har Node.js og npm (eller yarn) installert. Vi vil bruke Jest som vårt testrammeverk og Supertest for API-testing.

  1. Opprett et Node.js-prosjekt:
mkdir api-testing-example
cd api-testing-example
npm init -y
  1. Installer avhengigheter:
npm install --save-dev jest supertest
npm install express  # Eller ditt foretrukne rammeverk for å lage API-et
  1. Konfigurer Jest: Legg til følgende i din package.json-fil:
{
  "scripts": {
    "test": "jest"
  }
}
  1. Opprett et enkelt API-endepunkt: Opprett en fil med navnet app.js (eller lignende) med følgende kode:
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; // Eksporter for testing

Skrive din første Supertest-test

Nå som vi har satt opp miljøet vårt, la oss skrive en enkel Supertest-test for å verifisere API-endepunktet vårt. Opprett en fil med navnet app.test.js (eller lignende) i roten av prosjektet ditt:

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!');
  });
});

Forklaring:

For å kjøre testen, utfør følgende kommando i terminalen din:

npm test

Hvis alt er satt opp riktig, bør du se at testen passerer.

Avanserte Supertest-teknikker

Supertest tilbyr et bredt spekter av funksjoner for avansert API-testing. La oss utforske noen av dem.

1. Sende forespørselskropper (Request Bodies)

For å sende data i forespørselskroppen, kan du bruke .send()-metoden. La oss for eksempel opprette et endepunkt som godtar JSON-data:

app.post('/users', express.json(), (req, res) => {
  const { name, email } = req.body;
  // Simulerer oppretting av en bruker i en database
  const user = { id: Date.now(), name, email };
  res.status(201).json(user);
});

Slik kan du teste dette endepunktet ved hjelp av 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);
  });
});

Forklaring:

2. Sette headere

For å sette egendefinerte headere i forespørslene dine, kan du bruke .set()-metoden. Dette er nyttig for å sette autentiseringstokener, innholdstyper eller andre egendefinerte headere.

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 () => {
    // Simulerer henting av et gyldig token
    const token = 'valid-token';

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

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

Forklaring:

3. Håndtering av cookies

Supertest kan også håndtere cookies. Du kan sette cookies ved hjelp av .set('Cookie', ...)-metoden, eller du kan bruke .cookies-egenskapen for å få tilgang til og endre cookies.

4. Testing av filopplastinger

Supertest kan brukes til å teste API-endepunkter som håndterer filopplastinger. Du kan bruke .attach()-metoden for å legge ved filer i forespørselen.

5. Bruke påstandsbiblioteker (Chai)

Selv om Jests innebygde påstandsbibliotek er tilstrekkelig i mange tilfeller, kan du også bruke kraftigere påstandsbiblioteker som Chai med Supertest. Chai gir en mer uttrykksfull og fleksibel påstandssyntaks. For å bruke Chai, må du installere det:

npm install --save-dev chai

Deretter kan du importere Chai inn i testfilen din og bruke dets påstander:

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!');
  });
});

Merk: Du må kanskje konfigurere Jest for å fungere korrekt med Chai. Dette innebærer ofte å legge til en oppsettsfil som importerer Chai og konfigurerer det til å fungere med Jests globale expect.

6. Gjenbruke agenter

For tester som krever oppsett av et spesifikt miljø (f.eks. autentisering), er det ofte fordelaktig å gjenbruke en Supertest-agent. Dette unngår overflødig oppsettskode i hver testcase.

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

  beforeAll(() => {
    agent = request.agent(app); // Opprett en vedvarende agent
    // Simulerer autentisering
    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 () => {
    // Utfør andre autentiserte handlinger her
  });
});

I dette eksempelet oppretter vi en Supertest-agent i beforeAll-hooken og autentiserer agenten. Påfølgende tester innenfor describe-blokken kan deretter gjenbruke denne autentiserte agenten uten å måtte re-autentisere for hver test.

Beste praksis for API-integrasjonstesting med Supertest

For å sikre effektiv API-integrasjonstesting, bør du vurdere følgende beste praksis:

Vanlige feil å unngå

Konklusjon

API-integrasjonstesting er en essensiell del av programvareutviklingsprosessen. Ved å bruke Supertest kan du enkelt skrive omfattende og pålitelige API-integrasjonstester som bidrar til å sikre kvaliteten og stabiliteten til applikasjonen din. Husk å fokusere på å teste ende-til-ende-arbeidsflyter, bruke realistiske data, isolere testene dine og automatisere testprosessen. Ved å følge disse beste praksisene kan du betydelig redusere risikoen for integrasjonsproblemer og levere et mer robust og pålitelig produkt.

Ettersom API-er fortsetter å drive moderne applikasjoner og mikrotjenestearkitekturer, vil viktigheten av robust API-testing, og spesielt integrasjonstesting, bare fortsette å vokse. Supertest gir et kraftig og tilgjengelig verktøysett for utviklere over hele verden for å sikre påliteligheten og kvaliteten på deres API-interaksjoner.