CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-org-testcontainers--mariadb

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

Overview
Eval results
Files

container-providers.mddocs/

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, supporting both traditional JDBC patterns and modern testcontainers automation.

Capabilities

JDBC Container Provider

Factory for creating MariaDB containers from JDBC connection URLs, enabling automatic container management through specially formatted JDBC URLs.

/**
 * Factory for MariaDB containers supporting JDBC URL-based creation
 * Extends JdbcDatabaseContainerProvider for integration with Testcontainers JDBC URL patterns
 */
public class MariaDBContainerProvider extends JdbcDatabaseContainerProvider {
    
    /**
     * Checks if this provider supports the specified database type
     * @param databaseType Database type string to check
     * @return true if databaseType equals "mariadb"
     */
    public boolean supports(String databaseType);
    
    /**
     * Creates new MariaDB container with default settings
     * @return MariaDBContainer with default image and tag
     */
    public JdbcDatabaseContainer newInstance();
    
    /**
     * Creates new MariaDB container with specified version tag
     * @param tag Docker image tag/version to use
     * @return MariaDBContainer with specified version
     */
    public JdbcDatabaseContainer newInstance(String tag);
    
    /**
     * Creates MariaDB container from JDBC connection URL
     * @param connectionUrl Parsed JDBC URL with parameters
     * @return Configured MariaDBContainer based on URL parameters
     */
    public JdbcDatabaseContainer newInstance(ConnectionUrl connectionUrl);
}

Usage Examples:

import org.testcontainers.containers.MariaDBContainerProvider;
import org.testcontainers.jdbc.ConnectionUrl;

// Direct provider usage
MariaDBContainerProvider provider = new MariaDBContainerProvider();

// Check support
boolean supportsMariaDB = provider.supports("mariadb"); // true
boolean supportsMySQL = provider.supports("mysql");     // false

// Create containers
JdbcDatabaseContainer defaultContainer = provider.newInstance();
JdbcDatabaseContainer versionedContainer = provider.newInstance("10.3.39");

// From connection URL
ConnectionUrl url = ConnectionUrl.newInstance("jdbc:tc:mariadb://hostname/testdb");
JdbcDatabaseContainer urlContainer = provider.newInstance(url);

JDBC URL Patterns

Special JDBC URL formats that automatically create and manage MariaDB containers.

// Basic MariaDB container URL patterns:
// jdbc:tc:mariadb://hostname/databasename
// jdbc:tc:mariadb:version://hostname/databasename

// URL parameters supported:
// user=username                    - Database username
// password=password               - Database password  
// TC_INITSCRIPT=path/to/script   - Initialization SQL script
// TC_INITFUNCTION=Class::method  - Initialization function
// TC_MY_CNF=path/to/config       - Custom MariaDB configuration

Usage Examples:

import java.sql.Connection;
import java.sql.DriverManager;

// Basic automatic container
String basicUrl = "jdbc:tc:mariadb://hostname/testdb";
Connection conn1 = DriverManager.getConnection(basicUrl);

// With specific version
String versionedUrl = "jdbc:tc:mariadb:10.3.39://hostname/myapp";
Connection conn2 = DriverManager.getConnection(versionedUrl);

// With authentication and initialization
String configuredUrl = "jdbc:tc:mariadb:10.3.39://hostname/webapp" +
    "?user=appuser&password=secret&TC_INITSCRIPT=schema.sql";
Connection conn3 = DriverManager.getConnection(configuredUrl);

// With custom configuration
String customConfigUrl = "jdbc:tc:mariadb://hostname/perftest" +
    "?TC_MY_CNF=mariadb-performance-config";
Connection conn4 = DriverManager.getConnection(customConfigUrl);

// All connections automatically create, start, and manage containers

URL Parameter Processing

Handles URL parameters for container configuration and initialization.

// Parameter constants used internally
private static final String USER_PARAM = "user";
private static final String PASSWORD_PARAM = "password";

// Creates container from parsed URL with parameter handling
public JdbcDatabaseContainer newInstance(ConnectionUrl connectionUrl) {
    return newInstanceFromConnectionUrl(connectionUrl, USER_PARAM, PASSWORD_PARAM);
}

Supported URL Parameters:

// Authentication parameters
user=username                       // Sets container username
password=secret                     // Sets container password

// Initialization parameters  
TC_INITSCRIPT=path/to/init.sql     // Runs SQL script on startup
TC_INITFUNCTION=com.example.DB::init // Calls Java method for initialization

// Configuration parameters
TC_MY_CNF=config/mariadb           // Mounts custom configuration directory

// Standard JDBC parameters (passed through to connection)
connectTimeout=30000               // Connection timeout
useUnicode=true                    // Unicode support
characterEncoding=utf8             // Character encoding
rewriteBatchedStatements=true      // Batch statement optimization

Integration with Testing Frameworks

Seamless integration with JUnit and other testing frameworks through JDBC URL automation.

JUnit 4 Example:

public class MariaDBJdbcUrlTest {
    
    private static Connection connection;
    
    @BeforeClass
    public static void setUp() throws SQLException {
        // Container automatically created and started
        String jdbcUrl = "jdbc:tc:mariadb:10.3.39://hostname/junit4test" +
            "?user=testuser&TC_INITSCRIPT=test-schema.sql";
        connection = DriverManager.getConnection(jdbcUrl);
    }
    
    @Test
    public void testDatabaseAccess() throws SQLException {
        Statement stmt = connection.createStatement();
        ResultSet rs = stmt.executeQuery("SELECT COUNT(*) FROM users");
        assertTrue(rs.next());
        assertTrue(rs.getInt(1) >= 0);
    }
    
