io.goodforgod.testcontainers.extensions.cassandra.ScriptCassandraMigrationEngine Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of testcontainers-extensions-cassandra Show documentation

Testcontainers Testcontainers-extensions-cassandra Extension with advanced testing features

The newest version!

package io.goodforgod.testcontainers.extensions.cassandra;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.nio.file.Files;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.jetbrains.annotations.NotNull;

public final class ScriptCassandraMigrationEngine extends AbstractDropCassandraMigrationEngine {

    public ScriptCassandraMigrationEngine(CassandraConnection connection) {
        super(connection);
    }

    private static List getFilesFromLocations(List locations) {
        final ClassLoader loader = Thread.currentThread().getContextClassLoader();
        return locations.stream()
                .flatMap(location -> {
                    final URL url = loader.getResource(location);
                    final String path = url.getPath();
                    final File file = new File(path);
                    return file.isDirectory()
                            ? Arrays.stream(file.listFiles()).sorted(Comparator.comparing(File::getName))
                            : Stream.of(file);
                })
                .collect(Collectors.toList());
    }

    @Override
    public void apply(@NotNull List locations) {
        if (locations.isEmpty()) {
            logger.warn("Empty locations for schema migration for engine '{}' for connection: {}",
                    getClass().getSimpleName(), connection);
            return;
        }

        logger.debug("Starting schema migration for engine '{}' for connection: {}",
                getClass().getSimpleName(), connection);

        final Set validLocations = locations.stream()
                .filter(Objects::nonNull)
                .filter(location -> !location.isBlank())
                .collect(Collectors.toSet());

        if (validLocations.isEmpty()) {
            throw new IllegalArgumentException("Found 0 valid migration paths: " + locations);
        }

        final List filesToUseForMigration = getFilesFromLocations(locations);
        for (File file : filesToUseForMigration) {
            try {
                final String cql = Files.readString(file.toPath());
                final List queries = Arrays.stream(cql.split(";"))
                        .map(String::trim)
                        .filter(query -> !query.isBlank())
                        .map(query -> query.trim() + ";")
                        .collect(Collectors.toList());

                for (String query : queries) {
                    connection.execute(query);
                }
            } catch (IOException e) {
                throw new IllegalArgumentException("Illegal file for migration: " + file.getPath(), e);
            }
        }

        logger.info("Finished schema migration for engine '{}' for connection: {}",
                getClass().getSimpleName(), connection);
    }
}