nodemailer-mock

Easy as pie nodemailer mock for unit testing your Node.js applications.

install

npm install nodemailer-mock --save-dev

yarn add -D nodemailer-mock

module loading

Depending on your mock configuration nodemailer-mock may, or may not, have access to nodemailer when it is loaded. For example, using mockery you can replace nodemailer with require('nodemailer-mock'), however in jest you will need to inject nodemailer using module.exports = require('nodemailer-mock').getMockFor(require('nodemailer'));

mock api

Use with test suites like jest and mocha. There are some special methods available on the mocked module to help with testing. They are under the .mock key of the mocked nodemailer.

NodemailerMock.mock functions

• reset: () => void
  • resets the mock class to default values
• getSentMail: () => Mail.Options[]
  • returns an array of sent emails during your tests, since the last reset
• getCloseCallCount: () => number
  • get the number of times the transporter.close() was called across all instances
• setShouldFailOnce: (isSet?: boolean) => void
  • should the mock return an error on the next call to transporter.sendMail() or transport.send()
• isShouldFailOnce: () => boolean
  • returns status of setShouldFailOnce(?)
• setShouldFail: (isFail?: boolean) => void
  • indicate if errors should be returned for subsequent calls to transporter.sendMail() or transport.send()
    • if true, return error
    • if false, return success
• isShouldFail: () => boolean
  • returns status of setShouldFail()
• setShouldFailCheck: (check: CheckMailMessageOrNull) => void
  • indicate if the specific email passed to the function should fail the call to transporter.sendMail() or transport.send()
    • if function returns true, return error
    • if function returns false, return success
  • use type CheckMailMessageOrNull = ((email: MailMessage) => boolean) | null
• getShouldFailCheck: () => CheckMailMessageOrNull
  • returns the function used to check the MailMessage or null if it is not set
• setMockedVerify: (isMocked: boolean) => void
  • determine if a call to transport.verify() should be mocked or passed through to nodemailer, defaults to true.
    • if true, use a mocked callback
    • if false, pass through to a real nodemailer transport
• isMockedVerify: () => boolean
  • returns status of setMockedVerify(?)
• setMockedClose: (isMocked: boolean) => void
  • determine if calls to transporter.close() should be passed through to the underlying transport, defaults to true.
• isMockedClose: () => boolean
  • when the result is true the underlying transport is not used, when false the call is passed through.
• setSuccessResponse: (response: string) => void
  • set the success message that is returned in the callback for transporter.sendMail() or transport.send()
• getSuccessResponse: () => string
  • returns the success message value
• setFailResponse: (error: Error) => void
  • set the Error that is returned in the callback for transporter.sendMail() or transport.send()
• getFailResponse: () => Error
  • returns the fail Error value
• scheduleIsIdle: (isIdle: boolean, timeout: number) => void
  • schedule a status change for calls to transporter.isIdle() instances
• setIsIdle: (isIdle: boolean) => void
  • set the status that is returned by calls to all transporter.isIdle() instances
• setUnmockedUsePlugins: (isUnmockUsePlugins: boolean) => void default false
  • should the plugins added via transporter.use() be run outside the mock?
• isUnmockedUsePlugins: () => boolean
  • returns the status of setUnmockedUsePlugins(?)

NodemailerMockTransporter.mock functions

• getPlugins: () => { [key: string]: Mail.PluginFunction<Mail.Options>[] }
  • returns the plugins that have been added via transporter.use() as arrays, keyed by step
• getCloseCallCount: () => number
  • get the number of times close() has been called on this transporter. this number is not reset with the mock.
• setIdle(isIdle: boolean): void
  • sets the idle state of transporter.isIdle() and emits an idle event when the isIdle argument is true.

usage

The mocked module behaves in a similar fashion to other transports provided by nodemailer.

setup test

1const nodemailermock = require('nodemailer-mock');
2const transport = nodemailermock.createTransport();
3
4// the email you want to send
5const email = ... // <-- your email here

use nodestyle callbacks

