Replace old GitHub action with updated one.

.github/workflows/ci.yml

@@ -0,0 +1,37 @@
+name: 'GitHub CI'
+
+on:
+  push:
+    branches:
+      - master
+      - main
+  pull_request:
+
+jobs:
+  build:
+
+    strategy:
+      matrix:
+        platform: [ubuntu-latest, macos-latest, windows-latest]
+        jdk: [17, 21]
+
+    runs-on: ${{ matrix.platform }}
+    name: on ${{ matrix.platform }} with JDK ${{ matrix.jdk }}
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up JDK ${{ matrix.jdk }}
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '${{ matrix.jdk }}'
+          check-latest: true
+          cache: 'maven'
+      - name: Set up Maven
+        uses: stCarolas/setup-maven@v5
+        with:
+          maven-version: 3.9.6
+      - name: Build with Maven
+        env:
+          BROWSER: chrome-container
+        run: mvn -V --color always -ntp clean verify --file pom.xml '-Djenkins.test.timeout=5000' '-Dgpg.skip'

Jenkinsfile

@@ -1,8 +1,13 @@
 def configurations = [
-  [ platform: "linux", jdk: "11" ],
-  [ platform: "windows", jdk: "11" ]
+  [ platform: "linux", jdk: "21" ],
+  [ platform: "windows", jdk: "17" ]
 ]
 
-buildPlugin(failFast: false, configurations: configurations,
+def params = [
+    failFast: false,
+    configurations: configurations,
     checkstyle: [qualityGates: [[threshold: 1, type: 'NEW', unstable: true]]],
-    pmd: [qualityGates: [[threshold: 1, type: 'NEW', unstable: true]]] )
+    spotbugs: [qualityGates: [[threshold: 1, type: 'NEW', unstable: true]]]
+]
+
+buildPlugin(params)

src/main/java/io/jenkins/plugins/checks/status/FlowExecutionAnalyzer.java

