Hosting af en API har et ansvar for at sikre, at det fungerer. Der er ingen bedre eller nemmere måde at gøre det på end automatiseret test med et værktøj som Mocha.

Moderne softwareudvikling gør stor brug af API'er. De fungerer som et afgørende bindeled mellem klient-side-applikationer og backend-applikationer, såvel som mellem forskellige interne eller eksterne apps.

API'er tillader jævn kommunikation og dataudveksling, hvilket lader softwarekomponenter problemfrit interagere med hinanden. Det er yderst vigtigt at sikre pålideligheden, funktionaliteten og ydeevnen af ​​disse API'er for at levere en problemfri brugeroplevelse og bevare systemets overordnede integritet.

Det er derfor vigtigt at teste dine API'er grundigt for at markere og rette fejl under udvikling for at forhindre potentielle systemfejl i produktionsmiljøer.

Test af Node.js API'er ved hjælp af Mocha, Chai og Chai-HTTP

Mokka er en udbredt testramme, der er kompatibel med forskellige JavaScript rammer. En af dens nøglefunktioner er en fleksibel testløber, der forenkler processen med at administrere og udføre testcases effektivt.

instagram viewer

Det understøtter også forskellige teststile, herunder synkron og asynkron test, hvilket giver mulighed for en bred vifte af testscenarier.

På den anden side, Chai og Chai-HTTP er påstandsbiblioteker, som du kan bruge i forbindelse med Mocha. Chai tilbyder en bred vifte af udtryksfulde og læsbare påstandsgrænseflader såsom burde, forvente og hævde. Mens Chai-HTTP, en udvidelse af Chai, giver en grænseflade, der er specielt designet til at teste HTTP-anmodninger og hævde deres svar.

Ved at bruge Mocha i forbindelse med Chai og Chai-HTTP kan du teste API'er effektivt. Testens arbejdsgang omfatter:

  • Fremstilling af HTTP-anmodninger til de angivne API-endepunkter.
  • Definition af de forventede svar.
  • Validering af de modtagne data fra den angivne kilde, HTTP-statuskoderne og mere.

Du kan også simulere API-fejltestscenarier, der kan opstå i sådanne situationer, og hvilke handlinger der skal udløse, hvis de opstår.

Du kan finde dette projekts kode i dens GitHub-depot.

Konfigurer Express.js-projektet og MongoDB-databasen

For at komme i gang, oprette en Express-webserver, og installer disse pakker:

npm installer cors dotenv mongoose mongodb

Næste, oprette en MongoDB-database eller konfigurere en MongoDB-klynge i skyen. Kopier derefter databaseforbindelsens URL, opret en .env fil i rodmappen, og indsæt i databaseforbindelsesstrengen:

CONNECTION_STRING="forbindelsesstreng"

For at afslutte opsætningsprocessen skal du konfigurere databaseforbindelsen og definere datamodellerne for dine brugerdata. Se koden i dette projekts GitHub-lager til:

  • Konfigurer databaseforbindelsen i utils/db.js.
  • Definer brugerdataskemaet i models/user.model.js.

Definer Handler-funktionerne for API-ruterne

Controllerfunktionerne vil administrere tilføjelse og genfinding af brugerdata i databasen. For at sikre funktionaliteten af ​​disse behandlerfunktioner vil du teste, om de kan sende og hente data fra databasen.

I rodmappen skal du oprette en controllere/userControllers.js fil og tilføj følgende kode:

konst Bruger = kræve('../models/user.model');
exports.registerBruger = asynkron (req, res) => {
konst { brugernavn, adgangskode } = req.body;


prøve {
vente User.create({ brugernavn, adgangskode});
 res.status(201).sende({ besked: 'Bruger registreret med succes' });
 } fangst (fejl) {
konsol.log (fejl);
 res.status(500).sende({ besked: 'En fejl opstod!! ' });
 }
};
exports.getUsers = asynkron (req, res) => {
prøve {
konst brugere = vente Bruger.find({});
 res.json (brugere);
 } fangst (fejl) {
konsol.log (fejl);
 res.status(500).sende({ besked: 'En fejl opstod!!' });
 }
};

Definer API-ruterne

Opret en ny routes/userRoutes.js fil i rodmappen og tilføj følgende kode.

konst udtrykke = kræve('udtrykke');
konst router = ekspres. Router();
konst userControllers = kræve('../controllers/userControllers');
router.post('/api/register', userControllers.registerUser);
router.get('/api/brugere', userControllers.getUsers);
modul.exports = router;

Definer dit serverindgangspunkt

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

konst udtrykke = kræve('udtrykke');
konst cors = kræve('cors');
konst app = express();
konst port = 5000;
kræve('dotenv').config();
konst connectDB = kræve('./utils/db');
connectDB();


app.use (express.json());
app.use (express.urlencoded({ udvidet: rigtigt }));
app.use (cors());


konst brugerruter = kræve('./routes/brugerRoutes');
app.brug('/', brugerruter);


app.listen (port, () => {
konsol.log(`Serveren lytter kl http://localhost:${port}`);
});
modul.exports = app;