1// send with nodestyle callback
2transport.sendMail(email, function(err, info) {
3  if (err) {
4    return console.log('Error!', err, info);
5  }
6  return console.log('Success!', info);
7}
8
9// verify with nodestyle callback
10transport.verify(function(err, success) {
11  if (err) {
12    return console.log('Error!', err);
13  }
14  return console.log('Success!', success);
15});

use promises

1// send with promises
2transport.sendMail(email)
3  .then(function(info) {
4    console.log('Success!', info);
5  })
6  .catch(function(err) {
7    console.log('Error!', err);
8  });
9
10// verify with promises
11transport.verify()
12  .then(function(success) {
13    console.log('Success!', success);
14  });
15  .catch(function(err) {
16    console.log('Error!', err);
17  });

use async/await

1// send an email with async / wait
2try {
3  const info = await transport.sendMail(email);
4} catch (err) {
5  console.log("Error!", err);
6}
7
8// verify with async / wait
9try {
10  const info = await transport.verify();
11} catch (err) {
12  console.log("Error!", err);
13}

example tests using mocked module

To use nodemailer-mock in your tests you will need to mock nodemailer with it. There are working examples using jest and mocha in the ./examples/ folder of the project. The jest code is in ./examples/__mocks__ and ./examples/__tests__, and the mocha tests are in ./examples/test. Run the examples with npm run example:jest and npm run example:mocha. Both JavaScript and TypeScript example tests are provided.

example using jest

To mock nodemailer using jest create a file called ./__mocks__/nodemailer.js that exports the mocked module:

1/**
2 * Jest Mock
3 * ./__mocks__/nodemailer.js
4 **/
5// load the real nodemailer
6const nodemailer = require("nodemailer");
7// pass it in when creating the mock using getMockFor()
8const nodemailermock = require("nodemailer-mock").getMockFor(nodemailer);
9// export the mocked module
10module.exports = nodemailermock;

Once the mock file is created all calls to nodemailer from your tests will return the mocked module. To access to mock functions, just load it in your test file.

1/**
2 * Jest Test
3 * ./__tests__/my-test.js
4 **/
5const { mock } = require("nodemailer");
6
7test("Send an email using the mocked nodemailer", async () => {
8  /* ... run your tests that send emails here */
9
10  // check the mock for our sent emails
11  const sentEmails = mock.getSentMail();
12  // there should be one
13  expect(sentEmails.length).toBe(1);
14  // and it should match the to address
15  expect(sentEmails[0].to).toBe("justin@to.com");
16});

Using typescript you can coerce the NodemailerMock type.

1/**
2 * Jest Test
3 * ./__tests__/my-test.js
4 **/
5import { expect, test } from "@jest/globals";
6// 'nodemailer' is automatically mocked in ./__mocks__/nodemailer.js
7import * as nodemailer from "nodemailer";
8import { NodemailerMock } from "nodemailer-mock";
9const { mock } = nodemailer as unknown as NodemailerMock;
10
11test("Send an email using the mocked nodemailer + typescript", async () => {
12  /* ... run your tests that send emails here */
13
14  // check the mock for our sent emails
15  const sentEmails = mock.getSentMail();
16  // there should be one
17  expect(sentEmails.length).toBe(1);
18  // and it should match the to address
19  expect(sentEmails[0].to).toBe("justin@to.com");
20});

example using mocha and mockery

Here is an example of using a mocked nodemailer class in a mocha test using mockery. Make sure that any modules that require()'s a mocked module must be called AFTER the module is mocked or node will use the unmocked version from the module cache. Note that this example uses async/await. See the module tests for additional example code.

1/**
2 * Mocha Test / Mockery Mock
3 * ./test/my-test.js
4 **/
5const { expect } = require('chai');
6const mockery = require('mockery');
7const nodemailermock = require('nodemailer-mock');
8
9describe('Tests that send email',  async () {
10
11  /* This could be an app, Express, etc. It should be
12  instantiated *after* nodemailer is mocked. */
13  let app = null;
14
15  before(async () {
16    // Enable mockery to mock objects
17    mockery.enable({
18      warnOnUnregistered: false,
19    });
20
21    /* Once mocked, any code that calls require('nodemailer')
22    will get our nodemailermock */
23    mockery.registerMock('nodemailer', nodemailermock)
24
25    /*
26    ##################
27    ### IMPORTANT! ###
28    ##################
29    */
30    /* Make sure anything that uses nodemailer is loaded here,
31    after it is mocked just above... */
32    const moduleThatRequiresNodemailer = require('module-that-requires-nodemailer');
33
34  });
35
36  afterEach(async () {
37    // Reset the mock back to the defaults after each test
38    nodemailermock.mock.reset();
39  });
40
41  after(async () {
42    // Remove our mocked nodemailer and disable mockery
43    mockery.deregisterAll();
44    mockery.disable();
45  });
46
47  it('should send an email using nodemailer-mock', async () {
48    // call a service that uses nodemailer
49    const response = ... // <-- your email code here
50
51    // a fake test for something on our response
52    expect(response.value).to.equal('value');
53
54    // get the array of emails we sent
55    const sentMail = nodemailermock.mock.getSentMail();
56
57    // we should have sent one email
58    expect(sentMail.length).to.equal(1);
59
60    // check the email for something
61    expect(sentMail[0].property).to.equal('foobar');
62  });
63
64  it('should fail to send an email using nodemailer-mock', async () {
65    // tell the mock class to return an error
66    const err = new Error('My custom error');
67    nodemailermock.mock.setShouldFailOnce();
68    nodemailermock.mock.setFailResponse(err);
69
70    // call a service that uses nodemailer
71    var response = ... // <-- your code here
72
73    // a fake test for something on our response
74    expect(response.error).to.equal(err);
75  });
76
77  /* this will not work with jest as all nodemailers are mocked */
78  it('should verify using the real nodemailer transport', async () {
79    // tell the mock class to pass verify requests to nodemailer
80    nodemailermock.mock.setMockedVerify(false);
81
82    // call a service that uses nodemailer
83    var response = ... // <-- your code here
84
85    /* calls to transport.verify() will be passed through,
86       transporter.send() is still mocked */
87  });
88});