Å være vert for et API har et ansvar for å sørge for at det fungerer. Det er ingen bedre eller enklere måte å gjøre det på enn automatisert testing med et verktøy som Mocha.

Moderne programvareutvikling gjør stor bruk av APIer. De fungerer som en avgjørende kobling mellom klientsideapplikasjoner og backend-applikasjoner, så vel som mellom forskjellige interne eller eksterne apper.

APIer tillater jevn kommunikasjon og datautveksling, og lar programvarekomponenter sømløst samhandle med hverandre. Å sikre påliteligheten, funksjonaliteten og ytelsen til disse API-ene er av største betydning for å levere en sømløs brukeropplevelse og opprettholde den generelle integriteten til systemet.

Det er derfor viktig å teste API-ene dine grundig for å flagge og rette opp feil under utvikling for å forhindre potensielle systemfeil i produksjonsmiljøer.

Testing av Node.js APIer ved å bruke Mocha, Chai og Chai-HTTP

Mokka er et mye brukt testrammeverk som er kompatibelt med ulike JavaScript-rammeverk. En av nøkkelfunksjonene er en fleksibel testløper som forenkler prosessen med å administrere og utføre testsaker effektivt.

instagram viewer

Den støtter også ulike teststiler, inkludert synkron og asynkron testing, noe som gir mulighet for et bredt spekter av testscenarier.

På den andre siden, Chai og Chai-HTTP er påstandsbiblioteker som du kan bruke sammen med Mocha. Chai tilbyr et bredt spekter av uttrykksfulle og lesbare påstandsgrensesnitt som bør, forvente og hevde. Mens Chai-HTTP, en utvidelse av Chai, gir et grensesnitt spesielt designet for å teste HTTP-forespørsler og hevde deres svar.

Ved å bruke Mocha sammen med Chai og Chai-HTTP kan du teste API-er effektivt. Arbeidsflyten for testing omfatter:

  • Foreta HTTP-forespørsler til de angitte API-endepunktene.
  • Definere forventede svar.
  • Validering av mottatte data fra den angitte kilden, HTTP-statuskodene og mer.

Du kan også simulere API-feiltestscenarier som kan oppstå i slike situasjoner og hvilke handlinger som bør utløse i tilfelle de oppstår.

Du kan finne dette prosjektets kode i sin GitHub-depot.

Sett opp Express.js-prosjektet og MongoDB-databasen

For å komme i gang, opprette en Express-webserver, og installer disse pakkene:

npm installer cors dotenv mongoose mongodb

Neste, opprette en MongoDB-database eller konfigurere en MongoDB-klynge på skyen. Kopier deretter databasetilkoblings-URLen, lag en .env fil i rotkatalogen, og lim inn i databasetilkoblingsstrengen:

CONNECTION_STRING="tilkoblingsstreng"

For å fullføre oppsettprosessen må du konfigurere databasetilkoblingen og definere datamodellene for brukerdataene dine. Se koden i dette prosjektets GitHub-depot for å:

  • Konfigurer databasetilkoblingen, i utils/db.js.
  • Definer brukerdataskjemaet i models/user.model.js.

Definer behandlerfunksjonene for API-rutene

Kontrollerfunksjonene vil administrere tillegg og gjenfinning av brukerdata i databasen. For å sikre funksjonaliteten til disse behandlerfunksjonene, vil du teste om de kan poste og hente data fra databasen.

I rotkatalogen oppretter du en kontrollere/brukerkontrollere.js fil og legg til følgende kode:

konst Bruker = krever('../models/user.model');
exports.registerUser = asynkron (req, res) => {
konst { brukernavn, passord } = req.body;


prøve {
avvente User.create({ brukernavn, passord});
 res.status(201).sende({ beskjed: "Bruker registrert vellykket" });
 } å fange (feil) {
konsoll.log (feil);
 res.status(500).sende({ beskjed: 'En feil oppstod!! ' });
 }
};
exports.getUsers = asynkron (req, res) => {
prøve {
konst brukere = avvente Bruker.finn({});
 res.json (brukere);
 } å fange (feil) {
konsoll.log (feil);
 res.status(500).sende({ beskjed: 'En feil oppstod!!' });
 }
};

Definer API-rutene

Lage en ny routes/userRoutes.js fil i rotkatalogen og legg til følgende kode.

konst uttrykke = krever('uttrykke');
konst ruter = ekspress. Ruter();
konst userControllers = krever('../controllers/userControllers');
router.post('/api/register', userControllers.registerUser);
router.get('/api/brukere', userControllers.getUsers);
modul.exports = ruter;

Definer serverinngangspunktet

Oppdater din server.js fil med følgende kode.

konst uttrykke = krever('uttrykke');
konst cors = krever('cors');
konst app = express();
konst port = 5000;
krever('dotenv').config();
konst connectDB = krever('./utils/db');
koble DB();


app.use (express.json());
app.use (express.urlencoded({ forlenget: ekte }));
app.use (cors());


konst brukerruter = krever('./ruter/brukerruter');
app.bruk('/', brukerruter);


