feat: enable targeting a test process by its process identifier

Author: netmikey

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

@@ -35,6 +35,8 @@ public class TestProcessDefinitionBy<T extends TestProcessDefinition> {
 
     private Optional<String> beanName = Optional.empty();
 
+    private Optional<String> processIdentifier = Optional.empty();
+
     /**
      * Address a test process definition by its concrete type.
      * 
@@ -82,6 +84,23 @@ public static TestProcessDefinitionBy<? extends TestProcessDefinition> beanName(
         return result;
     }
 
+    /**
+     * Address a test process definition by its process identifier.
+     * 
+     * @param testProcessIdentifier
+     *            The identifier returned by
+     *            {@link TestProcessDefinition#getProcessIdentifier()}.
+     * @return The {@link TestProcessDefinitionBy} reference to the test process
+     *         with the specified testProcessIdentifier.
+     */
+    public static TestProcessDefinitionBy<? extends TestProcessDefinition> processIdentifier(
+        String testProcessIdentifier) {
+
+        TestProcessDefinitionBy<? extends TestProcessDefinition> result = new TestProcessDefinitionBy<>();
+        result.processIdentifier = Optional.of(testProcessIdentifier);
+        return result;
+    }
+
     /**
      * Get the clazz.
      * 
@@ -109,4 +128,12 @@ public Optional<String> getBeanName() {
         return beanName;
     }
 
+    /**
+     * Get the processIdentifier.
+     * 
+     * @return Returns the processIdentifier.
+     */
+    public Optional<String> getProcessIdentifier() {
+        return processIdentifier;
+    }
 }

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

@@ -352,6 +352,60 @@ private <T extends TestProcessDefinition> T retrieve(TestProcessDefinitionBy<T>
                         + matchingBeans.keySet().stream().collect(Collectors.joining(", ")));
                 }
 
+                result = matchingBeans.values()
+                    .stream()
+                    .findFirst()
+                    .get();
+            }
+        } else if (testProcessDefinitionBy.getProcessIdentifier().isPresent()) {
+            String processIdentifier = testProcessDefinitionBy.getProcessIdentifier().get();
+
+            // First, try to find a match within the currently running processes
+            Map<String, T> matchingRunning = runningProcesses.entrySet().stream()
+                .filter(p -> processIdentifier.equals(p.getValue().getDefinition().getProcessIdentifier()))
+                .collect(Collectors.toMap(
+                    e -> "instance " + e.getValue().getDefinition() + " with identifier "
+                        + e.getValue().getDefinition().getProcessIdentifier(),
+                    e -> (T) e.getValue().getDefinition()));
+
+            // Note that this shouldn't happen as only one process with a given
+            // processIdentifier should run at any time, but check for good
+            // measure...
+            if (matchingRunning.size() > 1) {
+                throw new TooManyTestProcessDefinitionsException("More than one TestProcessDefinition bean with "
+                    + "identifier " + processIdentifier + " were found to be running. Consider referencing your "
+                    + "test process using the class, instance or bean name rather than the process identifier. "
+                    + "Found beans were: " + matchingRunning.keySet().stream().collect(Collectors.joining(", ")));
+            }
+
+            if (matchingRunning.size() == 1) {
+                result = matchingRunning.values()
+                    .stream()
+                    .findFirst()
+                    .get();
+            } else {
+                // If no matching definition is running, try to find a matching
+                // Spring bean
+
+                Map<String, T> matchingBeans = testProcessDefinitionBeans.entrySet().stream()
+                    .filter(b -> processIdentifier.equals(b.getValue().getProcessIdentifier()))
+                    .collect(Collectors.toMap(e -> e.getKey(), e -> (T) e.getValue()));
+
+                if (matchingBeans.size() == 0) {
+                    throw new UnknownTestProcessDefinitionException(
+                        "No " + TestProcessDefinition.class.getSimpleName() + " with identifier "
+                            + processIdentifier + " could be found. Make sure you have a bean of type "
+                            + TestProcessDefinition.class.getSimpleName()
+                            + "that uses this identifier in your Spring Test-Context.");
+                }
+
+                if (matchingBeans.size() > 1) {
+                    throw new TooManyTestProcessDefinitionsException("More than one TestProcessDefinition "
+                        + "bean with identifier " + processIdentifier + " were found. Consider referencing it "
+                        + "using its class, the instance or bean name rather than the process identifier. "
+                        + "Found beans were: " + matchingBeans.keySet().stream().collect(Collectors.joining(", ")));
+                }
+
                 result = matchingBeans.values()
                     .stream()
                     .findFirst()

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

@@ -34,7 +34,8 @@ public void oneTestWereTestProcessShouldBeRunning() {
      * should be running. The execution order may vary and is not important.
      */
     @Test
-    public void anotherTestWereTestProcessShouldBeRunning() {
+    public void anotherTestWhereTestProcessShouldBeRunning() {
         assertEchoRunningByClass(registry);
+        assertEchoRunningByProcessIdentifier(registry);
     }
 }

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

@@ -14,6 +14,11 @@
 @Component
 public class EchoTestProcess extends AbstractTestProcessDefinition {
 
+    /**
+     * The process identifier.
+     */
+    public static String PROCESS_IDENTIFIER = "echo-process";
+
     /**
      * Default constructor.
      */
@@ -29,6 +34,6 @@ protected void buildProcess(ProcessBuilder builder) {
 
     @Override
     public String getProcessIdentifier() {
-        return "echo-process";
+        return PROCESS_IDENTIFIER;
     }
 }

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

@@ -86,6 +86,17 @@ public static void assertEchoRunningByClass(TestProcessesRegistry registry) {
         assertRunningByClass(registry, EchoTestProcess.class);
     }
 
+    /**
+     * Assert the {@link EchoTestProcess} is currently running using its process
+     * identifier for the lookup.
+     * 
+     * @param registry
+     *            The registry on which the lookup should be performed.
+     */
+    public static void assertEchoRunningByProcessIdentifier(TestProcessesRegistry registry) {
+        assertRunningByProcessIdentifier(registry, EchoTestProcess.PROCESS_IDENTIFIER);
+    }
+
     /**
      * Assert the {@link TestProcessDefinition} is currently running using its
      * class for the lookup.
@@ -103,6 +114,23 @@ public static void assertRunningByClass(TestProcessesRegistry registry,
         Assertions.assertEquals(TestProcessState.STARTED, runningEchoProcess.getDefinition().getActualState());
     }
 
+    /**
+     * Assert the {@link TestProcessDefinition} is currently running using its
+     * process identifier for the lookup.
+     * 
+     * @param registry
+     *            The registry on which the lookup should be performed.
+     * @param processIdentifier
+     *            The process identifier to be looked up.
+     */
+    public static void assertRunningByProcessIdentifier(TestProcessesRegistry registry, String processIdentifier) {
+
+        RunningTestProcess<?> runningEchoProcess = registry.retrieveRunningProcess(processIdentifier(processIdentifier))
+            .orElseThrow(() -> new AssertionFailedError(
+                "process with identifier `" + processIdentifier + "` should have been started"));
+        Assertions.assertEquals(TestProcessState.STARTED, runningEchoProcess.getDefinition().getActualState());
+    }
+
     /**
      * Assert the {@link EchoTestProcess} is currently running using its
      * {@link EchoTestProcess} instance for the lookup.