Usage Examples with Jest

Welcome to the usage examples guide for Datamint with Jest! This guide will show you how to use Datamint in your Jest test suites.

Setting Up a Dockerized Database for Jest Tests

You can use Jest's setup and teardown methods to manage your Dockerized databases. Here's an example of how you can do it:

import type { Config } from "jest";
 
const config: Config = {
  testEnvironment: "node",
  globalSetup: "./tests/global.setup.js",
  globalTeardown: "./tests/global.teardown.js",
};
 
export default config;

Start by defining the paths to your global setup and global teardown scripts in your Jest config.

const { Datamint, DatabaseType } = require("datamint");
 
const config = {
  name: "testdb",
  user: "testuser",
  password: "testpassword",
};
 
module.exports = async () => {
  const mint = new Datamint(DatabaseType.POSTGRESQL, config);
  await mint.start();
  global.__MINT__ = mint;
};

Here we are making sure that we are awaiting the process of spinning up the Docker container. The start method will also make sure that the Dockerized database is actually running and accepts connections. We are saving the mint object to a global variable, just to make sure we can access the same instance on teardown, but this can be done in multiple ways.

const { DatabaseType } = require("datamint");
 
module.exports = async () => {
  const mint = global.__MINT__;
  await mint.stop();
};

The stop method will do two things:

1. Take down the Docker container.
2. Remove any temporary files & directories used by the application.

Should any of these processes fail and cause an error, there are failsafe mechanisms in place to make sure that the resources are brought down in a graceful manner.

Using the Dockerized Database in Jest Tests

So now all the prerequisites are in place, and we can use the DatamintClient in our test suites. This is how we can achieve that:

describe("Datamint Test", () => {
  let datamint: DatamintClient<PostgreSQLPlugin>;
  const tableName = "your_table_name";
 
  beforeAll(async () => {
    datamint = new DatamintClient(DatabaseType.POSTGRESQL, {
      name: "test",
      password: "test",
      user: "test",
    });
 
    await datamint.connect();
 
    await datamint.createTable(tableName, {
      id: "SERIAL PRIMARY KEY",
      name: "VARCHAR(255)",
    });
  });
 
  afterAll(async () => {
    await datamint.reset();
    await datamint.disconnect();
  });
 
  it("should insert data into the specified table correctly", async () => {
    const mockData = [{ id: 1, name: "John" }];
    await datamint.insert(tableName, mockData);
 
    const result = await datamint.find(tableName, { id: 1 });
 
    expect(result[0]).toEqual({ id: 1, name: "John" });
  });
});

Here we are using the test-suite faced object DatamintClient, which is capable of CRUD database operations. As well as connecting and disconnecting the client from the database. We do not need to set up any Docker container logic at this point, we handled all of this in the global setup and teardown scripts. You can choose to do so in the beforeAll and afterAll methods if you wish. But considering it takes a little while to spin up Docker containers, I would recommend an approach where you handle this logic before and after the test suite lifecycle.

Setting up Datamint per Test Suite

If you want to set up a new Datamint instance for each test suite, you can do so by creating a new instance and starting it in the beforeAll method and stopping it in the afterAll method. Here's an example:

const mint = new Datamint(DatabaseType.MYSQL, {
  name: "test",
  password: "test",
  user: "test",
});
const client = new DatamintClient(DatabaseType.MYSQL, mockConfig);
 
describe("Datamint Test", () => {
  const tableName = "your_table_name";
 
  beforeAll(async () => await mint.start());
  afterAll(async () => await mint.stop());
 
  beforeEach(async () => {
    await client.connect();
    await client.createTable("test", {
      id: "INT AUTO_INCREMENT PRIMARY KEY",
      name: "VARCHAR(255)",
    });
  });
 
  afterEach(async () => {
    await client.reset();
    await client.disconnect();
  });
 
  it("should insert data into the specified table correctly", async () => {
    const mockData = [{ id: 1, name: "John" }];
    await client.insert(tableName, mockData);
 
    const result = await client.find(tableName, { id: 1 });
 
    expect(result[0]).toEqual({ id: 1, name: "John" });
  });
});

Providing a Custom Database Connection String

If you have your own database and you're not using Datamint containers, you can provide your own connection string. Here's how you can do it:

describe("Datamint Test", () => {
  let datamint: DatamintClient<PostgreSQLPlugin>;
  const tableName = "your_table_name";
 
  beforeAll(async () => {
    datamint = new DatamintClient(DatabaseType.POSTGRESQL);
 
    await datamint.connect("your_database_connection_string");
 
    await datamint.createTable(tableName, {
      id: "SERIAL PRIMARY KEY",
      name: "VARCHAR(255)",
    });
  });
 
  // ... rest of the code
});

Conclusion

In this guide, we've explored how to use Datamint with Jest for your testing needs. We started with the prerequisites, setting up a Dockerized database for Jest tests, and then dove into how to use this setup in your Jest tests. Using Datamint with Jest provides several benefits. It simplifies the process of setting up and tearing down Dockerized databases for your tests, ensuring a clean state for each test run. This makes your tests more reliable and easier to manage.

Furthermore, Datamint's flexibility allows you to use it with different database types, making it a versatile tool for your testing needs. Remember, the key to effective testing is a reliable and repeatable test setup. With Datamint and Jest, you can achieve this with ease.

Next Steps

Congratulations, you've just used Datamint in your Jest test suites! From here, you can start using Datamint in more complex testing scenarios. If you have any questions or run into any issues, feel free to contact me. Happy testing!