TOC

Comment simuler des services à l’aide de Mountebank et Node.js

L'auteur a sélectionné lesOpen Internet/Free Speech Fund pour recevoir un don dans le cadre du programmeWrite for DOnations.

introduction

Dans lesservice-oriented architectures (SOA) complexes, les programmes ont souvent besoin d'appeler plusieurs services pour exécuter un flux de travail donné. Tout va bien une fois que tout est en place, mais si le code sur lequel vous travaillez nécessite un service en cours de développement, vous pouvez être obligé d'attendre que d'autres équipes terminent leur travail avant de commencer le vôtre. En outre, à des fins de test, vous devrez peut-être interagir avec des services de fournisseurs externes, tels qu'une API météo ou un système de gestion des enregistrements. Les fournisseurs ne vous offrent généralement pas autant d'environnements que nécessaire et ne facilitent pas le contrôle des données de test sur leurs systèmes. Dans ces situations, des services non terminés et des services indépendants de votre volonté peuvent rendre les tests de code frustrants.

La solution à tous ces problèmes est de créer unservice mock. Un modèle de service est un code qui simule le service que vous utiliseriez dans le produit final, mais qui est plus léger, moins complexe et plus facile à contrôler que le service réel que vous utiliseriez en production. Vous pouvez définir un service fictif pour renvoyer une réponse par défaut ou des données de test spécifiques, puis exécuter le logiciel que vous souhaitez tester comme si le service dépendant était réellement présent. De ce fait, la possibilité de simuler des services de manière flexible peut rendre votre flux de travail plus rapide et plus efficace.

Dans une entreprise, la création de services simulés est parfois appeléeservice virtualization. La virtualisation de services est souvent associée à des outils d’entreprise coûteux, mais vous n’avez pas besoin d’un outil coûteux pour simuler un service. Mountebank est un outil de simulation de service gratuit et open source que vous pouvez utiliser pour simuler les services HTTP, y compris les servicesREST etSOAP. Vous pouvez également l'utiliser pour simuler les requêtesSMTP ouTCP.

Dans ce guide, vous allez créer deux applications flexibles de simulation de services en utilisantNode.js et Mountebank. Les deux services fictifs écouteront un port spécifique pour les demandes REST dans HTTP. En plus de ce simple comportement moqueur, le service récupérera également des données simulées à partir d'uncomma-separated values (CSV) file. Après ce tutoriel, vous pourrez vous moquer de tous les types de comportement de service afin de développer et de tester plus facilement vos applications.

Conditions préalables

Pour suivre ce tutoriel, vous aurez besoin des éléments suivants:

[[step-1 -—- starting-a-node-js-application]] == Étape 1 - Démarrage d'une application Node.js

Dans cette étape, vous allez créer une application de base Node.js qui servira de base à votre instance Mountebank et aux services fictifs que vous créerez ultérieurement.

[.Remarque]##

Note: Mountebank peut être utilisé comme application autonome en l'installant globalement à l'aide de la commandenpm install -g mountebank. Vous pouvez ensuite l'exécuter avec la commandemb et ajouter des simulations à l'aide de requêtes REST.

Bien que ce soit le moyen le plus rapide de faire fonctionner Mountebank, la création de l'application Mountebank vous-même vous permet d'exécuter un ensemble de simulations prédéfinies au démarrage de l'application, que vous pouvez ensuite stocker dans le contrôle de code source et partager avec votre équipe. Ce didacticiel créera l'application Mountebank manuellement pour en tirer parti.

Tout d’abord, créez un nouveau répertoire dans lequel mettre votre application. Vous pouvez le nommer comme vous le souhaitez, mais dans ce didacticiel, nous le nommeronsapp: 

mkdir app

Déplacez-vous dans le répertoire que vous venez de créer avec la commande suivante: 

cd app

Pour démarrer une nouvelle application Node.js, exécuteznpm init et remplissez les invites: 

npm init

Les données de ces invites seront utilisées pour remplir votre fichierpackage.json, qui décrit ce qu'est votre application, les packages sur lesquels elle s'appuie et les différents scripts qu'elle utilise. Dans les applications Node.js, les scripts définissent des commandes permettant de créer, d’exécuter et de tester votre application. Vous pouvez choisir les valeurs par défaut pour les invites ou indiquer le nom de votre package, votre numéro de version, etc.

