La création d'API fictives est un aspect essentiel du développement logiciel, que ce soit à des fins de test ou de prototypage rapide. APIGIT MockServer offre une solution simplifiée en s'appuyant sur Express.js, fournissant un environnement simplifié pour définir le comportement du serveur fictif sans avoir à installer et configurer manuellement une application Express.

APIGIT MockServer fonctionne dans un sandbox Node.js, en exploitant une application Express.js pour simplifier la création d'API fictives. Il permet un développement et une gestion rapides de diverses requêtes HTTP grâce à des définitions simples. Dans cette introduction, nous explorerons les fonctionnalités de MockServer, mettrons en évidence ses capacités et vous montrerons comment vous pouvez rapidement démarrer avec des exemples pratiques.

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 itinéraires 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**mock** objet. se moquerest un mondialApplication Express.jscréé automatiquement par le framework de serveur fictif apigit sous-jacent. Vous pouvez définir des itinéraires à l'aide de mock.[method], en suivant les instructions fournies dans la documentation Express.js.

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

• Utiliser **mock.[method](...)**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 :

mock.get("/user/:name", function (req, res) {
 return res.status(200).send("hello" + req.params.name);
});

mock.post('/test-urlencoded', (req, res) => {
 console.log('Received x-www-form-urlencoded data:', req.body);
 res.status(200).send({ message: 'Received x-www-form-urlencoded data', data: req.body });
});

mock.get('/testauth', exampelAuthMiddleware, (req, res) => {
 res.status(200).send('This route is to deomostrate auth through middleware ');
});

mock.get('/testmd2', firstMiddleware,  secondMiddleware, (req, res) => {
 res.status(200).send('This route has multiple middlewares!');
});

// !!!== mock.define is deprecated and provided for compatibility only. Please use mock.[method] instead, as it follows the native Express.js approach. !!!
mock.delete("/user/:name", function(req, res) {
  // handle req
  res.status(200).send("success");
});

Veuillez noter que**mock.define()est obsolète et n'est fourni qu'à des fins de compatibilité. Nous vous recommandons d'utilisermock.[method]au lieu de cela, car il s'aligne sur le natifExpress.js** approche.

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 :

const exampelAuthMiddleware = (req, res, next) => {
  const authHeader = req.headers['authorization'];
  if (!authHeader) {
    return res.status(401).send('Authorization header missing');
  }

  const token = authHeader.split(' ')[1];
  if (!token) {
    return res.status(401).send('Token missing');
  }

  try {
    const SECRET_KEY = 'your-secret-key';
    const decoded = jwt.verify(token, SECRET_KEY);
    req.user = decoded;
    next();
  } catch (err) {
    return res.status(403).send('Invalid token');
  }
};

function firstMiddleware(req, res, next) {
  console.log('First middleware');
  next();
}

function secondMiddleware(req, res, next) {
  console.log('Second middleware');
  next();
}

mock.use((req, res, next) => {
  console.log("middware for all routes");
  next();
});

mock.get('/testauth', exampelAuthMiddleware, (req, res) => {
  res.status(200).send('This route is to deomostrate auth through middleware ');
});

mock.get('/testmd2', firstMiddleware,  secondMiddleware, (req, res) => {
  res.status(200).send('This route has multiple middlewares!');
});
   

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.get('/repository/:user/:repo', (req, res) => {
  const { user, repo } = req.params;
  res.json({
    message: 'Repository Details',
    user: user,
    repo: repo
  });
});

mock.get('/search', (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.get('/not-found', (req, res) => {
  res.status(404).json({
    message: 'Resource not found',
    code: 404
  });
});

mock.get('/single-header', (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.get('/test-libs', (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.post('/users', (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, ce qui permet de maintenir votre base de code.

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.post('/user/:name', userPostHandler);
mock.delete('/user/:name', 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.