Le développement de logiciels modernes fait un grand usage des API. Elles servent de lien crucial entre les applications côté client et les applications dorsales, ainsi qu’entre différentes applications internes ou externes.
Les API permettent une communication et un échange de données fluides, ce qui permet aux composants logiciels d’interagir de manière transparente les uns avec les autres. Il est extrêmement important de garantir la fiabilité, la fonctionnalité et les performances de ces API afin d’offrir une expérience utilisateur transparente et de maintenir l’intégrité globale du système.
Il est donc important de tester minutieusement vos API afin de détecter et de rectifier les bogues au cours du développement et de prévenir les défaillances potentielles du système dans les environnements de production.
Tester les API Node.js avec Mocha, Chai et Chai-HTTP
Mocha est un cadre de test largement utilisé qui est compatible avec divers cadres JavaScript. L’une de ses principales caractéristiques est un gestionnaire de test flexible qui simplifie le processus de gestion et d’exécution des cas de test de manière efficace.
Il prend également en charge différents styles de test, y compris les tests synchrones et asynchrones, ce qui permet de réaliser un large éventail de scénarios de test.
D’autre part, Chai et Chai-HTTP sont des bibliothèques d’assertions que vous pouvez utiliser en conjonction avec Mocha. Chai fournit une large gamme d’interfaces d’assertion expressives et lisibles telles que should, expect et assert. Par ailleurs, Chai-HTTP, une extension de Chai, fournit une interface spécialement conçue pour tester les requêtes HTTP et affirmer leurs réponses.
En utilisant Mocha en conjonction avec Chai et Chai-HTTP, vous pouvez tester efficacement les API. Le flux de travail des tests implique :
- Effectuer des requêtes HTTP vers les points d’extrémité d’API spécifiés.
- Définition des réponses attendues.
- Valider les données reçues de la source spécifiée, les codes d’état HTTP, etc.
Vous pouvez également simuler des scénarios de test d’erreurs API susceptibles de survenir dans de telles situations et déterminer les actions à déclencher dans ce cas.
Vous pouvez trouver le code de ce projet dans son dépôt GitHub.
Configurer le projet Express.js et la base de données MongoDB
Pour commencer, créez un serveur web Express et installez ces paquets :
npm install cors dotenv mongoose mongodb
Ensuite, créez une base de données MongoDB ou configurez un cluster MongoDB sur le cloud. Copiez ensuite l’URL de connexion à la base de données, créez un fichier .env dans le répertoire racine, et collez la chaîne de connexion à la base de données :
CONNECTION_STRING="connection string"
Pour terminer le processus d’installation, vous devez configurer la connexion à la base de données et définir les modèles de données pour vos données utilisateur. Référez-vous au code dans le dépôt GitHub de ce projet pour :
- Configurer la connexion à la base de données, dans utils/db.js.
- Définir le schéma de données de l’utilisateur dans models/user.model.js.
Définir les fonctions de gestion pour les routes de l’API
Les fonctions du contrôleur gèrent l’ajout et la récupération des données de l’utilisateur dans la base de données. Pour garantir la fonctionnalité de ces fonctions de gestion, vous allez tester si elles peuvent afficher et récupérer avec succès des données dans la base de données.
Dans le répertoire racine, créez un fichier controllers/userControllers.js et ajoutez le code suivant :
const User = require('../models/user.model');
exports.registerUser = async (req, res) => {
const { username, password } = req.body;
try {
await User.create({ username, password});
res.status(201).send({ message: 'User registered successfully' });
} catch (error) {
console.log(error);
res.status(500).send({ message: 'An error occurred!! ' });
}
};
exports.getUsers = async (req, res) => {
try {
const users = await User.find({});
res.json(users);
} catch (error) {
console.log(error);
res.status(500).send({ message: 'An error occurred!!' });
}
};
Définir les routes API
Créer un nouveau routes/userRoutes.js dans le répertoire racine et ajoutez le code suivant.
const express = require('express');
const router = express.Router();
const userControllers = require('../controllers/userControllers');
router.post('/api/register', userControllers.registerUser);
router.get('/api/users', userControllers.getUsers);
module.exports = router;
Définir le point d’entrée de votre serveur
Mettez à jour votre server.js avec le code suivant.
const express = require('express');
const cors = require('cors');
const app = express();
const port = 5000;
require('dotenv').config();
const connectDB = require('./utils/db');
connectDB();
app.use(express.json());
app.use(express.urlencoded({ extended: true }));
app.use(cors());
const userRoutes = require('./routes/userRoutes');
app.use("https://www.makeuseof.com/", userRoutes);
app.listen(port, () => {
console.log(`Server is listening at http://localhost:${port}`);
});
module.exports = app;
Écrire et exécuter les cas de test avec Mocha
Avec l’API utilisateur en place, allez-y et configurez l’environnement de test. Tout d’abord, installez ces paquets en tant que dépendances dev.
npm install mocha chai chai-http --save-dev
Maintenant, ajoutez le script suivant à votre fichier package.json.
"scripts": {
"test": "mocha --timeout 10000"
},
Cette commande exécutera les cas de test – l’ajout de la propriété timeout avec une valeur appropriée vous permet de contrôler le temps maximum autorisé pour l’exécution des cas de test individuels.
Cela peut être utile pour éviter que les tests ne s’exécutent indéfiniment ou ne se terminent trop rapidement avant que les cas de test ne soient terminés.
Tester les points de terminaison de l’API
Dans le répertoire racine, créez un nouveau dossier et nommez-le test. Dans ce dossier, créez un nouveau fichier user.tests.js et ajoutez le code suivant pour le cas de test POST endpoint.
const chai = require('chai');
const chaiHttp = require('chai-http');
const app = require('../server');
chai.use(chaiHttp);
const expect = chai.expect;
describe('User API', () => {
describe('POST /api/register', () => {
it('should handle user registration', (done) => {
chai.request(app)
.post('/api/register')
.send({ username: 'testUser', password: 'testpassword' })
.end((err, res) => {
if (err) {
expect(res).to.have.status(500);
expect(res.body).to.have.property('message').that.is.equal('An error occurred!!');
} else {
expect(res).to.have.status(201);
expect(res.body).to.have.property('message').equal('User registered successfully');
}
done();
});
});
});
});
Ce code définit un scénario de test utilisant Chai et Chai HTTP pour tester la fonctionnalité d’enregistrement des utilisateurs de l’API utilisateur.
Il envoie une requête POST au point de terminaison spécifié et fait des affirmations sur la réponse attendue de l’API, en vérifiant si la fonctionnalité d’enregistrement de l’utilisateur a réussi ou si une erreur s’est produite.
Voici la décomposition des principaux composants du scénario de test :
- attente -Cet objet vous permet d’utiliser les méthodes d’assertion Chai pour faire des assertions sur la réponse attendue de l’API.
- décrire – Il décrit ensemble les cas de test apparentés, dans ce cas, les tests liés à l’élément API utilisateur. Le bloc de description imbriqué regroupe les cas de test associés, dans ce cas, le cas de test POST /api/register. Cela permet d’organiser les cas de test spécifiquement liés à une fonctionnalité particulière.
- il – Cette fonction décrit le comportement attendu du point de terminaison de l’API.
- fin – Cette fonction envoie la demande et fournit une fonction de rappel pour gérer la réponse. La fonction de rappel effectue des assertions à l’aide de la fonction attendez pour vérifier la réponse reçue de l’API.
- fait – Cette fonction s’exécute pour marquer la fin du cas de test.
Enfin, ajoutez le code du scénario de test GET juste après le scénario de test POST.
describe('GET /api/users', () => {
it('should fetch all user data', (done) => {
chai.request(app)
.get('/api/users')
.end((err, res) => {
if (err) {
expect(res).to.have.status(500);
expect(res.body).to.have.property('message').that.is.equal('An error occurred while fetching user data');
} else {
expect(res).to.have.status(200);
expect(res.body).to.be.an('array');
}
done();
});
});
});
Lancez le script de test sur votre terminal pour exécuter les deux scénarios de test.
npm test
Si l’exécution des cas de test ne rencontre aucune erreur, vous devriez voir une sortie similaire indiquant que les tests se sont déroulés avec succès.
Les échecs des tests peuvent être dus à diverses raisons, telles que des problèmes de connectivité réseau pendant les requêtes HTTP vers la base de données, des données requises manquantes, des erreurs logiques et d’autres problèmes.
Mocha fait un bon travail d’identification et de mise en évidence de ces erreurs, en fournissant des rapports de test clairs et détaillés dans les journaux affichés dans la fenêtre du terminal. Cela vous permet d’identifier et de diagnostiquer facilement les problèmes spécifiques qui ont causé les échecs des tests.
Mocha ne vous donne aucune excuse pour ne pas tester vos API
Bien que tester manuellement les fonctionnalités de vos API à l’aide d’outils tels que Postman soit une approche de test valable, l’utilisation de Mocha et d’autres frameworks de test pour les tests automatisés permet de passer à la vitesse supérieure.
Grâce à ces outils de test, vous pouvez rapidement et facilement automatiser les tests pour couvrir un large éventail de scénarios et de cas limites. Cela vous permet de détecter rapidement les bogues et de les résoudre avant de déployer vos API, garantissant ainsi la livraison d’un logiciel de haute qualité à la production.