app.listen (port, () => {
konsoll.Logg(`Tjeneren lytter til http://localhost:${port}`);
});
modul.exports = app;

Skriv og utfør testsakene med mokka

Med bruker-APIet på plass, fortsett og konfigurer testmiljøet. Installer først disse pakkene som dev-avhengigheter.

npm installer mocha chai chai-http --save-dev

Legg nå til følgende skript til filen package.json.

"skript": {
"test": "mokka --timeout 10000"
},

Denne kommandoen vil utføre testtilfellene – ved å legge til timeout-egenskapen med en passende verdi kan du kontrollere den maksimale tiden som er tillatt for individuelle testtilfeller å utføre.

Dette kan være nyttig for å forhindre at tester kjøres på ubestemt tid eller fullføres for raskt før testsakene er ferdige.

Test API-endepunktene

Opprett en ny mappe i rotkatalogen og navngi den test. Opprett en ny i denne mappen user.tests.js fil og legg til følgende kode for POST-endepunkttestsaken.

konst chai = krever('chai');
konst chaiHttp = krever('chai-http');
konst app = krever('../server'); 
chai.bruk (chaiHttp);
konst forvente = chai.forvente;


beskrive("Bruker API", () => {
 beskrive('POST /api/register', () => {
 den('skal håndtere brukerregistrering', (ferdig) => {
 chai.request (app)
 .post('/api/register')
 .sende({ brukernavn: 'testbruker', passord: 'testpassord' })
 .slutt((feil, res) => {
hvis (feil) {
 forventer (res).å.ha.status(500);
 forventer (res.body).to.ha.property('beskjed').som.er.lik('En feil oppstod!!');
 } ellers {
 forventer (res).å.ha.status(201);
 forventer (res.body).to.ha.property('beskjed').lik("Bruker registrert vellykket");
 }
 ferdig();
 });
 });
 });
});

Denne koden definerer et testtilfelle som bruker Chai og Chai HTTP for å teste brukerregistreringsfunksjonaliteten til bruker-API.

Den sender en POST-forespørsel til det angitte endepunktet og kommer med påstander om forventet API-svar, og bekrefter om brukerregistreringsfunksjonaliteten var vellykket eller om det oppsto en feil.

Her er en oversikt over hovedkomponentene i testsaken:

  • forvente -Dette objektet lar deg bruke Chai-påstandsmetodene for å komme med påstander om forventet respons fra API.
  • beskrive - Den beskriver relaterte testtilfeller sammen, i dette tilfellet tester relatert til Bruker-API. Den nestede beskrivelsen blokkerer ytterligere grupper relaterte testtilfeller sammen, i dette tilfellet POST /api/register. Dette hjelper til med å organisere testsakene spesifikt knyttet til en bestemt funksjonalitet.
  • den - Denne funksjonen beskriver forventet oppførsel til API-endepunktet.
  • slutt - Denne funksjonen sender forespørselen og gir en tilbakeringingsfunksjon for å håndtere svaret. Tilbakeringingsfunksjonen utfører påstander ved å bruke forvente funksjon for å sjekke svaret mottatt fra API.
  • ferdig - Denne funksjonen kjører for å markere slutten på testsaken.

Til slutt legger du til koden for GET-endepunkttestsaken rett etter POST-endepunkttestsaken.

beskrive('GET /api/brukere', () => {
 den('bør hente alle brukerdata', (ferdig) => {
 chai.request (app)
 .få('/api/brukere')
 .slutt((feil, res) => {
hvis (feil) {
 forventer (res).å.ha.status(500);
 forventer (res.body).to.ha.property('beskjed').som.er.lik("Det oppstod en feil under henting av brukerdata");
 } ellers {
 forventer (res).å.ha.status(200);
 forventer (res.body).to.be.an('array');
 }
 ferdig();
 });
 });
});

Gå videre og kjør testskriptet på terminalen din for å utføre de to testsakene.

npm test

Hvis utførelsen av testtilfellene ikke støter på noen feil, bør du se lignende utdata som indikerer at testene bestått.

Testfeil kan oppstå på grunn av ulike årsaker, for eksempel problemer med nettverkstilkobling under HTTP-forespørsler til databasen, manglende nødvendige data, logiske feil og andre problemer.

Mocha gjør en god jobb med å identifisere og fremheve slike feil, og gir klare og detaljerte testrapporter i loggene som vises i terminalvinduet. Dette lar deg enkelt identifisere og diagnostisere de spesifikke problemene som forårsaket testfeilene.

Mokka gir deg ingen unnskyldning for ikke å teste API-ene dine

Selv om manuell testing av funksjonaliteten til API-ene dine ved hjelp av verktøy som Postman er en gyldig testing tilnærming, utnytte Mocha og andre testrammeverk for automatisert testing tar det til neste nivå.

Med disse testverktøyene kan du raskt og enkelt automatisere tester for å dekke et bredt spekter av scenarier og kantsaker. Dette gjør at du raskt kan oppdage feil og løse dem før du distribuerer API-ene dine, og sikrer at du sender programvare av høy kvalitet til produksjon.