L'hébergement d'une API implique la responsabilité de s'assurer qu'elle fonctionne. Il n'y a pas de moyen meilleur ou plus simple de le faire que des tests automatisés avec un outil comme Mocha.

Le développement de logiciels modernes fait un grand usage des API. Ils servent de lien crucial entre les applications côté client et les applications backend, ainsi qu'entre différentes applications internes ou externes.

Les API permettent une communication et un échange de données fluides, permettant aux composants logiciels d'interagir de manière transparente les uns avec les autres. Garantir la fiabilité, la fonctionnalité et les performances de ces API est de la plus haute importance pour offrir une expérience utilisateur transparente et maintenir l'intégrité globale du système.

Il est donc important de tester minutieusement vos API pour signaler et corriger les bogues lors du développement afin d'éviter d'éventuelles défaillances du système dans les environnements de production.

Test des API Node.js à l'aide de Mocha, Chai et Chai-HTTP

instagram viewer

Moka est un cadre de test largement utilisé qui est compatible avec divers Cadres JavaScript. L'une de ses principales caractéristiques est un exécuteur de test flexible qui simplifie le processus de gestion et d'exécution efficace des cas de test.

Il prend également en charge divers styles de test, y compris les tests synchrones et asynchrones, permettant un large éventail de scénarios de test.

D'autre part, Chaï et Chai-HTTP sont des bibliothèques d'assertions que vous pouvez utiliser avec Mocha. Chai fournit une large gamme d'interfaces d'assertion expressives et lisibles telles que should, expect et assert. Tandis que 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 de test implique :

  • Envoi de requêtes HTTP aux points de terminaison d'API spécifiés.
  • Définir les réponses attendues.
  • Validation des données reçues de la source spécifiée, des codes d'état HTTP, etc.

Vous pouvez également simuler des scénarios de test d'erreur d'API qui peuvent survenir dans de telles situations et quelles actions doivent se déclencher si elles se produisent.

Vous pouvez trouver le code de ce projet dans son Référentiel GitHub.

Configurer le projet Express.js et la base de données MongoDB

Pour commencer, créer un serveur Web Express, et installez ces packages :

npm installer cors dotenv mangouste mongodb

Suivant, créer une base de données MongoDB ou configurer un cluster MongoDB sur le cloud. Copiez ensuite l'URL de connexion à la base de données, créez un .env fichier dans le répertoire racine et collez-y la chaîne de connexion à la base de données :

CONNECTION_STRING="chaîne de connexion"

Pour terminer le processus de configuration, vous devez configurer la connexion à la base de données et définir les modèles de données pour vos données utilisateur. Reportez-vous au code dans le référentiel GitHub de ce projet pour :

  • Configurez la connexion à la base de données, dans utils/db.js.
  • Définissez le schéma de données utilisateur dans modèles/user.model.js.

Définir les fonctions de gestionnaire pour les routes d'API

Les fonctions du contrôleur géreront 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 gestionnaire, vous testerez si elles peuvent correctement publier et extraire des données de la base de données.

Dans le répertoire racine, créez un controllers/userControllers.js fichier et ajoutez le code suivant :

