M

MLOG

Latviešu

Visaptveroša rokasgrāmata par integrācijas testēšanu, koncentrējoties uz API testēšanu ar Supertest, aptverot iestatīšanu, labāko praksi un progresīvas metodes.

Integrācijas testēšana: API testēšanas apgūšana ar Supertest

Programmatūras izstrādes jomā ir būtiski nodrošināt, ka atsevišķas sastāvdaļas pareizi darbojas izolēti (vienībtestēšana). Tomēr tikpat svarīgi ir pārbaudīt, ka šīs sastāvdaļas nevainojami darbojas kopā. Tieši šeit savu lomu spēlē integrācijas testēšana. Integrācijas testēšana koncentrējas uz mijiedarbības validāciju starp dažādiem moduļiem vai pakalpojumiem lietojumprogrammā. Šis raksts dziļi iedziļinās integrācijas testēšanā, īpaši koncentrējoties uz API testēšanu ar Supertest — jaudīgu un lietotājam draudzīgu bibliotēku HTTP apgalvojumu testēšanai Node.js vidē.

Kas ir integrācijas testēšana?

Integrācijas testēšana ir programmatūras testēšanas veids, kas apvieno atsevišķus programmatūras moduļus un testē tos kā grupu. Tās mērķis ir atklāt defektus integrēto vienību mijiedarbībā. Atšķirībā no vienībtestēšanas, kas koncentrējas uz atsevišķām sastāvdaļām, integrācijas testēšana pārbauda datu plūsmu un kontroles plūsmu starp moduļiem. Izplatītākās integrācijas testēšanas pieejas ir:

API kontekstā integrācijas testēšana ietver pārbaudi, vai dažādas API pareizi darbojas kopā, vai starp tām pārsūtītie dati ir konsekventi un vai kopējā sistēma darbojas, kā paredzēts. Piemēram, iedomājieties e-komercijas lietojumprogrammu ar atsevišķām API produktu pārvaldībai, lietotāju autentifikācijai un maksājumu apstrādei. Integrācijas testēšana nodrošinātu, ka šīs API pareizi sazinās, ļaujot lietotājiem pārlūkot produktus, droši pieteikties un pabeigt pirkumus.

Kāpēc API integrācijas testēšana ir svarīga?

API integrācijas testēšana ir kritiski svarīga vairāku iemeslu dēļ:

Apsveriet globālu ceļojumu rezervēšanas platformu. API integrācijas testēšana ir vissvarīgākā, lai nodrošinātu netraucētu saziņu starp API, kas apstrādā lidojumu rezervācijas, viesnīcu rezervācijas un maksājumu vārtejas no dažādām valstīm. Nespēja pareizi integrēt šīs API varētu novest pie nepareizām rezervācijām, maksājumu kļūmēm un sliktas lietotāja pieredzes, negatīvi ietekmējot platformas reputāciju un ieņēmumus.

Iepazīstinām ar Supertest: jaudīgs rīks API testēšanai

Supertest ir augsta līmeņa abstrakcija HTTP pieprasījumu testēšanai. Tā nodrošina ērtu un plūstošu API, lai nosūtītu pieprasījumus jūsu lietojumprogrammai un pārbaudītu atbildes. Balstīts uz Node.js, Supertest ir īpaši izstrādāts Node.js HTTP serveru testēšanai. Tas lieliski darbojas ar populāriem testēšanas ietvariem, piemēram, Jest un Mocha.

Supertest galvenās iezīmes:

Testēšanas vides iestatīšana

Pirms sākam, iestatīsim pamata testēšanas vidi. Mēs pieņemsim, ka jums ir instalēts Node.js un npm (vai yarn). Mēs izmantosim Jest kā testēšanas ietvaru un Supertest API testēšanai.

  1. Izveidojiet Node.js projektu:
mkdir api-testing-example
cd api-testing-example
npm init -y
  1. Instalējiet atkarības:
npm install --save-dev jest supertest
npm install express  # Vai jūsu vēlamo ietvaru API izveidei
  1. Konfigurējiet Jest: Pievienojiet šo savam package.json failam:
{
  "scripts": {
    "test": "jest"
  }
}
  1. Izveidojiet vienkāršu API gala punktu: Izveidojiet failu ar nosaukumu app.js (vai līdzīgu) ar šādu kodu:
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; // Eksportē testēšanai

Pirmā Supertest testa rakstīšana

Tagad, kad mūsu vide ir iestatīta, uzrakstīsim vienkāršu Supertest testu, lai pārbaudītu mūsu API gala punktu. Izveidojiet failu ar nosaukumu app.test.js (vai līdzīgu) sava projekta saknes direktorijā:

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

describe('GET /hello', () => {
  it('atbild ar 200 OK un atgriež "Hello, World!"', async () => {
    const response = await request(app).get('/hello');
    expect(response.statusCode).toBe(200);
    expect(response.text).toBe('Hello, World!');
  });
});

Paskaidrojums:

Lai palaistu testu, izpildiet šo komandu savā terminālī:

npm test

Ja viss ir iestatīts pareizi, jums vajadzētu redzēt, ka tests ir veiksmīgs.

Progresīvas Supertest metodes

Supertest piedāvā plašu funkciju klāstu progresīvai API testēšanai. Apskatīsim dažas no tām.

