or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

container-providers.mdindex.mdjdbc-containers.mdr2dbc-containers.md
tile.json

tessl/maven-org-testcontainers--mariadb

Testcontainers implementation for MariaDB - provides lightweight, throwaway instances of MariaDB databases for Java testing

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/org.testcontainers/mariadb@1.21.x

To install, run

npx @tessl/cli install tessl/maven-org-testcontainers--mariadb@1.21.0

index.mddocs/

MariaDB Testcontainers

A Java library providing throwaway MariaDB database containers for integration testing. Part of the Testcontainers ecosystem, it enables developers to run real MariaDB instances in Docker containers during tests, ensuring reliable database testing without external dependencies.

Package Information

  • Package Name: org.testcontainers:mariadb
  • Package Type: maven
  • Language: Java
  • Installation: implementation 'org.testcontainers:mariadb:1.21.3' (Gradle) or <dependency><groupId>org.testcontainers</groupId><artifactId>mariadb</artifactId><version>1.21.3</version></dependency> (Maven)

Installation

Add the MariaDB Testcontainers dependency to your project:

Gradle:

testImplementation 'org.testcontainers:mariadb:1.21.3'
// Required: MariaDB JDBC driver
testImplementation 'org.mariadb.jdbc:mariadb-java-client:3.4.1'

Maven:

<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>mariadb</artifactId>
    <version>1.21.3</version>
    <scope>test</scope>
</dependency>
<!-- Required: MariaDB JDBC driver -->
<dependency>
    <groupId>org.mariadb.jdbc</groupId>
    <artifactId>mariadb-java-client</artifactId>
    <version>3.4.1</version>
    <scope>test</scope>
</dependency>

Important: The MariaDB JDBC driver is required but not automatically included. Without it, you'll get SQLException: No suitable driver found.

For R2DBC support, also add:

Gradle:

testImplementation 'org.testcontainers:r2dbc:1.21.3'
testRuntimeOnly 'org.mariadb:r2dbc-mariadb:1.0.3'

Maven:

<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>r2dbc</artifactId>
    <version>1.21.3</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.mariadb</groupId>
    <artifactId>r2dbc-mariadb</artifactId>
    <version>1.0.3</version>
    <scope>test</scope>
</dependency>

Core Imports

import org.testcontainers.containers.MariaDBContainer;

For R2DBC support:

import org.testcontainers.containers.MariaDBR2DBCDatabaseContainer;
import io.r2dbc.spi.ConnectionFactoryOptions;

Basic Usage

import org.testcontainers.containers.MariaDBContainer;
import org.testcontainers.utility.DockerImageName;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;

// Create and configure a MariaDB container
try (MariaDBContainer<?> mariadb = new MariaDBContainer<>(
        DockerImageName.parse("mariadb:10.3.39"))
        .withDatabaseName("testdb")
        .withUsername("testuser")
        .withPassword("testpass")
        .withInitScript("schema.sql")) {
    
    mariadb.start();
    
    // Get connection details
    String jdbcUrl = mariadb.getJdbcUrl();
    String username = mariadb.getUsername();
    String password = mariadb.getPassword();
    
    System.out.println("MariaDB container started:");
    System.out.println("JDBC URL: " + jdbcUrl);
    System.out.println("Username: " + username);
    System.out.println("Host: " + mariadb.getHost());
    System.out.println("Port: " + mariadb.getMappedPort(3306));
    
    // Connect and perform database operations
    try (Connection conn = DriverManager.getConnection(jdbcUrl, username, password)) {
        // Create a table
        try (Statement stmt = conn.createStatement()) {
            stmt.execute("CREATE TABLE users (id INT PRIMARY KEY AUTO_INCREMENT, name VARCHAR(50), email VARCHAR(100))");
        }
        
        // Insert data
        try (PreparedStatement pstmt = conn.prepareStatement(
                "INSERT INTO users (name, email) VALUES (?, ?)")) {
            pstmt.setString(1, "Alice Smith");
            pstmt.setString(2, "alice@example.com");
            pstmt.executeUpdate();
            
            pstmt.setString(1, "Bob Johnson");
            pstmt.setString(2, "bob@example.com");
            pstmt.executeUpdate();
        }
        
        // Query data
        try (Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT COUNT(*) as user_count FROM users")) {
            
            if (rs.next()) {
                System.out.println("Total users: " + rs.getInt("user_count"));
            }
        }
        
        // Verify container is working
        try (Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT VERSION()")) {
            
            if (rs.next()) {
                System.out.println("MariaDB version: " + rs.getString(1));
            }
        }
    }
}
// Container automatically stopped when exiting try-with-resources