Skriv og udfør testsagen med mokka

Med bruger-API'en på plads, gå videre og konfigurer testmiljøet. Først skal du installere disse pakker som dev-afhængigheder.

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

Tilføj nu følgende script til din package.json-fil.

"scripts": {
"prøve": "mokka --timeout 10000"
},

Denne kommando vil udføre testcaserne - ved at tilføje timeout-egenskaben med en passende værdi kan du kontrollere den maksimale tid, der er tilladt for individuelle testcases at udføre.

Dette kan være nyttigt for at forhindre, at test kører på ubestemt tid eller gennemføres for hurtigt, før testcaserne er afsluttet.

Test API-endepunkterne

I rodmappen skal du oprette en ny mappe og navngive den prøve. Inde i denne mappe skal du oprette en ny bruger.tests.js fil, og tilføj følgende kode for POST-slutpunktstestcasen.

konst chai = kræve('chai');
konst chaiHttp = kræve('chai-http');
konst app = kræve('../server'); 
chai.use (chaiHttp);
konst forvente = chai.forvente;


beskrive('Bruger API', () => {
 beskrive('POST /api/register', () => {
 det('skal håndtere brugerregistrering', (færdig) => {
 chai.request (app)
 .stolpe('/api/register')
 .sende({ brugernavn: 'testbruger', adgangskode: 'testadgangskode' })
 .ende((fejl, res) => {
hvis (fejl) {
 forventer (res).at.have.status(500);
 forventer (res.body).at.have.ejendom('besked').der.er.lige('En fejl opstod!!');
 } andet {
 forventer (res).at.have.status(201);
 forventer (res.body).at.have.ejendom('besked').lige('Bruger registreret med succes');
 }
 Færdig();
 });
 });
 });
});

Denne kode definerer en testcase ved hjælp af Chai og Chai HTTP til at teste brugerregistreringsfunktionaliteten af ​​bruger-API'en.

Den sender en POST-anmodning til det angivne slutpunkt og fremsætter påstande om det forventede API-svar og verificerer, om brugerregistreringsfunktionen var vellykket, eller om der opstod en fejl.

Her er en oversigt over hovedkomponenterne i testcasen:

  • forventer -Dette objekt giver dig mulighed for at bruge Chai-påstandsmetoderne til at fremsætte påstande om det forventede svar fra API'en.
  • beskrive - Den beskriver relaterede testcases sammen, i dette tilfælde tests relateret til Bruger API. Den indlejrede beskrivelse blokerer yderligere grupper af relaterede testtilfælde sammen, i dette tilfælde POST /api/register. Dette hjælper med at organisere testcases specifikt relateret til en bestemt funktionalitet.
  • det - Denne funktion beskriver API-endepunktets forventede adfærd.
  • ende - Denne funktion sender anmodningen og giver en tilbagekaldsfunktion til at håndtere svaret. Tilbagekaldsfunktionen udfører påstande ved hjælp af forventer funktion til at kontrollere svaret modtaget fra API'en.
  • Færdig - Denne funktion kører for at markere slutningen af ​​testsagen.

Til sidst skal du tilføje koden for GET-endepunktstestcasen lige efter POST-slutpunktstestcasen.

beskrive('GET /api/brugere', () => {
 det('skal hente alle brugerdata', (færdig) => {
 chai.request (app)
 .få('/api/brugere')
 .ende((fejl, res) => {
hvis (fejl) {
 forventer (res).at.have.status(500);
 forventer (res.body).at.have.ejendom('besked').der.er.lige('Der opstod en fejl under hentning af brugerdata');
 } andet {
 forventer (res).at.have.status(200);
 forventer (res.body).to.be.an('array');
 }
 Færdig();
 });
 });
});

Gå videre og kør testscriptet på din terminal for at udføre de to testcases.

npm test

Hvis udførelsen af ​​testcaserne ikke støder på nogen fejl, bør du se lignende output, der indikerer, at testene bestået med succes.

Testfejl kan opstå på grund af forskellige årsager, såsom netværksforbindelsesproblemer under HTTP-anmodninger til databasen, manglende nødvendige data, logiske fejl og andre problemer.

Mocha gør et godt stykke arbejde med at identificere og fremhæve sådanne fejl ved at levere klare og detaljerede testrapporter i logfilerne, der vises i terminalvinduet. Dette giver dig mulighed for nemt at identificere og diagnosticere de specifikke problemer, der forårsagede testfejlene.

Mokka giver dig ingen undskyldning for ikke at teste dine API'er

Mens manuel test af funktionaliteten af ​​dine API'er ved hjælp af værktøjer som Postman er en gyldig test tilgang, udnyttelse af Mocha og andre testrammer til automatiseret test tager det til det næste niveau.

Med disse testværktøjer kan du hurtigt og nemt automatisere tests til at dække en lang række scenarier og edge cases. Dette giver dig mulighed for hurtigt at opdage fejl og løse dem, før du implementerer dine API'er, hvilket sikrer, at du sender software af høj kvalitet til produktion.