Wrap Mocha tests in transactions with mocha-slonik

[AndrewJo]

Hey guys, I've made a small library that allows you to wrap tests in transactions which should help with making sure your tests are well isolated.

You can install it by running:

npm i -D mocha-slonik

There are couple of modes of operation:

1. Registering a Mocha Root Hook plugin with --require mocha-slonik/register flag:

   • CLI: mocha --require mocha-slonik/register tests/**/*.ts
   • .mocharc:

     {
       "require": [
         "mocha-slonik/register"
        ]
     }

   This is the easiest way to get started if you're not utilizing factory design pattern for createPool or don't need advanced rollback strategy. Note that this option will globally modify createPool to wrap all methods in a transaction and will break your tests if your code utilizes copyFromBinary method.

   Example test.js:

   import { expect, use } from "chai";
   import chaiHttp from "chai-http";
   import { createPool, sql } from "slonik";
   import { app } from "./app";
   
   use(chaiHttp);
   
   describe("/articles", function () {
     let client;
     let server;
     let pool;
   
     before(async function () {
       server = app.listen(9090);
       client = chai.request(server).keepOpen();
       pool = createPool(process.env.DATABASE_URL);
     });
   
     beforeEach(async function () {
       // Assume 3 items of test fixture data to be inserted into the database.
       const testFixtures = [
         [ /* ... */ ],
         // ...
       ];
   
       // Bulk insert test fixture (rolls back after each test)
       await pool.query(sql`
         INSERT INTO articles (title, body)
         SELECT * FROM ${sql.unnest(testFixtures, ["text", "text"])};
       `);
     });
   
     after(function (done) {
       pool.end().then(() => {
         client.close();
         server.close(done);
       });
     });
   
     it("should insert a new article", async function () {
       const payload = {
         title: "Never Gonna Give You Up",
         body: "We're no strangers to love"
       };
   
       // oldCount should be 3 based on test fixture.
       const oldCount = await pool.oneFirst(sql`SELECT COUNT(*) FROM articles;`);
   
       const response = await client.post("/articles").send(payload);
   
       // newCount should now be 4
       const newCount = await pool.oneFirst(sql`SELECT COUNT(*) FROM articles;`);
   
       expect(response.body).to.eql(payload);
       expect(newCount).to.be.above(oldCount);
     });
   
     it("should get an article by id", async function () {
       const response = await client.get("/articles/1").send();
       const expected = {
         title: "Lorem ipsum",
         body: "Lorem ipsum dolor amit"
       };
   
       // Previous test shouldn't affect this test and count return 3
       const count = await pool.oneFirst(sql`SELECT COUNT(*) FROM articles;`);
   
       expect(response.body).to.eql(expected);
     });
   });

2. Use the factory design pattern to manually wrap createPool method. This doesn't require modifying .mocharc or adding --require flags. This is a more advanced use case that will let you have greater control on when you can rollback your transactions (by letting you rollback in after/afterEach block):

   import { createPool } from "mocha-slonik";
   
   describe("outer block", function () {
     let pool;
   
     before(function () {
       pool = createPool(/* ... */);
     });
   
     describe("test group 1", function () {
       // Group 1 rolls back after the entire group has completed running.
       after(async function () {
         await pool.rollback();
       });
   
       it("should insert data", async function () {
         // ...
       });
   
       it("should test something else with inserted data", async function () {
         // ...
       });
     });
   
     describe("test group 2", function () {
       // Group 2 rolls back after EACH test completed running.
       afterEach(async function () {
         await pool.rollback();
       });
   
       it("shouldn't be affected by changes to data by tests in group 1", async function () {
         // ...
       })
     });
   
   });

   Example test.js:

   import { expect, use } from "chai";
   import chaiHttp from "chai-http";
   import { createPool } from "mocha-slonik";
   import { sql } from "slonik";
   import { createServer } from "./app";
   
   use(chaiHttp);
   
   describe("/articles", function () {
     let app;
     let client;
     let server;
     let pool;
   
     before(async function () {
       app = express();
       pool = createPool(process.env.DATABASE_URL);
       // The createServer method is a factory method that wraps the express.js app and createPool and returns a server instance
       server = createServer({ app, createPool });
       client = chai.request(server).keepOpen();
     });
   
     beforeEach(async function () {
       // Assume 3 items of test fixture data to be inserted into the database.
       const testFixtures = [
         [ /* ... */ ],
         // ...
       ];
   
       // Bulk insert test fixture
       await pool.query(sql`
         INSERT INTO articles (title, body)
         SELECT * FROM ${sql.unnest(testFixtures, ["text", "text"])};
       `);
     });
   
     // Remember to rollback the pool afterEach test.
     afterEach(async function () {
       await pool.rollback();
     });
   
     after(function (done) {
       pool.end().then(() => {
         client.close();
         server.close(done);
       });
     });
   
     it("should insert a new article", async function () {
       const payload = {
         title: "Never Gonna Give You Up",
         body: "We're no strangers to love"
       };
   
       // oldCount should be 3 based on test fixture.
       const oldCount = await pool.oneFirst(sql`SELECT COUNT(*) FROM articles;`);
   
       const response = await client.post("/articles").send(payload);
   
       // newCount should now be 4
       const newCount = await pool.oneFirst(sql`SELECT COUNT(*) FROM articles;`);
   
       expect(response.body).to.eql(payload);
       expect(newCount).to.be.above(oldCount);
     });
   
     it("should get an article by id", async function () {
       const response = await client.get("/articles/1").send();
       const expected = {
         title: "Lorem ipsum",
         body: "Lorem ipsum dolor amit"
       };
   
       // Previous test shouldn't affect this test and count return 3
       const count = await pool.oneFirst(sql`SELECT COUNT(*) FROM articles;`);
   
       expect(response.body).to.eql(expected);
     });
   });

More details available on the mocha-slonik README.

Feel free to try it out and I hope it's useful for those who want to use transactions to isolate each of the test cases in your Mocha tests.