How to Automate Database Testing in CI/CD Pipelines

Are you tired of manual database testing that delays your application releases and obstructs the constant delivery of new features? Do you want to implement CI/CD workflows that include automated database testing alongside your code? Look no further, because in this article, we’ll show you how to make your database testing automated and effortless.

Database testing is a crucial aspect of the software development process. Changes to the schema or data could break your application, causing data loss, downtime, and angry customers. To avoid such negative outcomes, you need to ensure that your database changes don’t have any unintended effects. Manual testing can be slow, costly, and error-prone, especially when you have to test across multiple database platforms and versions. That’s why automating your database testing in CI/CD pipelines can help you achieve consistent, scalable, and accurate testing. With automation, you can run tests more frequently, detect issues faster, and get timely feedback. So, let’s dive into the steps to automate your database testing.

Step 1: Choose a Database Schema Migration Tool

Before you can test your database changes, you first need to apply them to your database schema. For this purpose, you can use a database schema migration tool, like Liquibase or Flyway. These tools allow you to version your database schema, track your changes, and apply them in a repeatable and reversible manner. They work with multiple database management systems (DBMS), such as Oracle, Microsoft SQL Server, PostgreSQL, MySQL, MongoDB, and more. Additionally, Liquibase and Flyway integrate with CI/CD tools, like Jenkins, TeamCity, Bamboo, or GitLab CI/CD, which will streamline your database changes, and enable you to test them automatically.

Liquibase is an open-source tool for database schema versioning and migrations. It uses a declarative approach based on XML, YAML, or JSON files, where you describe your database changes as change sets. Liquibase supports various DBMS and provides features, such as preconditions, contexts, labels, rollbacks, and diffs, which make your migrations more robust and flexible. You can also use Liquibase extensions for more advanced functionality, such as managing stored procedures, triggers, functions, or data masking.

Flyway is another open-source tool for database schema management and migrations. It uses a migration-first approach based on SQL scripts, where you write your database changes as SQL statements that are executed in order. Flyway supports several DBMS and offers features, such as placeholders, callbacks, resolvers, undo scripts, and metadata tables, which improve your migrations’ maintainability and recoverability. You can also use Flyway plugins or Editions, such as Teams or Enterprise, for more features, like LDAP authentication, enterprise support, or SQL-based migrations.

Both Liquibase and Flyway help you automate your database schema migrations and versioning, which simplify your testing process, and integrate with your CI/CD pipelines. You can choose the tool that best matches your preferences, skills, and project requirements.

Step 2: Write Database Test Scripts

To test your database changes, you need to write database test scripts that verify the correctness and consistency of your database schema and data. Your tests should cover various scenarios, such as adding columns, modifying tables, inserting data, querying data, and deleting data. You should test your changes under different constraints, such as concurrent transactions, error conditions, and performance thresholds. You can use any testing framework or tool that supports your database platform and programming language, such as JUnit, TestNG, NUnit, PyTest, or RSpec. You can also leverage database-specific tools or libraries, such as DBUnit, SQLUnit, SQLAlchemy, or ActiveRecord.

For instance, let’s see an example of a JUnit test that tests a Liquibase-based schema migration that adds a new column to a table:

package com.example;

import org.junit.Test;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import liquibase.Liquibase;
import liquibase.database.Database;
import liquibase.database.DatabaseConnection;
import liquibase.database.DatabaseFactory;
import liquibase.database.jvm.JdbcConnection;
import liquibase.resource.ClassLoaderResourceAccessor;

import static org.junit.Assert.assertEquals;

public class MyDatabaseTest {

