Add capturing checks publisher, make publishChecks withChecksName aware

src/main/java/io/jenkins/plugins/checks/api/test/CapturingChecksPublisher.java

@@ -0,0 +1,62 @@
+package io.jenkins.plugins.checks.api.test;
+
+import hudson.ExtensionList;
+import hudson.model.Job;
+import hudson.model.Run;
+import hudson.model.TaskListener;
+import io.jenkins.plugins.checks.api.ChecksDetails;
+import io.jenkins.plugins.checks.api.ChecksPublisher;
+import io.jenkins.plugins.checks.api.ChecksPublisherFactory;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Implementation of {@link ChecksPublisher} for use in testing, that records each captured checks in a simple list.
+ *
+ * For example:
+ *
+ * <pre>
+ * public class ChecksPublishingTest {
+ *     &#64;TestExtension
+ *     public static final CapturingChecksPublisher.Factory PUBLISHER_FACTORY = new CapturingChecksPublisher.Factory();
+ *
+ *     &#64;After
+ *     public void clearPublishedChecks() {
+ *         PUBLISHER_FACTORY.getPublishedChecks().clear();
+ *     }
+ * }
+ * </pre>
+ */
+public class CapturingChecksPublisher extends ChecksPublisher {
+
+    private final List<ChecksDetails> publishedChecks = new ArrayList<>();
+
+    @Override
+    public void publish(final ChecksDetails details) {
+        publishedChecks.add(details);
+    }
+
+    /**
+     * Implementation of {@link ChecksPublisherFactory} that returns a {@link CapturingChecksPublisher}.
+     */
+    public static class Factory extends ChecksPublisherFactory {
+
+        private final CapturingChecksPublisher publisher = new CapturingChecksPublisher();
+
+        @Override
+        protected Optional<ChecksPublisher> createPublisher(final Run<?, ?> run, final TaskListener listener) {
+            return Optional.of(publisher);
+        }
+
+        @Override
+        protected Optional<ChecksPublisher> createPublisher(final Job<?, ?> job, final TaskListener listener) {
+            return Optional.of(publisher);
+        }
+
+        public List<ChecksDetails> getPublishedChecks() {
+            return ExtensionList.lookup(Factory.class).get(0).publisher.publishedChecks;
+        }
+    }
+}

src/main/java/io/jenkins/plugins/checks/api/test/package-info.java

@@ -0,0 +1,8 @@
+/**
+ * Provides default Findbugs annotations.
+ */
+@DefaultAnnotation(NonNull.class)
+package io.jenkins.plugins.checks.api.test;
+
+import edu.umd.cs.findbugs.annotations.DefaultAnnotation;
+import edu.umd.cs.findbugs.annotations.NonNull;

src/main/java/io/jenkins/plugins/checks/steps/PublishChecksStep.java

@@ -3,6 +3,7 @@
 import edu.hm.hafner.util.VisibleForTesting;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import hudson.Extension;
+import hudson.Util;
 import hudson.model.Run;
 import hudson.model.TaskListener;
 import hudson.util.ListBoxModel;
@@ -180,9 +181,16 @@ protected Void run() throws IOException, InterruptedException {
         }
 
         @VisibleForTesting
