La création d'API fictives est souvent une partie essentielle du développement de logiciels, que ce soit pour des tests ou un prototypage rapide.Serveur simulé, un outil puissant qui s'enroule autourExpress.jspour fournir un environnement simplifié pour définir le comportement du serveur fictif sans avoir à installer et configurer manuellement une application Express.

MockServer est essentiellement un wrapper pour une application Express.js exécutée dans un environnement sandbox Node.js. Il vous aide à créer rapidement des API fictives et à gérer diverses requêtes HTTP en utilisant des définitions simples. Cet article de blog vous présentera MockServer, expliquera ses fonctionnalités et montrera à quel point il est facile de démarrer avec quelques exemples.

Principales caractéristiques de MockServer

• Wrapper Express.js:MockServer s'enroule autour d'Express.js, le rendant familier et facile à utiliser pour les développeurs qui connaissent déjà Express.js.
• Bibliothèques préinstallées: Bibliothèques JavaScript populaires telles quelodash,moment,faker, et bien d'autres sont préinstallés, simplifiant la création de réponses fictives dynamiques.
• Prend en charge les routes et les intergiciels: Définissez les routes et les intergiciels comme vous le feriez dans une application Express.
• Données avec état:Gérez facilement les données entre les requêtes à l'aide d'une variable d'état globale, ce qui la rend parfaite pour simuler un comportement réel.
• Organisation modulaire:Les scripts du serveur fictif sont organisés de manière modulaire, similaire aux pratiques de développement quotidiennes, ce qui facilite la gestion et la réutilisation du code.

Comment fonctionne MockServer

MockServer fonctionne en vous permettant de définir des itinéraires API à l'aide de**mockobjet. Lemockl'objet est une instance globale qui encapsule une application Express.js et prend en charge la définition d'itinéraires via lemock.define()**fonction. Il offre la flexibilité d'Express.js, ce qui simplifie la création et la gestion des API à des fins de test et de développement.

Voici un aperçu de la manière dont MockServer simplifie la création d’API :

• Utiliser mock.define()pour définir des itinéraires et des gestionnaires de requêtes.
• Utilisez les méthodes standard d'Express.js telles quereq et respour gérer les requêtes et les réponses HTTP.
• Les bibliothèques préinstallées éliminent le besoin d'installation manuelle, vous permettant de vous concentrer sur la définition de votre logique fictive.

Exemple : définition des routes et du middleware

L'exemple suivant montre à quel point il est facile de créer des itinéraires à l'aide de MockServer :

const { routeCallBackFunc } = require('./util.js');

// Define routes using mock.define(path, method, handler)
mock.define("/user/:name", "POST", function(req, res) {
  // Handle the request
  res.status(404).send("User not found");
});

mock.define("/user/:name", "DELETE", function(req, res) {
  res.status(200).send("User deleted successfully");
});

// Use request handlers from separate files
mock.define("/user/:name", "POST", routeCallBackFunc);

Cet exemple montre comment utilisermock.define()pour créer des itinéraires POST et DELETE. Les itinéraires sont définis de manière similaire aux applications Express.js standard, garantissant une structure d'API familière.

Utilisation du middleware avec MockServer

Tout comme dans Express.js, vous pouvez utiliser un middleware pour traiter les requêtes avant qu'elles n'atteignent le gestionnaire de route final :

function mw1(req, res, next) {
  console.log("Middleware 1 executed");
  next();
}

function mw2(req, res, next) {
  console.log("Middleware 2 executed");
  next();
}

mock.use(mw1);
mock.use(mw2);

// Define middleware for a specific path
mock.use('/specific-path', (req, res, next) => {
  console.log('Middleware for /specific-path executed');
  next();
});

Le mock.use()la fonction peut être utilisée pour définir un middleware pour toutes les routes ou des chemins spécifiques, comme dans une application Express.

Travailler avec des requêtes et des réponses

MockServer fournit un moyen simple d'interagir avec les requêtes et les réponses à l'aide des conventions standard d'Express.js. Vous trouverez ci-dessous quelques exemples de tâches courantes :

Gestion des paramètres d'itinéraire et des paramètres de requête

mock.define('/repository/:user/:repo', 'GET', (req, res) => {
  const { user, repo } = req.params;
  res.json({
    message: 'Repository Details',
    user: user,
    repo: repo
  });
});

mock.define('/search', 'GET', (req, res) => {
  const { keyword, page, limit } = req.query;
  res.json({
    message: 'Search Parameters Received',
    keyword: keyword || 'none',
    page: page ? parseInt(page, 10) : 1,
    limit: limit ? parseInt(limit, 10) : 10
  });
});

Définition du statut de réponse et des en-têtes

mock.define('/not-found', 'GET', (req, res) => {
  res.status(404).json({
    message: 'Resource not found',
    code: 404
  });
});