@@ -89,7 +89,7 @@ private Pair<String, String> processStageOrBranchRow(final FlowGraphTable.Row ro
         if (row.getNode().isActive()) {
             nodeTextBuilder.append(" *(running)*");
         }
-        else if (row.getDurationMillis() > 0) {
+        else {
             nodeTextBuilder.append(String.format(" *(%s)*", row.getDurationString()));
         }
         nodeTextBuilder.append("\n");

src/test/java/io/jenkins/plugins/checks/status/BuildStatusChecksPublisherITest.java

@@ -31,21 +31,20 @@
  */
 @SuppressWarnings({"PMD.AddEmptyString", "checkstyle:LambdaBodyLength"})
 @SuppressFBWarnings("NP_NONNULL_FIELD_NOT_INITIALIZED_IN_CONSTRUCTOR")
 class BuildStatusChecksPublisherITest extends IntegrationTestWithJenkinsPerTest {
-
     private CapturingChecksPublisher.Factory getFactory() {
         return getJenkins().getInstance().getExtensionList(ChecksPublisherFactory.class)
                 .stream()
                 .filter(f -> f instanceof CapturingChecksPublisher.Factory)
                 .map(f -> (CapturingChecksPublisher.Factory) f)
                 .findAny()
                 .orElseThrow(() -> new AssertionError("No CapturingChecksPublisher registered as @TestExtension?"));
     }
 
     /**
      * Clean captured checks between tests.
      */
     @AfterEach
     public void clearChecks() {
         getFactory().getPublishedChecks().clear();
     }
@@ -100,19 +99,19 @@
 
         ChecksDetails details = getFactory().getPublishedChecks().get(0);
 
-        assertThat(details.getName()).isPresent().get().isEqualTo("Test Status");
+        assertThat(details.getName()).contains("Test Status");
         assertThat(details.getStatus()).isEqualTo(ChecksStatus.QUEUED);
         assertThat(details.getConclusion()).isEqualTo(ChecksConclusion.NONE);
 
         details = getFactory().getPublishedChecks().get(1);
 
-        assertThat(details.getName()).isPresent().get().isEqualTo("Test Status");
+        assertThat(details.getName()).contains("Test Status");
         assertThat(details.getStatus()).isEqualTo(ChecksStatus.IN_PROGRESS);
         assertThat(details.getConclusion()).isEqualTo(ChecksConclusion.NONE);
 
         details = getFactory().getPublishedChecks().get(2);
 
-        assertThat(details.getName()).isPresent().get().isEqualTo("Test Status");
+        assertThat(details.getName()).contains("Test Status");
         assertThat(details.getStatus()).isEqualTo(ChecksStatus.COMPLETED);
         assertThat(details.getConclusion()).isEqualTo(ChecksConclusion.SUCCESS);
     }
@@ -156,34 +155,34 @@
         ChecksDetails details = checksDetails.get(0);
         assertThat(details.getStatus()).isEqualTo(ChecksStatus.QUEUED);
         assertThat(details.getConclusion()).isEqualTo(ChecksConclusion.NONE);
-        assertThat(details.getName()).isPresent().contains("Test Status");
+        assertThat(details.getName()).contains("Test Status");
         assertThat(details.getOutput()).isNotPresent();
 
         // Details 1, first stage
         details = checksDetails.get(1);
         assertThat(details.getStatus()).isEqualTo(ChecksStatus.IN_PROGRESS);
         assertThat(details.getConclusion()).isEqualTo(ChecksConclusion.NONE);
         assertThat(details.getOutput()).isPresent().get().satisfies(output -> {
-            assertThat(output.getTitle()).isPresent().contains("In progress");
+            assertThat(output.getTitle()).contains("In progress");
             assertThat(output.getSummary()).isPresent().get().satisfies(StringUtils::isBlank);
             assertThat(output.getText()).isPresent().get().asString().contains("* Simple Stage *(running)*");
         });
 
         // Details 2, first stage finished, parallel started
         details = checksDetails.get(2);
         assertThat(details.getOutput()).isPresent().get().satisfies(output -> {
+            assertThat(output.getTitle()).contains("In progress");
             assertThat(output.getSummary()).isPresent().get().satisfies(StringUtils::isBlank);
             assertThat(output.getText()).isPresent().get().satisfies(text -> {
-                assertThat(output.getTitle()).isPresent().contains("In progress");
-                assertThat(text).doesNotContain("* Simple Stage *(running)*");
-                assertThat(text).contains("* Simple Stage", "* In parallel *(running)*");
+                assertThat(text).matches(Pattern.compile(".*\\* Simple Stage \\*\\([^)]+\\)\\*.*", Pattern.DOTALL));
+                assertThat(text).contains("  * In parallel *(running)*");
             });
         });
 
         // Details 6, p1s1 has finished and emitted unstable
         details = checksDetails.get(6);
         assertThat(details.getOutput()).isPresent().get().satisfies(output -> {
-            assertThat(output.getTitle()).isPresent().contains("In parallel/p1/p1s1: warning in 'unstable' step");
+            assertThat(output.getTitle()).contains("In parallel/p1/p1s1: warning in 'unstable' step");
             assertThat(output.getSummary()).isPresent().get().asString().isEqualToIgnoringNewLines(""
                     + "### `In parallel / p1 / p1s1 / Set stage result to unstable`\n"
                     + "Warning in `unstable` step, with arguments `something went wrong`.\n"
@@ -192,21 +191,21 @@
                     + "```\n"
                     + "\n");
             assertThat(output.getText()).isPresent().get().asString().matches(Pattern.compile(".*"
-                    + "  \\* Simple Stage \\*\\([^)]+\\)\\*\n"
-                    + "  \\* In parallel \\*\\(running\\)\\*\n"
-                    + "    \\* p1 \\*\\(running\\)\\*\n"
-                    + "      \\* p1s1 \\*\\([^)]+\\)\\*\n"
-                    + "        \\*\\*Unstable\\*\\*: \\*something went wrong\\*\n"
-                    + "      \\* p1s2 \\*\\(running\\)\\*\n"
-                    + "    \\* p2 \\*\\([^)]+\\)\\*\n.*", Pattern.DOTALL));
+                    + "  \\* Simple Stage \\*\\([^)]+\\)\\*\\s+"
+                    + "  \\* In parallel \\*\\(running\\)\\*\\s+"
+                    + "    \\* p1 \\*\\(running\\)\\*\\s+"
+                    + "      \\* p1s1 \\*\\([^)]+\\)\\*\\s+"
+                    + "        \\*\\*Unstable\\*\\*: \\*something went wrong\\*\\s+"
+                    + "      \\* p1s2 \\*\\(running\\)\\*\\s+"
+                    + "    \\* p2 \\*\\([^)]+\\)\\*\\s+.*", Pattern.DOTALL));
         });
 
         // Details 8, final checks
         details = checksDetails.get(8);
         assertThat(details.getStatus()).isEqualTo(ChecksStatus.COMPLETED);
         assertThat(details.getConclusion()).isEqualTo(ChecksConclusion.FAILURE);
         assertThat(details.getOutput()).isPresent().get().satisfies(output -> {
-            assertThat(output.getTitle()).isPresent().get().isEqualTo("Fails: error in 'error' step");
+            assertThat(output.getTitle()).contains("Fails: error in 'error' step");
             assertThat(output.getSummary()).isPresent().get().asString().matches(Pattern.compile(".*"
                     + "### `In parallel / p1 / p1s1 / Set stage result to unstable`\\s+"
                     + "Warning in `unstable` step, with arguments `something went wrong`\\.\\s+"
@@ -218,16 +217,16 @@
                     + "```\\s+"
                     + "a fatal error occurs\\s+"
                     + "```\\s+", Pattern.DOTALL));
-            assertThat(output.getText()).isPresent().asString().matches(Pattern.compile(".*"
-                            + "  \\* Simple Stage \\*\\([^)]+\\)\\*\n"
-                            + "  \\* In parallel \\*\\([^)]+\\)\\*\n"
-                            + "    \\* p1 \\*\\([^)]+\\)\\*\n"
-                            + "      \\* p1s1 \\*\\([^)]+\\)\\*\n"
-                            + "        \\*\\*Unstable\\*\\*: \\*something went wrong\\*\n"
-                            + "      \\* p1s2 \\*\\([^)]+\\)\\*\n"
-                            + "    \\* p2 \\*\\([^)]+\\)\\*\n"
-                            + "  \\* Fails \\*\\([^)]+\\)\\*\n"
-                            + "    \\*\\*Error\\*\\*: \\*a fatal error occurs\\*\n.*",
+            assertThat(output.getText()).isPresent().get().asString().matches(Pattern.compile(".*"
+                            + "  \\* Simple Stage \\*\\([^)]+\\)\\*\\s+"
+                            + "  \\* In parallel \\*\\([^)]+\\)\\*\\s+"
+                            + "    \\* p1 \\*\\([^)]+\\)\\*\\s+"
+                            + "      \\* p1s1 \\*\\([^)]+\\)\\*\\s+"
+                            + "        \\*\\*Unstable\\*\\*: \\*something went wrong\\*\\s+"
+                            + "      \\* p1s2 \\*\\([^)]+\\)\\*\\s+"
+                            + "    \\* p2 \\*\\([^)]+\\)\\*\\s+"
+                            + "  \\* Fails \\*\\([^)]+\\)\\*\\s+"
+                            + "    \\*\\*Error\\*\\*: \\*a fatal error occurs\\*\\s+.*",
                     Pattern.DOTALL));
         });
     }
@@ -271,7 +270,7 @@
         assertThat(details.getStatus()).isEqualTo(ChecksStatus.COMPLETED);
         assertThat(details.getConclusion()).isEqualTo(ChecksConclusion.FAILURE);
         assertThat(details.getOutput()).isPresent().get().satisfies(output -> {
-            assertThat(output.getTitle()).isPresent().get().isEqualTo("Fails: error in 'archiveArtifacts' step");
+            assertThat(output.getTitle()).contains("Fails: error in 'archiveArtifacts' step");
             assertThat(output.getSummary()).isPresent().get().asString().matches(Pattern.compile(".*"
                     + "### `In parallel / p1 / p1s1 / Set stage result to unstable`\\s+"
                     + "Warning in `unstable` step, with arguments `something went wrong`\\.\\s+"
@@ -284,15 +283,15 @@
                     + "No artifacts found that match the file pattern \"oh dear\"\\. Configuration error\\?\\s+"
                     + "```\\s+", Pattern.DOTALL));
             assertThat(output.getText()).isPresent().asString().matches(Pattern.compile(".*"
-                            + "  \\* Simple Stage \\*\\([^)]+\\)\\*\n"
-                            + "  \\* In parallel \\*\\([^)]+\\)\\*\n"
-                            + "    \\* p1 \\*\\([^)]+\\)\\*\n"
-                            + "      \\* p1s1 \\*\\([^)]+\\)\\*\n"
-                            + "        \\*\\*Unstable\\*\\*: \\*something went wrong\\*\n"
-                            + "      \\* p1s2 \\*\\([^)]+\\)\\*\n"
-                            + "    \\* p2 \\*\\([^)]+\\)\\*\n"
-                            + "  \\* Fails \\*\\([^)]+\\)\\*\n"
-                            + "    \\*\\*Error\\*\\*: \\*No artifacts found that match the file pattern \"oh dear\". Configuration error\\?\\*\n.*",
+                            + "  \\* Simple Stage \\*\\([^)]+\\)\\*\\s+"
+                            + "  \\* In parallel \\*\\([^)]+\\)\\*\\s+"
+                            + "    \\* p1 \\*\\([^)]+\\)\\*\\s+"
+                            + "      \\* p1s1 \\*\\([^)]+\\)\\*\\s+"
+                            + "        \\*\\*Unstable\\*\\*: \\*something went wrong\\*\\s+"
+                            + "      \\* p1s2 \\*\\([^)]+\\)\\*\\s+"
+                            + "    \\* p2 \\*\\([^)]+\\)\\*\\s+"
+                            + "  \\* Fails \\*\\([^)]+\\)\\*\\s+"
+                            + "    \\*\\*Error\\*\\*: \\*No artifacts found that match the file pattern \"oh dear\". Configuration error\\?\\*\\s+.*",
                     Pattern.DOTALL));
         });
     }
@@ -317,7 +316,7 @@
         List<ChecksDetails> checksDetails = getFactory().getPublishedChecks();
 
         ChecksDetails details = checksDetails.get(1);
-        assertThat(details.getOutput()).isPresent().get().satisfies(output -> assertThat(output.getTitle()).isPresent().get().isEqualTo("Success"));
+        assertThat(details.getOutput()).isPresent().get().satisfies(output -> assertThat(output.getTitle()).contains("Success"));
     }
 
     /**