Att vara värd för ett API har ett ansvar att se till att det fungerar. Det finns inget bättre eller enklare sätt att göra det än automatiserad testning med ett verktyg som Mocha.

Modern mjukvaruutveckling gör stor användning av API: er. De fungerar som en avgörande länk mellan applikationer på klientsidan och backend-applikationer, såväl som mellan olika interna eller externa appar.

API: er möjliggör smidig kommunikation och datautbyte, vilket låter programvarukomponenter sömlöst interagera med varandra. Att säkerställa tillförlitligheten, funktionaliteten och prestandan hos dessa API: er är av yttersta vikt för att leverera en sömlös användarupplevelse och bibehålla systemets övergripande integritet.

Det är därför viktigt att noggrant testa dina API: er för att flagga och rätta till buggar under utveckling för att förhindra potentiella systemfel i produktionsmiljöer.

Testa Node.js API: er med Mocha, Chai och Chai-HTTP

Mocka är ett allmänt använt testramverk som är kompatibelt med olika JavaScript-ramverk

instagram viewer
. En av dess nyckelfunktioner är en flexibel testlöpare som förenklar processen att hantera och utföra testfall effektivt.

Den stöder också olika teststilar, inklusive synkrona och asynkrona tester, vilket möjliggör ett brett utbud av testscenarier.

Å andra sidan, Chai och Chai-HTTP är påståendebibliotek som du kan använda tillsammans med Mocha. Chai tillhandahåller ett brett utbud av uttrycksfulla och läsbara påståendegränssnitt som bör, förvänta sig och hävda. Medan Chai-HTTP, en förlängning av Chai, tillhandahåller ett gränssnitt speciellt utformat för att testa HTTP-förfrågningar och hävda deras svar.

Genom att använda Mocha i kombination med Chai och Chai-HTTP kan du testa API: er effektivt. Testarbetsflödet innefattar:

  • Gör HTTP-förfrågningar till de angivna API-slutpunkterna.
  • Definiera förväntade svar.
  • Validerar mottagen data från den angivna källan, HTTP-statuskoderna och mer.

Du kan också simulera API-feltestscenarier som kan uppstå i sådana situationer och vilka åtgärder som ska utlösa om de inträffar.

Du kan hitta detta projekts kod i dess GitHub-förråd.

Konfigurera Express.js-projektet och MongoDB-databasen

För att starta, skapa en Express-webbserver, och installera dessa paket:

npm installera cors dotenv mongoose mongodb

Nästa, skapa en MongoDB-databas eller konfigurera ett MongoDB-kluster i molnet. Kopiera sedan webbadressen till databasanslutningen, skapa en .env fil i rotkatalogen och klistra in databasanslutningssträngen:

CONNECTION_STRING="anslutningssträng"

För att avsluta installationsprocessen måste du konfigurera databasanslutningen och definiera datamodellerna för dina användardata. Se koden i detta projekts GitHub-förråd för att:

  • Konfigurera databasanslutningen, i utils/db.js.
  • Definiera användardataschemat i models/user.model.js.

Definiera hanterarfunktionerna för API-rutter

Controllerfunktionerna kommer att hantera tillägg och hämtning av användardata i databasen. För att säkerställa funktionaliteten hos dessa hanterarfunktioner kommer du att testa om de framgångsrikt kan lägga upp och hämta data från databasen.

Skapa en i rotkatalogen controllers/userControllers.js fil och lägg till följande kod:

konst Användare = behöva('../models/user.model');
exports.registerUser = asynkron (req, res) => {
konst { användarnamn, lösenord } = req.body;


Prova {
vänta User.create({ användarnamn, lösenord});
 res.status(201).skicka({ meddelande: "Användaren har registrerats framgångsrikt" });
 } fånga (fel) {
trösta.log (fel);
 res.status(500).skicka({ meddelande: 'Ett fel uppstod!! ' });
 }
};
exports.getUsers = asynkron (req, res) => {
Prova {
konst användare = vänta User.find({});
 res.json (användare);
 } fånga (fel) {
trösta.log (fel);
 res.status(500).skicka({ meddelande: 'Ett fel uppstod!!' });
 }
};

Definiera API-rutter

Skapa en ny routes/userRoutes.js fil i rotkatalogen och lägg till följande kod.

konst uttrycka = behöva('uttrycka');
konst router = express. Router();
konst userControllers = behöva('../controllers/userControllers');
router.post('/api/register', userControllers.registerUser);
router.get('/api/users', userControllers.getUsers);
modul.exports = router;

Definiera din serveringångspunkt

Uppdatera din server.js fil med följande kod.

konst uttrycka = behöva('uttrycka');
konst cors = behöva('cors');
konst app = express();
konst port = 5000;
behöva('dotenv').config();
konst connectDB = behöva('./utils/db');
connectDB();


app.use (express.json());
app.use (express.urlencoded({ förlängt: Sann }));
app.use (cors());


konst userRoutes = behöva('./routes/userRoutes');
app.use('/', användarvägar);


