[PHEE-534] Parallel execution of feature file

.circleci/config.yml

@@ -156,7 +156,7 @@ jobs:
       NAMESPACE: paymenthub
     steps:
       - setup_remote_docker:
-          version: 20.10.14
+          version: 20.10.24
       - kubernetes/install-kubectl
       - run: git clone https://github.com/openmf/ph-ee-env-labs
       - aws-eks/update-kubeconfig-with-authenticator:
@@ -231,9 +231,9 @@ jobs:
             echo -n "Test execution is completed, kill ngrok"
             pkill ngrok
       - store_test_results:
-          path: build/test-results/test/TEST-org.mifos.integrationtest.TestRunner.xml
+          path: build/test-results/test/TEST-courgette.api.junit.Courgette.xml
       - store_artifacts:
-          path: build/test-results
+          path: build/courgette-report
   test-chart-ams:
     docker:
       - image: cimg/openjdk:17.0.0
@@ -264,13 +264,13 @@ jobs:
             export CALLBACK_URL="https://$NGROK_PUBLIC_URL"
             echo -n "Public url ."
             echo $CALLBACK_URL
-            ./gradlew test -Dcucumber.filter.tags="@amsIntegration"
+            ./gradlew test -Dcucumber.tags="@amsIntegration"
             echo -n "Test execution is completed, kill ngrok"
             pkill ngrok
       - store_test_results:
-          path: build/test-results/test/TEST-org.mifos.integrationtest.TestRunner.xml
+          path: build/test-results/test/TEST-courgette.api.junit.Courgette.xml
       - store_artifacts:
-          path: build/test-results
+          path: build/courgette-report
 workflows:
   deploy:
     jobs:

README.md

@@ -73,54 +73,42 @@ Now we can run respective feature file directly form the intellij.
 
 ## Adding runner configuration
 Below java class will make sure to run cucumber test using JUnit test command.