constante Utilisateur = exiger('../modèles/utilisateur.modèle');
exports.registerUser = asynchrone (req, res) => {
constante { nom d'utilisateur, mot de passe } = req.body ;


essayer {
attendre User.create({nom d'utilisateur, mot de passe});
 res.statut(201).envoyer({ message: 'Utilisateur enregistré avec succès' });
 } attraper (erreur) {
console.log (erreur);
 res.statut(500).envoyer({ message: 'Une erreur s'est produite!! ' });
 }
};
exports.getUsers = asynchrone (req, res) => {
essayer {
constante utilisateurs = attendre Utilisateur.find({});
 res.json (utilisateurs);
 } attraper (erreur) {
console.log (erreur);
 res.statut(500).envoyer({ message: 'Une erreur s'est produite !!' });
 }
};

Définir les routes d'API

Créer un nouveau routes/userRoutes.js fichier dans le répertoire racine et ajoutez le code suivant.

constante exprimer = exiger('exprimer');
constante routeur = express. Routeur();
constante userControllers = exiger('../controllers/userControllers');
routeur.post('/api/s'inscrire', userControllers.registerUser);
routeur.get('/api/utilisateurs', userControllers.getUsers);
module.exports = routeur ;

Définissez votre point d'entrée de serveur

Mettez à jour votre serveur.js fichier avec le code suivant.

constante exprimer = exiger('exprimer');
constante cors = exiger('cors');
constante app = express();
constante port = 5000;
exiger('dotenv').config();
constante connectDB = exiger('./utils/db');
connectDB();


app.use (express.json());
app.use (express.urlencodé({ étendu: vrai }));
app.use (cors());


constante userRoutes = exiger('./routes/userRoutes');
app.use('/', userRoutes);


app.listen (port, () => {
console.enregistrer(`Le serveur écoute à http://localhost:${port}`);
});
module.exports = application ;

Écrire et exécuter les cas de test avec Mocha

Une fois l'API utilisateur en place, continuez et configurez l'environnement de test. Tout d'abord, installez ces packages en tant que dépendances de développement.

npm installer moka chai chai-http --save-dev

Maintenant, ajoutez le script suivant à votre fichier package.json.

"scénarios": {
"test": "moka --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 maximal autorisé pour l'exécution des cas de test individuels.

Cela peut être utile pour empêcher les tests de s'exécuter indéfiniment ou de se terminer trop rapidement avant la fin des cas de test.

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 user.tests.js fichier et ajoutez le code suivant pour le cas de test de point de terminaison POST.

constante chaï = exiger('chaï');
constante chaiHttp = exiger('chai-http');
constante application = exiger('../serveur'); 
chai.use (chaiHttp);
constante attendre = chai.attendre;


décrire('API utilisateur', () => {
 décrire('POSTER /api/s'inscrire', () => {
 il('doit gérer l'enregistrement de l'utilisateur', (fait) => {
 chai.request (application)
 .poste('/api/s'inscrire')
 .envoyer({ nom d'utilisateur: 'testUser', mot de passe: 'mot de passe de test' })
 .fin((erreur, res) => {
si (erre) {
 attendre (res).to.have.status(500);
 attendre (res.body).to.have.property('message').qui.est.égal('Une erreur s'est produite !!');
 } autre {
 attendre (res).to.have.status(201);
 attendre (res.body).to.have.property('message').égal('Utilisateur enregistré avec succès');
 }
 fait();
 });
 });
 });
});

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 demande POST au point de terminaison spécifié et fait des assertions sur la réponse d'API attendue, en vérifiant si la fonctionnalité d'enregistrement de l'utilisateur a réussi ou si une erreur s'est produite.

Voici une ventilation des principaux composants du cas de test :

  • attendre -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 les cas de test associés ensemble, dans ce cas, les tests liés à la API utilisateur. Le bloc de description imbriqué regroupe en outre les cas de test associés, dans ce cas, le 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 requête et fournit une fonction de rappel pour gérer la réponse. La fonction de rappel effectue des assertions à l'aide de la attendre fonction 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 de point de terminaison GET juste après le scénario de test de point de terminaison POST.

décrire('OBTENIR /api/utilisateurs', () => {
 il('devrait récupérer toutes les données utilisateur', (fait) => {
 chai.request (application)
 .obtenir('/api/utilisateurs')
 .fin((erreur, res) => {
si (erre) {
 attendre (res).to.have.status(500);
 attendre (res.body).to.have.property('message').qui.est.égal('Une erreur s'est produite lors de la récupération des données utilisateur');
 } autre {
 attendre (res).to.have.status(200);
 attendre (res.body).to.be.an('déployer');
 }
 fait();
 });
 });
});

Allez-y et exécutez le script de test sur votre terminal pour exécuter les deux cas de test.

test npm

Si l'exécution des cas de test ne rencontre aucune erreur, vous devriez voir une sortie similaire indiquant que les tests ont réussi.

Les échecs de test peuvent se produire pour diverses raisons, telles que des problèmes de connectivité réseau lors des requêtes HTTP à 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 sur la fenêtre du terminal. Cela vous permet d'identifier et de diagnostiquer facilement les problèmes spécifiques à l'origine des échecs du test.

Mocha ne vous donne aucune excuse pour ne pas tester vos API

Bien que tester manuellement la fonctionnalité de vos API à l'aide d'outils tels que Postman soit un test valide approche, en tirant parti de Mocha et d'autres cadres de test pour les tests automatisés, il passe à l'étape suivante niveau.

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 extrêmes. Cela vous permet de détecter rapidement les bogues et de les résoudre avant de déployer vos API, vous assurant ainsi de livrer des logiciels de haute qualité à la production.