mainframe-migration-toolkit 0.2.0__py3-none-any.whl

mainframe_toolkit/_workspace/validator-java/src/main/java/io/mainframe/migration/validator/ValidationService.java

@@ -0,0 +1,395 @@
+package io.mainframe.migration.validator;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Objects;
+import java.util.TreeSet;
+
+public final class ValidationService {
+    public ValidationReport validate(ValidationOptions options) throws IOException {
+        validateInput(options.expected());
+        validateInput(options.actual());
+
+        DataFormat expectedFormat = options.expected().resolvedFormat();
+        DataFormat actualFormat = options.actual().resolvedFormat();
+        Accumulator accumulator = new Accumulator(options.maxDifferences());
+
+        try (TabularReader expected = TabularReaderFactory.open(options.expected());
+             TabularReader actual = TabularReaderFactory.open(options.actual())) {
+            List<String> expectedColumns = expected.columns();
+            List<String> actualColumns = actual.columns();
+            if (expected.hasNamedColumns() && actual.hasNamedColumns()) {
+                compareColumns(expectedColumns, actualColumns, accumulator);
+            }
+
+            ComparisonStats stats;
+            if (options.keys().isEmpty()) {
+                stats = comparePositionally(
+                        expected, actual, expectedColumns, actualColumns, options, accumulator);
+            } else {
+                if (!expected.hasNamedColumns() || !actual.hasNamedColumns()) {
+                    throw new IllegalArgumentException("--key exige cabeçalhos ou colunas Parquet nomeadas");
+                }
+                stats = compareByKey(
+                        expected, actual, expectedColumns, actualColumns, options, accumulator);
+            }
+
+            List<String> normalizations = Arrays.stream(Normalization.values())
+                    .filter(options.normalizations()::contains)
+                    .map(value -> value.name().toLowerCase(Locale.ROOT))
+                    .toList();
+            return new ValidationReport(
+                    accumulator.count == 0 ? "MATCH" : "DIFFERENT",
+                    options.expected().path().toString(),
+                    options.actual().path().toString(),
+                    expectedFormat.name(),
+                    actualFormat.name(),
+                    List.copyOf(options.keys()),
+                    normalizations,
+                    stats.expectedRows,
+                    stats.actualRows,
+                    stats.expectedColumns,
+                    stats.actualColumns,
+                    accumulator.count,
+                    accumulator.differences.size(),
+                    accumulator.count > accumulator.differences.size(),
+                    List.copyOf(accumulator.differences));
+        }
+    }
+
+    private static void validateInput(InputOptions input) throws IOException {
+        if (!Files.exists(input.path())) {
+            throw new IllegalArgumentException("Arquivo ou diretório não encontrado: " + input.path());
+        }
+        if (!Files.isReadable(input.path())) {
+            throw new IllegalArgumentException("Entrada local não legível: " + input.path());
+        }
+        if (!Files.isRegularFile(input.path()) && !Files.isDirectory(input.path())) {
+            throw new IllegalArgumentException("Entrada deve ser arquivo ou diretório local: " + input.path());
+        }
+        input.resolvedFormat();
+        InputFileSet.files(input);
+    }
+
+    private static ComparisonStats comparePositionally(
+            TabularReader expected,
+            TabularReader actual,
+            List<String> expectedColumns,
+            List<String> actualColumns,
+            ValidationOptions options,
+            Accumulator accumulator) throws IOException {
+        ComparisonStats stats = new ComparisonStats(expectedColumns.size(), actualColumns.size());
+        long line = 0;
+        while (true) {
+            List<String> expectedRow = expected.readRow();
+            List<String> actualRow = actual.readRow();
+            if (expectedRow == null && actualRow == null) {
+                return stats;
+            }
+            line++;
+            stats.observeExpected(expectedRow);
+            stats.observeActual(actualRow);
+            compareRow(
+                    line,
+                    Map.of(),
+                    expectedRow,
+                    actualRow,
+                    expectedColumns,
+                    actualColumns,
+                    options,
+                    accumulator);
+        }
+    }
+
+    private static ComparisonStats compareByKey(
+            TabularReader expected,
+            TabularReader actual,
+            List<String> expectedColumns,
+            List<String> actualColumns,
+            ValidationOptions options,
+            Accumulator accumulator) throws IOException {
+        int[] expectedKeyIndexes = keyIndexes(options.keys(), expectedColumns, "referência");
+        int[] actualKeyIndexes = keyIndexes(options.keys(), actualColumns, "arquivo gerado");
+        ComparisonStats stats = new ComparisonStats(expectedColumns.size(), actualColumns.size());
+        Map<CompositeKey, List<RowEntry>> expectedRows = indexRows(
+                expected, expectedKeyIndexes, options, stats, true);
+        Map<CompositeKey, List<RowEntry>> actualRows = indexRows(
+                actual, actualKeyIndexes, options, stats, false);
+
+        TreeSet<CompositeKey> orderedKeys = new TreeSet<>();
+        orderedKeys.addAll(expectedRows.keySet());
+        orderedKeys.addAll(actualRows.keySet());
+        for (CompositeKey key : orderedKeys) {
+            List<RowEntry> expectedEntries = expectedRows.getOrDefault(key, List.of());
+            List<RowEntry> actualEntries = actualRows.getOrDefault(key, List.of());
+            RowEntry expectedRow = expectedEntries.isEmpty() ? null : expectedEntries.get(0);
+            RowEntry actualRow = actualEntries.isEmpty() ? null : actualEntries.get(0);
+            Map<String, String> displayKey = displayKey(
+                    options.keys(),
+                    expectedRow != null ? expectedRow : actualRow,
+                    expectedRow != null ? expectedKeyIndexes : actualKeyIndexes);
+
+            reportDuplicates(
+                    expectedEntries, true, options.keys(), expectedKeyIndexes, accumulator);
+            reportDuplicates(
+                    actualEntries, false, options.keys(), actualKeyIndexes, accumulator);
+
+            long line = expectedRow != null ? expectedRow.line : actualRow.line;
+            compareRow(
+                    line,
+                    displayKey,
+                    expectedRow == null ? null : expectedRow.values,
+                    actualRow == null ? null : actualRow.values,
+                    expectedColumns,
+                    actualColumns,
+                    options,
+                    accumulator);
+        }
+        return stats;
+    }
+
+    private static Map<CompositeKey, List<RowEntry>> indexRows(
+            TabularReader reader,
+            int[] keyIndexes,
+            ValidationOptions options,
+            ComparisonStats stats,
+            boolean expected) throws IOException {
+        Map<CompositeKey, List<RowEntry>> rows = new HashMap<>();
+        long line = 0;
+        while (true) {
+            List<String> values = reader.readRow();
+            if (values == null) {
+                return rows;
+            }
+            line++;
+            if (expected) {
+                stats.observeExpected(values);
+            } else {
+                stats.observeActual(values);
+            }
+            List<String> keyValues = new ArrayList<>(keyIndexes.length);
+            for (int index : keyIndexes) {
+                String raw = index < values.size() ? values.get(index) : null;
+                keyValues.add(ValueNormalizer.normalize(raw, options.normalizations()));
+            }
+            CompositeKey key = new CompositeKey(keyValues);
+            rows.computeIfAbsent(key, ignored -> new ArrayList<>()).add(new RowEntry(line, values));
+        }
+    }
+
+    private static void reportDuplicates(
+            List<RowEntry> entries,
+            boolean expected,
+            List<String> keys,
+            int[] keyIndexes,
+            Accumulator accumulator) {
+        for (int duplicateIndex = 1; duplicateIndex < entries.size(); duplicateIndex++) {
+            RowEntry duplicate = entries.get(duplicateIndex);
+            Map<String, String> displayKey = displayKey(keys, duplicate, keyIndexes);
+            int firstIndex = keyIndexes[0];
+            String firstValue = firstIndex < duplicate.values.size() ? duplicate.values.get(firstIndex) : null;
+            accumulator.add(new Difference(
+                    duplicate.line,
+                    displayKey,
+                    firstIndex + 1,
+                    keys.get(0),
+                    expected ? firstValue : null,
+                    expected ? null : firstValue,
+                    expected ? "DUPLICATE_EXPECTED_KEY" : "DUPLICATE_ACTUAL_KEY"));
+        }
+    }
+
+    private static Map<String, String> displayKey(List<String> names, RowEntry row, int[] indexes) {
+        Map<String, String> result = new LinkedHashMap<>();
+        for (int index = 0; index < names.size(); index++) {
+            int column = indexes[index];
+            result.put(names.get(index), column < row.values.size() ? row.values.get(column) : null);
+        }
+        return result;
+    }
+
+    private static int[] keyIndexes(List<String> keys, List<String> columns, String side) {
+        int[] result = new int[keys.size()];
+        for (int keyIndex = 0; keyIndex < keys.size(); keyIndex++) {
+            String key = keys.get(keyIndex);
+            int found = -1;
+            for (int columnIndex = 0; columnIndex < columns.size(); columnIndex++) {
+                if (key.equals(columns.get(columnIndex))) {
+                    if (found >= 0) {
+                        throw new IllegalArgumentException("Coluna de chave ambígua em " + side + ": " + key);
+                    }
+                    found = columnIndex;
+                }
+            }
+            if (found < 0) {
+                throw new IllegalArgumentException("Coluna de chave ausente em " + side + ": " + key);
+            }
+            result[keyIndex] = found;
+        }
+        return result;
+    }
+
+    private static void compareColumns(
+            List<String> expected,
+            List<String> actual,
+            Accumulator accumulator) {
+        int width = Math.max(expected.size(), actual.size());
+        for (int index = 0; index < width; index++) {
+            boolean hasExpected = index < expected.size();
+            boolean hasActual = index < actual.size();
+            String expectedName = hasExpected ? expected.get(index) : null;
+            String actualName = hasActual ? actual.get(index) : null;
+            if (hasExpected && hasActual && Objects.equals(expectedName, actualName)) {
+                continue;
+            }
+            String reason;
+            if (!hasExpected) {
+                reason = "UNEXPECTED_COLUMN";
+            } else if (!hasActual) {
+                reason = "MISSING_COLUMN";
+            } else {
+                reason = "COLUMN_NAME_MISMATCH";
+            }
+            accumulator.add(new Difference(
+                    0,
+                    index + 1,
+                    expectedName != null ? expectedName : actualName,
+                    expectedName,
+                    actualName,
+                    reason));
+        }
+    }
+
+    private static void compareRow(
+            long line,
+            Map<String, String> key,
+            List<String> expected,
+            List<String> actual,
+            List<String> expectedColumns,
+            List<String> actualColumns,
+            ValidationOptions options,
+            Accumulator accumulator) {
+        int expectedSize = expected == null ? 0 : expected.size();
+        int actualSize = actual == null ? 0 : actual.size();
+        int width = Math.max(expectedSize, actualSize);
+        for (int index = 0; index < width; index++) {
+            boolean hasExpected = index < expectedSize;
+            boolean hasActual = index < actualSize;
+            String expectedValue = hasExpected ? expected.get(index) : null;
+            String actualValue = hasActual ? actual.get(index) : null;
+
+            String reason = null;
+            if (!hasExpected) {
+                reason = "UNEXPECTED_ACTUAL_CELL";
+            } else if (!hasActual) {
+                reason = "MISSING_ACTUAL_CELL";
+            } else if (!Objects.equals(
+                    ValueNormalizer.normalize(expectedValue, options.normalizations()),
+                    ValueNormalizer.normalize(actualValue, options.normalizations()))) {
+                reason = "VALUE_MISMATCH";
+            }
+            if (reason != null) {
+                accumulator.add(new Difference(
+                        line,
+                        key,
+                        index + 1,
+                        columnName(index, expectedColumns, actualColumns),
+                        expectedValue,
+                        actualValue,
+                        reason));
+            }
+        }
+    }
+
+    private static String columnName(int index, List<String> expected, List<String> actual) {
+        if (index < expected.size()) {
+            return expected.get(index);
+        }
+        if (index < actual.size()) {
+            return actual.get(index);
+        }
+        return "COLUMN_" + (index + 1);
+    }
+
+    private record RowEntry(long line, List<String> values) {
+    }
+
+    private record CompositeKey(List<String> values) implements Comparable<CompositeKey> {
+        private CompositeKey {
+            values = Collections.unmodifiableList(new ArrayList<>(values));
+        }
+
+        @Override
+        public int compareTo(CompositeKey other) {
+            for (int index = 0; index < values.size(); index++) {
+                String left = values.get(index);
+                String right = other.values.get(index);
+                if (Objects.equals(left, right)) {
+                    continue;
+                }
+                if (left == null) {
+                    return -1;
+                }
+                if (right == null) {
+                    return 1;
+                }
+                int comparison = left.compareTo(right);
+                if (comparison != 0) {
+                    return comparison;
+                }
+            }
+            return Integer.compare(values.size(), other.values.size());
+        }
+    }
+
+    private static final class ComparisonStats {
+        private long expectedRows;
+        private long actualRows;
+        private int expectedColumns;
+        private int actualColumns;
+
+        private ComparisonStats(int expectedColumns, int actualColumns) {
+            this.expectedColumns = expectedColumns;
+            this.actualColumns = actualColumns;
+        }
+
+        private void observeExpected(List<String> row) {
+            if (row != null) {
+                expectedRows++;
+                expectedColumns = Math.max(expectedColumns, row.size());
+            }
+        }
+
+        private void observeActual(List<String> row) {
+            if (row != null) {
+                actualRows++;
+                actualColumns = Math.max(actualColumns, row.size());
+            }
+        }
+    }
+
+    private static final class Accumulator {
+        private final int maxDifferences;
+        private final List<Difference> differences = new ArrayList<>();
+        private long count;
+
+        private Accumulator(int maxDifferences) {
+            this.maxDifferences = maxDifferences;
+        }
+
+        private void add(Difference difference) {
+            count++;
+            if (differences.size() < maxDifferences) {
+                differences.add(difference);
+            }
+        }
+    }
+}

