fix: use StreamStart.CURRENT_TEST for imperatively started processes

A misleading sanity check was failing when it was tried to retrieve one
of the process' streams with `StreamStart.CURRENT_TEST` when the process
was started manually / using the API during that very test (so if the
process wasn't already running before the start of the test).

This has been fixed and is now possible. In this case, the whole stream
is returned since the entirety of it took place during the current test.

Author: netmikey

testprocesses-core/src/main/java/io/github/netmikey/testprocesses/TestProcessesRegistry.java

@@ -250,15 +250,6 @@ private InputStream streamOf(TestProcessDefinitionBy<?> testProcessDefinitionBy,
 
         Optional<Long> streamFileStartPositionOfCurrentTest = streamPositionRetriever.apply(runningTestProcess);
 
-        if (StreamStart.CURRENT_TEST.equals(streamStart)
-            && streamFileStartPositionOfCurrentTest.isEmpty()) {
-            throw new IllegalStateException(
-                "Test process " + runningTestProcess.getDefinition().getProcessIdentifier()
-                    + " defined in bean " + runningTestProcess.getDefinition()
-                    + " seems to be running but does not have the current test's start position on its "
-                    + streamDescription + " marked. This shouldn't happen.");
-        }
-
         try {
             /*
              * Open new channel, seek to the position in it where the current

testprocesses-core/src/test/java/io/github/netmikey/testprocesses/functional/StreamStartImperativeTest.java

@@ -0,0 +1,82 @@
+package io.github.netmikey.testprocesses.functional;
+
+import static io.github.netmikey.testprocesses.TestProcessDefinitionBy.*;
+import static io.github.netmikey.testprocesses.functional.testfixtures.TestHelper.*;
+
+import org.junit.jupiter.api.TestMethodOrder;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import io.github.netmikey.testprocesses.StartStrategy;
+import io.github.netmikey.testprocesses.TestProcessDefinitionBy;
+import io.github.netmikey.testprocesses.TestProcessesRegistry;
+import io.github.netmikey.testprocesses.functional.testfixtures.EchoTestProcess;
+import io.github.netmikey.testprocesses.utils.StreamStart;
+
+/**
+ * Test the bahvior of the {@link StreamStart} setting when retrieving streams
+ * from a test process that has been started imperatively using the API (instead
+ * of the test-method-bound annotation).
+ * <p>
+ * To do this, the test method execution is ordered. Beware of the order when
+ * editing this test. Also, since the order and the state between the running
+ * test methods is important, running single test methods will fail of course.
+ */
+@TestProcessesSpringBootTest
+@TestMethodOrder(OrderAnnotation.class)
+public class StreamStartImperativeTest {
+
+    private static final String MARKER_1 = "+++ MARKER_1";
+
+    private static final String MARKER_2 = "+++ MARKER_2";
+
+    @Autowired
+    private TestProcessesRegistry registry;
+
+    private TestProcessDefinitionBy<EchoTestProcess> echoTestProcess = clazz(EchoTestProcess.class);
+
+    /**
+     * Test starting a test process imperatively / "manually" / using the API
+     * and then retrieving its stdOut stream.
+     */
+    @Test
+    @Order(1)
+    public void testWithProcessStartedViaAPI() {
+        // Start EchoTestProcess using API
+        registry.start(echoTestProcess, StartStrategy.REQUIRE_RESTART);
+
+        sendToEchoProcess(registry, MARKER_1);
+
+        // JUnit Test was running before EchoTestProcess, should return the
+        // whole stream
+        String absoluteLog = registry.stdOutAsStringOf(echoTestProcess, StreamStart.ABSOLUTE);
+        String currentTestLog = registry.stdOutAsStringOf(echoTestProcess, StreamStart.CURRENT_TEST);
+
+        // Both should be equal
+        Assertions.assertThat(absoluteLog).isEqualTo(currentTestLog);
+    }
+
+    /**
+     * Test that a test process started imperatively / "manually" / using the
+     * API in a previous test obtains the "current test" markers on its streams
+     * when the present test starts and behaves as any regular already-running
+     * process.
+     */
+    @Test
+    @Order(2)
+    public void testWithProcessFromPreviousTestStartedViaAPI() {
+        // EchoTestProcess should still be running
+
+        sendToEchoProcess(registry, MARKER_2);
+
+        Assertions.assertThat(registry.stdOutAsStringOf(echoTestProcess, StreamStart.ABSOLUTE))
+            .contains(MARKER_1, MARKER_2);
+
+        Assertions.assertThat(registry.stdOutAsStringOf(echoTestProcess, StreamStart.CURRENT_TEST))
+            .contains(MARKER_2)
+            .doesNotContain(MARKER_1);
+    }
+}