Faciliter les tests des promises quand nous utilions Mocha, Chai et Sinon

Hop, une petite extension à l'article "Sinon: restorer les espions et stubs automatiquements".


Ici, nous allons voir comment tester des Promises dans nos tests unitaires. Car nous savons que Mocha nous facilite déjà la tâche en nous proposant une mécanique bien spécifique de gestion de l'asynchronisme.

Par défaut, nous devons déclarer une variable dans notre "it" afin de pouvoir déclarer à Mocha que notre test est asynchrone, mais aussi de pouvoir dire quand cela se termine:


it('an unit test with a promise', function (done) {
   myService
      .myPromiseFunc(42)
      .then(function (response) {
         chai.expect(response).equals(21);
         done();
      })
      .catch(done);
});

it('an unit test with a promise in a fail case', function (done) {
   myService
      .myPromiseFunc(21)
      .then(function () {
         done('The then method shall not be called');
      })
      .catch(function (err) {
         chai.expect(err).to.be.instanceof(MyCustomError);
         done();
      })
      .catch(done);
});


Déjà, qu'est-ce que nous pouvons dire ? Nous sommes obligés de déclarer un "catch" sur nos tests de Promise, car si l'assertion n'est pas respecté, Mocha va lever une exception (du moins, dans le monde NodeJs). Du coup, par sécurité, nous devons déclarer cette exception.

Inversement, si nous espérons avoir une exception, nous devons déclarer un then au cas où l'exception n'est pas levé, quand même déclarer ce fameux catch ! Ce qui fait un peu de boilerplate de code.

Nous pouvons résumer ces deux précédents tests, en retournant la Promise dans le "it". Mocha saura que le test est asynchrone:

it('an unit test with a promise', function () {
   return myService
      .myPromiseFunc(42)
      .then(function (response) {
         chai.expect(response).equals(21);
      });
});

it('an unit test with a promise in a fail case', function () {
   return myService
      .myPromiseFunc(21)
      .then(function () {
         throw new Error('The then method shall not be called');
      })
      .catch(function (err) {
         chai.expect(err).to.be.instanceof(MyCustomError);
      });
});



Maintenant, imaginons, nous devons faire des "spies" et des "stubs" autour des Promises via Sinon, nous allons avoir des tests dans ce genre-là (dans un cas plutôt simple), ce qui ne donne pas une lecture toujours très claire du dit test:

const chai = require('chai');
const sinon = require('sinon');
 
describe('My awesome tests', function () {
   const MyService = require('../lib/my-service');
   let sandBox = null;
   
   beforeEach(function (){
        sandBox = sinon.sandbox.create();
    });
 
    afterEach(function () {
        sandBox.restore();
    });
   
   it('shall raise an exception if no parameter is set', function() {
      return MyService
         .findSomething()
         .then(function () {
            throw new Error('The then method shall not be called');
         })
         .catch(function(error) {
            chai.expect(error).to.be.exist;
            chai.expect(error).to.be.instanceof(Error);
            chai.expect(error.message).equals('You must set a parameter!');
         });
   });
   
   it('shall made an SQL query into the database', function() {
      let stubCall = sandBox.stub(MyService, 'queryInDatabase', function () {
         return Promise.resolve([{ 'value': 'some value' }]);
      });
   
      return MyService
         .findSomething(42)
         .then(function (results) {
            chai.expect(stubCall.called).to.be.true;
            chai.expect(stubCall.calledOnce).to.be.true;
            chai.expect(stubCall.calledWith(sinon.match.string, [42])).to.be.true;
            chai.expect(results).deep.equals(['some value']);
         });
   });
});



Ici, dans le dernier test, nous voyons que nous "mockons" un accès à la base de données afin de simuler la réponse, et que nous vérifions également que cette même fonction n'a bien été appelé une seule fois avec des paramètres spécifiques (notamment, en reprenant le paramètre fourni à la méthode que nous voulons tester originellement).

