Update DockerCompose tests to Junit5

Also had to account for some changes in Mockito w/ varargs methods.

Suggested changes from PR review

Author: onobc

spring-cloud-dataflow-common/spring-cloud-dataflow-common-test-docker/src/test/java/org/springframework/cloud/dataflow/common/test/docker/compose/execution/CommandTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2018-2019 the original author or authors.
+ * Copyright 2018-2024 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,88 +20,80 @@
 import java.util.List;
 import java.util.function.Consumer;
 
-import org.junit.Before;
-import org.junit.Ignore;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 
 import static org.apache.commons.io.IOUtils.toInputStream;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.contains;
 import static org.hamcrest.core.Is.is;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
 
-@RunWith(MockitoJUnitRunner.class)
-public class CommandTests {
-    @Mock private Process executedProcess;
-    @Mock private DockerComposeExecutable dockerComposeExecutable;
-    @Mock private ErrorHandler errorHandler;
+class CommandTests {
+
+    private Process executedProcess = mock(Process.class);
+    private DockerComposeExecutable dockerComposeExecutable = mock(DockerComposeExecutable.class);
+    private ErrorHandler errorHandler = mock(ErrorHandler.class);
     private Command dockerComposeCommand;
     private final List<String> consumedLogLines = new ArrayList<>();
     private final Consumer<String> logConsumer = s -> consumedLogLines.add(s);
 
-    @Before
-    public void before() throws IOException {
+    @BeforeEach
+    void prepareForTest() throws IOException {
+        when(dockerComposeExecutable.commandName()).thenReturn("docker-compose");
         when(dockerComposeExecutable.execute(any())).thenReturn(executedProcess);
+        when(dockerComposeExecutable.execute(any(String[].class))).thenReturn(executedProcess);
         dockerComposeCommand = new Command(dockerComposeExecutable, logConsumer);
-
         givenTheUnderlyingProcessHasOutput("");
         givenTheUnderlyingProcessTerminatesWithAnExitCodeOf(0);
     }
 
-    @Test public void
-    invoke_error_handler_when_exit_code_of_the_executed_process_is_non_0() throws IOException, InterruptedException {
+    @Test
+    void invokeErrorHandlerWhenExitCodeOfTheExecutedProcessIsNonZero() throws Exception {
         int expectedExitCode = 1;
         givenTheUnderlyingProcessTerminatesWithAnExitCodeOf(expectedExitCode);
         dockerComposeCommand.execute(errorHandler, "rm", "-f");
-
         verify(errorHandler).handle(expectedExitCode, "", "docker-compose", "rm", "-f");
     }
 
-    @Test public void
-    not_invoke_error_handler_when_exit_code_of_the_executed_process_is_0() throws IOException, InterruptedException {
+    @Test
+    void notInvokeErrorHandlerWhenExitCodeOfTheExecutedProcessIsZero() throws Exception {
         dockerComposeCommand.execute(errorHandler, "rm", "-f");
-
         verifyNoMoreInteractions(errorHandler);
     }
 
-    @Test public void
-    return_output_when_exit_code_of_the_executed_process_is_non_0() throws IOException, InterruptedException {
+    @Test
+    void returnOutputWhenExitCodeOfTheExecutedProcessIsNonZero() throws Exception {
         String expectedOutput = "test output";
         givenTheUnderlyingProcessTerminatesWithAnExitCodeOf(1);
         givenTheUnderlyingProcessHasOutput(expectedOutput);
         String commandOutput = dockerComposeCommand.execute(errorHandler, "rm", "-f");
-
         assertThat(commandOutput, is(expectedOutput));
     }
 
-    @Test public void
-    return_output_when_exit_code_of_the_executed_process_is_0() throws IOException, InterruptedException {
+    @Test
+    void returnOutputWhenExitCodeOfTheExecutedProcessIsZero() throws Exception {
         String expectedOutput = "test output";
         givenTheUnderlyingProcessHasOutput(expectedOutput);
         String commandOutput = dockerComposeCommand.execute(errorHandler, "rm", "-f");
-
         assertThat(commandOutput, is(expectedOutput));
     }
 
-    @Test public void
-    give_the_output_to_the_specified_consumer_as_it_is_available() throws IOException, InterruptedException {
+    @Test
+    void giveTheOutputToTheSpecifiedConsumerAsItIsAvailable() throws Exception {
         givenTheUnderlyingProcessHasOutput("line 1\nline 2");
-
         dockerComposeCommand.execute(errorHandler, "rm", "-f");
-
         assertThat(consumedLogLines, contains("line 1", "line 2"));
     }
 
-    // flaky test: https://circleci.com/gh/palantir/docker-compose-rule/378, 370, 367, 366
-    @Ignore
-    @Test public void
-    not_create_long_lived_threads_after_execution() throws IOException, InterruptedException {
+    @Disabled("flaky test: https://circleci.com/gh/palantir/docker-compose-rule/378, 370, 367, 366")
+    @Test
+    void notCreateLongLivedThreadsAfterExecution() throws Exception {
         int preThreadCount = Thread.getAllStackTraces().entrySet().size();
         dockerComposeCommand.execute(errorHandler, "rm", "-f");
         int postThreadCount = Thread.getAllStackTraces().entrySet().size();