Une fois cette commande terminée, vous aurez une application Node.js de base, y compris le fichierpackage.json.

Maintenant, installez le paquet Mountebank npm en utilisant les éléments suivants: 

npm install -save mountebank

Cette commande récupère le package Mountebank et l’installe dans votre application. Assurez-vous d'utiliser l'indicateur-save afin de mettre à jour votre fichierpackage.json avec Mountebank comme dépendance.

Ensuite, ajoutez un script de démarrage à votrepackage.json qui exécute la commandenode src/index.js. Ce script définit le point d'entrée de votre application en tant queindex.js, que vous créerez dans une étape ultérieure.

Ouvrezpackage.json dans un éditeur de texte. Vous pouvez utiliser l'éditeur de texte de votre choix, mais ce tutoriel utilisera nano. 

nano package.json

Accédez à la section"scripts" et ajoutez la ligne"start": "node src/index.js". Cela ajoutera une commandestart pour exécuter votre application.

Votre fichierpackage.json devrait ressembler à ceci, selon la façon dont vous avez rempli les invites initiales:

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

Vous avez maintenant la base de votre application Mountebank, que vous avez créée en créant votre application, en installant Mountebank et en ajoutant un script de démarrage. Ensuite, vous ajouterez un fichier de paramètres pour stocker les paramètres spécifiques à l’application.

[[step-2 -—- creation-a-settings-file]] == Étape 2 - Création d'un fichier de paramètres

Dans cette étape, vous allez créer un fichier de paramètres qui détermine les ports que l'instance de Mountebank et les deux services fictifs écouteront.

Chaque fois que vous exécutez une instance de Mountebank ou un service fictif, vous devrez spécifier sur quel port réseau ce service s'exécutera (par exemple,http://localhost:5000/). En les plaçant dans un fichier de paramètres, les autres parties de votre application pourront importer ces paramètres dès qu’elles auront besoin de connaître le numéro de port des services et de l’instance Mountebank. Bien que vous puissiez les coder directement dans votre application en tant que constantes, la modification ultérieure des paramètres sera plus facile si vous les stockez dans un fichier. De cette façon, il vous suffira de changer les valeurs en un seul endroit.

Commencez par créer un répertoire appelésrc à partir de votre répertoireapp: 

mkdir src

Accédez au dossier que vous venez de créer: 

cd src

Créez un fichier appelésettings.js et ouvrez-le dans votre éditeur de texte: 

nano settings.js

Ajoutez ensuite les paramètres des ports pour l’instance principale de Mountebank et les deux services fictifs que vous créerez ultérieurement:

app/src/settings.js

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

Ce fichier de paramètres comporte trois entrées:port: 5000 attribue le port5000 à l'instance principale de Mountebank,hello_service_port: 5001 attribue le port5001 au service de test Hello World que vous créerez ultérieurement étape, etcustomer_service_port: 5002 attribue le port5002 à l'application de service fictive qui répondra avec des données CSV. Si les ports ici sont occupés, n'hésitez pas à les changer à votre guise. module.exports = permet à vos autres fichiers d'importer ces paramètres.

Dans cette étape, vous avez utilisésettings.js pour définir les ports que Mountebank et vos services simulés écouteront et avez mis ces paramètres à la disposition d'autres parties de votre application. Dans l'étape suivante, vous allez créer un script d'initialisation avec ces paramètres pour démarrer Mountebank.

[[step-3 -—- building-the-initialization-script]] == Étape 3 - Construction du script d'initialisation

Dans cette étape, vous allez créer un fichier qui démarre une instance de Mountebank. Ce fichier sera le point d’entrée de l’application, ce qui signifie que ce script s’exécutera en premier lorsque vous exécuterez l’application. Vous ajouterez plus de lignes à ce fichier lors de la création de nouveaux modèles de service.

Depuis le répertoiresrc, créez un fichier appeléindex.js et ouvrez-le dans votre éditeur de texte: 

nano index.js

Pour démarrer une instance de Mountebank qui s'exécutera sur le port spécifié dans le fichiersettings.js que vous avez créé à la dernière étape, ajoutez le code suivant au fichier:

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: ['*']
    });

Ce code fait trois choses. Tout d'abord, il importe le package Mountebank npm que vous avez installé précédemment (const mb = require('mountebank');). Ensuite, il importe le module de paramètres que vous avez créé à l'étape précédente (const settings = require('./settings');). Enfin, il crée une instance du serveur Mountebank avecmb.create().