Architecture

MariaDB Testcontainers is built around several key components:

  • MariaDBContainer: Main container class extending JdbcDatabaseContainer for JDBC-based database testing
  • Provider Classes: Factory classes for automatic container creation from JDBC URLs and R2DBC connection options
  • R2DBC Integration: Reactive database access support through MariaDBR2DBCDatabaseContainer
  • Configuration System: Environment variables and volume mounting for MariaDB-specific configuration
  • JUnit Integration: Seamless integration with JUnit test lifecycle for automatic container management

Capabilities

JDBC Container Management

Core container functionality for creating and managing MariaDB instances with JDBC connectivity. Provides database connection details, lifecycle management, and MariaDB-specific configuration options.

public class MariaDBContainer<SELF extends MariaDBContainer<SELF>> extends JdbcDatabaseContainer<SELF> {
    public MariaDBContainer(String dockerImageName);
    public MariaDBContainer(DockerImageName dockerImageName);
    
    // Database connection methods
    public String getJdbcUrl();
    public String getDriverClassName();
    public String getDatabaseName();
    public String getUsername();
    public String getPassword();
    public String getTestQueryString();
    public Connection createConnection(String queryString) throws SQLException, NoDriverFoundException;
    
    // Configuration methods
    public SELF withDatabaseName(String databaseName);
    public SELF withUsername(String username);
    public SELF withPassword(String password);
    public SELF withConfigurationOverride(String configPath);
    public SELF withUrlParam(String paramName, String paramValue);
    
    // Initialization methods (inherited from JdbcDatabaseContainer)
    public SELF withInitScript(String initScriptPath);
    public SELF withInitScripts(String... initScriptPaths);
    
    // Container lifecycle methods (inherited from GenericContainer)
    public void start();
    public void stop();
    public boolean isRunning();
    public String getHost();
    public Integer getMappedPort(int originalPort);
    
    // Timeout configuration (inherited from JdbcDatabaseContainer)
    public SELF withStartupTimeoutSeconds(int startupTimeoutSeconds);
    public SELF withConnectTimeoutSeconds(int connectTimeoutSeconds);
}

JDBC Containers

R2DBC Container Management

Reactive database access support for MariaDB containers using R2DBC drivers. Enables non-blocking database operations with full container lifecycle integration.

public class MariaDBR2DBCDatabaseContainer implements R2DBCDatabaseContainer {
    public static ConnectionFactoryOptions getOptions(MariaDBContainer<?> container);
    public ConnectionFactoryOptions configure(ConnectionFactoryOptions options);
}

public class MariaDBR2DBCDatabaseContainerProvider implements R2DBCDatabaseContainerProvider {
    public boolean supports(ConnectionFactoryOptions options);
    public R2DBCDatabaseContainer createContainer(ConnectionFactoryOptions options);
    public ConnectionFactoryMetadata getMetadata(ConnectionFactoryOptions options);
}

R2DBC Containers

Container Provider System

Factory classes for automatic container creation from JDBC URLs and connection options. Enables declarative container management through configuration rather than explicit instantiation.

public class MariaDBContainerProvider extends JdbcDatabaseContainerProvider {
    public boolean supports(String databaseType);
    public JdbcDatabaseContainer newInstance();
    public JdbcDatabaseContainer newInstance(String tag);
    public JdbcDatabaseContainer newInstance(ConnectionUrl connectionUrl);
}

Container Providers

Types

// Container configuration constants (public)
public static final String NAME = "mariadb";
public static final Integer MARIADB_PORT = 3306;
// Note: DEFAULT_USER and DEFAULT_PASSWORD are package-private constants, not part of public API

// Docker image configuration
import org.testcontainers.utility.DockerImageName;

// JDBC URL patterns for automatic containers
// jdbc:tc:mariadb://hostname/databasename
// jdbc:tc:mariadb:version://hostname/databasename

// R2DBC URL patterns for reactive containers  
// r2dbc:tc:mariadb:///databasename?TC_IMAGE_TAG=version