app.listen (port, () => {
trösta.logga(`Server lyssnar på http://localhost:${port}`);
});
modul.exports = app;

Skriv och utför testfallen med Mocha

Med användar-API: et på plats, fortsätt och konfigurera testmiljön. Installera först dessa paket som dev-beroenden.

npm installera mocha chai chai-http --save-dev

Lägg nu till följande skript i filen package.json.

"skript": {
"testa": "mocka --timeout 10000"
},

Detta kommando kommer att exekvera testfallen – genom att lägga till timeout-egenskapen med ett lämpligt värde kan du kontrollera den maximala tiden som tillåts för individuella testfall att exekvera.

Detta kan vara användbart för att förhindra att tester körs på obestämd tid eller slutföras för snabbt innan testfallen har avslutats.

Testa API-ändpunkterna

Skapa en ny mapp i rotkatalogen och namnge den testa. Skapa en ny i den här mappen user.tests.js fil och lägg till följande kod för POST-slutpunktstestfallet.

konst chai = behöva('chai');
konst chaiHttp = behöva('chai-http');
konst app = behöva('../server'); 
chai.use (chaiHttp);
konst förvänta = chai.förvänta;


beskriva("Användar-API", () => {
 beskriva('POST /api/register', () => {
 Det("ska hantera användarregistrering", (klar) => {
 chai.request (app)
 .posta('/api/register')
 .skicka({ Användarnamn: "testanvändare", Lösenord: 'testlösenord' })
 .slutet((fel, res) => {
om (fel) {
 förvänta (res).att.ha.status(500);
 förvänta (res.body).att.ha.egenskap('meddelande').som.är.lika('Ett fel uppstod!!');
 } annan {
 förvänta (res).att.ha.status(201);
 förvänta (res.body).att.ha.egenskap('meddelande').likvärdig("Användaren har registrerats framgångsrikt");
 }
 Gjort();
 });
 });
 });
});

Den här koden definierar ett testfall som använder Chai och Chai HTTP för att testa användarregistreringsfunktionaliteten för användar-API.

Den skickar en POST-begäran till den angivna slutpunkten och gör påståenden om det förväntade API-svaret, verifierar om användarregistreringsfunktionen lyckades eller om ett fel inträffade.

Här är en uppdelning av huvudkomponenterna i testfallet:

  • förvänta -Detta objekt låter dig använda Chai-påståendemetoderna för att göra påståenden om det förväntade svaret från API: et.
  • beskriva - Den beskriver relaterade testfall tillsammans, i det här fallet, tester relaterade till Användar-API. Det kapslade beskriver blocket ytterligare grupperar relaterade testfall tillsammans, i det här fallet POST /api/register. Detta hjälper till att organisera testfallen specifikt relaterade till en viss funktionalitet.
  • Det - Den här funktionen beskriver det förväntade beteendet för API-slutpunkten.
  • slutet - Den här funktionen skickar förfrågan och tillhandahåller en återuppringningsfunktion för att hantera svaret. Återuppringningsfunktionen utför påståenden med hjälp av förvänta funktion för att kontrollera svaret som tas emot från API: et.
  • Gjort - Den här funktionen körs för att markera slutet på testfallet.

Lägg slutligen till koden för GET-slutpunktstestfallet direkt efter POST-slutpunktstestfallet.

beskriva('GET /api/users', () => {
 Det("bör hämta all användardata", (klar) => {
 chai.request (app)
 .skaffa sig('/api/users')
 .slutet((fel, res) => {
om (fel) {
 förvänta (res).att.ha.status(500);
 förvänta (res.body).att.ha.egenskap('meddelande').som.är.lika("Ett fel uppstod vid hämtning av användardata");
 } annan {
 förvänta (res).att.ha.status(200);
 förvänta (res.body).to.be.an('matris');
 }
 Gjort();
 });
 });
});

Gå vidare och kör testskriptet på din terminal för att köra de två testfallen.

npm test

Om exekveringen av testfallen inte stöter på några fel, bör du se liknande utdata som indikerar att testerna har godkänts.

Testfel kan uppstå på grund av olika orsaker, till exempel problem med nätverksanslutning under HTTP-förfrågningar till databasen, saknade nödvändiga data, logiska fel och andra problem.

Mocha gör ett bra jobb med att identifiera och markera sådana fel, och tillhandahåller tydliga och detaljerade testrapporter i loggarna som visas i terminalfönstret. Detta gör att du enkelt kan identifiera och diagnostisera de specifika problem som orsakade testfelen.

Mocha ger dig ingen ursäkt att inte testa dina API: er

Att manuellt testa funktionaliteten hos dina API: er med hjälp av verktyg som Postman är ett giltigt test tillvägagångssätt, utnyttja Mocha och andra testramar för automatiserad testning tar det till nästa nivå.

Med dessa testverktyg kan du snabbt och enkelt automatisera tester för att täcka ett brett spektrum av scenarier och kantfall. Detta gör att du snabbt kan upptäcka buggar och lösa dem innan du distribuerar dina API: er, vilket säkerställer att du skickar högkvalitativ programvara till produktion.