Le serveur écoute sur le port spécifié dans le fichier de paramètres. Les paramètrespidfile,logfile etprotofile concernent les fichiers que Mountebank utilise en interne pour enregistrer son ID de processus, spécifier où il conserve ses journaux et définir un fichier pour charger les implémentations de protocole personnalisé. Le paramètreipWhitelist spécifie les adresses IP autorisées à communiquer avec le serveur Mountebank. Dans ce cas, vous l’ouvrez à n’importe quelle adresse IP.

Enregistrez et quittez le fichier.

Une fois ce fichier en place, entrez la commande suivante pour exécuter votre application: 

npm start

L'invite de commande disparaîtra et vous verrez ce qui suit: 

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

Cela signifie que votre application est ouverte et prête à recevoir des demandes.

Ensuite, vérifiez vos progrès. Ouvrez une nouvelle fenêtre de terminal et utilisezcurl pour envoyer la requêteGET suivante au serveur Mountebank: 

curl http://localhost:5000/

Cela renverra la réponse JSON suivante: 

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

Le code JSON renvoyé par Mountebank décrit les trois points de terminaison différents que vous pouvez utiliser pour ajouter ou supprimer des objets dans Mountebank. En utilisantcurl pour envoyer des demandes à ces points de terminaison, vous pouvez interagir avec votre instance Mountebank.

Lorsque vous avez terminé, revenez à votre première fenêtre de terminal et quittez l'application en utilisantCTRL +C. Ceci quitte votre application Node.js afin que vous puissiez continuer à l'ajouter.

Vous avez maintenant une application qui exécute avec succès une instance de Mountebank. Dans l'étape suivante, vous allez créer un client Mountebank qui utilise des requêtes REST pour ajouter des services fictifs à votre application Mountebank.

[[step-4 -—- building-a-mountebank-client]] == Étape 4 - Création d'un client Mountebank

Mountebank communique à l'aide d'une API REST. Vous pouvez gérer les ressources de votre instance Mountebank en envoyant des demandes HTTP aux différents systèmes d'extrémité mentionnés à la dernière étape. Pour ajouter un service fictif, vous envoyez une requête HTTPPOST au point de terminaison des imposteurs. Unimposter est le nom d'un service simulé dans Mountebank. Les imposteurs peuvent être simples ou complexes, en fonction des comportements que vous souhaitez dans votre maquette.

Dans cette étape, vous allez créer un client Mountebank pour envoyer automatiquement les requêtesPOST au service Mountebank. Vous pouvez envoyer une requêtePOST au point de terminaison des imposteurs en utilisantcurl ou Postman, mais vous devrez envoyer cette même requête chaque fois que vous redémarrez votre serveur de test. Si vous exécutez un exemple d’API avec plusieurs modélisations, il sera plus efficace d’écrire un script client à cet effet.

Commencez par installer la bibliothèquenode-fetch: 

npm install -save node-fetch

Lenode-fetch library vous donne une implémentation de l'API JavaScript Fetch, que vous pouvez utiliser pour écrire des requêtes HTTP plus courtes. Vous pouvez utiliser la bibliothèque standardhttp, mais utilisernode-fetch est une solution plus légère.

Maintenant, créez un module client pour envoyer des demandes à Mountebank. Vous n'avez besoin que de poster des imposteurs, donc ce module aura une méthode.

Utiliseznano pour créer un fichier appelémountebank-helper.js: 

nano mountebank-helper.js

Pour configurer le client, placez le code suivant dans le fichier:

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

Ce code commence par extraire la bibliothèquenode-fetch et votre fichier de paramètres. Ce module expose ensuite une fonction appeléepostImposter qui publie des simulations de service sur Mountebank. Ensuite,body: détermine que la fonction prendJSON.stringify(body), un objet JavaScript. Cet objet est ce que vous allez envoyerPOST au service Mountebank. Étant donné que cette méthode s'exécute localement, vous exécutez votre requête sur127.0.0.1 (localhost). La méthode fetch prend l'objet envoyé dans les paramètres et envoie la requêtePOST auxurl.

Dans cette étape, vous avez créé un client Mountebank pour publier de nouveaux services fictifs sur le serveur Mountebank. Dans l’étape suivante, vous utiliserez ce client pour créer votre premier service fictif.

