TOC

So verspotten Sie Services mit Mountebank und Node.js

Der Autor hat dieOpen Internet/Free Speech Fundausgewählt, um eine Spende im Rahmen desWrite for DOnations-Programms zu erhalten.

Einführung

In komplexenservice-oriented architectures (SOA) müssen Programme häufig mehrere Dienste aufrufen, um einen bestimmten Workflow auszuführen. Dies ist in Ordnung, sobald alles eingerichtet ist. Wenn jedoch für den Code, an dem Sie arbeiten, ein Dienst erforderlich ist, der sich noch in der Entwicklung befindet, müssen Sie möglicherweise nicht warten, bis andere Teams ihre Arbeit beendet haben, bevor Sie mit Ihrer beginnen. Darüber hinaus müssen Sie zu Testzwecken möglicherweise mit externen Anbieterdiensten wie einer Wetter-API oder einem Aufzeichnungssystem interagieren. Hersteller geben Ihnen in der Regel nicht so viele Umgebungen an, wie Sie benötigen, und machen es häufig nicht einfach, Testdaten auf ihren Systemen zu kontrollieren. In diesen Situationen können unfertige Dienste und Dienste außerhalb Ihrer Kontrolle das Testen von Code frustrierend machen.

Die Lösung für all diese Probleme besteht darin,service mock zu erstellen. Ein Service-Mock ist ein Code, der den Service simuliert, den Sie im Endprodukt verwenden würden. Er ist jedoch leichter, weniger komplex und einfacher zu steuern als der tatsächliche Service, den Sie in der Produktion verwenden würden. Sie können einen Mock-Service festlegen, um eine Standardantwort oder bestimmte Testdaten zurückzugeben, und dann die Software ausführen, die Sie testen möchten, als ob der abhängige Service wirklich vorhanden wäre. Aus diesem Grund kann eine flexible Möglichkeit, Services zu verspotten, Ihren Workflow beschleunigen und effizienter gestalten.

In einer Unternehmensumgebung wird das Erstellen von Scheindiensten manchmal alsservice virtualization bezeichnet. Service-Virtualisierung ist häufig mit teuren Unternehmenstools verbunden, aber Sie benötigen kein teures Tool, um einen Service zu verspotten. Mountebank ist ein kostenloses Open-Source-Tool zum Verspotten von Diensten, mit dem Sie HTTP-Dienste verspotten können, einschließlich der Dienste vonREST undSOAP. Sie können es auch verwenden, umSMTP oderTCP Anfragen zu verspotten.

In diesem Handbuch erstellen Sie zwei flexible Service-Mocking-Anwendungen mitNode.js und Mountebank. Beide Mock-Services überwachen einen bestimmten Port auf REST-Anforderungen in HTTP. Zusätzlich zu diesem einfachen Verspottungsverhalten ruft der Dienst auch Verspottungsdaten voncomma-separated values (CSV) file ab. Nach diesem Lernprogramm können Sie alle Arten von Serviceverhalten nachahmen, um Ihre Anwendungen einfacher entwickeln und testen zu können.

Voraussetzungen

Um diesem Tutorial zu folgen, benötigen Sie Folgendes:

[[Schritt-1 - Starten einer Node-js-Anwendung]] == Schritt 1 - Starten einer Node.js-Anwendung

In diesem Schritt erstellen Sie eine grundlegende Node.js-Anwendung, die als Basis für Ihre Mountebank-Instanz und die in späteren Schritten erstellten Mock-Services dient.

[.Hinweis]##

Note: Mountebank kann als eigenständige Anwendung verwendet werden, indem sie global mit dem Befehlnpm install -g mountebank installiert wird. Sie können es dann mit dem Befehlmbausführen und mithilfe von REST-Anforderungen Mocks hinzufügen.

Dies ist der schnellste Weg, um Mountebank zum Laufen zu bringen. Wenn Sie die Mountebank-Anwendung jedoch selbst erstellen, können Sie beim Start der App eine Reihe vordefinierter Mocks ausführen, die Sie in der Quellcodeverwaltung speichern und mit Ihrem Team teilen können. In diesem Tutorial wird die Mountebank-Anwendung manuell erstellt, um diese.
zu nutzen

