public class MyTest {
    
    private static final String JDBC_URL_CTX_KEY = "JDBC_URL";

    @ClassRule
    public static CockroachDB cockroachDB = newCockroachDB(
            builder()
                    .stdErr(System.err)// Redirect the cockroach db process errors to std err
                    .stdOut(System.out)// Redirect the cockroach db process std out to System.out
                    // There ae other config options here like .version(...) .host(...) etc..
                    .build(),
            context -> {

                // Some initialization. You can put this in a @BeforeClass method

                final ProcessDetails pd = getFromContext(context, PROCESS_DETAILS_CTX_KEY, ProcessDetails.class);
                final String jdbcUrl = String.format("jdbc:postgresql://%s:%d/test?sslmode=disable", pd.getHost(), pd.getPort());
                context.put(JDBC_URL_CTX_KEY, jdbcUrl);
                initDatabase(jdbcUrl);
            }
    );

    private static void initDatabase(final String jdbcUrl){
        try (final Connection db = DriverManager.getConnection(jdbcUrl, "root", "")){
            Class.forName("org.postgresql.Driver");
            db.createStatement().execute("CREATE DATABASE IF NOT EXISTS test;");
            db.createStatement().execute("CREATE TABLE IF NOT EXISTS logs (id INT PRIMARY KEY, log TEXT);");
        }catch (Exception e){
            throw new IllegalStateException("Cannot initialise the database", e);
        }
    }

    @Test
    public void testRule() throws Exception {

        // Here we can interact with the cockroach db.

        final String jdbcUrl = cockroachDB.getFromContextOrThrow(JDBC_URL_CTX_KEY, String.class);
        try (final Connection db = DriverManager.getConnection(jdbcUrl, "root", "")){

            db.createStatement().execute("INSERT INTO test.logs (id, log) VALUES (1, 'value 1'), (2, 'value 2');");
            final ResultSet res = db.createStatement().executeQuery("SELECT id, log FROM test.logs ORDER BY id ASC;");
            int count = 1;
            while (res.next()) {
                Assert.assertEquals(count, res.getInt("id"));
                Assert.assertEquals(String.format("value %d", count), res.getString("log"));
                count++;
            }
            res.close();
        }
    }
}

public class CrDbTestExecutionListener implements TestExecutionListener {

    private static final Logger logger = LoggerFactory.getLogger(CrDbApplicationContextInitializer.class);

    private Cockroach cockroach;

    private static ThreadLocal<ProcessDetails> crdbProcessDetails = new ThreadLocal<ProcessDetails>();
    public static ProcessDetails getCrDbProcessDetailsForThisThreadOrThrow(){
        final ProcessDetails details = crdbProcessDetails.get();
        if (details == null){
            throw new IllegalStateException("CockroacDB process details not initialised");
        }
        return details;
    }

    @Override
    public void beforeTestClass(TestContext testContext) throws Exception {
        logger.info("Starting cockroach db");
        final Cockroach cockroach = builder()
                .stdOut(System.out)
                .stdErr(System.err)
                .build();
        final ProcessDetails processDetails = cockroach.startUp();
        crdbProcessDetails.set(processDetails);
        logger.info("Cockroach db up and running. Details: " + processDetails);
    }

    @Override
    public void afterTestClass(TestContext testContext) throws Exception {
        logger.info("Shutting down cockroach db");
        if (cockroach != null) {
            cockroach.shutDown();
        }
        logger.info("cockroach db shut down");
    }
}

@Order(0)
public class CrDbApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {

    private static final Logger logger = LoggerFactory.getLogger(CrDbApplicationContextInitializer.class);

    private static final String DATASOURCE_URL_PROPERTY = "spring.datasource.url";

    @Override
    public void initialize(ConfigurableApplicationContext configurableApplicationContext) {

        logger.info("CrDbApplicationContextInitializer initialize");

        final ProcessDetails details = CrDbTestExecutionListener.getCrDbProcessDetailsForThisThreadOrThrow();
        final String jdbcUrl = String.format("jdbc:postgresql://%s:%d/consustags?sslmode=disable", details.getHost(), details.getPort());
        configurableApplicationContext.getEnvironment().getPropertySources().addFirst(new PropertySource<Object>("junit") {
            @Nullable
            @Override
            public Object getProperty(@NonNull String propertyName) {
                if (propertyName.equalsIgnoreCase(DATASOURCE_URL_PROPERTY)){
                    logger.info("Serving " + propertyName + ": " + jdbcUrl);
                    return jdbcUrl;
                }else{
                    return null;
                }
            }
        });
    }
}

@RunWith(SpringRunner.class)
@ContextConfiguration(initializers = {CrDbApplicationContextInitializer.class})
@TestExecutionListeners({CrDbTestExecutionListener.class})
public class CrDbTest{
    
    // The DataSource bean should be initialised with the url served by the custom PropertySource added to the spring 
    // application context in the CrDbApplicationContextInitializer
    // Instead of the DataSource the bean, you could inject a JdbcTemplate, a DAO or a Service...whatever object that gives access to te database.
    @Autowired
    public DataSource datasource;
    
    @Test
    public void test(){
        // here we can use the DataSource...
    }
    
}