Das Erstellen von Mock-APIs ist ein wichtiger Aspekt der Softwareentwicklung, sei es zu Testzwecken oder zum schnellen Prototyping. APIGIT MockServer bietet eine optimierte Lösung, indem es Express.js umschließt und eine vereinfachte Umgebung zum Definieren des Mock-Serververhaltens bereitstellt, ohne dass eine Express-Anwendung manuell eingerichtet und konfiguriert werden muss.

APIGIT MockServer läuft in einer Node.js-Sandbox und nutzt eine Express.js-App, um die Erstellung von Mock-APIs zu vereinfachen. Es ermöglicht eine schnelle Entwicklung und Verarbeitung verschiedener HTTP-Anfragen durch unkomplizierte Definitionen. In dieser Einführung erkunden wir die Funktionen von MockServer, heben seine Fähigkeiten hervor und zeigen Ihnen anhand praktischer Beispiele, wie Sie schnell loslegen können.

Hauptfunktionen von MockServer

• Express.js-Wrapper: MockServer umschließt Express.js und macht es für Entwickler, die Express.js bereits kennen, vertraut und einfach zu verwenden.
• Vorinstallierte Bibliotheken: Beliebte JavaScript-Bibliotheken wielodash,moment,fakerund mehr sind vorinstalliert, wodurch die Erstellung dynamischer simulierter Antworten vereinfacht wird.
• Unterstützt Routen und Middleware: Definieren Sie Routen und Middleware genau wie in einer Express-Anwendung.
• Statusbehaftete Daten: Einfache Verwaltung von Daten zwischen Anfragen mithilfe einer globalen Statusvariable. Ideal für die Simulation realen Verhaltens.
• Modulare Organisation: Mock-Server-Skripte sind modular organisiert, ähnlich wie tägliche Entwicklungspraktiken, wodurch die Verwaltung und Wiederverwendung von Code einfach wird.

So funktioniert MockServer

MockServer funktioniert, indem Sie API-Routen definieren können mit**mockObjekt.verspottenist ein globalesExpress.js-App**automatisch erstellt vom zugrunde liegenden apigit Mock-Server-Framework. Sie können Routen mit mock.[method] definieren und dabei den Richtlinien in der Express.js-Dokumentation folgen.

Hier ist ein Überblick darüber, wie MockServer das Erstellen von APIs vereinfacht:

• Verwenden **mock.[method](...)**um Routen und Anforderungshandler zu definieren.
• Verwenden Sie Standardmethoden von Express.js wiereq Und resum HTTP-Anfragen und -Antworten zu verarbeiten.
• Vorinstallierte Bibliotheken machen eine manuelle Installation überflüssig, sodass Sie sich auf die Definition Ihrer Mock-Logik konzentrieren können.

Beispiel: Definieren von Routen und Middleware

Das folgende Beispiel zeigt, wie einfach es ist, Routen mit MockServer zu erstellen:

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

Bitte beachten Sie:mock.define()ist veraltet und wird nur aus Kompatibilitätsgründen bereitgestellt. Wir empfehlen die Verwendung vonmock.[method]stattdessen, da es mit dem nativenExpress.js Ansatz.

Verwenden von Middleware mit MockServer

Genau wie in Express.js können Sie Middleware verwenden, um Anfragen zu verarbeiten, bevor sie den endgültigen Routenhandler erreichen:

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

Der mock.use()Mit der Funktion kann Middleware für alle Routen oder bestimmte Pfade definiert werden, genau wie in einer Express-App.

Arbeiten mit Anfragen und Antworten

MockServer bietet eine einfache Möglichkeit, mit Anfragen und Antworten unter Verwendung standardmäßiger Express.js-Konventionen zu interagieren. Nachfolgend finden Sie einige Beispiele für gängige Aufgaben:

Umgang mit Routenparametern und Abfrageparametern

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

Festlegen des Antwortstatus und der Header

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

Vorinstallierte Bibliotheken verwenden

MockServer wird mit vorinstallierten beliebten JavaScript-Bibliotheken geliefert, sodass Sie diese direkt in Ihren Mock-Definitionen verwenden können:

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

Mit diesen Bibliotheken können Sie problemlos umfangreiche, dynamische Antworten erstellen, ohne dass zusätzliche Installationen erforderlich sind. Wenn Sie eine Bibliothek benötigen, die nicht aufgeführt ist, wenden Sie sich bitte an APIGIT. Wir werden sie prüfen und schnell hinzufügen. Zu den unterstützten Bibliotheken gehören:

• @faker-js/faker(v9.2.0) - Datengenerator
• adj(v8.17.1) - JSON-Schemavalidierung
• base64-js(v1.5.1) – Base64-Kodierung/Dekodierung
• Korsett(v2.8.5) - Cross-Origin-Ressourcenfreigabe-Middleware
• jsonwebtoken(v9.0.2) - JWT-Erstellung und -Verifizierung
• lodash(v4.17.21) – allgemeines Dienstprogramm
• Moment(v2.30.1) - Zeit- und Datumsbehandlung
• UUID(v11.0.3) - UUID-Generator
• Prüfer(v13.12.0) - Validierungshilfe

Stateful Data mit MockServer

MockServer bietet einestate-Objekt, mit dem Sie Daten zwischen Anfragen speichern und abrufen können. Dadurch wird die Simulation eines dauerhaften Zustands vereinfacht:

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

Modulare Mock-Skripte mit MockServer

Um saubereren und besser organisierten Code zu erhalten, unterstützt MockServer das modulare Aufteilen von Mock-Skripten in mehrere Dateien, ähnlich wie bei alltäglichen Entwicklungspraktiken. Normalerweise haben Sie einemain.jsDatei, die alle Routen definiert, was dann Handlerdefinitionen aus separaten Dateien erfordert. Auf diese Weise können Sie wiederverwendbare, gut strukturierte Module für Routenhandler erstellen und so Ihre Codebasis wartbar halten.

Zum Beispiel:

• Haupt-JS: Die Hauptdatei, die alle Routen definiert und andere Dateien für die Handlerdefinitionen benötigt. Die Handlermodule werden am Anfang der Datei benötigt, um die Lesbarkeit und Organisation zu verbessern. Beispielsweise können Handler wie das Hinzufügen oder Löschen von Benutzern in einer Datei definiert und gemeinsam exportiert werden mitmodule.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);

• handlers/userHandlers.js: Eine separate Datei, die Funktionen zum Verarbeiten verschiedener benutzerbezogener Anfragen exportiert.module.exportsum sie zusammen zu exportieren.

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

Dieser modulare Ansatz hilft Ihnen, Routen logisch zu organisieren und ermöglicht die Wiederverwendbarkeit in verschiedenen Mock-Projekten.

Abschluss

MockServer vereinfacht das Einrichten von Mock-APIs, indem es die Leistung von Express.js in einer Sandbox-Umgebung nutzt. Mit integrierten Bibliotheken, einfachen Routendefinitionen, Middleware-Unterstützung und statusabhängiger Datenverwaltung ist es eine praktische Lösung für Entwickler, die schnell und effizient Mock-APIs erstellen möchten.

Egal, ob Sie Anfänger oder erfahrener Entwickler sind, MockServer bietet die Tools, die Sie zum Simulieren des API-Verhaltens benötigen, ohne dass Sie einen vollständigen Express-Server einrichten müssen. Probieren Sie es aus und machen Sie Ihre API-Tests und Prototypen reibungsloser und produktiver.