feat(#1218): add further methods to TestListener

- onFinalActionsStart - onFinalActionsEnd - onAfterSequenceBeforeTest - onAfterSequenceAfterTest - onBeforeSequenceBeforeTest - onBeforeSequenceAfterTest - onTestEnd Co-authored-by: Thorsten Schlathoelter<tschlat@gmx.de>
citrusframework · Feb 7, 2025 · 22a89d4 · 22a89d4
1 parent cb889b2
commit 22a89d4
Show file tree

Hide file tree

Showing 4 changed files with 256 additions and 39 deletions.
diff --git a/core/citrus-api/src/main/java/org/citrusframework/report/TestListener.java b/core/citrus-api/src/main/java/org/citrusframework/report/TestListener.java
@@ -24,32 +24,80 @@
  */
 public interface TestListener {
     /**
-     * Invoked when test gets started
-     * @param test
+     * Invoked when test when a test starts execution
      */
     void onTestStart(TestCase test);
 
     /**
-     * Invoked when test gets finished
-     * @param test
+     * Invoked when test execution has finished (before final actions execution and SequenceAfter execution)
+     * @see #onTestEnd(TestCase)
      */
     void onTestFinish(TestCase test);
 
     /**
-     * Invoked when test finished with success
-     * @param test
+     * Invoked at the very end of test execution (including final actions and SequenceAfter)
+     * @see #onTestFinish(TestCase)
+     */
+    default void onTestEnd(TestCase test) {
+        // Default implementation does nothing
+    }
+
+    /**
+     * Invoked when a test finishes successfully
      */
     void onTestSuccess(TestCase test);
 
     /**
-     * Invoked when test finished with failure
-     * @param test
+     * Invoked when a test finishes with failure
      */
     void onTestFailure(TestCase test, Throwable cause);
 
     /**
-     * Invoked when test is skipped
-     * @param test
+     * Invoked when a test is skipped
      */
     void onTestSkipped(TestCase test);
+
+
+
+    /**
+     * Invoked when final actions start
+     */
+    default void onFinalActionsStart(TestCase test) {
+        // Default implementation does nothing
+    }
+
+    /**
+     * Invoked after final actions have completely finished
+     */
+    default void onFinalActionsEnd(TestCase test) {
+        // Default implementation does nothing
+    }
+
+    /**
+     * Invoked after SequenceBefore, only if it exists
+     */
+    default void onAfterSequenceBeforeTest(TestCase test) {
+        // Default implementation does nothing
+    }
+
+    /**
+     * Invoked after SequenceAfter, only if it exists
+     */
+    default void onAfterSequenceAfterTest(TestCase test) {
+        // Default implementation does nothing
+    }
+
+    /**
+     * Invoked before SequenceBefore, only if it exists
+     */
+    default void onBeforeSequenceBeforeTest(TestCase test) {
+        // Default implementation does nothing
+    }
+
+    /**
+     * Invoked before SequenceAfter, only if it exists
+     */
+    default void onBeforeSequenceAfterTest(TestCase test) {
+        // Default implementation does nothing
+    }
 }
diff --git a/core/citrus-api/src/main/java/org/citrusframework/report/TestListeners.java b/core/citrus-api/src/main/java/org/citrusframework/report/TestListeners.java
@@ -55,6 +55,48 @@ public void onTestStart(TestCase test) {
         }
     }
 
