Comment se moquer es6 classe à l'aide de la Plaisanterie

Je cherche à simuler une classe Mailer à l'aide de la blague et je ne peux pas comprendre comment le faire. Les docs ne pas donner de nombreux exemples de la façon dont cela fonctionne. Le processus est la je vais avoir un noeud événement password-reset qui est tiré et que lorsque l'événement est déclenché, je veux envoyer un e-mail à l'aide de Mailer.send(to, subject, body). Voici ma structure de répertoire:

project_root
-- __test__
---- server
------ services
-------- emails
---------- mailer.test.js
-- server
---- services
------ emails
-------- mailer.js
-------- __mocks__
---------- mailer.js

Voici ma maquette fichier __mocks__/mailer.js:

const Mailer = jest.genMockFromModule('Mailer');

function send(to, subject, body) {
  return { to, subject, body };
}

module.exports = Mailer;

et mon mailer.test.js

const EventEmitter = require('events');
const Mailer = jest.mock('../../../../server/services/emails/mailer');

test('sends an email when the password-reset event is fired', () => {
  const send = Mailer.send();
  const event = new EventEmitter();
  event.emit('password-reset');
  expect(send).toHaveBeenCalled();
});

et enfin mon mailer.js classe:

class Mailer {

  constructor() {
    this.mailgun = require('mailgun-js')({
      apiKey: process.env.MAILGUN_API_KEY,
      domain: process.env.MAILGUN_DOMAIN,
    });
  }

  send(to, subject, body) {
    return new Promise((reject, resolve) => {
      this.mailgun.messages().send({
        from: 'Securely App <[email protected]>',
        to,
        subject: subject,
        html: body,
      }, (error, body) => {
        if (error) {
          return reject(error);
        }

        return resolve('The email was sent successfully!');
      });
    });
  }

}

module.exports = new Mailer();

Alors, comment réussir à se moquer et de tester cette classe, à l'aide de la Blague? Merci beaucoup pour aider!

OriginalL'auteur dericcain | 2017-05-03

15

Vous n'avez pas à se moquer de votre mailer classe, mais la mailgun-js module. Donc mailgun est une fonction qui renvoie la fonction messages que de retour de la fonction send. Si la maquette ressemble à ceci.

pour le plaisir du chemin
```
const happyPath = () => ({
  messages: () => ({
    send: (args, callback) => callback()
  })
})
```
pour l'erreur de cas
```
const errorCase = () => ({
  messages: () => ({
    send: (args, callback) => callback('someError')
  })
})
```
que vous avez ce 2 cas il judicieux de se moquer du module à l'intérieur de votre test. D'abord, vous avez de s'en moquer avec un simple espion où plus tard, on peut définir la mise en œuvre de notre cas et il faut importer le module.
```
jest.mock('mailgun-js', jest.fn())
import mailgun from 'mailgun-js'
import Mailer from '../../../../server/services/emails/mailer'
```
Que votre module utilise les promesses que nous avons 2 options soit de retour, la promesse de le tester ou d'utiliser async/await. J'utilise la plus récente pour plus d'infos, jetez un oeil ici.
```
test('test the happy path', async() => {
 //mock the mailgun so it returns our happy path mock
  mailgun.mockImplementation(() => happyPath)
  //we need to use async/awit here to let jest recognize the promise
  const send = await Mailer.send();
  expect(send).toBe('The email was sent successfully!')
});
```
Si vous souhaitez tester que le mailgun send méthode a été appelée avec le paramètre approprié vous avez besoin d'adapter la maquette comme ceci:
```
const send = jest.fn((args, callback) => callback())
const happyPath = () => ({
  messages: () => ({
    send: send
  })
})
```
Maintenant, vous pouvez vérifier que le premier paramètre pour envoyer était correct:
```
expect(send.mock.calls[0][0]).toMatchSnapshot()
```
Je ne peux pas attendre de rentrer à la maison et essayer cela. Merci beaucoup pour le super-grande explication.

OriginalL'auteur Andreas Köberle
6

Juste pour les Googlers et les futurs visiteurs, voici comment j'ai configuré rire moqueur pour ES6 classes.
J'ai aussi un exemple de travail sur github, avec babel-jest pour transpiling le module ES de la syntaxe, de sorte que la plaisanterie peut se moquer d'eux correctement.

__mocks__/MockedClass.js
```
const stub = {
  someMethod: jest.fn(),
  someAttribute: true
}

module.exports = () => stub;
```
Votre code peut appeler cette fonction avec la nouvelle, et dans vos tests, vous pouvez appeler la fonction et d'écraser tout défaut de mise en œuvre.

example.spec.js
```
const mockedClass = require("path/to/MockedClass")(); 
const AnotherClass = require("path/to/AnotherClass");
let anotherClass;

jest.mock("path/to/MockedClass");

describe("AnotherClass", () => {
  beforeEach(() => {
    mockedClass.someMethod.mockImplementation(() => {
      return { "foo": "bar" };
    });

    anotherClass = new AnotherClass();
  });

  describe("on init", () => {
    beforeEach(() => { 
      anotherClass.init(); 
    });

    it("uses a mock", () => {
      expect(mockedClass.someMethod.toHaveBeenCalled();
      expect(anotherClass.settings)
        .toEqual(expect.objectContaining({ "foo": "bar" }));
    });
  });

});
```
Pas de travail pour moi. mockedClass.someMethod est undefined. À l'aide de la plaisanterie 21.2.1.
vous avez raison! J'ai mis à jour l'exemple de code.
génial - j'ai été la recherche d'une solution pour que cela fait déjà un certain temps, mais le retour d'une fonction qui renvoie toujours la même instance est assez intelligent. Merci!
comment pouvez-vous appeler new sur une flèche de la fonction? J'obtiens l'erreur 'mockedClass n'est pas un constructeur" quand AnotherClass appels new mockedClass().
J'ai mis à jour ma réponse au point d'un exemple de travail, un dépôt github.

OriginalL'auteur Justus Romijn

Vous devez vous connecter pour publier un commentaire.