Erstellen Sie zunächst ein neues Verzeichnis, in das Ihre Anwendung gestellt werden soll. Sie können es beliebig benennen, aber in diesem Tutorial nennen wir esapp: 

mkdir app

Gehen Sie mit dem folgenden Befehl in Ihr neu erstelltes Verzeichnis: 

cd app

Um eine neue Node.js-Anwendung zu starten, führen Sienpm init aus und füllen Sie die folgenden Eingabeaufforderungen aus: 

npm init

Die Daten aus diesen Eingabeaufforderungen werden verwendet, um diepackage.json-Datei auszufüllen, in der beschrieben wird, was Ihre Anwendung ist, auf welche Pakete sie sich stützt und welche verschiedenen Skripts sie verwendet. In Node.js-Anwendungen definieren Skripts Befehle, mit denen Ihre Anwendung erstellt, ausgeführt und getestet wird. Sie können die Standardeinstellungen für die Eingabeaufforderungen übernehmen oder den Paketnamen, die Versionsnummer usw. eingeben.

Nachdem Sie diesen Befehl ausgeführt haben, verfügen Sie über eine grundlegende Node.js-Anwendung, einschließlich der Dateipackage.json.

Installieren Sie nun das Mountebank npm-Paket wie folgt: 

npm install -save mountebank

Dieser Befehl erfasst das Mountebank-Paket und installiert es in Ihrer Anwendung. Stellen Sie sicher, dass Sie das Flag-save verwenden, um die Dateipackage.json mit Mountebank als Abhängigkeit zu aktualisieren.

Fügen Sie als Nächstes Ihrempackage.json ein Startskript hinzu, das den Befehlnode src/index.js ausführt. Dieses Skript definiert den Einstiegspunkt Ihrer App alsindex.js, den Sie in einem späteren Schritt erstellen werden.

Öffnen Siepackage.json in einem Texteditor. Sie können einen beliebigen Texteditor verwenden, in diesem Lernprogramm wird jedoch Nano verwendet. 

nano package.json

Navigieren Sie zum Abschnitt"scripts" und fügen Sie die Zeile"start": "node src/index.js" hinzu. Dadurch wird einstart-Befehl hinzugefügt, um Ihre Anwendung auszuführen.

Die Dateipackage.jsonollte ungefähr so ​​aussehen, je nachdem, wie Sie die ersten Eingabeaufforderungen ausgefüllt haben:

app/package.json

{
  "name": "diy-service-virtualization",
  "version": "1.0.0",
  "description": "An application to mock services.",
  "main": "index.js",
  "scripts": {
    "start": "node src/index.js"
  },
  "author": "Dustin Ewers",
  "license": "MIT",
  "dependencies": {
    "mountebank": "^2.0.0"
  }
}

Sie haben jetzt die Basis für Ihre Mountebank-Anwendung, die Sie erstellt haben, indem Sie Ihre App erstellt, Mountebank installiert und ein Startskript hinzugefügt haben. Als Nächstes fügen Sie eine Einstellungsdatei zum Speichern anwendungsspezifischer Einstellungen hinzu.

[[Schritt-2 -—- Erstellen einer Einstellungsdatei]] == Schritt 2 - Erstellen einer Einstellungsdatei

In diesem Schritt erstellen Sie eine Einstellungsdatei, die festlegt, welche Ports die Mountebank-Instanz und die beiden Mock-Services überwachen.