+    public void onTestEnd(TestCase test) {
+        for (TestListener listener : testListeners) {
+            listener.onTestEnd(test);
+        }
+    }
+
+    public void onFinalActionsStart(TestCase test) {
+        for (TestListener listener : testListeners) {
+            listener.onFinalActionsStart(test);
+        }
+    }
+
+    public void onFinalActionsEnd(TestCase test) {
+        for (TestListener listener : testListeners) {
+            listener.onFinalActionsEnd(test);
+        }
+    }
+
+    public void onAfterSequenceBeforeTest(TestCase test) {
+        for (TestListener listener : testListeners) {
+            listener.onAfterSequenceBeforeTest(test);
+        }
+    }
+
+    public void onAfterSequenceAfterTest(TestCase test) {
+        for (TestListener listener : testListeners) {
+            listener.onAfterSequenceAfterTest(test);
+        }
+    }
+
+    public void onBeforeSequenceBeforeTest(TestCase test) {
+        for (TestListener listener : testListeners) {
+            listener.onBeforeSequenceBeforeTest(test);
+        }
+    }
+
+    public void onBeforeSequenceAfterTest(TestCase test) {
+        for (TestListener listener : testListeners) {
+            listener.onBeforeSequenceAfterTest(test);
+        }
+    }
+
     public void onTestSuccess(TestCase test) {
         for (TestListener listener : testListeners) {
             listener.onTestSuccess(test);
@@ -70,7 +112,6 @@ public void addTestListener(TestListener listener) {
 
     /**
      * Obtains the testListeners.
-     * @return
      */
     public List<TestListener> getTestListeners() {
         return testListeners;

diff --git a/core/citrus-base/src/main/java/org/citrusframework/DefaultTestCase.java b/core/citrus-base/src/main/java/org/citrusframework/DefaultTestCase.java
@@ -157,6 +157,19 @@ public void start(final TestContext context) {
     public void beforeTest(final TestContext context) {
         restartTimer();
 
+        if (context.getBeforeTest().isEmpty()) {
+            return;
+        }
+
+        try {
+            context.getTestListeners().onBeforeSequenceBeforeTest(this);
+            doExecuteSequenceBefore(context);
+        } finally {
+            context.getTestListeners().onAfterSequenceBeforeTest(this);
+        }
+    }
+
+    private void doExecuteSequenceBefore(TestContext context) {
         for (final BeforeTest sequenceBeforeTest : context.getBeforeTest()) {
             try {
                 if (sequenceBeforeTest.shouldExecute(getName(), packageName, groups)) {
@@ -170,6 +183,19 @@ public void beforeTest(final TestContext context) {
 
     @Override
     public void afterTest(final TestContext context) {
+        if (context.getAfterTest().isEmpty()) {
+            return;
+        }
+
+        try {
+            context.getTestListeners().onBeforeSequenceAfterTest(this);
+        } finally {
+            doExecuteSequenceAfter(context);
+            context.getTestListeners().onAfterSequenceAfterTest(this);
+        }
+    }
+
+    private void doExecuteSequenceAfter(TestContext context) {
         for (final AfterTest sequenceAfterTest : context.getAfterTest()) {
             try {
                 if (sequenceAfterTest.shouldExecute(getName(), packageName, groups)) {
@@ -250,6 +276,12 @@ public void finish(final TestContext context) {
             testResult = getTestResultInstanceProvider(context).createFailed(this, e);
             throw new TestCaseFailedException(e);
         } finally {
+            doFinishTest(context);
+        }
+    }
+
+    private void doFinishTest(TestContext context) {
+        try {
             if (testResult != null) {
                 if (testResult.isSuccess()) {
                     context.getTestListeners().onTestSuccess(this);
@@ -259,8 +291,9 @@ public void finish(final TestContext context) {
             }
 
             afterTest(context);
-
             completeTestResultWithDuration();
+        } finally {
+            context.getTestListeners().onTestEnd(this);
         }
     }
 
@@ -289,7 +322,27 @@ private void gracefullyStopTimer() {
      * Run final test actions.
      */
     private void executeFinalActions(TestContext context) {
+        if (finalActions.isEmpty() && context.getFinalActions().isEmpty()) {
+            return;
+        }
+
+        try {
+            context.getTestListeners().onFinalActionsStart(this);
+            doExecuteFinalActions(context);
+        } finally {
+            context.getTestListeners().onFinalActionsEnd(this);
+        }
+
+        if (testResult.isSuccess() && context.hasExceptions()) {
+            CitrusRuntimeException contextException = context.getExceptions().remove(0);
+            testResult = getTestResultInstanceProvider(context).createFailed(this, contextException);
+            throw new TestCaseFailedException(contextException);
+        }
+    }
+
+    private void doExecuteFinalActions(TestContext context) {
         if (!finalActions.isEmpty()) {
+
             logger.debug("Entering finally block in test case");
 
             /* walk through the finally-chain and execute the actions in there */
@@ -307,6 +360,8 @@ private void executeFinalActions(TestContext context) {
 
         /* test context may also have some actions to run finally */
         for (final TestActionBuilder<?> actionBuilder : context.getFinalActions()) {
+            context.getTestListeners().onFinalActionsStart(this);
+
             TestAction action = actionBuilder.build();
             if (!action.isDisabled(context)) {
                 context.getTestActionListeners().onTestActionStart(this, action);
@@ -316,19 +371,10 @@ private void executeFinalActions(TestContext context) {
                 context.getTestActionListeners().onTestActionSkipped(this, action);
             }
         }
-
-        if (testResult.isSuccess() && context.hasExceptions()) {
-            CitrusRuntimeException contextException = context.getExceptions().remove(0);
-            testResult = getTestResultInstanceProvider(context).createFailed(this, contextException);
-            throw new TestCaseFailedException(contextException);
-        }
     }
 
     /**
      * Print variables in given test context.
-     *
-     * @param scope
-     * @param context
      */
     private void debugVariables(String scope, TestContext context) {
         /* Debug print global variables */
@@ -342,9 +388,6 @@ private void debugVariables(String scope, TestContext context) {
 
     /**
      * Sets test parameters as test variables.
-     *
-     * @param parameters
-     * @param context
      */
     private void initializeTestParameters(Map<String, Object> parameters, TestContext context) {
         // add default variables for test
@@ -359,9 +402,6 @@ private void initializeTestParameters(Map<String, Object> parameters, TestContex
 
     /**
      * Initialize the test variables in the given test context.
-     *
-     * @param variableDefinitions
-     * @param context
      */
     private void initializeTestVariables(Map<String, Object> variableDefinitions, TestContext context) {
         /* build up the global test variables in TestContext by
@@ -381,8 +421,6 @@ private void initializeTestVariables(Map<String, Object> variableDefinitions, Te
 
     /**
      * Setter for variables.
-     *
-     * @param variableDefinitions
      */
     public void setVariableDefinitions(final Map<String, Object> variableDefinitions) {
         this.variableDefinitions = variableDefinitions;
@@ -395,8 +433,6 @@ public Map<String, Object> getVariableDefinitions() {
 
     /**
      * Setter for finally chain.
-     *
-     * @param finalActions
      */
     public void setFinalActions(final List<TestAction> finalActions) {
         this.finalActions = finalActions.stream().map(action -> (TestActionBuilder<?>) () -> action).collect(Collectors.toList());
@@ -543,17 +579,13 @@ public void setGroups(final String[] groups) {
 
     /**
      * Sets the timeout.
-     *
-     * @param timeout
      */
     public void setTimeout(final long timeout) {
         this.timeout = timeout;
     }
 
     /**
      * Gets the timeout.
-     *
-     * @return
      */
     public long getTimeout() {
         return timeout;