Issue #237 parse flakyFailure and rerunFailure from surefire report files

pom.xml

@@ -198,6 +198,12 @@
       <artifactId>mockito-core</artifactId>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>org.xmlunit</groupId>
+      <artifactId>xmlunit-core</artifactId>
+      <version>2.11.0</version>
+      <scope>test</scope>
+    </dependency>
   </dependencies>
 
   <repositories>

src/main/java/hudson/tasks/junit/CaseResult.java

@@ -84,6 +84,8 @@
     private String errorStackTrace;
     private String errorDetails;
     private Map<String, String> properties;
+    private List<FlakyFailure> flakyFailures;
+    private List<RerunFailure> rerunFailures;
 
     @SuppressFBWarnings(value = "SE_TRANSIENT_FIELD_NOT_RESTORED", justification = "Specific method to restore it")
     private transient SuiteResult parent;
@@ -247,6 +249,8 @@
         }
         this.properties = properties;
         this.keepTestNames = keepTestNames;
+        this.flakyFailures = parseFlakyFailures(testCase);
+        this.rerunFailures = parseRerunFailures(testCase);
     }
 
     public CaseResult(CaseResult src) {
@@ -263,12 +267,46 @@
         this.stderr = src.stderr;
         this.properties = new HashMap<>();
         this.properties.putAll(src.properties);
+        this.flakyFailures = src.flakyFailures;
+        this.rerunFailures = src.rerunFailures;
     }
 
     public static float clampDuration(float d) {
         return Math.min(365.0f * 24 * 60 * 60, Math.max(0.0f, d));
     }
 
+    private static List<FlakyFailure> parseFlakyFailures(Element testCase) {
+        List<FlakyFailure> flakyFailures = new ArrayList<>();
+        List<Element> flakyFailuresElements = testCase.elements("flakyFailure");
+        if (flakyFailuresElements != null) {
+            for (Element flakyFailuresElement : flakyFailuresElements) {
+                String message = flakyFailuresElement.attributeValue("message");
+                String type = flakyFailuresElement.attributeValue("type");
+                String stackTrace = flakyFailuresElement.elementText("stackTrace");
+                String stdout = flakyFailuresElement.elementText("system-out");
+                String stderr = flakyFailuresElement.elementText("system-err");
+                flakyFailures.add(new FlakyFailure(message, type, stackTrace, stdout, stderr));
+            }
+        }
+        return flakyFailures;
+    }
+
+    private static List<RerunFailure> parseRerunFailures(Element testCase) {
+        List<RerunFailure> rerunFailures = new ArrayList<>();
+        List<Element> rerunFailureElements = testCase.elements("rerunFailure");
+        if (rerunFailureElements != null) {
+            for (Element rerunFailureElement : rerunFailureElements) {
+                String message = rerunFailureElement.attributeValue("message");
+                String type = rerunFailureElement.attributeValue("type");
+                String stackTrace = rerunFailureElement.elementText("stackTrace");
+                String stdout = rerunFailureElement.elementText("system-out");
+                String stderr = rerunFailureElement.elementText("system-err");
+                rerunFailures.add(new RerunFailure(message, type, stackTrace, stdout, stderr));
+            }
+        }
+        return rerunFailures;
+    }
+
     static CaseResult parse(SuiteResult parent, final XMLStreamReader reader, String context, String ver)
             throws XMLStreamException {
         CaseResult r = new CaseResult(parent, null, null, null);
@@ -320,6 +358,12 @@
                         r.properties = new HashMap<>();
                         parseProperties(r.properties, reader, context, ver);
                         break;
+                    case "flakyFailures":
+                        r.flakyFailures = parseFlakyFailures(reader, context, ver);
+                        break;
+                    case "rerunFailures":
+                        r.rerunFailures = parseRerunFailures(reader, context, ver);
+                        break;
                     default:
                         LOGGER.finest(() -> "Unknown field in " + context + ": " + elementName);
                 }
@@ -328,6 +372,126 @@
         return r;
     }
 