    public void testAddNewColumn() throws Exception {
        // Arrange
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost/mydb", "user", "password");
        DatabaseConnection dbConnection = new JdbcConnection(connection);
        Database database = DatabaseFactory.getInstance().findCorrectDatabaseImplementation(dbConnection);
        Liquibase liquibase = new Liquibase("com/example/changelog.xml", new ClassLoaderResourceAccessor(), database);

        // Act
        Statement statement = connection.createStatement();
        ResultSet resultSet = statement.executeQuery("SELECT COUNT(*) FROM mytable WHERE new_column IS NULL");

        // Assert
        assertEquals(0, resultSet.getInt(1));

This test first loads the MySQL JDBC driver and creates a database connection to a test database. Then, it creates a Liquibase instance, passing the changelog file location, the resource accessor, and the database instance. After that, it applies the changes to the database by calling the update() method. Finally, it executes a SELECT statement that counts the number of records in the table that have the new column value as null. The test asserts that the result is 0, which means that the new column was successfully added to the table.

You can write similar tests for Flyway-based migrations or for other database platforms and frameworks. The point is that you need to have tests that verify the correctness and consistency of your schema changes, and that run automatically as part of your CI/CD pipeline.

Step 3: Integrate Database Testing in CI/CD Pipelines

Now that you have your database schema migration tool and your database test scripts, you need to integrate them into your CI/CD pipelines. Your CI/CD tool should be able to run your database migrations and tests alongside your application code changes, and provide you with feedback on the results. To achieve this, you can use plugins or extensions that match your tool and your database platform.

For example, if you use Jenkins as your CI/CD tool and MySQL as your database, you can use the Jenkins Liquibase Plugin to automate your Liquibase migrations and the MySQL Plugin to run your database tests in a Docker container. The Liquibase Plugin allows you to specify the location of your changelog file, the database credentials, and the list of contexts or labels to apply. The MySQL Plugin allows you to create a Docker container with the MySQL database, load the test scripts, run the tests, and publish the test results to Jenkins. You can also use Jenkins Pipeline to define your CI/CD process as code, and reuse your database tasks across different pipelines or projects.

If you use GitLab CI/CD, you can leverage the GitLab Database Migration Tool that supports both Liquibase and Flyway. This tool provides a Docker image with the necessary settings and dependencies to run your migrations and tests. You can use the migrate or validate commands to apply your migrations or test your schema, respectively. You can also use the fingerprint command to generate a unique identifier for your schema version, which you can use as a reference in your GitLab CI/CD pipeline. Moreover, you can track your schema changes in your GitLab repository, and tag your releases with the corresponding schema version.

Similar integration options exist for other CI/CD tools, such as Bitbucket Pipelines, Travis CI, CircleCI, or Azure DevOps. You should choose the integration that suits your needs and aligns with your workflow.


Automating your database testing in CI/CD pipelines can help you achieve faster releases, better quality, and more confidence in your database changes. By using a database schema migration tool, such as Liquibase or Flyway, you can manage your schema changes in a versioned, repeatable, and reversible manner. By writing database test scripts that cover the various aspects of your changes, you can ensure that your schema is valid and consistent. And by integrating your migrations and tests into your CI/CD pipelines, you can detect issues early, get timely feedback, and streamline your database development process.

We hope that this article has provided you with useful insights and practical tips on how to automate your database testing in CI/CD pipelines. We encourage you to try out the tools and techniques we’ve discussed, and share your feedback with us. Our website,, is dedicated to helping you manage your databases in CI/CD environment cloud deployments, Liquibase, Flyway, and more. Stay tuned for more articles, tutorials, and resources!

Editor Recommended Sites

AI and Tech News
Best Online AI Courses
Classic Writing Analysis
Tears of the Kingdom Roleplay
DBT Book: Learn DBT for cloud. AWS GCP Azure
Crypto Defi - Best Defi resources & Staking and Lending Defi: Defi tutorial for crypto / blockchain / smart contracts
Developer Key Takeaways: Key takeaways from the best books, lectures, youtube videos and deep dives
Rust Book: Best Rust Programming Language Book
Tech Debt - Steps to avoiding tech debt & tech debt reduction best practice: Learn about technical debt and best practice to avoid it