-        ChecksDetails extractChecksDetails() {
+        ChecksDetails extractChecksDetails() throws IOException, InterruptedException {
+            // If a checks name has been provided as part of the step, use that.
+            // If not, check to see if there is an active ChecksInfo context (e.g. from withChecks).
+            String checksName = Optional.ofNullable(Util.fixEmpty(step.getName())).orElse(
+                    Optional.ofNullable(getContext().get(ChecksInfo.class))
+                            .map(ChecksInfo::getName)
+                            .orElse(StringUtils.EMPTY)
+            );
             return new ChecksDetails.ChecksDetailsBuilder()
-                    .withName(step.getName())
+                    .withName(checksName)
                     .withStatus(step.getStatus())
                     .withConclusion(step.getConclusion())
                     .withDetailsURL(step.getDetailsURL())

src/test/java/io/jenkins/plugins/checks/steps/PublishChecksStepITest.java

@@ -1,23 +1,37 @@
 package io.jenkins.plugins.checks.steps;
 
+import io.jenkins.plugins.checks.api.ChecksConclusion;
+import io.jenkins.plugins.checks.api.ChecksDetails;
+import io.jenkins.plugins.checks.api.ChecksStatus;
+import io.jenkins.plugins.checks.api.test.CapturingChecksPublisher;
 import io.jenkins.plugins.util.IntegrationTestWithJenkinsPerTest;
 import org.jenkinsci.plugins.workflow.job.WorkflowJob;
 import org.junit.Test;
 import org.jvnet.hudson.test.JenkinsRule;
+import org.jvnet.hudson.test.TestExtension;
 
 import java.io.IOException;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.eq;
 
 /**
  * Tests the pipeline step to publish checks.
  */
 public class PublishChecksStepITest extends IntegrationTestWithJenkinsPerTest {
+
+    /**
+     * Provide a {@link CapturingChecksPublisher} to check published checks on each test.
+     */
+    @TestExtension
+    public static final CapturingChecksPublisher.Factory PUBLISHER_FACTORY = new CapturingChecksPublisher.Factory();
+
     /**
      * Tests that the step "publishChecks" can be used in pipeline script.
      *
      * @throws IOException if fails get log from run
      */
+    @SuppressWarnings("OptionalGetWithoutIsPresent")
     @Test
     public void shouldPublishChecksWhenUsingPipeline() throws IOException {
         WorkflowJob job = createPipeline();
@@ -26,7 +40,17 @@ public void shouldPublishChecksWhenUsingPipeline() throws IOException {
                 + "text: 'Pipeline support for checks', status: 'IN_PROGRESS', conclusion: 'NONE'"));
 
         assertThat(JenkinsRule.getLog(buildSuccessfully(job)))
-                .contains("[Pipeline] publishChecks")
-                .contains("[Checks API] No suitable checks publisher found.");
+                .contains("[Pipeline] publishChecks");
+
+        assertThat(PUBLISHER_FACTORY.getPublishedChecks().size()).isEqualTo(1);
+
+        ChecksDetails details = PUBLISHER_FACTORY.getPublishedChecks().get(0);
+
+        assertThat(details.getName().get()).isEqualTo("customized-check");
+        assertThat(details.getOutput().get().getTitle().get()).isEqualTo("Publish Checks Step");
+        assertThat(details.getOutput().get().getSummary().get()).isEqualTo("customized check created in pipeline");
+        assertThat(details.getOutput().get().getText().get()).isEqualTo("Pipeline support for checks");
+        assertThat(details.getStatus()).isEqualTo(ChecksStatus.IN_PROGRESS);
+        assertThat(details.getConclusion()).isEqualTo(ChecksConclusion.NONE);
     }
 }

src/test/java/io/jenkins/plugins/checks/steps/WithChecksStepITest.java

@@ -1,9 +1,14 @@
 package io.jenkins.plugins.checks.steps;
 
 import hudson.model.Run;
+import io.jenkins.plugins.checks.api.ChecksConclusion;
+import io.jenkins.plugins.checks.api.ChecksDetails;
+import io.jenkins.plugins.checks.api.ChecksStatus;
+import io.jenkins.plugins.checks.api.test.CapturingChecksPublisher;
 import io.jenkins.plugins.util.IntegrationTestWithJenkinsPerTest;
 import org.jenkinsci.plugins.workflow.job.WorkflowJob;
 import org.jenkinsci.plugins.workflow.steps.*;
+import org.junit.After;
 import org.junit.Test;
 import org.jvnet.hudson.test.TestExtension;
 import org.kohsuke.stapler.DataBoundConstructor;
@@ -20,6 +25,7 @@
  * Tests the "withChecks" step.
  */
 public class WithChecksStepITest extends IntegrationTestWithJenkinsPerTest {
+
     /**
      * Tests that the step can inject the {@link ChecksInfo} into the closure.
      */
@@ -31,6 +37,68 @@ public void shouldInjectChecksInfoIntoClosure() {
         buildSuccessfully(job);
     }
 
+    /**
+     * Provide a {@link CapturingChecksPublisher} to check published checks on each test.
+     */
+    @TestExtension
+    public static final CapturingChecksPublisher.Factory PUBLISHER_FACTORY = new CapturingChecksPublisher.Factory();
+
+    /**
+     * Clear captured checks on the {@link WithChecksStepITest#PUBLISHER_FACTORY} after each test.
+     */
+    @After
+    public void clearPublisher() {
+        PUBLISHER_FACTORY.getPublishedChecks().clear();
+    }
+
+    /**
+     * Test that the publishChecks step picks up names from the withChecks context.
+     */
+    @SuppressWarnings("OptionalGetWithoutIsPresent")
+    @Test
+    public void publishChecksShouldTakeNameFromWithChecks() {
+        WorkflowJob job = createPipeline();
+        job.setDefinition(asStage("withChecks('test injection') { publishChecks() }"));
+
+        buildSuccessfully(job);
+
+        assertThat(PUBLISHER_FACTORY.getPublishedChecks().size()).isEqualTo(2);
+        ChecksDetails autoChecks = PUBLISHER_FACTORY.getPublishedChecks().get(0);
+        ChecksDetails manualChecks = PUBLISHER_FACTORY.getPublishedChecks().get(1);
+
+        assertThat(autoChecks.getName().get()).isEqualTo("test injection");
+        assertThat(autoChecks.getStatus()).isEqualTo(ChecksStatus.IN_PROGRESS);
+        assertThat(autoChecks.getConclusion()).isEqualTo(ChecksConclusion.NONE);
+
+        assertThat(manualChecks.getName().get()).isEqualTo("test injection");
+        assertThat(manualChecks.getStatus()).isEqualTo(ChecksStatus.COMPLETED);
+        assertThat(manualChecks.getConclusion()).isEqualTo(ChecksConclusion.SUCCESS);
+    }
+
+    /**
+     * Tests that withChecks step ignores names from the withChecks context if one has been explicitly set.
+     */
+    @SuppressWarnings("OptionalGetWithoutIsPresent")
+    @Test
+    public void publishChecksShouldTakeNameFromWithChecksUnlessOverridden() {
+        WorkflowJob job = createPipeline();
+        job.setDefinition(asStage("withChecks('test injection') { publishChecks name: 'test override' }"));
+
+        buildSuccessfully(job);
+
+        assertThat(PUBLISHER_FACTORY.getPublishedChecks().size()).isEqualTo(2);
+        ChecksDetails autoChecks = PUBLISHER_FACTORY.getPublishedChecks().get(0);
+        ChecksDetails manualChecks = PUBLISHER_FACTORY.getPublishedChecks().get(1);
+
+        assertThat(autoChecks.getName().get()).isEqualTo("test injection");
+        assertThat(autoChecks.getStatus()).isEqualTo(ChecksStatus.IN_PROGRESS);
+        assertThat(autoChecks.getConclusion()).isEqualTo(ChecksConclusion.NONE);
+
+        assertThat(manualChecks.getName().get()).isEqualTo("test override");
+        assertThat(manualChecks.getStatus()).isEqualTo(ChecksStatus.COMPLETED);
+        assertThat(manualChecks.getConclusion()).isEqualTo(ChecksConclusion.SUCCESS);
+    }
+
     /**
      * Assert that the injected {@link ChecksInfo} is as expected.
      */

src/test/resources/design.puml

@@ -7,12 +7,14 @@ skinparam component {
 }
 
 [API] <<..checks.api>>
+[Test] <<..checks.api.test>>
 [Steps] <<..checks.steps>>
 [Status] <<..checks.status>>
 [Checks] <<..checks>>
 
 [Steps] --> [API]
 [Status] --> [API]
 [Checks] --> [API]
+[Test] --> [API]
 
 @enduml