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:

• Top-down-integrasjon: Starter med modulene på høyeste nivå og integrerer nedover.
• Bottom-up-integrasjon: Starter med modulene på laveste nivå og integrerer oppover.
• Big-bang-integrasjon: Integrerer alle moduler samtidig. Denne tilnærmingen er generelt mindre anbefalt på grunn av vanskeligheten med å isolere problemer.
• Sandwich-integrasjon: En kombinasjon av top-down- og bottom-up-integrasjon.

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:

• Sikrer systempålitelighet: Det hjelper med å identifisere integrasjonsproblemer tidlig i utviklingssyklusen, og forhindrer uventede feil i produksjon.
• Validerer dataintegritet: Det verifiserer at data overføres og transformeres korrekt mellom forskjellige API-er.
• Forbedrer applikasjonsytelse: Det kan avdekke ytelsesflaskehalser relatert til API-interaksjoner.
• Forbedrer sikkerheten: Det kan identifisere sikkerhetssårbarheter som oppstår fra feilaktig API-integrasjon. For eksempel å sikre riktig autentisering og autorisasjon når API-er kommuniserer.
• Reduserer utviklingskostnader: Å fikse integrasjonsproblemer tidlig er betydelig billigere enn å håndtere dem senere i utviklingslivssyklusen.

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:

• Enkel å bruke: Supertest tilbyr et enkelt og intuitivt API for å sende HTTP-forespørsler og gjøre påstander.
• Asynkron testing: Det håndterer sømløst asynkrone operasjoner, noe som gjør det ideelt for testing av API-er som er avhengige av asynkron logikk.
• Flytende grensesnitt: Det gir et flytende grensesnitt, som lar deg kjede metoder sammen for konsise og lesbare tester.
• Omfattende påstandsstøtte: Det støtter et bredt spekter av påstander for å verifisere responsstatuskoder, headere og body.
• Integrasjon med testrammeverk: Det integreres sømløst med populære testrammeverk som Jest og Mocha, slik at du kan bruke din eksisterende testinfrastruktur.

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
            

              
                Copy
              
            
          

2. Installer avhengigheter:

            npm install --save-dev jest supertest
npm install express  # Eller ditt foretrukne rammeverk for å lage API-et
            

              
                Copy
              
            
          

3. Konfigurer Jest: Legg til følgende i din package.json-fil:

            {
  "scripts": {
    "test": "jest"
  }
}
            

              
                Copy
              
            
          

4. 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

            

              
                Copy
              
            
          

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

            

              
                Copy
              
            
          

Forklaring:

• Vi importerer supertest og vår Express-app.
• Vi bruker describe for å gruppere testene våre.
• Vi bruker it for å definere en spesifikk testcase.
• Vi bruker request(app) for å opprette en Supertest-agent som vil sende forespørsler til appen vår.
• Vi bruker .get('/hello') for å sende en GET-forespørsel til /hello-endepunktet.
• Vi bruker await for å vente på responsen. Supertests metoder returnerer promises, noe som lar oss bruke async/await for renere kode.
• Vi bruker expect(response.statusCode).toBe(200) for å påstå at responsens statuskode er 200 OK.
• Vi bruker expect(response.text).toBe('Hello, World!') for å påstå at responsens body er "Hello, World!".

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

            npm test
            

              
                Copy
              
            
          

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

              
                Copy
              
            
          

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

              
                Copy
              
            
          

Forklaring:

• Vi bruker .post('/users') for å sende en POST-forespørsel til /users-endepunktet.
• Vi bruker .send(userData) for å sende userData-objektet i forespørselskroppen. Supertest setter automatisk Content-Type-headeren til application/json.
• Vi bruker .expect(201) for å påstå at responsens statuskode er 201 Created.
• Vi bruker expect(response.body).toHaveProperty('id') for å påstå at responsens body inneholder en id-egenskap.
• Vi bruker expect(response.body.name).toBe(userData.name) og expect(response.body.email).toBe(userData.email) for å påstå at name- og email-egenskapene i responsens body samsvarer med dataene vi sendte i forespørselen.

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

              
                Copy
              
            
          

Forklaring:

• Vi bruker .set('Authorization', `Bearer ${token}`) for å sette Authorization-headeren til Bearer ${token}.

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
            

              
                Copy
              
            
          

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

              
                Copy
              
            
          

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

              
                Copy
              
            
          

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:

• Test ende-til-ende-arbeidsflyter: Fokuser på å teste komplette brukerarbeidsflyter i stedet for isolerte API-endepunkter. Dette hjelper med å identifisere integrasjonsproblemer som kanskje ikke er tydelige når man tester individuelle API-er isolert.
• Bruk realistiske data: Bruk realistiske data i testene dine for å simulere virkelige scenarier. Dette inkluderer bruk av gyldige dataformater, grenseverdier og potensielt ugyldige data for å teste feilhåndtering.
• Isoler testene dine: Sørg for at testene dine er uavhengige av hverandre og at de ikke er avhengige av delt tilstand. Dette vil gjøre testene dine mer pålitelige og enklere å feilsøke. Vurder å bruke en dedikert testdatabase eller mocke eksterne avhengigheter.
• Mock eksterne avhengigheter: Bruk mocking for å isolere API-et ditt fra eksterne avhengigheter, som databaser, tredjeparts-API-er eller andre tjenester. Dette vil gjøre testene dine raskere og mer pålitelige, og det vil også tillate deg å teste forskjellige scenarier uten å være avhengig av tilgjengeligheten til eksterne tjenester. Biblioteker som nock er nyttige for å mocke HTTP-forespørsler.
• Skriv omfattende tester: Sikt på omfattende testdekning, inkludert positive tester (verifisering av vellykkede responser), negative tester (verifisering av feilhåndtering) og grensetester (verifisering av grensetilfeller).
• Automatiser testene dine: Integrer API-integrasjonstestene dine i din kontinuerlige integrasjons (CI)-pipeline for å sikre at de kjøres automatisk hver gang endringer gjøres i kodebasen. Dette vil bidra til å identifisere integrasjonsproblemer tidlig og forhindre at de når produksjon.
• Dokumenter testene dine: Dokumenter API-integrasjonstestene dine klart og konsist. Dette vil gjøre det enklere for andre utviklere å forstå formålet med testene og å vedlikeholde dem over tid.
• Bruk miljøvariabler: Lagre sensitiv informasjon som API-nøkler, databasepassord og andre konfigurasjonsverdier i miljøvariabler i stedet for å hardkode dem i testene dine. Dette vil gjøre testene dine sikrere og enklere å konfigurere for forskjellige miljøer.
• Vurder API-kontrakter: Benytt API-kontrakttesting for å validere at API-et ditt overholder en definert kontrakt (f.eks. OpenAPI/Swagger). Dette bidrar til å sikre kompatibilitet mellom forskjellige tjenester og forhindrer ødeleggende endringer. Verktøy som Pact kan brukes for kontrakttesting.

Vanlige feil å unngå

• Ikke isolere tester: Tester bør være uavhengige. Unngå å stole på utfallet av andre tester.
• Teste implementeringsdetaljer: Fokuser på API-ets oppførsel og kontrakt, ikke den interne implementeringen.
• Ignorere feilhåndtering: Test grundig hvordan API-et ditt håndterer ugyldige inndata, grensetilfeller og uventede feil.
• Hoppe over autentiserings- og autorisasjonstesting: Sørg for at API-ets sikkerhetsmekanismer testes ordentlig for å forhindre uautorisert tilgang.

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.