[[step-5 -—- creating-your-first-mock-service]] == Étape 5 - Création de votre premier service simulé

Dans les étapes précédentes, vous avez créé une application qui crée un serveur Mountebank et un code pour appeler ce serveur. Il est maintenant temps d’utiliser ce code pour créer un imposteur ou un service factice.

Dans Mountebank, chaque imposteur contientstubs. Les stubs sont des ensembles de configuration qui déterminent la réponse d'un imposteur. Les stubs peuvent être divisés en combinaisons depredicates and responses. Un prédicat est la règle qui déclenche la réponse de l'imposteur. Les prédicats peuvent utiliser de nombreux types d'informations différents, notamment des URL, un contenu de requête (à l'aide de XML ou de JSON) et des méthodes HTTP.

Vu du point de vue d'une applicationModel-View-Controller (MVC), un imposteur agit comme un contrôleur et les stubs comme des actions dans ce contrôleur. Les prédicats sont des règles de routage qui pointent vers une action spécifique du contrôleur.

Pour créer votre premier service simulé, créez un fichier appeléhello-service.js. Ce fichier contiendra la définition de votre service fictif.

Ouvrezhello-service.js dans votre éditeur de texte: 

nano hello-service.js

Ajoutez ensuite le code suivant:

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

Ce code définit un imposteur avec un seul stub contenant un prédicat et une réponse. Ensuite, il envoie cet objet au serveur Mountebank. Ce code ajoutera un nouveau service simulé qui écoute les requêtesGET à la racineurl et renvoie{ message: "hello world" } quand il en obtient un.

Jetons un œil à la fonctionaddService() créée par le code précédent. Tout d'abord, il définit un message de réponsehello world: 

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

Ensuite, il définit un stub: 

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

Ce talon a deux parties. La partie prédicat recherche une requêteGET à l'URL racine (/). Cela signifie questubs retournera la réponse lorsque quelqu'un envoie une requêteGET à l'URL racine du service fictif. La deuxième partie du stub est le tableauresponses. Dans ce cas, il existe une réponse, qui renvoie un résultat JSON avec un code d'état HTTP de200.

La dernière étape définit un imposteur contenant ce stub: 

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

C'est l'objet que vous allez envoyer au point de terminaison/imposters pour créer un imposteur qui se moque d'un service avec un seul point de terminaison. Le code précédent définit votre imposteur en définissant lesport sur le port que vous avez déterminé dans le fichier de paramètres, en définissant lesprotocol sur HTTP et en affectantstubs comme stubs de l’imposteur.

Maintenant que vous avez un service fictif, le code l'envoie au serveur Mountebank: 

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

Comme mentionné précédemment, Mountebank utilise une API REST pour gérer ses objets. Le code précédent utilise la fonctionpostImposter() que vous avez définie précédemment pour envoyer une requêtePOST au serveur pour activer le service.

Une fois que vous avez terminé avechello-service.js, enregistrez et quittez le fichier.

Ensuite, appelez la fonctionaddService() nouvellement créée dansindex.js. Ouvrez le fichier dans votre éditeur de texte: 

nano index.js

Pour vous assurer que la fonction est appelée lors de la création de l'instance de Mountebank, ajoutez les lignes en surbrillance suivantes:

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

Lorsqu'une instance Mountebank est créée, elle renvoie unpromise. Une promesse est un objet qui ne détermine sa valeur que plus tard. Ceci peut être utilisé pour simplifier les appels de fonctions asynchrones. Dans le code précédent, la fonction.then(function(){...}) s'exécute lorsque le serveur Mountebank est initialisé, ce qui se produit lorsque la promesse se résout.

Enregistrez et quittezindex.js.

Pour vérifier que le service fictif est créé lors de l'initialisation de Mountebank, démarrez l'application: 

npm start

Le processus Node.js occupera le terminal, alors ouvrez une nouvelle fenêtre de terminal et envoyez une requêteGET àhttp://localhost:5001/: 

curl http://localhost:5001

Vous recevrez la réponse suivante, indiquant que le service fonctionne: 

Output{"message": "hello world"}

Maintenant que vous avez testé votre application, revenez à la première fenêtre de terminal et quittez l'application Node.js en utilisantCTRL +C.