mainframe_toolkit/_workspace/validator-java/src/main/java/io/mainframe/migration/validator/ValidatorCli.java

@@ -0,0 +1,190 @@
+package io.mainframe.migration.validator;
+
+import picocli.CommandLine;
+import picocli.CommandLine.Command;
+import picocli.CommandLine.Option;
+import picocli.CommandLine.Parameters;
+import picocli.CommandLine.Spec;
+import picocli.CommandLine.Model.CommandSpec;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.concurrent.Callable;
+
+@Command(
+        name = "dataset-validator",
+        description = "Compara arquivos CSV e Parquet célula a célula.",
+        mixinStandardHelpOptions = true,
+        version = "dataset-validator 0.1.0",
+        sortOptions = false)
+public final class ValidatorCli implements Callable<Integer> {
+    public static final int EXIT_MATCH = 0;
+    public static final int EXIT_DIFFERENT = 1;
+    public static final int EXIT_INPUT_ERROR = 2;
+    public static final int EXIT_INTERNAL_ERROR = 3;
+
+    @Parameters(index = "0", paramLabel = "EXPECTED", description = "Arquivo de referência.")
+    private Path expected;
+
+    @Parameters(index = "1", paramLabel = "ACTUAL", description = "Arquivo gerado.")
+    private Path actual;
+
+    @Option(names = "--format", defaultValue = "auto", paramLabel = "auto|csv|parquet",
+            description = "Formato dos dois arquivos; padrão: ${DEFAULT-VALUE}.")
+    private String format;
+
+    @Option(names = "--expected-format", paramLabel = "auto|csv|parquet",
+            description = "Sobrescreve o formato do arquivo de referência.")
+    private String expectedFormat;
+
+    @Option(names = "--actual-format", paramLabel = "auto|csv|parquet",
+            description = "Sobrescreve o formato do arquivo gerado.")
+    private String actualFormat;
+
+    @Option(names = {"-d", "--delimiter"}, defaultValue = ",", paramLabel = "CHAR",
+            description = "Separador CSV; aceita caractere, tab, comma, semicolon ou pipe.")
+    private String delimiter;
+
+    @Option(names = "--expected-delimiter", paramLabel = "CHAR",
+            description = "Sobrescreve o separador CSV da referência.")
+    private String expectedDelimiter;
+
+    @Option(names = "--actual-delimiter", paramLabel = "CHAR",
+            description = "Sobrescreve o separador CSV do arquivo gerado.")
+    private String actualDelimiter;
+
+    @Option(names = "--header", arity = "1", defaultValue = "true", paramLabel = "true|false",
+            description = "CSV contém cabeçalho; padrão: ${DEFAULT-VALUE}.")
+    private boolean header;
+
+    @Option(names = "--no-header", description = "CSV não contém cabeçalho.")
+    private boolean noHeader;
+
+    @Option(names = "--expected-header", arity = "1", paramLabel = "true|false",
+            description = "Sobrescreve o uso de cabeçalho da referência.")
+    private Boolean expectedHeader;
+
+    @Option(names = "--actual-header", arity = "1", paramLabel = "true|false",
+            description = "Sobrescreve o uso de cabeçalho do arquivo gerado.")
+    private Boolean actualHeader;
+
+    @Option(names = "--charset", defaultValue = "UTF-8", paramLabel = "CHARSET",
+            description = "Codificação dos CSVs; padrão: ${DEFAULT-VALUE}.")
+    private String charset;
+
+    @Option(names = "--normalize", split = ",", paramLabel = "trim,decimal",
+            description = "Normalizações opcionais; repetível.")
+    private List<String> normalizationNames = new ArrayList<>();
+
+    @Option(names = "--trim", description = "Atalho para --normalize trim.")
+    private boolean trim;
+
+    @Option(names = "--normalize-decimal", description = "Atalho para --normalize decimal.")
+    private boolean normalizeDecimal;
+
+    @Option(names = "--max-differences", defaultValue = "100", paramLabel = "N",
+            description = "Máximo de diferenças detalhadas no JSON; padrão: ${DEFAULT-VALUE}.")
+    private int maxDifferences;
+
+    @Option(names = "--key", split = ",", paramLabel = "COL[,COL...]",
+            description = "Compara linhas por chave; repetível e aceita lista separada por vírgulas.")
+    private List<String> keys = new ArrayList<>();
+
+    @Option(names = {"-r", "--report"}, defaultValue = "-", paramLabel = "PATH",
+            description = "Destino do relatório JSON; '-' escreve no stdout.")
+    private String report;
+
+    @Spec
+    private CommandSpec spec;
+
+    @Override
+    public Integer call() {
+        try {
+            DataFormat commonFormat = DataFormat.parse(format);
+            DataFormat resolvedExpectedFormat = expectedFormat == null
+                    ? commonFormat
+                    : DataFormat.parse(expectedFormat);
+            DataFormat resolvedActualFormat = actualFormat == null
+                    ? commonFormat
+                    : DataFormat.parse(actualFormat);
+            char commonDelimiter = parseDelimiter(delimiter);
+            Charset csvCharset = Charset.forName(charset);
+
+            EnumSet<Normalization> normalizations = EnumSet.noneOf(Normalization.class);
+            for (String name : normalizationNames) {
+                normalizations.add(Normalization.parse(name));
+            }
+            if (trim) {
+                normalizations.add(Normalization.TRIM);
+            }
+            if (normalizeDecimal) {
+                normalizations.add(Normalization.DECIMAL);
+            }
+
+            boolean commonHeader = noHeader ? false : header;
+            ValidationOptions options = new ValidationOptions(
+                    new InputOptions(
+                            expected,
+                            resolvedExpectedFormat,
+                            expectedDelimiter == null ? commonDelimiter : parseDelimiter(expectedDelimiter),
+                            expectedHeader == null ? commonHeader : expectedHeader,
+                            csvCharset),
+                    new InputOptions(
+                            actual,
+                            resolvedActualFormat,
+                            actualDelimiter == null ? commonDelimiter : parseDelimiter(actualDelimiter),
+                            actualHeader == null ? commonHeader : actualHeader,
+                            csvCharset),
+                    normalizations,
+                    maxDifferences,
+                    keys);
+
+            ValidationReport result = new ValidationService().validate(options);
+            JsonReportWriter writer = new JsonReportWriter();
+            if ("-".equals(report)) {
+                writer.write(result, spec.commandLine().getOut());
+            } else {
+                writer.write(result, Path.of(report));
+            }
+            return result.matches() ? EXIT_MATCH : EXIT_DIFFERENT;
+        } catch (IllegalArgumentException | IOException exception) {
+            spec.commandLine().getErr().println("Erro: " + exception.getMessage());
+            return EXIT_INPUT_ERROR;
+        }
+    }
+
+    static char parseDelimiter(String value) {
+        if (value == null) {
+            throw new IllegalArgumentException("Separador CSV ausente");
+        }
+        String decoded = switch (value.toLowerCase(Locale.ROOT)) {
+            case "tab", "\\t" -> "\t";
+            case "comma" -> ",";
+            case "semicolon" -> ";";
+            case "pipe" -> "|";
+            default -> value;
+        };
+        if (decoded.length() != 1) {
+            throw new IllegalArgumentException("Separador CSV deve conter exatamente um caractere: " + value);
+        }
+        return decoded.charAt(0);
+    }
+
+    public static CommandLine commandLine() {
+        CommandLine commandLine = new CommandLine(new ValidatorCli());
+        commandLine.setExecutionExceptionHandler((exception, current, parseResult) -> {
+            current.getErr().println("Erro interno: " + exception.getMessage());
+            return EXIT_INTERNAL_ERROR;
+        });
+        return commandLine;
+    }
+
+    public static void main(String[] args) {
+        System.exit(commandLine().execute(args));
+    }
+}