1. Pieprasījuma satura sūtīšana

Lai nosūtītu datus pieprasījuma saturā (body), varat izmantot .send() metodi. Piemēram, izveidosim gala punktu, kas pieņem JSON datus:

app.post('/users', express.json(), (req, res) => {
  const { name, email } = req.body;
  // Simulē lietotāja izveidi datu bāzē
  const user = { id: Date.now(), name, email };
  res.status(201).json(user);
});

Šādi jūs varat testēt šo gala punktu, izmantojot Supertest:

describe('POST /users', () => {
  it('izveido jaunu lietotāju', 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);
  });
});

Paskaidrojums:

2. Galveņu iestatīšana

Lai iestatītu pielāgotas galvenes (headers) savos pieprasījumos, varat izmantot .set() metodi. Tas ir noderīgi, lai iestatītu autentifikācijas marķierus (tokens), satura tipus vai citas pielāgotas galvenes.

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

  it('atgriež 200 OK ar derīgu marķieri', async () => {
    // Simulē derīga marķiera iegūšanu
    const token = 'valid-token';

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

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

Paskaidrojums:

3. Sīkdatņu (Cookies) apstrāde

Supertest var apstrādāt arī sīkdatnes. Jūs varat iestatīt sīkdatnes, izmantojot .set('Cookie', ...) metodi, vai arī varat izmantot .cookies īpašību, lai piekļūtu un modificētu sīkdatnes.

4. Failu augšupielādes testēšana

Supertest var izmantot, lai testētu API gala punktus, kas apstrādā failu augšupielādes. Varat izmantot .attach() metodi, lai pievienotu failus pieprasījumam.

5. Apgalvojumu bibliotēku (Chai) izmantošana

Lai gan Jest iebūvētā apgalvojumu bibliotēka ir pietiekama daudzos gadījumos, jūs varat izmantot arī jaudīgākas apgalvojumu bibliotēkas, piemēram, Chai ar Supertest. Chai nodrošina izteiksmīgāku un elastīgāku apgalvojumu sintaksi. Lai izmantotu Chai, jums tas būs jāinstalē:

npm install --save-dev chai

Tad jūs varat importēt Chai savā testa failā un izmantot tā apgalvojumus:

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

describe('GET /hello', () => {
  it('atbild ar 200 OK un atgriež "Hello, World!"', async () => {
    const response = await request(app).get('/hello');
    expect(response.statusCode).to.equal(200);
    expect(response.text).to.equal('Hello, World!');
  });
});

Piezīme: Jums var būt nepieciešams konfigurēt Jest, lai tas pareizi darbotos ar Chai. Tas bieži ietver iestatīšanas faila pievienošanu, kas importē Chai un konfigurē to darbam ar Jest globālo expect.

6. Aģentu atkārtota izmantošana

Testiem, kuriem nepieciešama īpašas vides iestatīšana (piemēram, autentifikācija), bieži ir izdevīgi atkārtoti izmantot Supertest aģentu. Tas ļauj izvairīties no lieka iestatīšanas koda katrā testa gadījumā.

describe('Autentificēti API testi', () => {
  let agent;

  beforeAll(() => {
    agent = request.agent(app); // Izveido pastāvīgu aģentu
    // Simulē autentifikāciju
    return agent
      .post('/login')
      .send({ username: 'testuser', password: 'password123' });
  });

  it('var piekļūt aizsargātam resursam', async () => {
    const response = await agent.get('/protected').expect(200);
    expect(response.text).toBe('Protected Resource');
  });

  it('var veikt citas darbības, kurām nepieciešama autentifikācija', async () => {
    // Šeit veiciet citas autentificētas darbības
  });
});

Šajā piemērā mēs izveidojam Supertest aģentu beforeAll āķī (hook) un autentificējam aģentu. Turpmākie testi describe blokā var atkārtoti izmantot šo autentificēto aģentu, neveicot atkārtotu autentifikāciju katram testam.

Labākā prakse API integrācijas testēšanā ar Supertest

Lai nodrošinātu efektīvu API integrācijas testēšanu, apsveriet šādas labākās prakses:

Biežākās kļūdas, no kurām jāizvairās

Noslēgums

API integrācijas testēšana ir būtiska programmatūras izstrādes procesa daļa. Izmantojot Supertest, jūs varat viegli rakstīt visaptverošus un uzticamus API integrācijas testus, kas palīdz nodrošināt jūsu lietojumprogrammas kvalitāti un stabilitāti. Atcerieties koncentrēties uz pilnu darbplūsmu testēšanu, izmantojot reālistiskus datus, izolējot savus testus un automatizējot testēšanas procesu. Ievērojot šīs labākās prakses, jūs varat ievērojami samazināt integrācijas problēmu risku un piegādāt stabilāku un uzticamāku produktu.

Tā kā API turpina virzīt modernas lietojumprogrammas un mikropakalpojumu arhitektūras, stabilas API testēšanas, īpaši integrācijas testēšanas, nozīme tikai pieaugs. Supertest nodrošina jaudīgu un pieejamu rīku komplektu izstrādātājiem visā pasaulē, lai nodrošinātu savu API mijiedarbību uzticamību un kvalitāti.