    @AfterClass
    public static void tearDown() throws SQLException {
        if (connection != null) {
            connection.close(); // Container automatically stopped
        }
    }
}

JUnit 5 with @DataSource Integration:

@SpringBootTest
@Testcontainers
class MariaDBIntegrationTest {
    
    @TestConfiguration
    static class TestConfig {
        
        @Bean
        @Primary
        public DataSource dataSource() {
            HikariConfig config = new HikariConfig();
            config.setJdbcUrl("jdbc:tc:mariadb:10.3.39://hostname/springtest" +
                "?TC_INITSCRIPT=spring-schema.sql");
            config.setUsername("spring");
            config.setPassword("test");
            return new HikariDataSource(config);
        }
    }
    
    @Autowired
    private UserRepository userRepository;
    
    @Test
    void testUserRepository() {
        // Database automatically available with initialized schema
        User user = new User("Alice", "alice@example.com");
        User saved = userRepository.save(user);
        assertNotNull(saved.getId());
    }
}

Connection Pooling Integration

Works with popular connection pool libraries for production-like testing environments.

HikariCP Example:

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;

HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:tc:mariadb:10.3.39://hostname/pooltest?user=pooluser");
config.setMaximumPoolSize(10);
config.setMinimumIdle(2);
config.setConnectionTimeout(30000);

HikariDataSource dataSource = new HikariDataSource(config);

// Use DataSource for testing with connection pooling
try (Connection conn = dataSource.getConnection()) {
    // Perform database operations
}

Apache DBCP Example:

import org.apache.commons.dbcp2.BasicDataSource;

BasicDataSource dataSource = new BasicDataSource();
dataSource.setUrl("jdbc:tc:mariadb://hostname/dbcptest?TC_INITSCRIPT=test-data.sql");
dataSource.setUsername("dbcp");
dataSource.setPassword("test");
dataSource.setInitialSize(5);
dataSource.setMaxTotal(20);

// Container managed automatically by Testcontainers

Advanced URL Patterns

Initialization Scripts

Automatically run SQL scripts when the container starts:

// Single initialization script
"jdbc:tc:mariadb://hostname/mydb?TC_INITSCRIPT=schema.sql"

// Multiple scripts (comma-separated)
"jdbc:tc:mariadb://hostname/mydb?TC_INITSCRIPT=schema.sql,data.sql,indexes.sql"

// Scripts from classpath resources
"jdbc:tc:mariadb://hostname/mydb?TC_INITSCRIPT=classpath:db/migration/V1__create_tables.sql"

Initialization Functions

Call Java methods for programmatic database initialization:

// Static method reference
"jdbc:tc:mariadb://hostname/mydb?TC_INITFUNCTION=com.example.DatabaseSetup::initialize"

// Method signature expected:
public class DatabaseSetup {
    public static void initialize(Connection connection) throws SQLException {
        // Custom database setup logic
        Statement stmt = connection.createStatement();
        stmt.execute("CREATE TABLE IF NOT EXISTS test_data (id INT PRIMARY KEY, name VARCHAR(100))");
        stmt.execute("INSERT INTO test_data VALUES (1, 'Sample Data')");
    }
}

Custom Configuration

Mount custom MariaDB configuration files:

// Custom configuration directory
"jdbc:tc:mariadb://hostname/mydb?TC_MY_CNF=mariadb-config"

// Directory structure:
// src/test/resources/mariadb-config/
//   ├── custom.cnf
//   ├── performance.cnf
//   └── logging.cnf

// Files automatically mounted to /etc/mysql/conf.d/ in container

Error Handling

Common error scenarios and solutions:

// Missing MariaDB JDBC driver
try {
    Connection conn = DriverManager.getConnection("jdbc:tc:mariadb://hostname/test");
} catch (SQLException e) {
    // Add mariadb-java-client dependency
    // implementation 'org.mariadb.jdbc:mariadb-java-client:3.4.1'
}

// Invalid initialization script path
try {
    String url = "jdbc:tc:mariadb://hostname/test?TC_INITSCRIPT=nonexistent.sql";
    Connection conn = DriverManager.getConnection(url);
} catch (ContainerLaunchException e) {
    // Ensure script exists in classpath or provide correct path
}

// Container startup timeout
try {
    String url = "jdbc:tc:mariadb://hostname/test";
    Connection conn = DriverManager.getConnection(url);
} catch (ContainerLaunchException e) {
    // Check Docker daemon, increase timeout, or verify image availability
}

Types

import org.testcontainers.jdbc.JdbcDatabaseContainerProvider;
import org.testcontainers.jdbc.ConnectionUrl;
import org.testcontainers.containers.JdbcDatabaseContainer;

// Provider interface methods
boolean supports(String databaseType);
JdbcDatabaseContainer newInstance();
JdbcDatabaseContainer newInstance(String tag);
JdbcDatabaseContainer newInstance(ConnectionUrl connectionUrl);

// URL parameter constants
String USER_PARAM = "user";
String PASSWORD_PARAM = "password";

// Testcontainers URL parameters
String TC_INITSCRIPT = "TC_INITSCRIPT";     // Initialization script path
String TC_INITFUNCTION = "TC_INITFUNCTION"; // Initialization function reference
String TC_MY_CNF = "TC_MY_CNF";             // Custom MariaDB configuration path

Install with Tessl CLI

npx tessl i tessl/maven-org-testcontainers--mariadb

docs

container-providers.md

index.md

jdbc-containers.md

r2dbc-containers.md

tile.json