Node.js REST API's testen met Mocha, Chai en Chai-HTTP

Moderne softwareontwikkeling maakt veel gebruik van API's. Ze dienen als een cruciale schakel tussen client-side applicaties en backend-applicaties, maar ook tussen verschillende interne of externe apps.

API's zorgen voor een soepele communicatie en gegevensuitwisseling, waardoor softwarecomponenten naadloos met elkaar kunnen communiceren. Het waarborgen van de betrouwbaarheid, functionaliteit en prestaties van deze API's is van het grootste belang om een ​​naadloze gebruikerservaring te bieden en de algehele integriteit van het systeem te behouden.

Het is daarom belangrijk om uw API's grondig te testen om bugs tijdens de ontwikkeling te markeren en te corrigeren om mogelijke systeemstoringen in productieomgevingen te voorkomen.

Node.js API's testen met Mocha, Chai en Chai-HTTP

Mokka is een veelgebruikt testraamwerk dat compatibel is met verschillende

JavaScript-frameworks. Een van de belangrijkste kenmerken is een flexibele testrunner die het proces van het effectief beheren en uitvoeren van testgevallen vereenvoudigt.

Het ondersteunt ook verschillende teststijlen, waaronder synchroon en asynchrone tests, waardoor een breed scala aan testscenario's mogelijk is.

Aan de andere kant, Chai En Chai-HTTP zijn assertion-bibliotheken die u kunt gebruiken in combinatie met Mocha. Chai biedt een breed scala aan expressieve en leesbare assertion-interfaces, zoals zouden moeten, verwachten en beweren. Terwijl Chai-HTTP, een uitbreiding van Chai, een interface biedt die speciaal is ontworpen voor het testen van HTTP-verzoeken en het bevestigen van hun antwoorden.

Door Mocha te gebruiken in combinatie met Chai en Chai-HTTP, kunt u API's effectief testen. De testworkflow omvat:

• HTTP-aanvragen doen naar de opgegeven API-eindpunten.
• Het definiëren van de verwachte reacties.
• Het valideren van de ontvangen gegevens van de opgegeven bron, de HTTP-statuscodes en meer.

U kunt ook API-fouttestscenario's simuleren die zich in dergelijke situaties kunnen voordoen en welke acties moeten worden geactiveerd als ze zich voordoen.

U kunt de code van dit project vinden in de bijbehorende GitHub-opslagplaats.

Stel het Express.js-project en de MongoDB-database in

Starten, een Express-webserver maken, en installeer deze pakketten:

npm install cors dotenv mongoose mongodb

Volgende, maak een MongoDB-database of configureer een MongoDB-cluster in de cloud. Kopieer vervolgens de URL van de databaseverbinding, maak een .env bestand in de hoofdmap en plak de databaseverbindingsreeks in:

CONNECTION_STRING="verbindingsreeks"

Om het installatieproces te voltooien, moet u de databaseverbinding configureren en de gegevensmodellen voor uw gebruikersgegevens definiëren. Raadpleeg de code in de GitHub-repository van dit project om:

• Configureer de databaseverbinding, in utils/db.js.
• Definieer het gebruikersgegevensschema in modellen/gebruiker.model.js.

Definieer de handlerfuncties voor de API-routes

De controllerfuncties beheren het toevoegen en ophalen van gebruikersgegevens in de database. Om de functionaliteit van deze handlerfuncties te waarborgen, test je of ze met succes gegevens uit de database kunnen posten en ophalen.

Maak in de hoofdmap een controllers/userControllers.js bestand en voeg de volgende code toe:

const Gebruiker = vereisen('../modellen/gebruiker.model');
export.registerUser = asynchroon (req, res) => {
const { gebruikersnaam, wachtwoord } = req.body;
poging {
wachten User.create({ gebruikersnaam, wachtwoord});
 res.status(201).versturen({ bericht: 'Gebruiker succesvol geregistreerd' });
 } vangst (fout) {
troosten.log (fout);
 res.status(500).versturen({ bericht: 'Er is een fout opgetreden!! ' });
 }
};
export.getUsers = asynchroon (req, res) => {
poging {
const gebruikers = wachten Gebruiker.zoeken({});
 res.json (gebruikers);
 } vangst (fout) {
troosten.log (fout);
 res.status(500).versturen({ bericht: 'Er is een fout opgetreden!!' });
 }
};

Definieer de API-routes

Maak een nieuwe aan routes/userRoutes.js bestand in de hoofdmap en voeg de volgende code toe.

const uitdrukken = vereisen('nadrukkelijk');
const router = expres. Router();
const gebruikerControllers = vereisen('../controllers/userControllers');
router.post('/api/register', userControllers.registerUser);
router.get('/api/gebruikers', userControllers.getUsers);
moduul.export = router;

Definieer uw servertoegangspunt

Update uw server.js bestand met de volgende code.