+    static List<FlakyFailure> parseFlakyFailures(final XMLStreamReader reader, String context, String ver)
+            throws XMLStreamException {
+        List<FlakyFailure> flakyFailures = new ArrayList<>();
+        while (reader.hasNext()) {
+            final int event = reader.next();
+            if (event == XMLStreamReader.END_ELEMENT && reader.getLocalName().equals("flakyFailures")) {
+                break;
+            }
+            if (event == XMLStreamReader.START_ELEMENT) {
+                final String elementName = reader.getLocalName();
+                switch (elementName) {
+                    case "flakyFailure":
+                        flakyFailures.add(parseFlakyFailure(reader, context, ver));
+                        break;
+                    default:
+                        LOGGER.finest(() -> "Unknown field in " + context + ": " + elementName);
+                }
+            }
+        }
+        return flakyFailures;
+    }
+
+    public static FlakyFailure parseFlakyFailure(XMLStreamReader reader, String context, String ver)
+            throws XMLStreamException {
+        String message = null;
+        String type = null;
+        String stackTrace = null;
+        String stdout = null;
+        String stderr = null;
+        while (reader.hasNext()) {
+            int event = reader.next();
+            if (event == XMLStreamReader.END_ELEMENT && "flakyFailure".equals(reader.getLocalName())) {
+                break;
+            }
+            if (event == XMLStreamReader.START_ELEMENT) {
+                String elementName = reader.getLocalName();
+                switch (elementName) {
+                    case "message":
+                        message = reader.getElementText();
+                        break;
+                    case "type":
+                        type = reader.getElementText();
+                        break;
+                    case "stackTrace":
+                        stackTrace = reader.getElementText();
+                        break;
+                    case "stdout":
+                        stdout = reader.getElementText();
+                        break;
+                    case "stderr":
+                        stderr = reader.getElementText();
+                        break;
+                    default:
+                        LOGGER.finest(() -> "Unknown field in " + context + ": " + elementName);
+                }
+            }
+        }
+        return new FlakyFailure(message, type, stackTrace, stdout, stderr);
+    }
+
+    static List<RerunFailure> parseRerunFailures(final XMLStreamReader reader, String context, String ver)
+            throws XMLStreamException {
+        List<RerunFailure> rerunFailures = new ArrayList<>();
+        while (reader.hasNext()) {
+            final int event = reader.next();
+            if (event == XMLStreamReader.END_ELEMENT && reader.getLocalName().equals("rerunFailures")) {
+                break;
+            }
+            if (event == XMLStreamReader.START_ELEMENT) {
+                final String elementName = reader.getLocalName();
+                switch (elementName) {
+                    case "rerunFailure":
+                        rerunFailures.add(parseRerunFailure(reader, context, ver));
+                        break;
+                    default:
+                        LOGGER.finest(() -> "Unknown field in " + context + ": " + elementName);
+                }
+            }
+        }
+        return rerunFailures;
+    }
+
+    public static RerunFailure parseRerunFailure(XMLStreamReader reader, String context, String ver)
+            throws XMLStreamException {
+        String message = null;
+        String type = null;
+        String stackTrace = null;
+        String stdout = null;
+        String stderr = null;
+        while (reader.hasNext()) {
+            int event = reader.next();
+            if (event == XMLStreamReader.END_ELEMENT && "rerunFailure".equals(reader.getLocalName())) {
+                break;
+            }
+            if (event == XMLStreamReader.START_ELEMENT) {
+                String elementName = reader.getLocalName();
+                switch (elementName) {
+                    case "message":
+                        message = reader.getElementText();
+                        break;
+                    case "type":
+                        type = reader.getElementText();
+                        break;
+                    case "stackTrace":
+                        stackTrace = reader.getElementText();
+                        break;
+                    case "stdout":
+                        stdout = reader.getElementText();
+                        break;
+                    case "stderr":
+                        stderr = reader.getElementText();
+                        break;
+                    default:
+                        LOGGER.finest(() -> "Unknown field in " + context + ": " + elementName);
+                }
+            }
+        }
+        return new RerunFailure(message, type, stackTrace, stdout, stderr);
+    }
+
     static void parseProperties(Map<String, String> r, final XMLStreamReader reader, String context, String ver)
             throws XMLStreamException {
         while (reader.hasNext()) {
@@ -1040,6 +1204,18 @@
         this.parent = parent;
     }
 
+    @Exported
+    @Override
+    public List<FlakyFailure> getFlakyFailures() {
+        return flakyFailures == null ? Collections.emptyList() : Collections.unmodifiableList(flakyFailures);
+    }
+
+    @Exported
+    @Override
+    public List<RerunFailure> getRerunFailures() {
+        return rerunFailures == null ? Collections.emptyList() : Collections.unmodifiableList(rerunFailures);
+    }
+
     /**
      * Constants that represent the status of this test.
      */

src/main/java/hudson/tasks/junit/FlakyFailure.java

@@ -0,0 +1,63 @@
+package hudson.tasks.junit;
+
+import java.io.Serializable;
+import org.kohsuke.stapler.export.ExportedBean;
+
+@ExportedBean
+public class FlakyFailure implements Serializable {
+    private String message;
+    private String type;
+    private String stackTrace;
+    private String stdout;
+    private String stderr;
+
+    public FlakyFailure() {}
+
+    public FlakyFailure(String message, String type, String stackTrace, String stdout, String stderr) {
+        this.message = message;
+        this.type = type;
+        this.stackTrace = stackTrace;
+        this.stdout = stdout;
+        this.stderr = stderr;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public void setType(String type) {
+        this.type = type;
+    }
+
+    public String getStackTrace() {
+        return stackTrace;
+    }
+
+    public void setStackTrace(String stackTrace) {
+        this.stackTrace = stackTrace;
+    }
+
+    public String getStdout() {
+        return stdout;
+    }
+
+    public void setStdout(String stdout) {
+        this.stdout = stdout;
+    }
+
+    public String getStderr() {
+        return stderr;
+    }
+
+    public void setStderr(String stderr) {
+        this.stderr = stderr;
+    }
+}

src/main/java/hudson/tasks/junit/RerunFailure.java

@@ -0,0 +1,61 @@
+package hudson.tasks.junit;
+
+import java.io.Serializable;
+
+public class RerunFailure implements Serializable {
+    private String message;
+    private String type;
+    private String stackTrace;
+    private String stdout;
+    private String stderr;
+
+    public RerunFailure() {}
+
+    public RerunFailure(String message, String type, String stackTrace, String stdout, String stderr) {
+        this.message = message;
+        this.type = type;
+        this.stackTrace = stackTrace;
+        this.stdout = stdout;
+        this.stderr = stderr;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public void setType(String type) {
+        this.type = type;
+    }
+
+    public String getStackTrace() {
+        return stackTrace;
+    }
+
+    public void setStackTrace(String stackTrace) {
+        this.stackTrace = stackTrace;
+    }
+
+    public String getStdout() {
+        return stdout;
+    }
+
+    public void setStdout(String stdout) {
+        this.stdout = stdout;
+    }
+
+    public String getStderr() {
+        return stderr;
+    }
+
+    public void setStderr(String stderr) {
+        this.stderr = stderr;
+    }
+}

src/main/java/hudson/tasks/junit/TestResultAction.java

@@ -427,6 +427,8 @@ public Widget getWidget() {
         XSTREAM.alias("result", TestResult.class);
         XSTREAM.alias("suite", SuiteResult.class);
         XSTREAM.alias("case", CaseResult.class);
+        XSTREAM.alias("flakyFailure", FlakyFailure.class);
+        XSTREAM.alias("rerunFailure", RerunFailure.class);
         XSTREAM.registerConverter(new HeapSpaceStringConverter(), 100);
     }
 }

src/main/java/hudson/tasks/test/TestResult.java

@@ -26,9 +26,12 @@
 import hudson.model.Job;
 import hudson.model.Result;
 import hudson.model.Run;
+import hudson.tasks.junit.FlakyFailure;
+import hudson.tasks.junit.RerunFailure;
 import hudson.tasks.junit.TestAction;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.List;
 import java.util.Map;
 import java.util.logging.Level;
 import java.util.logging.Logger;
@@ -263,6 +266,14 @@
         return Collections.emptyMap();
     }
 
+    public List<FlakyFailure> getFlakyFailures() {
+        return Collections.emptyList();
+    }
+
+    public List<RerunFailure> getRerunFailures() {
+        return Collections.emptyList();
+    }
+
     /**
      * @return true if the test was not skipped and did not fail, false otherwise.
      */