Added logic to support not clearing allure results if not needed. Added Retry logger to track flaky tests in csv file

Author: Ninna994

src/main/java/custom_framework/utils/ExtentReporting.java

@@ -3,11 +3,16 @@
 import com.aventstack.extentreports.ExtentReports;
 import com.aventstack.extentreports.reporter.ExtentSparkReporter;
 
+import java.util.Properties;
+
 public class ExtentReporting {
     static ExtentReports extent;
 
     public static ExtentReports getReportObject() {
         String path = System.getProperty("user.dir") + "\\reports\\index.html";
+        Properties settings = Settings.load("settings.properties");
+        String browser = settings.getProperty("browser");
+        String environment = settings.getProperty("environment");
         ExtentSparkReporter reporter = new ExtentSparkReporter(path);
 
         reporter.config().setReportName("Custom Framework Report Name");
@@ -18,6 +23,10 @@ public static ExtentReports getReportObject() {
         extent.attachReporter(reporter);
         extent.setSystemInfo("Framework creator", "Nikolina Djekic");
         extent.setSystemInfo("Linkedin", "https://www.linkedin.com/in/nikolina-djekic/");
+        extent.setSystemInfo("Browser", System.getProperty("browser", browser));
+        extent.setSystemInfo("Environment", System.getProperty("environment", environment));
+        extent.setSystemInfo("Java Version", System.getProperty("java.version"));
+        extent.setSystemInfo("OS", System.getProperty("os.name"));
         return extent;
     }
 

src/main/java/custom_framework/utils/Listeners.java

@@ -10,6 +10,11 @@
 
 import java.io.FileInputStream;
 import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Comparator;
+import java.util.Properties;
 
 public class Listeners extends SharedMethods implements ITestListener {
 
@@ -19,7 +24,8 @@ public class Listeners extends SharedMethods implements ITestListener {
 
     @Override
     public void onTestStart(ITestResult result) {
-        test = extent.createTest(result.getMethod().getMethodName());
+        String testName = result.getTestClass().getName() + " - " + result.getMethod().getMethodName();
+        test = extent.createTest(testName);
         extentTest.set(test); // to support parallel execution
     }
 
@@ -54,10 +60,47 @@ public void onTestSkipped(ITestResult result) {
         }
     }
 
+    @Override
+    public void onStart(ITestContext context) {
+        if (shouldClearAllureResults()) {
+            clearAllureResultsDirectory();
+        }
+    }
+
     @Override
     public void onFinish(ITestContext context) {
         extent.flush();
         extentTest.remove();
     }
 
+    private boolean shouldClearAllureResults() {
+        Properties properties = new Properties();
+        try {
+            FileInputStream fileInputStream = new FileInputStream("src/main/resources/settings.properties");
+            properties.load(fileInputStream);
+            return Boolean.parseBoolean(properties.getProperty("clear.allure.results"));
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return false; // Default to not clearing if the property cannot be read
+    }
+
+    private void clearAllureResultsDirectory() {
+        Path allureResultsPath = Paths.get("target/allure-results");
+        if (Files.exists(allureResultsPath)) {
+            try (var paths = Files.walk(allureResultsPath)) {
+                paths.sorted(Comparator.reverseOrder())
+                        .forEach(path -> {
+                            try {
+                                Files.delete(path);
+                            } catch (IOException e) {
+                                log.warn("Failed to delete file: {}", path.toAbsolutePath(), e);
+                            }
+                        });
+            } catch (IOException e) {
+                log.error("Failed to clear allure results directory", e);
+            }
+        }
+    }
+
 }

src/main/java/custom_framework/utils/Retry.java

@@ -3,17 +3,22 @@
 import org.testng.IRetryAnalyzer;
 import org.testng.ITestResult;
 
+import java.util.HashMap;
+import java.util.Map;
+
 public class Retry implements IRetryAnalyzer {
 
     private int count = 0;
     private static final int NUMBER_OF_TRIES = 1;
+    private static Map<String, Integer> retryCountMap = new HashMap<>();  // To store retry counts
 
     @Override
     public boolean retry(ITestResult iTestResult) {
         if (!iTestResult.isSuccess()) {                      //Check if test not succeed
             if (count < NUMBER_OF_TRIES) {                   //Check if NUMBER_OF_TRIES count is reached
                 count++;                                     //Increase the maxTry count by 1
                 iTestResult.setStatus(ITestResult.FAILURE);  //Mark test as failed
+                trackRetry(iTestResult);
                 return true;                                 //Tells TestNG to re-run the test
             } else {
                 iTestResult.setStatus(ITestResult.FAILURE);  //If maxCount reached,test marked as failed
@@ -23,4 +28,15 @@ public boolean retry(ITestResult iTestResult) {
         }
         return false;
     }
+
+    private void trackRetry(ITestResult result) {
+        String testName = result.getMethod().getMethodName();
+        int retries = retryCountMap.getOrDefault(testName, 0) + 1;
+        retryCountMap.put(testName, retries);
+    }
+
+    public static Map<String, Integer> getRetryCountMap() {
+        return retryCountMap;
+    }
+
 }

src/main/java/custom_framework/utils/RetryLogger.java

@@ -0,0 +1,58 @@
+package custom_framework.utils;
+
+import java.io.*;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.HashMap;
+import java.util.Map;
+
+public class RetryLogger {
+
+    private static final String LOG_FILE_PATH = "target/retry-log.csv";
+
+    // Read the existing retry data from the CSV file
+    public static Map<String, Integer> readExistingRetryData() {
+        Map<String, Integer> existingData = new HashMap<>();
+        if (Files.exists(Paths.get(LOG_FILE_PATH))) {
+            try (BufferedReader reader = new BufferedReader(new FileReader(LOG_FILE_PATH))) {
+                String line;
+                while ((line = reader.readLine()) != null) {
+                    String[] split = line.split(",");
+                    if (split.length == 2) {
+                        String testName = split[0].trim().replace("Test: ", "");
+                        int retryCount = Integer.parseInt(split[1].trim().replace("Retries: ", ""));
+                        existingData.put(testName, retryCount);
+                    }
+                }
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        return existingData;
+    }
+
+    // Log retry data, updating existing entries if needed
+    public static void logRetryData(Map<String, Integer> retryCountMap) {
+        Map<String, Integer> existingRetryData = readExistingRetryData();
+
+        // Update retry data
+        for (Map.Entry<String, Integer> entry : retryCountMap.entrySet()) {
+            String testName = entry.getKey();
+            int newRetryCount = entry.getValue();
+
+            // If the test already exists in the CSV, update the retry count
+            existingRetryData.put(testName, existingRetryData.getOrDefault(testName, 0) + newRetryCount);
+        }
+
+        // Write updated data back to the CSV
+        try (BufferedWriter writer = new BufferedWriter(new FileWriter(LOG_FILE_PATH))) {
+            for (Map.Entry<String, Integer> entry : existingRetryData.entrySet()) {
+                writer.write("Test: " + entry.getKey() + ", Retries: " + entry.getValue());
+                writer.newLine();
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

src/main/resources/settings.properties

@@ -30,6 +30,7 @@ environment=TEST
 timeout=10
 system=theinternet
 #system=webdriveruniversity
+clear.allure.results=false
 remoteUrl=localhost
 #
 # ==================== WHAT ELSE COULD BE ADDED ====================