mainframe_toolkit/_workspace/validator-java/src/main/java/io/mainframe/migration/validator/ValueNormalizer.java

@@ -0,0 +1,27 @@
+package io.mainframe.migration.validator;
+
+import java.math.BigDecimal;
+import java.util.Set;
+
+final class ValueNormalizer {
+    private ValueNormalizer() {
+    }
+
+    static String normalize(String value, Set<Normalization> normalizations) {
+        if (value == null) {
+            return null;
+        }
+        String normalized = normalizations.contains(Normalization.TRIM) ? value.strip() : value;
+        if (normalizations.contains(Normalization.DECIMAL)) {
+            try {
+                BigDecimal decimal = new BigDecimal(normalized);
+                normalized = decimal.compareTo(BigDecimal.ZERO) == 0
+                        ? "0"
+                        : decimal.stripTrailingZeros().toPlainString();
+            } catch (NumberFormatException ignored) {
+                // Non-numeric cells remain unchanged.
+            }
+        }
+        return normalized;
+    }
+}

mainframe_toolkit/_workspace/validator-java/src/test/java/io/mainframe/migration/validator/DirectoryValidationTest.java

@@ -0,0 +1,70 @@
+package io.mainframe.migration.validator;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Set;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class DirectoryValidationTest {
+    @TempDir
+    Path temporaryDirectory;
+
+    @Test
+    void readsSparkCsvPartsInLexicalOrderAndSkipsMarkers() throws Exception {
+        Path expected = Files.createDirectory(temporaryDirectory.resolve("expected"));
+        Files.writeString(expected.resolve("part-00001.csv"), "id,name\n2,Bia\n");
+        Files.writeString(expected.resolve("part-00000.csv"), "id,name\n1,Ana\n");
+        Files.writeString(expected.resolve("_SUCCESS"), "");
+        Files.writeString(expected.resolve(".part-hidden.csv"), "id,name\n9,Hidden\n");
+        Files.writeString(expected.resolve("notes.csv"), "id,name\n8,Ignored\n");
+
+        Path actual = Files.createDirectory(temporaryDirectory.resolve("actual"));
+        Files.writeString(actual.resolve("part-00000.csv"), "id,name\n1,Ana\n2,Bia\n");
+
+        ValidationReport report = validate(expected, actual, DataFormat.AUTO);
+
+        assertTrue(report.matches());
+        assertEquals(2, report.expectedRows());
+        assertEquals(2, report.actualRows());
+        assertEquals("CSV", report.expectedFormat());
+    }
+
+    @Test
+    void rejectsMixedSparkFormatsWhenFormatIsAuto() throws Exception {
+        Path mixed = Files.createDirectory(temporaryDirectory.resolve("mixed"));
+        Files.writeString(mixed.resolve("part-00000.csv"), "id\n1\n");
+        Files.writeString(mixed.resolve("part-00001.parquet"), "not parquet");
+
+        IllegalArgumentException exception = assertThrows(
+                IllegalArgumentException.class,
+                () -> DataFormat.AUTO.resolve(mixed));
+
+        assertTrue(exception.getMessage().contains("CSV e Parquet"));
+    }
+
+    @Test
+    void explicitFormatSelectsOnlyMatchingParts() throws Exception {
+        Path expected = Files.createDirectory(temporaryDirectory.resolve("expected"));
+        Files.writeString(expected.resolve("part-00000.csv"), "id\n1\n");
+        Files.writeString(expected.resolve("part-00001.parquet"), "ignored");
+        Path actual = Files.createDirectory(temporaryDirectory.resolve("actual"));
+        Files.writeString(actual.resolve("part-00000.csv"), "id\n1\n");
+
+        ValidationReport report = validate(expected, actual, DataFormat.CSV);
+
+        assertTrue(report.matches());
+    }
+
+    private ValidationReport validate(Path expected, Path actual, DataFormat format) throws Exception {
+        InputOptions left = new InputOptions(expected, format, ',', true, StandardCharsets.UTF_8);
+        InputOptions right = new InputOptions(actual, format, ',', true, StandardCharsets.UTF_8);
+        return new ValidationService().validate(new ValidationOptions(left, right, Set.of(), 100));
+    }
+}