-Where the `glue` property is for defining the package which contains the step definitions, `feature` refers to the path where feature file is located and `plugin` is for providing different plugin configuration supported by cucumber.
+Where the `glue` property is for defining the package which contains the step definitions and `plugin` is for providing different plugin configuration supported by cucumber.
 ```java
-@RunWith(Cucumber.class)
-@CucumberOptions(
-        features = {"src/test/java/resources"},
-        glue = {"org.mifos.integrationtest.cucumber"},
-        plugin = {
-            "html:cucumber-report",
-            "json:cucumber.json",
-            "pretty",
-            "html:build/cucumber-report.html",
-            "json:build/cucumber-report.json"
+
+@RunWith(Courgette.class)
+@CourgetteOptions(threads = 3, runLevel = CourgetteRunLevel.FEATURE, rerunFailedScenarios = false,
+        testOutput = CourgetteTestOutput.CONSOLE,
+
+        reportTitle = "Courgette-JVM Example",
+        reportTargetDir = "build",
+        environmentInfo = "browser=chrome; git_branch=master",
+        cucumberOptions = @CucumberOptions(features = "src/test/java/resources",
+                glue = "org.mifos.integrationtest.cucumber",
+                tags = "@gov",
+                publish = true,
+                plugin = {
+                            "pretty", "json:build/cucumber-report/cucumber.json",
+                            "html:build/cucumber-report/cucumber.html",
+                            "junit:build/cucumber-report/cucumber.xml"
+                         }))
+
 ## Adding gradle configuration
-Adding gradle configuration will allow us to run all the cucumber feature file at using using a CLI.
+Adding gradle configuration will allow us to run all the cucumber feature file at using a CLI.
 
-```gradle
-configurations {
-    cucumberRuntime {
-        extendsFrom testImplementation
-    }
+tasks.withType(Test) {
+    systemProperties = System.getProperties()
 }
 
-task cucumberCli() {
-    dependsOn assemble, testClasses
-    doLast {
-        javaexec {
-            main = "io.cucumber.core.cli.Main"
-            classpath = configurations.cucumberRuntime + sourceSets.main.output + sourceSets.test.output
-            args = [
-                    '--plugin', 'pretty',
-                    '--plugin', 'html:target/cucumber-report.html',
-                    '--glue', 'org.mifos.connector.slcb.cucumber',
-                    'src/test/java/resources']
-        }
-)
-public class TestRunner {
-}
-```
-Adding below configuration will allow us to wire the CLI arguments be passed in the actual runner configuration while running the cucumber test using JUnit.
-```groovy
-test {
-    systemProperty "cucumber.filter.tags", System.getProperty("cucumber.filter.tags")
+task parallelRun(type: Test) {
+    include '**/TestRunner.class'
+    outputs.upToDateWhen { false }
 }
 ```
 ## Running an integration test
 Use below command to execute the integration test.
 ```shell
-./gradlew test -Dcucumber.filter.tags="<cucumber tag>"
+./gradlew test -Dcucumber.tags="<cucumber tag>"
 ```
 Where `<cucumber tag>` has to be replaced with valid tag, for example if you are willing to run test cases related to g2p scenario then pass the tag `@gov`. If `-Dcucumber.filter.tags` flag is omitted then all the test cases would be triggered independent of the tag.
 ```shell

build.gradle

@@ -171,50 +171,20 @@ dependencies {
     implementation 'com.opencsv:opencsv:5.5.2'
     testImplementation 'org.apache.commons:commons-csv:1.5'
     testImplementation 'org.awaitility:awaitility:4.2.0'
+    implementation 'io.github.prashant-ramcharan:courgette-jvm:6.12.0'
 }
 
-tasks.named('test') {
-    useJUnitPlatform()
-}
+//tasks.named('test') {
+//    useJUnitPlatform()
+//}
 
 
-configurations {
-    cucumberRuntime {
-        extendsFrom testImplementation
-    }
-    testlogger {
-        // pick a theme - mocha, standard, plain, mocha-parallel, standard-parallel or plain-parallel
-        theme 'mocha'
-        showSkipped false
-        showStackTraces true
-    }
-}
 
-test {
-    systemProperty "cucumber.filter.tags", System.getProperty("cucumber.filter.tags")
-    systemProperty "cucumber.filter.name", System.getProperty("cucumber.filter.name")
+tasks.withType(Test) {
+    systemProperties = System.getProperties()
 }
-task cucumberCli() {
-    dependsOn assemble, testClasses
-    doLast {
-        javaexec {
-            main = "io.cucumber.core.cli.Main"
-            classpath = configurations.cucumberRuntime + sourceSets.main.output + sourceSets.test.output
-            args = [
-                '--plugin',
-                'html:cucumber-report',
-                '--plugin',
-                'json:cucumber.json',
-                '--plugin',
-                'pretty',
-                '--plugin',
-                'html:build/cucumber-report.html',
-                '--plugin',
-                'json:build/cucumber-report.json',
-                '--glue',
-                'org.mifos.integrationtest.cucumber',
-                'src/test/java/resources'
-            ]
-        }
-    }
+
+task parallelRun(type: Test) {
+    include '**/TestRunner.class'
+    outputs.upToDateWhen { false }
 }

src/test/java/org/mifos/integrationtest/TestRunner.java

@@ -1,11 +1,36 @@
 package org.mifos.integrationtest;
 
-import io.cucumber.junit.Cucumber;
-import io.cucumber.junit.CucumberOptions;
+import courgette.api.CourgetteAfterAll;
+import courgette.api.CourgetteBeforeAll;
+import courgette.api.CourgetteOptions;
+import courgette.api.CourgetteRunLevel;
+import courgette.api.CourgetteTestOutput;
+import courgette.api.CucumberOptions;
+import courgette.api.junit.Courgette;
 import org.junit.runner.RunWith;
+import org.mifos.integrationtest.config.WireMockServerSingleton;
 
-@RunWith(Cucumber.class)
-@CucumberOptions(features = { "src/test/java/resources" }, glue = { "org.mifos.integrationtest.cucumber" }, plugin = {
-        "html:cucumber-report", "json:cucumber.json", "pretty", "html:build/cucumber-report.html", "json:build/cucumber-report.json",
-        "junit:build/cucumber.xml" })
-public class TestRunner {}
+//@RunWith(Cucumber.class)
+//@CucumberOptions(features = { "src/test/java/resources" }, glue = { "org.mifos.integrationtest.cucumber" }, plugin = {
+//        "html:cucumber-report", "json:cucumber.json", "pretty", "html:build/cucumber-report.html", "json:build/cucumber-report.json",
+//        "junit:build/cucumber.xml" })
+
+@RunWith(Courgette.class)
+@CourgetteOptions(threads = 3, runLevel = CourgetteRunLevel.FEATURE, rerunFailedScenarios = false, testOutput = CourgetteTestOutput.CONSOLE, generateCourgetteRunLog = true,
+
+        reportTitle = "Paymenthub Test results", reportTargetDir = "build", cucumberOptions = @CucumberOptions(features = "src/test/java/resources", glue = "org.mifos.integrationtest.cucumber", tags = "@gov", publish = true, plugin = {
+                "html:cucumber-report", "json:cucumber.json", "pretty", "html:build/cucumber-report.html",
+                "json:build/cucumber-report.json", "junit:build/cucumber.xml" }))
+@SuppressWarnings({ "FinalClass", "HideUtilityClassConstructor" })
+public class TestRunner {
+
+    @CourgetteBeforeAll
+    public static void setupWireMockServer() {
+        WireMockServerSingleton.getInstance(); // Start WireMock server
+    }
+
+    @CourgetteAfterAll
+    public static void stopWireMockServer() {
+        WireMockServerSingleton.getInstance().stop(); // Stop WireMock server
+    }
+}

src/test/java/org/mifos/integrationtest/config/MockServerConfig.java

@@ -11,11 +11,11 @@
 @Slf4j
 public class MockServerConfig implements MockServer {
 
-    private static WireMockServer singleInstance = null;
-
     @Value("${mock-server.port}")
     private int port;
 
+    private static WireMockServer singleInstance = null;
+
     public WireMockServer getMockServer() {
         if (MockServerConfig.singleInstance == null) {
             MockServerConfig.singleInstance = new WireMockServer(wireMockConfig().port(this.port));

src/test/java/org/mifos/integrationtest/config/WireMockServerSingleton.java

@@ -0,0 +1,60 @@
+package org.mifos.integrationtest.config;
+
+import com.github.tomakehurst.wiremock.WireMockServer;
+import com.github.tomakehurst.wiremock.common.FatalStartupException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+
+@Component
+@SuppressWarnings({ "FinalClass", "HideUtilityClassConstructor" })
+public class WireMockServerSingleton {
+
+    static Logger logger = LoggerFactory.getLogger(WireMockServerSingleton.class);
+    private static final ThreadLocal<WireMockServer> threadLocalInstance = new ThreadLocal<>();
+
+    public static WireMockServer getInstance() {
+        WireMockServer instance = threadLocalInstance.get();
+        if (instance == null || !instance.isRunning()) {
+            synchronized (WireMockServerSingleton.class) {
+                instance = threadLocalInstance.get(); // Double-check idiom
+                if (instance == null || !instance.isRunning()) {
+                    instance = startWireMockServerWithRetry(3); // Retry 3 times
+                    threadLocalInstance.set(instance);
+                }
+            }
+        }
+        return instance;
+    }
+
+    private static WireMockServer startWireMockServerWithRetry(int maxRetries) {
+        WireMockServer server = null;
+        for (int attempt = 1; attempt <= maxRetries; attempt++) {
+            int port = getRandomPort();
+            server = new WireMockServer(port);
+            try {
+                server.start();
+                logger.info("WireMock started on port {}", server.port());
+                return server;
+            } catch (FatalStartupException e) {
+                logger.error("Failed to start WireMock on port {} (Attempt {}/{}). Retrying...", port, attempt, maxRetries, e);
+                // Optionally, add a short delay here if needed
+            }
+        }
+        throw new IllegalStateException("Failed to start WireMock server after " + maxRetries + " attempts.");
+    }
+
+    private static int getRandomPort() {
+        // This returns a port number in the range 1024-65535
+        return 1024 + (int) (Math.random() * ((65535 - 1024) + 1));
+    }
+
+    public static int getPort() {
+        WireMockServer instance = threadLocalInstance.get();
+        if (instance != null && instance.isRunning()) {
+            return instance.port();
+        } else {
+            throw new IllegalStateException("WireMock server is not running.");
+        }
+    }
+}

src/test/java/org/mifos/integrationtest/cucumber/stepdef/BaseStepDef.java

@@ -22,10 +22,10 @@
 import org.mifos.integrationtest.config.ChannelConnectorConfig;
 import org.mifos.integrationtest.config.FspConfig;
 import org.mifos.integrationtest.config.IdentityMapperConfig;
-import org.mifos.integrationtest.config.MockServer;
 import org.mifos.integrationtest.config.OperationsAppConfig;
 import org.mifos.integrationtest.config.TenantConfig;
 import org.mifos.integrationtest.config.VoucherManagementConfig;
+import org.mifos.integrationtest.config.WireMockServerSingleton;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -46,9 +46,6 @@ public class BaseStepDef {
     @Autowired
     ChannelConnectorConfig channelConnectorConfig;
 
-    @Autowired
-    MockServer mockServer;
-
     @Autowired
     IdentityMapperConfig identityMapperConfig;
 
@@ -77,6 +74,7 @@ public class BaseStepDef {
 
     @Autowired
     ScenarioScopeState scenarioScopeState;
+    int port = WireMockServerSingleton.getPort();
 
     Logger logger = LoggerFactory.getLogger(this.getClass());
     protected static BatchRequestDTO batchRequestDTO;

src/test/java/org/mifos/integrationtest/cucumber/stepdef/BatchApiStepDef.java

@@ -1,6 +1,5 @@
 package org.mifos.integrationtest.cucumber.stepdef;
 
-import static com.github.tomakehurst.wiremock.client.WireMock.getAllServeEvents;
 import static com.google.common.truth.Truth.assertThat;
 import static java.util.concurrent.TimeUnit.SECONDS;
 import static org.awaitility.Awaitility.await;
@@ -60,6 +59,7 @@
 import org.mifos.integrationtest.config.BulkProcessorConfig;
 import org.mifos.integrationtest.config.ChannelConnectorConfig;
 import org.mifos.integrationtest.config.MockPaymentSchemaConfig;
+import org.mifos.integrationtest.config.WireMockServerSingleton;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.core.env.Environment;
@@ -667,7 +667,7 @@ public void iShouldAssertTotalTxnCountAndSuccessfulTxnCountInPaymentBatchDetailR
     @Then("I should be able to extract response body from callback for batch")
     public void iShouldBeAbleToExtractResponseBodyFromCallbackForBatch() {
         boolean flag = false;
-        List<ServeEvent> allServeEvents = getAllServeEvents();
+        List<ServeEvent> allServeEvents = WireMockServerSingleton.getInstance().getAllServeEvents();
         for (int i = allServeEvents.size() - 1; i >= 0; i--) {
             ServeEvent request = allServeEvents.get(i);
             if (!(request.getRequest().getBodyAsString()).isEmpty()) {