Jedes Mal, wenn Sie eine Instanz von Mountebank oder einen Scheindienst ausführen, müssen Sie angeben, auf welchem ​​Netzwerkport dieser Dienst ausgeführt wird (z. B.http://localhost:5000/). Wenn Sie diese in eine Einstellungsdatei einfügen, können die anderen Teile Ihrer Anwendung diese Einstellungen immer dann importieren, wenn sie die Portnummer für die Dienste und die Mountebank-Instanz kennen müssen. Während Sie diese direkt als Konstanten in Ihre Anwendung codieren können, ist es später einfacher, die Einstellungen zu ändern, wenn Sie sie in einer Datei speichern. Auf diese Weise müssen Sie die Werte nur an einer Stelle ändern.

Erstellen Sie zunächst ein Verzeichnis mit dem Namensrc aus Ihrem Verzeichnisapp: 

mkdir src

Navigieren Sie zu dem Ordner, den Sie gerade erstellt haben: 

cd src

Erstellen Sie eine Datei mit dem Namensettings.js und öffnen Sie sie in Ihrem Texteditor: 

nano settings.js

Fügen Sie als Nächstes Einstellungen für die Ports für die Hauptinstanz von Mountebank und die beiden Mock-Services hinzu, die Sie später erstellen werden:

app/src/settings.js

module.exports = {
    port: 5000,
    hello_service_port: 5001,
    customer_service_port: 5002
}

Diese Einstellungsdatei enthält drei Einträge:port: 5000 weist der Hauptinstanz der Mountebank Port5000 zu,hello_service_port: 5001 weist dem Hello World-Testdienst Port5001 zu, den Sie später erstellen werden Schritt, undcustomer_service_port: 5002 weist der Mock-Service-App Port5002 zu, die mit CSV-Daten antwortet. Wenn die Ports hier belegt sind, können Sie sie beliebig ändern. module.exports = ermöglicht es Ihren anderen Dateien, diese Einstellungen zu importieren.

In diesem Schritt haben Siesettings.js verwendet, um die Ports zu definieren, die Mountebank und Ihre Mock-Services abhören, und diese Einstellungen anderen Teilen Ihrer App zur Verfügung gestellt. Im nächsten Schritt erstellen Sie ein Initialisierungsskript mit diesen Einstellungen, um Mountebank zu starten.

[[Schritt-3 - Erstellen des Initialisierungsskripts]] == Schritt 3 - Erstellen des Initialisierungsskripts

In diesem Schritt erstellen Sie eine Datei, mit der eine Instanz von Mountebank gestartet wird. Diese Datei ist der Einstiegspunkt der Anwendung, dh, wenn Sie die App ausführen, wird dieses Skript zuerst ausgeführt. Sie werden dieser Datei weitere Zeilen hinzufügen, wenn Sie neue Service-Mocks erstellen.

Erstellen Sie aus dem Verzeichnissrc eine Datei mit dem Namenindex.js und öffnen Sie sie in Ihrem Texteditor: 

nano index.js

Fügen Sie der Datei den folgenden Code hinzu, um eine Instanz von Mountebank zu starten, die auf dem Port ausgeführt wird, der in dersettings.js-Datei angegeben ist, die Sie im letzten Schritt erstellt haben:

app/src/index.js

const mb = require('mountebank');
const settings = require('./settings');

const mbServerInstance = mb.create({
        port: settings.port,
        pidfile: '../mb.pid',
        logfile: '../mb.log',
        protofile: '../protofile.json',
        ipWhitelist: ['*']
    });

Dieser Code macht drei Dinge. Zunächst wird das zuvor installierte Mountebank npm-Paket (const mb = require('mountebank');) importiert. Anschließend wird das Einstellungsmodul importiert, das Sie im vorherigen Schritt erstellt haben (const settings = require('./settings');). Schließlich wird eine Instanz des Mountebank-Servers mitmb.create() erstellt.

Der Server überwacht den in der Einstellungsdatei angegebenen Port. Die Parameterpidfile,logfile undprotofile gelten für Dateien, die Mountebank intern verwendet, um die Prozess-ID aufzuzeichnen, anzugeben, wo die Protokolle aufbewahrt werden, und eine Datei zum Laden benutzerdefinierter Protokollimplementierungen festzulegen. Die EinstellungipWhitelistgibt an, welche IP-Adressen mit dem Mountebank-Server kommunizieren dürfen. In diesem Fall öffnen Sie es für eine beliebige IP-Adresse.

Speichern und beenden Sie die Datei.

Nachdem diese Datei vorhanden ist, geben Sie den folgenden Befehl ein, um Ihre Anwendung auszuführen: 

npm start

Die Eingabeaufforderung verschwindet und Sie sehen Folgendes: 

info: [mb:5000] mountebank v2.0.0 now taking orders - point your browser to http://localhost:5000/ for help

Dies bedeutet, dass Ihre Anwendung geöffnet ist und Anfragen entgegennehmen kann.

Überprüfen Sie anschließend Ihren Fortschritt. Öffnen Sie ein neues Terminalfenster und senden Sie mitcurl die folgendeGET-Anfrage an den Mountebank-Server: 

curl http://localhost:5000/

Dies gibt die folgende JSON-Antwort zurück: 

Output{
    "_links": {
        "imposters": {
            "href": "http://localhost:5000/imposters"
        },
        "config": {
            "href": "http://localhost:5000/config"
        },
        "logs": {
            "href": "http://localhost:5000/logs"
        }
    }
}

Der von Mountebank zurückgegebene JSON beschreibt die drei verschiedenen Endpunkte, die Sie zum Hinzufügen oder Entfernen von Objekten in Mountebank verwenden können. Indem Siecurl verwenden, um Anfragen an diese Endpunkte zu senden, können Sie mit Ihrer Mountebank-Instanz interagieren.

Wenn Sie fertig sind, wechseln Sie zurück zu Ihrem ersten Terminalfenster und beenden Sie die Anwendung mitCTRL +C. Hierdurch wird Ihre Node.js-App beendet, sodass Sie sie weiterhin hinzufügen können.

Jetzt haben Sie eine Anwendung, mit der eine Instanz von Mountebank erfolgreich ausgeführt wird. Im nächsten Schritt erstellen Sie einen Mountebank-Client, der REST-Anforderungen verwendet, um Ihrer Mountebank-Anwendung Scheindienste hinzuzufügen.

[[Schritt 4 - Aufbau eines Mountebank-Clients]] == Schritt 4 - Aufbau eines Mountebank-Clients

Die Mountebank kommuniziert über eine REST-API. Sie können die Ressourcen Ihrer Mountebank-Instanz verwalten, indem Sie HTTP-Anforderungen an die verschiedenen im letzten Schritt genannten Endpunkte senden. Um einen Scheindienst hinzuzufügen, senden Sie eine HTTPPOST-Anforderung an den Endpunkt des Betrügers. Einimposter ist der Name für einen Mock-Service in der Mountebank. Betrüger können einfach oder komplex sein, abhängig von dem Verhalten, das Sie in Ihrem Mock wollen.

In diesem Schritt erstellen Sie einen Mountebank-Client, der automatischPOST-Anfragen an den Mountebank-Service sendet. Sie können einePOST-Anforderung mitcurl oder Postman an den Endpunkt des Betrügers senden, müssen diese Anforderung jedoch jedes Mal senden, wenn Sie Ihren Testserver neu starten. Wenn Sie eine Beispiel-API mit mehreren Mocks ausführen, ist es effizienter, ein Clientskript zu schreiben, um dies für Sie zu tun.

Beginnen Sie mit der Installation der Bibliotheknode-fetch: 

npm install -save node-fetch

Mitnode-fetch library erhalten Sie eine Implementierung der JavaScript-Abruf-API, mit der Sie kürzere HTTP-Anforderungen schreiben können. Sie können die Standardbibliothekhttpverwenden, aber die Verwendung vonnode-fetch ist eine leichtere Lösung.

Erstellen Sie nun ein Client-Modul, um Anfragen an die Mountebank zu senden. Sie müssen nur Betrüger posten, damit dieses Modul eine Methode hat.

Verwenden Sienano, um eine Datei mit dem Namenmountebank-helper.js zu erstellen: 

nano mountebank-helper.js

Fügen Sie den folgenden Code in die Datei ein, um den Client einzurichten:

app/src/mountebank-helper.js

const fetch = require('node-fetch');
const settings = require('./settings');

function postImposter(body) {
    const url = `http://127.0.0.1:${settings.port}/imposters`;

    return fetch(url, {
                    method:'POST',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify(body)
                });
}

module.exports = { postImposter };

Dieser Code beginnt mit dem Abrufen dernode-fetch-Bibliothek und Ihrer Einstellungsdatei. Dieses Modul macht dann eine Funktion namenspostImposter verfügbar, die Service-Mocks an Mountebank sendet. Als nächstes bestimmtbody:, dass die FunktionJSON.stringify(body), ein JavaScript-Objekt, verwendet. Dieses Objekt wird anPOST an den Mountebank-Dienst weitergeleitet. Da diese Methode lokal ausgeführt wird, führen Sie Ihre Anforderung für127.0.0.1 (localhost) aus. Die Abrufmethode nimmt das in den Parametern gesendete Objekt und sendet die AnforderungPOST anurl.

In diesem Schritt haben Sie einen Mountebank-Client erstellt, um neue Mock-Services auf dem Mountebank-Server bereitzustellen. Im nächsten Schritt erstellen Sie mit diesem Client Ihren ersten Mock-Service.

[[Schritt 5 - Erstellen Ihres ersten Mock-Dienstes]] == Schritt 5 - Erstellen Ihres ersten Mock-Dienstes

In den vorherigen Schritten haben Sie eine Anwendung erstellt, die einen Mountebank-Server und Code zum Aufrufen dieses Servers erstellt. Jetzt ist es an der Zeit, mit diesem Code einen Betrüger oder einen Scheindienst zu erstellen.

In der Mountebank enthält jeder Betrügerstubs. Stichleitungen sind Konfigurationssätze, die die Reaktion eines Betrügers bestimmen. Stichleitungen können weiter in Kombinationen vonpredicates and responses unterteilt werden. Ein Prädikat ist die Regel, die die Reaktion des Betrügers auslöst. Prädikate können viele verschiedene Arten von Informationen verwenden, einschließlich URLs, Anforderungsinhalten (unter Verwendung von XML oder JSON) und HTTP-Methoden.

Aus der Sicht einerModel-View-Controller (MVC)-App verhält sich ein Betrüger wie ein Controller und die Stubs wie Aktionen innerhalb dieses Controllers. Prädikate sind Routing-Regeln, die auf eine bestimmte Controller-Aktion verweisen.

Erstellen Sie eine Datei mit dem Namenhello-service.js, um Ihren ersten Mock-Service zu erstellen. Diese Datei enthält die Definition Ihres Mock-Service.

Öffnen Siehello-service.js in Ihrem Texteditor: 

nano hello-service.js

Fügen Sie dann den folgenden Code hinzu:

app/src/hello-service.js

const mbHelper = require('./mountebank-helper');
const settings = require('./settings');

function addService() {
    const response = { message: "hello world" }

    const stubs = [
        {
            predicates: [ {
                equals: {
                    method: "GET",
                    "path": "/"
                }
            }],
            responses: [
                {
                    is: {
                        statusCode: 200,
                        headers: {
                            "Content-Type": "application/json"
                        },
                        body: JSON.stringify(response)
                    }
                }
            ]
        }
    ];

    const imposter = {
        port: settings.hello_service_port,
        protocol: 'http',
        stubs: stubs
    };

    return mbHelper.postImposter(imposter);
}

module.exports = { addService };

Dieser Code definiert einen Betrüger mit einem einzelnen Stub, der ein Prädikat und eine Antwort enthält. Dann sendet es das Objekt an den Mountebank-Server. Dieser Code fügt einen neuen Mock-Service hinzu, derGET-Anforderungen an den Stammurl abhört und{ message: "hello world" } zurückgibt, wenn er einen erhält.

Werfen wir einen Blick auf dieaddService()-Funktion, die der vorhergehende Code erstellt. Zunächst wird eine Antwortnachrichthello world definiert: 

    const response = { message: "hello world" }
...

Dann definiert es einen Stub: 

...
        const stubs = [
        {
            predicates: [ {
                equals: {
                    method: "GET",
                    "path": "/"
                }
            }],
            responses: [
                {
                    is: {
                        statusCode: 200,
                        headers: {
                            "Content-Type": "application/json"
                        },
                        body: JSON.stringify(response)
                    }
                }
            ]
        }
    ];
...

Dieser Stummel besteht aus zwei Teilen. Der Prädikatteil sucht nach einer Anforderung vonGETan die Stamm-URL (/). Dies bedeutet, dassstubs die Antwort zurückgibt, wenn jemand eineGET-Anforderung an die Stamm-URL des Scheindienstes sendet. Der zweite Teil des Stubs ist dasresponses-Array. In diesem Fall gibt es eine Antwort, die ein JSON-Ergebnis mit einem HTTP-Statuscode von200 zurückgibt.

Der letzte Schritt definiert einen Betrüger, der diesen Stub enthält: 

...
    const imposter = {
        port: settings.hello_service_port,
        protocol: 'http',
        stubs: stubs
    };
...

Dies ist das Objekt, das Sie an den Endpunkt von/impostersenden möchten, um einen Betrüger zu erstellen, der einen Dienst mit einem einzelnen Endpunkt verspottet. Der vorstehende Code definiert Ihren Betrüger, indem Sieport auf den in der Einstellungsdatei festgelegten Port setzen,protocol auf HTTP setzen undstubs als Stubs des Betrügers zuweisen.

Nachdem Sie einen Mock-Service haben, sendet der Code diesen an den Mountebank-Server: 

...
    return mbHelper.postImposter(imposter);
...

Wie bereits erwähnt, verwendet die Mountebank eine REST-API, um ihre Objekte zu verwalten. Der vorhergehende Code verwendet die zuvor definierte FunktionpostImposter(), um eine AnforderungPOSTan den Server zu senden, um den Dienst zu aktivieren.

Wenn Sie mithello-service.js fertig sind, speichern Sie die Datei und beenden Sie sie.

Rufen Sie als nächstes die neu erstellteaddService()-Funktion inindex.js auf. Öffnen Sie die Datei in Ihrem Texteditor: 

nano index.js

Fügen Sie die folgenden hervorgehobenen Zeilen hinzu, um sicherzustellen, dass die Funktion beim Erstellen der Mountebank-Instanz aufgerufen wird:

app/src/index.js

const mb = require('mountebank');
const settings = require('./settings');
const helloService = require('./hello-service');

const mbServerInstance = mb.create({
        port: settings.port,
        pidfile: '../mb.pid',
        logfile: '../mb.log',
        protofile: '../protofile.json',
        ipWhitelist: ['*']
    });

mbServerInstance.then(function() {
    helloService.addService();
});

Wenn eine Mountebank-Instanz erstellt wird, gibt siepromise zurück. Ein Versprechen ist ein Objekt, dessen Wert erst später bestimmt wird. Dies kann verwendet werden, um asynchrone Funktionsaufrufe zu vereinfachen. Im vorhergehenden Code wird die Funktion.then(function(){...})ausgeführt, wenn der Mountebank-Server initialisiert wird. Dies geschieht, wenn das Versprechen aufgelöst wird.

Speichern und beenden Sieindex.js.

Um zu testen, ob der Mock-Service beim Initialisieren von Mountebank erstellt wird, starten Sie die Anwendung: 

npm start

Der Node.js-Prozess belegt das Terminal. Öffnen Sie daher ein neues Terminalfenster und senden Sie eine Anforderung vonGETanhttp://localhost:5001/: 

curl http://localhost:5001

Sie erhalten die folgende Antwort, die darauf hinweist, dass der Dienst ausgeführt wird: 

Output{"message": "hello world"}

Nachdem Sie Ihre Anwendung getestet haben, wechseln Sie zurück zum ersten Terminalfenster und beenden Sie die Anwendung Node.js mitCTRL +C.

In diesem Schritt haben Sie Ihren ersten Mock-Service erstellt. Dies ist ein Testdienstmodell, dashello world als Antwort auf eine Anforderung vonGETzurückgibt. Dieses Modell ist zu Demonstrationszwecken gedacht. Es gibt Ihnen nichts, was Sie mit der Erstellung einer kleinen Express-Anwendung nicht erreichen könnten. Im nächsten Schritt erstellen Sie ein komplexeres Modell, das einige der Funktionen der Mountebank nutzt.

[[Schritt 6 - Erstellen eines datengestützten Mock-Dienstes]] == Schritt 6 - Erstellen eines datengestützten Mock-Dienstes

Während die Art des Dienstes, den Sie im vorherigen Schritt erstellt haben, für einige Szenarien in Ordnung ist, erfordern die meisten Tests komplexere Antworten. In diesem Schritt erstellen Sie einen Dienst, der einen Parameter aus der URL entnimmt und ihn zum Nachschlagen eines Datensatzes in einer CSV-Datei verwendet.

Wechseln Sie zunächst zum Hauptverzeichnis vonappzurück: 

cd ~/app

Erstellen Sie einen Ordner mit dem Namendata: 

mkdir data

Öffnen Sie eine Datei für Ihre Kundendaten mit dem Namencustomers.csv: 

nano data/customers.csv

Fügen Sie die folgenden Testdaten hinzu, damit Ihr Mock-Service etwas abrufen kann:

app/data/customers.csv

id,first_name,last_name,email,favorite_color
1,Erda,Birkin,[email protected],Aquamarine
2,Cherey,Endacott,[email protected],Fuscia
3,Shalom,Westoff,[email protected],Red
4,Jo,Goulborne,[email protected],Red

Hierbei handelt es sich um gefälschte Kundendaten, die vom API-Mocking-ToolMockaroo generiert wurden, ähnlich den gefälschten Daten, die Sie im Service selbst in eine Kundentabelle laden würden.

Speichern und schließen Sie die Datei.

Erstellen Sie dann ein neues Modul mit dem Namencustomer-service.js im Verzeichnissrc: 

nano src/customer-service.js

Fügen Sie den folgenden Code hinzu, um einen Betrüger zu erstellen, der die Anforderungen vonGETauf dem Endpunkt von/customers/abhört:

app/src/customer-service.js

const mbHelper = require('./mountebank-helper');
const settings = require('./settings');

function addService() {
    const stubs = [
        {
            predicates: [{
                and: [
                    { equals: { method: "GET" } },
                    { startsWith: { "path": "/customers/" } }
                ]
            }],
            responses: [
                {
                    is: {
                        statusCode: 200,
                        headers: {
                            "Content-Type": "application/json"
                        },
                        body: '{ "firstName": "${row}[first_name]", "lastName": "${row}[last_name]", "favColor": "${row}[favorite_color]" }'
                    },
                    _behaviors: {
                        lookup: [
                            {
                                "key": {
                                  "from": "path",
                                  "using": { "method": "regex", "selector": "/customers/(.*)$" },
                                  "index": 1
                                },
                                "fromDataSource": {
                                  "csv": {
                                    "path": "data/customers.csv",
                                    "keyColumn": "id"
                                  }
                                },
                                "into": "${row}"
                              }
                        ]
                    }
                }
            ]
        }
    ];

    const imposter = {
        port: settings.customer_service_port,
        protocol: 'http',
        stubs: stubs
    };

    return mbHelper.postImposter(imposter);
}

module.exports = { addService };

Dieser Code definiert einen Service-Mock, der nachGET Anforderungen mit einem URL-Format voncustomers/<id> sucht. Wenn eine Anfrage eingeht, fragt sie die URL nachid des Kunden ab und gibt dann den entsprechenden Datensatz aus der CSV-Datei zurück.

Dieser Code verwendet einige mehr Mountebank-Funktionen als der Diensthello, den Sie im letzten Schritt erstellt haben. Erstens verwendet es eine Funktion der Mountebank namensbehaviors. Mit Verhalten können Sie einem Stub Funktionen hinzufügen. In diesem Fall verwenden Sie das Verhalten vonlookup, um einen Datensatz in einer CSV-Datei nachzuschlagen: 

...
  _behaviors: {
      lookup: [
          {
              "key": {
                "from": "path",
                "using": { "method": "regex", "selector": "/customers/(.*)$" },
                "index": 1
              },
              "fromDataSource": {
                "csv": {
                  "path": "data/customers.csv",
                  "keyColumn": "id"
                }
              },
              "into": "${row}"
            }
      ]
  }
...

Die Eigenschaftkeyverwendet einen regulären Ausdruck, um den eingehenden Pfad zu analysieren. In diesem Fall nehmen Sie dieid, die nachcustomers/ in der URL stehen.

Die EigenschaftfromDataSourceverweist auf die Datei, in der Sie Ihre Testdaten speichern.

Die Eigenschaftinto fügt das Ergebnis in eine Variable${row} ein. Auf diese Variable wird im folgenden Abschnitt vonbodyverwiesen: 

...
  is: {
      statusCode: 200,
      headers: {
          "Content-Type": "application/json"
      },
      body: '{ "firstName": "${row}[first_name]", "lastName": "${row}[last_name]", "favColor": "${row}[favorite_color]" }'
  },
...

Die Zeilenvariable wird verwendet, um den Hauptteil der Antwort auszufüllen. In diesem Fall handelt es sich um eine JSON-Zeichenfolge mit den Kundendaten.

Speichern und schließen Sie die Datei.

Öffnen Sie als Nächstesindex.js, um der Initialisierungsfunktion den neuen Service-Mock hinzuzufügen: 

nano src/index.js

Fügen Sie die markierte Zeile hinzu:

app/src/index.js

const mb = require('mountebank');
const settings = require('./settings');
const helloService = require('./hello-service');
const customerService = require('./customer-service');

const mbServerInstance = mb.create({
        port: settings.port,
        pidfile: '../mb.pid',
        logfile: '../mb.log',
        protofile: '../protofile.json',
        ipWhitelist: ['*']
    });

mbServerInstance.then(function() {
    helloService.addService();
    customerService.addService();
});

Speichern und schließen Sie die Datei.

Starten Sie nun Mountebank mitnpm start. Dadurch wird die Eingabeaufforderung ausgeblendet. Öffnen Sie daher ein anderes Terminalfenster. Testen Sie Ihren Dienst, indem Sie eineGET-Anforderung anlocalhost:5002/customers/3 senden. Dadurch werden die Kundeninformationen unterid3 nachgeschlagen. 

curl localhost:5002/customers/3

Sie werden die folgende Antwort sehen: 

Output{
    "firstName": "Shalom",
    "lastName": "Westoff",
    "favColor": "Red"
}

In diesem Schritt haben Sie einen Mock-Service erstellt, der Daten aus einer CSV-Datei liest und als JSON-Antwort zurückgibt. Von hier aus können Sie weiterhin komplexere Mocks erstellen, die den zu testenden Diensten entsprechen.

Fazit

In diesem Artikel haben Sie mithilfe von Mountebank und Node.js eine eigene Anwendung zum Verspotten von Diensten erstellt. Jetzt können Sie Mock-Services erstellen und diese mit Ihrem Team teilen. Egal, ob es sich um ein komplexes Szenario mit einem zu testenden Anbieterservice handelt oder um einen einfachen Mock, während Sie darauf warten, dass ein anderes Team seine Arbeit beendet, Sie können Ihr Team in Bewegung halten, indem Sie Mock-Services erstellen.

Wenn Sie mehr über Mountebank erfahren möchten, überprüfen Sie derendocumentation. Wenn Sie diese Anwendung containerisieren möchten, überprüfen SieContainerizing a Node.js Application for Development With Docker Compose. Wenn Sie diese Anwendung in einer produktionsähnlichen Umgebung ausführen möchten, überprüfen SieHow To Set Up a Node.js Application for Production on Ubuntu 18.04.

Related