Pour faciliter la lecture (même si l'exemple précédent reste lisible. Cela devient plus compliqué quand nous devons en faire plusieurs), nous allons utiliser deux plugins:
Ces deux plugins vont étendre à la fois Chai  et Sinon pour étendre la syntaxe. Mais nous allons utiliser la notation "Mock" en association les "Expectations" de Sinon. Ce dernier permet de définir un contrat de test de manière plus "humaine" et fluide:



const chai = require('chai');
const sinon = require('sinon');
 
chai.use(require('chai-as-promised'));
require('sinon-as-promised');
 
describe('My awesome tests', function () {
   const MyService = require('../lib/my-service');
   let sandBox = null;
   
   beforeEach(function (){
        sandBox = sinon.sandbox.create();
    });
 
    afterEach(function () {
        sandBox.restore();
    });
   
   it('shall raise an exception if no parameter is set', function() {
      return MyService
         .findSomething()
         .then(function () {
            throw new Error('The then method shall not be called');
         })
         .catch(function(error) {
            chai.expect(error).to.be.exist;
            chai.expect(error).to.be.instanceof(Error);
            chai.expect(error.message).equals('You must set a parameter!');
         });
   });
   
   it('shall made an SQL query into the database', function() {      
      let stubCall = sandBox.mock(MyService);
      stubCall
         .expects('queryInDatabase')
         .once()
         .withArgs(sinon.match.string, [42])
         .resolves([{ 'value': 'some value' }]);
       
      return chai
          .expect(MyService.findSomething(42)).to.be.eventually.deep.equal(['some value'])
          .then(function () {
            findAllMock.verify();
          });
   });
});



Un peu plus sympa non ?


Commentaires

Enregistrer un commentaire

Posts les plus consultés de ce blog

ISO: liens & outils utiles

Image
Voici quelques normes ISO à connaître et que vous aurez à faire face dans vos développements. Et quelques liens / outils permettant de s'assurer que nous faisons correctement leurs intégrations Code Pays https://countrycode.org/ est super site qui permet de lister les pays du monde avec leur country code (en mode number et iso): Et par pays, nous pouvons avoir des informations supplémentaires, comme le format téléphone, la position géographique, la time zone, la monnaie, etc: Ce site du coup regroupe les country code: En ISO 3166 name (où un nom est attribué à un pays) En ISO 3166 numeric (où un chiffre numérique est attribué à un pays) En ISO 3166-1 alpha-2 (code en 2 alpha majuscule) En ISO 3166-1 alpha-3 (code en 3 alpha majuscule) Ainsi que les langues. Tout cela est d'ailleurs regroupés dans ce fichier téléchargeable . Code langue / locale Là, nous tombons dans un des plus grands soucis d'un développeur: co...
Lire la suite

NodeJs et SSL: une petite analyse

Le but de cet article est de faire un petit tour d'horizon de l'usage de SSL dans nos applications NodeJs, en l'occurence, quand nous souhaitons faire une application Web, une API REST, ou les deux. Nous allons avoir 6 étapes pour de réalisation d'un serveur NodeJs, avec à chaque fois 12 clients: Un client NodeJs sans certificats SSL - strictSSL à false Un client NodeJs sans certificats SSL - strictSSL à true Un client NodeJs avec un certificat SSL client non fiable - strictSSL à false Un client NodeJs avec un certificat SSL client non fiable - strictSSL à true Un client NodeJs avec un certificat SSL server non fiable - strictSSL à false Un client NodeJs avec un certificat SSL server non fiable - strictSSL à true Un client NodeJs avec un certificat SSL client fiable - strictSSL à false Un client NodeJs avec un certificat SSL client fiable - strictSSL à true Un client NodeJs avec un certificat SSL serveur fiable - strictSSL à false...
Lire la suite

Créer sa commande slack en quelques minutes

Image
Le but de cet article est de vous montrer que très simplement, nous pouvons créer une commande personnalisée pour Slack. Ici, nous allons afficher des chats :)" Tout d'abord, nous allons nous créer des comptes sur: Slack:  https://slack.com Heroku:  http://www.heroku.com/ qui permettra d'héberger notre service REST pour Slack Gitlab: https://gitlab.com  qui permet évidemment d'héberger notre code, mais qui pourra de manière automatiser déployer notre application sur Heroku à chaque commit (et cela, même en mode "gratuit") Concentrons-nous tout d'abord sur Heroku et Gitlab. Créons un compte Heroku. Une fois cela fait, aller dans votre compte :. Vous verrez alors une section nommée "API key": Cliquez sur "Reveal" pour voir la valeur et conservez la bien en mémoire. Ensuite, sur en retournant sur votre dashboard d'applications Heroku , cliquez sur "New" et créez une nouvelle application. Dans...
Lire la suite