Creare API fittizie è un aspetto critico dello sviluppo software, sia per scopi di test che per la prototipazione rapida. APIGIT MockServer offre una soluzione semplificata avvolgendo Express.js, fornendo un ambiente semplificato per definire il comportamento del server fittizio senza la necessità di impostare e configurare manualmente un'applicazione Express.

APIGIT MockServer opera all'interno di un sandbox Node.js, sfruttando un'app Express.js per semplificare la creazione di API fittizie. Consente uno sviluppo e una gestione rapidi di varie richieste HTTP tramite definizioni semplici. In questa introduzione, esploreremo le funzionalità di MockServer, evidenzieremo le sue capacità e mostreremo come puoi iniziare rapidamente con esempi pratici.

Caratteristiche principali di MockServer

• Wrapper Express.js: MockServer racchiude Express.js, rendendolo familiare e facile da usare per gli sviluppatori che già conoscono Express.js.
• Librerie preinstallate: Librerie JavaScript popolari comelodash,moment,fakere altri ancora sono preinstallati, semplificando la creazione di risposte simulate dinamiche.
• Supporta percorsi e middleware: Definisci percorsi e middleware proprio come faresti in un'applicazione Express.
• Dati con stato: Gestisci facilmente i dati tra le richieste utilizzando una variabile di stato globale, rendendolo perfetto per simulare un comportamento nel mondo reale.
• Organizzazione modulare: Gli script del server fittizio sono organizzati in modo modulare, in modo simile alle pratiche di sviluppo quotidiane, semplificando la gestione e il riutilizzo del codice.

Come funziona MockServer

MockServer funziona consentendoti di definire percorsi API utilizzando**mockoggetto.deridereè un globaleApplicazione Express.js**creato automaticamente dal framework del server mock apigit sottostante. Puoi definire percorsi usando mock.[method], seguendo le linee guida fornite nella documentazione di Express.js.

Ecco una panoramica di come MockServer semplifica la creazione di API:

• Utilizzo **mock.[method](...)**per definire percorsi e gestori delle richieste.
• Utilizzare metodi Express.js standard comereq E resper gestire le richieste e le risposte HTTP.
• Le librerie preinstallate eliminano la necessità di un'installazione manuale, consentendoti di concentrarti sulla definizione della logica simulata.

Esempio: Definizione di percorsi e middleware

L'esempio seguente mostra quanto sia semplice creare percorsi utilizzando 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");
});

Si prega di notare che**mock.define()è stato deprecato ed è fornito solo per scopi di compatibilità. Consigliamo di utilizzaremock.[method]invece, poiché si allinea con il nativoExpress.js**approccio.

Utilizzo del middleware con MockServer

Proprio come in Express.js, puoi utilizzare il middleware per elaborare le richieste prima che raggiungano il gestore del percorso finale:

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

IL mock.use()La funzione può essere utilizzata per definire il middleware per tutti i percorsi o percorsi specifici, proprio come in un'app Express.

Lavorare con richieste e risposte

MockServer fornisce un modo semplice per interagire con richieste e risposte utilizzando le convenzioni standard di Express.js. Di seguito sono riportati alcuni esempi di attività comuni:

Gestione dei parametri di percorso e dei parametri di query

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

Impostazione dello stato di risposta e delle intestazioni

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

Utilizzo delle librerie preinstallate

MockServer è dotato di librerie JavaScript preinstallate, così puoi utilizzarle direttamente nelle tue definizioni fittizie:

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

Queste librerie ti aiutano a creare facilmente risposte ricche e dinamiche senza la necessità di installazioni aggiuntive. Se hai bisogno di una libreria non elencata, contatta APIGIT e la valuteremo e la aggiungeremo rapidamente. Le librerie supportate includono:

• @faker-js/faker(v9.2.0) - generatore di dati
• agg(v8.17.1) - Validazione dello schema JSON
• base64-js(v1.5.1) - Codifica/decodifica Base64
• corsa(v2.8.5) - Middleware di condivisione delle risorse tra origini
• jsonwebtoken(v9.0.2) - Creazione e verifica JWT
• lodash(v4.17.21) - utilità generale
• momento(v2.30.1) - gestione data e ora
• UUID (codice univoco univoco)(v11.0.3) - Generatore UUID
• validatore(v13.12.0) - assistente di convalida

Dati con stato con MockServer

MockServer fornisce unstateoggetto, che consente di memorizzare e recuperare dati tra le richieste, semplificando la simulazione dello stato 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" });
});

Script fittizi modulari con MockServer

Per mantenere un codice più pulito e organizzato, MockServer supporta la suddivisione degli script fittizi in più file in modo modulare, simile alle pratiche di sviluppo quotidiane. In genere, avresti unmain.jsfile che definisce tutte le route, che poi richiede definizioni di handler da file separati. Questo ti consente di creare moduli riutilizzabili e ben strutturati per i route handler, mantenendo la tua base di codice gestibile.

Per esempio:

• principale.js: Il file principale che definisce tutti i percorsi e richiede altri file per le definizioni del gestore. I moduli del gestore sono richiesti all'inizio del file per una migliore leggibilità e organizzazione. Ad esempio, gestori come l'aggiunta o l'eliminazione di utenti possono essere definiti in un file ed esportati insieme utilizzandomodule.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);

• gestori/userHandlers.js: Un file separato che esporta funzioni per gestire diverse richieste relative all'utente, utilizzandomodule.exportsper esportarli insieme.

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

Questo approccio modulare aiuta a organizzare i percorsi in modo logico e consente la riutilizzabilità in diversi progetti simulati.

Conclusione

MockServer semplifica il processo di impostazione di API fittizie sfruttando la potenza di Express.js in un ambiente sandbox. Con librerie integrate, definizioni di route semplici, supporto middleware e gestione dei dati con stato, è una soluzione comoda per gli sviluppatori che desiderano creare API fittizie in modo rapido ed efficiente.

Che tu sia un principiante o uno sviluppatore esperto, MockServer fornisce gli strumenti di cui hai bisogno per simulare il comportamento delle API senza il sovraccarico di dover configurare un server Express completo. Provalo e rendi i tuoi test e prototipi API più fluidi e produttivi.