Dans cette étape, vous avez créé votre premier service factice. Il s'agit d'une maquette de service de test qui renvoiehello world en réponse à une requêteGET. Cette maquette est destinée à des fins de démonstration; cela ne vous donne pas vraiment quelque chose que vous ne pourriez obtenir en construisant une petite application Express. Dans la prochaine étape, vous créerez une maquette plus complexe qui tire parti de certaines fonctionnalités de Mountebank.

[[step-6 -—- building-a-data-back-mock-service]] == Étape 6 - Création d'un service de simulation basé sur les données

Bien que le type de service que vous avez créé à l'étape précédente convient à certains scénarios, la plupart des tests nécessitent un ensemble de réponses plus complexe. Au cours de cette étape, vous allez créer un service qui extrait un paramètre de l’URL et l’utilise pour rechercher un enregistrement dans un fichier CSV.

Tout d'abord, revenez au répertoire principalapp: 

cd ~/app

Créez un dossier appelédata: 

mkdir data

Ouvrez un fichier pour vos données client appelécustomers.csv: 

nano data/customers.csv

Ajoutez les données de test suivantes afin que votre service fictif ait quelque chose à récupérer:

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

Il s'agit de fausses données client générées par l'outil de simulation d'APIMockaroo, similaires aux fausses données que vous chargez dans une table clients dans le service lui-même.

Enregistrez et quittez le fichier.

Ensuite, créez un nouveau module appelécustomer-service.js dans le répertoiresrc: 

nano src/customer-service.js

Pour créer un imposteur qui écoute les requêtesGET sur le point de terminaison/customers/, ajoutez le code suivant:

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

Ce code définit une maquette de service qui recherche les requêtesGET avec un format d'URL decustomers/<id>. Lorsqu'une demande est reçue, il interroge l'URL pour lesid du client, puis renvoie l'enregistrement correspondant à partir du fichier CSV.

Ce code utilise un peu plus de fonctionnalités Mountebank que le servicehello que vous avez créé à la dernière étape. Premièrement, il utilise une fonctionnalité de Mountebank appeléebehaviors. Les comportements permettent d’ajouter des fonctionnalités à un stub. Dans ce cas, vous utilisez le comportement delookup pour rechercher un enregistrement dans un fichier CSV: 

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

La propriétékey utilise une expression régulière pour analyser le chemin entrant. Dans ce cas, vous prenez lesid qui viennent aprèscustomers/ dans l'URL.

La propriétéfromDataSource pointe vers le fichier que vous utilisez pour stocker vos données de test.

La propriétéinto injecte le résultat dans une variable${row}. Cette variable est référencée dans la sectionbody suivante: 

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

La variable de ligne est utilisée pour renseigner le corps de la réponse. Dans ce cas, il s’agit d’une chaîne JSON avec les données du client.

Enregistrez et quittez le fichier.

Ensuite, ouvrezindex.js pour ajouter le nouveau service simulé à votre fonction d'initialisation: 

nano src/index.js

Ajouter la ligne en surbrillance:

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

Enregistrez et quittez le fichier.

Démarrez maintenant Mountebank avecnpm start. Cela cachera l'invite, ouvrez une autre fenêtre de terminal. Testez votre service en envoyant une requêteGET àlocalhost:5002/customers/3. Cela recherchera les informations client sousid3. 

curl localhost:5002/customers/3

Vous verrez la réponse suivante: 

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

Dans cette étape, vous avez créé un service fictif qui lisait les données d'un fichier CSV et les renvoyait sous forme de réponse JSON. À partir de là, vous pouvez continuer à créer des modèles plus complexes correspondant aux services que vous devez tester.

Conclusion

Dans cet article, vous avez créé votre propre application de service-mocking à l'aide de Mountebank et Node.js. Vous pouvez maintenant créer des services factices et les partager avec votre équipe. Qu'il s'agisse d'un scénario complexe impliquant un service fournisseur que vous devez tester ou d'une simple simulation pendant que vous attendez qu'une autre équipe termine son travail, vous pouvez garder votre équipe en mouvement en créant des services factices.

Si vous voulez en savoir plus sur Mountebank, consultez leursdocumentation. Si vous souhaitez conteneuriser cette application, consultezContainerizing a Node.js Application for Development With Docker Compose. Si vous souhaitez exécuter cette application dans un environnement de production, consultezHow To Set Up a Node.js Application for Production on Ubuntu 18.04.

Related