const uitdrukken = vereisen('nadrukkelijk');
const koren = vereisen('cors');
const app = uitdrukken();
const poort = 5000;
vereisen('dotenv'.config();
const connectDB = vereisen('./utils/db');
connectDB();
app.gebruik (express.json());
app.gebruik (express.urlencoded({ verlengd: WAAR }));
app.gebruik (cors());
const gebruikerRoutes = vereisen('./routes/userRoutes');
app.gebruik('/', gebruikerRoutes);
app.listen (poort, () => {
troosten.log(`Server luistert naar http://localhost:${poort}`);
});
moduul.export = app;

Schrijf en voer de testgevallen uit met Mocha

Met de gebruikers-API kunt u doorgaan en de testomgeving configureren. Installeer deze pakketten eerst als dev-afhankelijkheden.

npm install mocha chai chai-http --save-dev

Voeg nu het volgende script toe aan uw package.json-bestand.

"scripts": {
"test": "mokka --time-out 10000"
},

Met deze opdracht worden de testcases uitgevoerd. Door de timeout-eigenschap met een geschikte waarde toe te voegen, kunt u de maximale tijd bepalen die is toegestaan ​​voor individuele testcases om uit te voeren.

Dit kan handig zijn om te voorkomen dat tests voor onbepaalde tijd worden uitgevoerd of te snel worden voltooid voordat de testgevallen zijn voltooid.

Test de API-eindpunten

Maak in de hoofdmap een nieuwe map en geef deze een naam test. Maak in deze map een nieuw gebruiker.tests.js -bestand en voeg de volgende code toe voor de POST-eindpunttestcase.

const chai = vereisen('chai');
const chaiHttp = vereisen('chai-http');
const app= vereisen('../server'); 
chai.gebruik (chaiHttp);
const verwachten = chai.verwachten;
beschrijven('Gebruikers-API', () => {
 beschrijven('POST /api/register', () => {
 Het('moet gebruikersregistratie afhandelen', (klaar) => {
 chai.request (app)
 .na('/api/register')
 .versturen({ gebruikersnaam: 'testGebruiker', wachtwoord: 'testwachtwoord' })
 .einde((fout, res) => {
als (fout) {
 verwachten (res).status.hebben(500);
 verwachten (res.body).to.have.property('bericht').dat.is.gelijk('Er is een fout opgetreden!!');
 } anders {
 verwachten (res).status.hebben(201);
 verwachten (res.body).to.have.property('bericht').gelijkwaardig('Gebruiker succesvol geregistreerd');
 }
 klaar();
 });
 });
 });
});

Deze code definieert een testcase met behulp van Chai en Chai HTTP om de gebruikersregistratiefunctionaliteit van de gebruikers-API te testen.

Het stuurt een POST-verzoek naar het gespecificeerde eindpunt en doet uitspraken over de verwachte API-respons, waarbij wordt geverifieerd of de gebruikersregistratiefunctionaliteit succesvol was of dat er een fout is opgetreden.

Hier volgt een overzicht van de belangrijkste componenten van de testcase:

• verwachten -Dit object stelt u in staat om de Chai-bevestigingsmethoden te gebruiken om beweringen te doen over de verwachte reactie van de API.
• beschrijven - Het beschrijft gerelateerde testgevallen samen, in dit geval tests gerelateerd aan de Gebruikers-API. Het geneste blok Beschrijving groepeert verder gerelateerde testgevallen samen, in dit geval de POST /api/register. Dit helpt bij het organiseren van de testgevallen die specifiek betrekking hebben op een bepaalde functionaliteit.
• Het - Deze functie beschrijft het verwachte gedrag van het API-eindpunt.
• einde - Deze functie verzendt het verzoek en biedt een terugbelfunctie om het antwoord af te handelen. De callback-functie voert beweringen uit met behulp van de verwachten functie om het antwoord van de API te controleren.
• klaar - Deze functie wordt uitgevoerd om het einde van de testcase te markeren.

Voeg ten slotte de code voor de GET-eindpunttestcase direct na de POST-eindpunttestcase toe.

beschrijven('GET /api/gebruikers', () => {
 Het('zou alle gebruikersgegevens moeten ophalen', (klaar) => {
 chai.request (app)
 .krijgen('/api/gebruikers')
 .einde((fout, res) => {
als (fout) {
 verwachten (res).status.hebben(500);
 verwachten (res.body).to.have.property('bericht').dat.is.gelijk('Er is een fout opgetreden bij het ophalen van gebruikersgegevens');
 } anders {
 verwachten (res).status.hebben(200);
 verwacht (res.body).to.be.an('matrix');
 }
 klaar();
 });
 });
});

Ga je gang en voer het testscript uit op je terminal om de twee testcases uit te voeren.

npm-test

Als de uitvoering van de testgevallen geen fouten tegenkomt, zou u vergelijkbare uitvoer moeten zien die aangeeft dat de tests met succes zijn doorstaan.

Testfouten kunnen om verschillende redenen optreden, zoals problemen met de netwerkverbinding tijdens HTTP-verzoeken aan de database, ontbrekende vereiste gegevens, logische fouten en andere problemen.

Mocha kan dergelijke fouten goed identificeren en markeren, door duidelijke en gedetailleerde testrapporten te leveren in de logboeken die in het terminalvenster worden weergegeven. Hierdoor kunt u eenvoudig de specifieke problemen identificeren en diagnosticeren die de testfouten hebben veroorzaakt.

Mocha geeft u geen excuus om uw API's niet te testen

Hoewel het handmatig testen van de functionaliteit van uw API's met behulp van tools zoals Postman een geldige test is aanpak, het gebruik van Mocha en andere testkaders voor geautomatiseerd testen brengt het naar de volgende stap niveau.

Met deze testtools kunt u snel en eenvoudig tests automatiseren om een ​​breed scala aan scenario's en randgevallen te dekken. Hierdoor kunt u snel bugs detecteren en oplossen voordat u uw API's implementeert, zodat u software van hoge kwaliteit naar productie verzendt.