La creación de API simuladas es un aspecto fundamental del desarrollo de software, ya sea con fines de prueba o de creación rápida de prototipos. APIGIT MockServer ofrece una solución optimizada que se basa en Express.js y proporciona un entorno simplificado para definir el comportamiento del servidor simulado sin necesidad de configurar manualmente una aplicación Express.

APIGIT MockServer opera dentro de un entorno de pruebas de Node.js y aprovecha una aplicación Express.js para simplificar la creación de API simuladas. Permite el desarrollo y el manejo rápidos de varias solicitudes HTTP mediante definiciones sencillas. En esta introducción, exploraremos las características de MockServer, destacaremos sus capacidades y demostraremos cómo puede comenzar rápidamente con ejemplos prácticos.

Características principales de MockServer

• Envoltorio Express.js:MockServer se basa en Express.js, lo que lo hace familiar y fácil de usar para los desarrolladores que ya conocen Express.js.
• Bibliotecas preinstaladas:Bibliotecas de JavaScript populares comolodash,moment,fakery más están preinstalados, lo que agiliza la creación de respuestas simuladas dinámicas.
• Admite rutas y middleware:Defina rutas y middleware tal como lo haría en una aplicación Express.
• Datos con estado:Mantenga fácilmente los datos entre solicitudes utilizando una variable de estado global, lo que lo hace perfecto para simular el comportamiento del mundo real.
• Organización modular:Los scripts del servidor simulado están organizados modularmente, de manera similar a las prácticas de desarrollo diarias, lo que facilita la administración y reutilización del código.

Cómo funciona MockServer

MockServer funciona permitiéndole definir rutas API usando**mock** objeto. imitares un globalAplicación Express.jscreado automáticamente por el marco de servidor simulado apigit subyacente. Puede definir rutas usando mock.[method], siguiendo las pautas proporcionadas en la documentación de Express.js.

A continuación se muestra una descripción general de cómo MockServer simplifica la creación de API:

• Usar **mock.[method](...)**para definir rutas y manejadores de solicitudes.
• Utilice métodos estándar de Express.js comoreq y respara gestionar solicitudes y respuestas HTTP.
• Las bibliotecas preinstaladas eliminan la necesidad de instalación manual, lo que le permite concentrarse en definir su lógica simulada.

Ejemplo: Definición de rutas y middleware

El siguiente ejemplo muestra lo fácil que es crear rutas usando 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");
});

Tenga en cuenta que**mock.define()ha quedado obsoleto y se proporciona únicamente con fines de compatibilidad. Recomendamos utilizarmock.[method]En cambio, a medida que se alinea con el nativoExpress.js** acercarse.

Uso de middleware con MockServer

Al igual que en Express.js, puedes usar middleware para procesar solicitudes antes de que lleguen al controlador de ruta 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!');
});
   

El mock.use()La función se puede utilizar para definir middleware para todas las rutas o rutas específicas, como en una aplicación Express.

Trabajar con solicitudes y respuestas

MockServer ofrece una forma sencilla de interactuar con solicitudes y respuestas mediante las convenciones estándar de Express.js. A continuación, se muestran algunos ejemplos de tareas comunes:

Manejo de parámetros de ruta y parámetros de consulta

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
  });
});

Configuración del estado de respuesta y los encabezados

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!' });
});

Uso de bibliotecas preinstaladas

MockServer viene con bibliotecas JavaScript populares preinstaladas, por lo que puede usarlas directamente en sus definiciones simuladas:

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
  });
});

Estas bibliotecas le ayudan a crear respuestas dinámicas y completas fácilmente sin necesidad de instalaciones adicionales. Si necesita una biblioteca que no se encuentra en la lista, comuníquese con APIGIT y la evaluaremos y la agregaremos rápidamente. Las bibliotecas compatibles incluyen:

• @faker-js/faker(v9.2.0) - generador de datos
• adj.(v8.17.1) - Validación del esquema JSON
• base64-js(v1.5.1) - Codificación/decodificación Base64
• Corsés(v2.8.5) - Middleware de intercambio de recursos de origen cruzado
• jsonwebtoken(v9.0.2) - Creación y verificación de JWT
• lodash(v4.17.21) - utilidad general
• momento(v2.30.1) - manejo de fecha y hora
• Identificador único(v11.0.3) - Generador de UUID
• validador(v13.12.0) - Asistente de validación

Datos con estado con MockServer

MockServer proporciona unastateobjeto, que permite almacenar y recuperar datos entre solicitudes, lo que facilita la simulación del estado persistente:

// 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 simulación modulares con MockServer

Para mantener el código más limpio y organizado, MockServer permite dividir los scripts simulados en varios archivos de forma modular, de forma similar a las prácticas de desarrollo cotidianas. Normalmente, tendrías unmain.jsarchivo que define todas las rutas, que luego requiere definiciones de controladores de archivos separados. Esto le permite crear módulos reutilizables y bien estructurados para controladores de rutas, manteniendo su base de código mantenible.

Por ejemplo:

• principal.js: El archivo principal que define todas las rutas y requiere otros archivos para las definiciones de controladores. Los módulos de controladores son necesarios al principio del archivo para una mejor legibilidad y organización. Por ejemplo, los controladores como agregar o eliminar usuarios se pueden definir en un archivo y exportar juntos usandomodule.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);

• manejadores/userHandlers.js:Un archivo separado que exporta funciones para manejar diferentes solicitudes relacionadas con el usuario, utilizandomodule.exportspara exportarlos juntos.

// 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
};

Este enfoque modular le ayuda a organizar las rutas de forma lógica y permite la reutilización en diferentes proyectos simulados.

Conclusión

MockServer simplifica el proceso de configuración de API simuladas aprovechando la potencia de Express.js en un entorno aislado. Con bibliotecas integradas, definiciones de rutas sencillas, compatibilidad con middleware y gestión de datos con estado, es una solución conveniente para los desarrolladores que buscan crear API simuladas de forma rápida y eficiente.

Tanto si eres un principiante como un desarrollador experimentado, MockServer te ofrece las herramientas que necesitas para simular el comportamiento de la API sin la sobrecarga que supone configurar un servidor Express completo. Pruébalo y haz que tus pruebas y prototipos de API sean más fluidos y productivos.