mock.define('/single-header', 'GET', (req, res) => {
  res.set('Content-Type', 'application/json');
  res.set('X-Custom-Header', ['value1', 'value2']);
  res.json({ message: 'Headers set successfully!' });
});

Utilisation des bibliothèques préinstallées

MockServer est livré avec des bibliothèques JavaScript populaires préinstallées, vous pouvez donc les utiliser directement dans vos définitions fictives :

const _ = require('lodash');
const moment = require('moment');
const { faker } = require('@faker-js/faker');

mock.define('/test-libs', 'GET', (req, res) => {
  const randomUser = {
    id: faker.datatype.uuid(),
    name: faker.name.findName(),
    email: faker.internet.email()
  };
  res.json({
    currentDate: moment().format(),
    activeUsers: _.filter([{ active: true }, { active: false }], { active: true }),
    randomUser: randomUser
  });
});

Ces bibliothèques vous aident à créer facilement des réponses riches et dynamiques sans avoir besoin d'installations supplémentaires. Si vous avez besoin d'une bibliothèque qui n'est pas répertoriée, veuillez contacter APIGIT, et nous l'évaluerons et l'ajouterons rapidement. Les bibliothèques prises en charge incluent :

• @faker-js/faker(v9.2.0) - générateur de données
• adj(v8.17.1) - Validation du schéma JSON
• base64-js(v1.5.1) - Encodage/décodage Base64
• cors(v2.8.5) - Middleware de partage de ressources inter-origines
• jsonwebtoken(v9.0.2) - Création et vérification de JWT
• lodash(v4.17.21) - utilitaire général
• moment(v2.30.1) - gestion de l'heure et de la date
• UUID(v11.0.3) - Générateur d'UUID
• validateur(v13.12.0) - assistant de validation

Données avec état avec MockServer

MockServer fournit unstateobjet, qui vous permet de stocker et de récupérer des données entre les requêtes, facilitant ainsi la simulation d'un état persistant :

// Create a stateful list of users
state.users = state.users || [];

mock.define('/users', 'POST', (req, res) => {
  if (!req.body.username) {
    return res.status(400).json({ status: "error", details: "Missing username" });
  }

  state.users.push(req.body);
  return res.status(200).json({ status: "ok" });
});

Scripts de simulation modulaires avec MockServer

Pour maintenir un code plus propre et mieux organisé, MockServer prend en charge la division des scripts fictifs en plusieurs fichiers de manière modulaire, similaire aux pratiques de développement quotidiennes. En règle générale, vous auriez unmain.jsfichier qui définit toutes les routes, ce qui nécessite ensuite des définitions de gestionnaires à partir de fichiers séparés. Cela vous permet de créer des modules réutilisables et bien structurés pour les gestionnaires de routes, gardant votre base de code maintenable.

Par exemple:

• main.js: Le fichier principal qui définit toutes les routes et nécessite d'autres fichiers pour les définitions de gestionnaire. Les modules de gestionnaire sont requis au début du fichier pour une meilleure lisibilité et organisation. Par exemple, les gestionnaires tels que l'ajout ou la suppression d'utilisateurs peuvent être définis dans un fichier et exportés ensemble à l'aide demodule.exports.

// main.js

// Require handler modules at the top
const { userPostHandler, userDeleteHandler } = require('./handlers/userHandlers');

// Define routes
mock.define('/user/:name', 'POST', userPostHandler);
mock.define('/user/:name', 'DELETE', userDeleteHandler);

• gestionnaires/userHandlers.js:Un fichier séparé qui exporte des fonctions pour gérer différentes demandes liées à l'utilisateur, en utilisantmodule.exportspour les exporter ensemble.

// handlers/userHandlers.js

function userPostHandler(req, res) {
  res.status(404).send('User not found');
}

function userDeleteHandler(req, res) {
  res.status(200).send('User deleted successfully');
}

module.exports = {
  userPostHandler,
  userDeleteHandler
};

Cette approche modulaire vous aide à organiser les itinéraires de manière logique et permet la réutilisabilité dans différents projets de simulation.

Conclusion

MockServer simplifie le processus de configuration des API fictives en exploitant la puissance d'Express.js dans un environnement sandbox. Avec des bibliothèques intégrées, des définitions d'itinéraire simples, une prise en charge des intergiciels et une gestion des données avec état, c'est une solution pratique pour les développeurs qui cherchent à créer des API fictives rapidement et efficacement.

Que vous soyez un développeur débutant ou expérimenté, MockServer fournit les outils dont vous avez besoin pour simuler le comportement des API sans avoir à configurer un serveur Express complet. Essayez-le et rendez vos tests et votre prototypage d'API plus fluides et plus productifs.