Improve handling of working directory and add missing tests for main class

Author: Donnerbart

src/main/java/de/donnerbart/split/Arguments.java

@@ -6,7 +6,9 @@
 import org.jetbrains.annotations.Nullable;
 
 import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.util.Arrays;
+import java.util.Objects;
 
 class Arguments {
 
@@ -49,7 +51,8 @@ class Arguments {
 
     @Parameter(names = {"--working-directory", "-w"},
                description = "The working directory. Defaults to the current directory.")
-    @Nullable Path workingDirectory;
+    @SuppressWarnings("NotNullFieldNotInitialized")
+    @NotNull Path workingDirectory;
 
     @Parameter(names = {"--calculate-optimal-total-split", "-o"},
                description = "Calculates the optimal test split (only on the first split index). Logs a warning if --split-total does not match.")
@@ -62,6 +65,12 @@ class Arguments {
     @Parameter(names = {"--debug", "-d"}, description = "Enables debug logging.")
     boolean debug = false;
 
+    void init() {
+        workingDirectory = Objects.requireNonNullElse(workingDirectory, Paths.get(System.getProperty("user.dir")))
+                .toAbsolutePath()
+                .normalize();
+    }
+
     public static class FormatOptionConverter implements IStringConverter<FormatOption> {
 
         @Override

src/main/java/de/donnerbart/split/TestSplitMain.java

@@ -11,12 +11,9 @@
 import org.slf4j.LoggerFactory;
 
 import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
 import java.text.SimpleDateFormat;
 import java.time.Instant;
 import java.util.Date;
-import java.util.Objects;
 import java.util.Properties;
 import java.util.Set;
 import java.util.function.Consumer;
@@ -27,39 +24,48 @@ public class TestSplitMain {
 
     private static final @NotNull Logger LOG = LoggerFactory.getLogger(TestSplitMain.class);
 
+    private TestSplitMain() {
+    }
+
     public static void main(final @Nullable String @NotNull [] args) throws Exception {
-        run(System::exit, args);
+        final var arguments = init(System::exit, args);
+        run(System::exit, arguments);
     }
 
     @VisibleForTesting
-    static @NotNull Splits run(final @NotNull Consumer<Integer> exitConsumer, final @Nullable String @NotNull [] args)
-            throws Exception {
+    static @NotNull Arguments init(
+            final @NotNull Consumer<Integer> exitConsumer,
+            final @Nullable String @NotNull [] args) {
         final var arguments = new Arguments();
         final var jCommander = JCommander.newBuilder().addObject(arguments).build();
         jCommander.parse(args);
+        arguments.init();
         if (arguments.help) {
             jCommander.usage();
             exitConsumer.accept(0);
+            return arguments;
         }
         if (arguments.debug) {
             final var root = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
             root.setLevel(Level.DEBUG);
         }
-        final var workingDirectory =
-                Objects.requireNonNullElse(arguments.workingDirectory, Paths.get(System.getProperty("user.dir")))
-                        .toAbsolutePath()
-                        .normalize();
-        if (!validateArguments(arguments, workingDirectory)) {
+        if (!validateArguments(arguments)) {
             exitConsumer.accept(1);
         }
+        return arguments;
+    }
+
+    @VisibleForTesting
+    static @NotNull Splits run(final @NotNull Consumer<Integer> exitConsumer, final @NotNull Arguments arguments)
+            throws Exception {
         final var properties = readProperties("split-tests-java.properties");
         LOG.info("split-tests-java {} (commit: {} on branch: {}) built on {}",
                 properties.getProperty("version", "unknown"),
                 properties.getProperty("git.commit.id.abbrev", "unknown"),
                 properties.getProperty("git.branch", "unknown"),
                 getBuiltTime(properties.getProperty("git.commit.time", "unknown")));
         LOG.info("Split index {} (total: {})", arguments.splitIndex, arguments.splitTotal);
-        LOG.info("Working directory: {}", workingDirectory);
+        LOG.info("Working directory: {}", arguments.workingDirectory);
         LOG.info("Glob: {}", arguments.glob);
         if (arguments.excludeGlob != null) {
             LOG.info("Exclude glob: {}", arguments.excludeGlob);
@@ -72,8 +78,8 @@ public static void main(final @Nullable String @NotNull [] args) throws Exceptio
                 arguments.excludeGlob,
                 arguments.junitGlob,
                 arguments.newTestTimeOption,
-                workingDirectory,
-                System::exit);
+                arguments.workingDirectory,
+                exitConsumer);
         final var testCases = testLoader.load();
         if (arguments.calculateOptimalTotalSplit) {
             calculateOptimalTotalSplit(arguments, testCases);
@@ -87,7 +93,7 @@ public static void main(final @Nullable String @NotNull [] args) throws Exceptio
     }
 
     @VisibleForTesting
-    static boolean validateArguments(final @NotNull Arguments arguments, final @NotNull Path workingDirectory) {
+    static boolean validateArguments(final @NotNull Arguments arguments) {
         if (arguments.splitTotal < 1) {
             LOG.error("--split-total must be greater than 0");
             return false;
@@ -96,7 +102,7 @@ static boolean validateArguments(final @NotNull Arguments arguments, final @NotN
             LOG.error("--split-index must lesser than --split-total");
             return false;
         }
-        if (!Files.exists(workingDirectory)) {
+        if (!Files.exists(arguments.workingDirectory)) {
             LOG.error("Working directory does not exist: {}", arguments.workingDirectory);
             return false;
         }

src/test/java/de/donnerbart/split/TestSplitMainTest.java

@@ -19,6 +19,7 @@
 import static java.nio.file.attribute.PosixFilePermission.OWNER_READ;
 import static java.nio.file.attribute.PosixFilePermission.OWNER_WRITE;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatNoException;
 
 class TestSplitMainTest {
 
@@ -64,20 +65,48 @@ void setUp() throws Exception {
                 PERMISSIONS);
     }
 
+    @Test
+    void main_fullLifecycle() {
+        assertThatNoException().isThrownBy(() -> TestSplitMain.main(new String[]{
+                "-i", "0", "-t", "2", "-g", "**/example-project/**/*Test.java", "-w", tmp.toString()}));
+    }
+
+    @Test
+    void init() {
+        TestSplitMain.init(exitCode::set,
+                new String[]{"-i", "0", "-t", "1", "-g", "**/*Test.java", "-w", tmp.toString()});
+        assertThat(exitCode).hasNullValue();
+    }
+
+    @Test
+    void init_withHelp() {
+        TestSplitMain.init(exitCode::set, new String[]{"-h"});
+        assertThat(exitCode).hasValue(0);
+    }
+
+    @Test
+    void init_withInvalidArguments() {
+        TestSplitMain.init(exitCode::set, new String[]{"-i", "0", "-t", "0", "-g", "**/*Test.java"});
+        assertThat(exitCode).hasValue(1);
+    }
+
     @Test
     void run() throws Exception {
-        final var splits = TestSplitMain.run(exitCode::set, new String[]{
-                "-i",
+        jCommander.parse("-i",
                 "0",
                 "-t",
                 "2",
                 "-g",
                 "**/example-project/**/*Test.java",
+                "-e",
+                "**/example-project/**/*Abstract*.java",
                 "-j",
                 "**/junit-reports/*.xml",
                 "-w",
-                tmp.toAbsolutePath().toString(),
-                "-d"});
+                tmp.toString(),
+                "-o",
+                "-d");
+        final var splits = TestSplitMain.run(exitCode::set, arguments);
         assertThat(exitCode).hasNullValue();
 
         assertThat(splits.size()).isEqualTo(2);
@@ -89,32 +118,32 @@ void run() throws Exception {
 
     @Test
     void validateArguments() {
-        jCommander.parse("-i", "0", "-t", "1", "-g", "**/*Test.java");
-        assertThat(TestSplitMain.validateArguments(arguments, tmp)).isTrue();
+        jCommander.parse("-i", "0", "-t", "1", "-g", "**/*Test.java", "-w", tmp.toAbsolutePath().toString());
+        assertThat(TestSplitMain.validateArguments(arguments)).isTrue();
     }
 
     @Test
     void validateArguments_withZeroSplitTotal() {
-        jCommander.parse("-i", "0", "-t", "0", "-g", "**/*Test.java");
-        assertThat(TestSplitMain.validateArguments(arguments, tmp)).isFalse();
+        jCommander.parse("-i", "0", "-t", "0", "-g", "**/*Test.java", "-w", tmp.toAbsolutePath().toString());
+        assertThat(TestSplitMain.validateArguments(arguments)).isFalse();
     }
 
     @Test
     void validateArguments_withNegativeSplitTotal() {
-        jCommander.parse("-i", "0", "-t", "-1", "-g", "**/*Test.java");
-        assertThat(TestSplitMain.validateArguments(arguments, tmp)).isFalse();
+        jCommander.parse("-i", "0", "-t", "-1", "-g", "**/*Test.java", "-w", tmp.toAbsolutePath().toString());
+        assertThat(TestSplitMain.validateArguments(arguments)).isFalse();
     }
 
     @Test
     void validateArguments_withTooSmallSplitIndex() {
-        jCommander.parse("-i", "1", "-t", "1", "-g", "**/*Test.java");
-        assertThat(TestSplitMain.validateArguments(arguments, tmp)).isFalse();
+        jCommander.parse("-i", "1", "-t", "1", "-g", "**/*Test.java", "-w", tmp.toAbsolutePath().toString());
+        assertThat(TestSplitMain.validateArguments(arguments)).isFalse();
     }
 
     @Test
     void validateArguments_withInvalidWorkingDirectory() {
-        jCommander.parse("-i", "0", "-t", "1", "-g", "**/*Test.java");
-        assertThat(TestSplitMain.validateArguments(arguments, tmp.resolve("does-not-exist"))).isFalse();
+        jCommander.parse("-i", "0", "-t", "1", "-g", "**/*Test.java", "-w", tmp.resolve("does-not-exist").toString());
+        assertThat(TestSplitMain.validateArguments(arguments)).isFalse();
     }
 
     @Test