From 07f6a3ccf335fa8b4a0e44e95d0118d2e6f0211e Mon Sep 17 00:00:00 2001
From: Martin Kouba <mkouba@redhat.com>
Date: Wed, 21 Feb 2024 15:25:59 +0100
Subject: [PATCH] Qute: introduce RenderedResults assert API for tests

---
 docs/src/main/asciidoc/qute-reference.adoc    |   6 +
 .../qute/deployment/QuteProcessor.java        |  17 ++
 .../qute/deployment/test/FooTemplates.java    |  12 ++
 .../test/RenderedResultsDisabledTest.java     |  33 ++++
 .../deployment/test/RenderedResultsTest.java  |  98 ++++++++++++
 .../qute/deployment/test/SimpleBean.java      |  19 +++
 .../io/quarkus/qute/runtime/QuteConfig.java   |   8 +-
 .../qute/runtime/QuteTestModeConfig.java      |  17 ++
 .../qute/runtime/TemplateProducer.java        |  22 ++-
 .../runtime/test/RenderedResultsCreator.java  |  14 ++
 .../qute/ForwardingTemplateInstance.java      |  82 ++++++++++
 .../java/io/quarkus/qute/RenderedResults.java | 145 ++++++++++++++++++
 .../ResultsCollectingTemplateInstance.java    |  71 +++++++++
 ...ResultsCollectingTemplateInstanceTest.java | 126 +++++++++++++++
 14 files changed, 664 insertions(+), 6 deletions(-)
 create mode 100644 extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/test/FooTemplates.java
 create mode 100644 extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/test/RenderedResultsDisabledTest.java
 create mode 100644 extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/test/RenderedResultsTest.java
 create mode 100644 extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/test/SimpleBean.java
 create mode 100644 extensions/qute/runtime/src/main/java/io/quarkus/qute/runtime/QuteTestModeConfig.java
 create mode 100644 extensions/qute/runtime/src/main/java/io/quarkus/qute/runtime/test/RenderedResultsCreator.java
 create mode 100644 independent-projects/qute/core/src/main/java/io/quarkus/qute/ForwardingTemplateInstance.java
 create mode 100644 independent-projects/qute/core/src/main/java/io/quarkus/qute/RenderedResults.java
 create mode 100644 independent-projects/qute/core/src/main/java/io/quarkus/qute/ResultsCollectingTemplateInstance.java
 create mode 100644 independent-projects/qute/core/src/test/java/io/quarkus/qute/ResultsCollectingTemplateInstanceTest.java

diff --git a/docs/src/main/asciidoc/qute-reference.adoc b/docs/src/main/asciidoc/qute-reference.adoc
index ba56d9283048c..799ac39c1b0bb 100644
--- a/docs/src/main/asciidoc/qute-reference.adoc
+++ b/docs/src/main/asciidoc/qute-reference.adoc
@@ -2654,6 +2654,12 @@ The configration value is a regular expression that matches the template path re
 For example, `quarkus.qute.dev-mode.no-restart-templates=templates/foo.html` matches the template `src/main/resources/templates/foo.html`.
 The matching templates are reloaded and only runtime validations are performed.
 
+=== Testing
+
+In the test mode, the rendering results of injected and type-safe templates are recorded in the managed `io.quarkus.qute.RenderedResults` which is registered as a CDI bean.
+You can inject `RenderedResults` in a test or any other CDI bean and assert the results.
+However, it's possible to set the `quarkus.qute.test-mode.record-rendered-results` configuration property to `false` to disable this feature.
+
 [[type-safe-message-bundles]]
 === Type-safe Message Bundles
 
diff --git a/extensions/qute/deployment/src/main/java/io/quarkus/qute/deployment/QuteProcessor.java b/extensions/qute/deployment/src/main/java/io/quarkus/qute/deployment/QuteProcessor.java
index c2fc7b7393167..e2ab7c880eaed 100644
--- a/extensions/qute/deployment/src/main/java/io/quarkus/qute/deployment/QuteProcessor.java
+++ b/extensions/qute/deployment/src/main/java/io/quarkus/qute/deployment/QuteProcessor.java
@@ -41,6 +41,8 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import jakarta.inject.Singleton;
+
 import org.jboss.jandex.AnnotationInstance;
 import org.jboss.jandex.AnnotationTarget;
 import org.jboss.jandex.AnnotationTarget.Kind;
@@ -77,6 +79,7 @@
 import io.quarkus.deployment.ApplicationArchive;
 import io.quarkus.deployment.Feature;
 import io.quarkus.deployment.GeneratedClassGizmoAdaptor;
+import io.quarkus.deployment.IsTest;
 import io.quarkus.deployment.annotations.BuildProducer;
 import io.quarkus.deployment.annotations.BuildStep;
 import io.quarkus.deployment.annotations.Record;
@@ -109,6 +112,7 @@
 import io.quarkus.qute.ParameterDeclaration;
 import io.quarkus.qute.ParserHelper;
 import io.quarkus.qute.ParserHook;
+import io.quarkus.qute.RenderedResults;
 import io.quarkus.qute.ResultNode;
 import io.quarkus.qute.SectionHelper;
 import io.quarkus.qute.SectionHelperFactory;
@@ -148,6 +152,7 @@
 import io.quarkus.qute.runtime.extensions.OrOperatorTemplateExtensions;
 import io.quarkus.qute.runtime.extensions.StringTemplateExtensions;
 import io.quarkus.qute.runtime.extensions.TimeTemplateExtensions;
+import io.quarkus.qute.runtime.test.RenderedResultsCreator;
 import io.quarkus.runtime.util.StringUtil;
 
 public class QuteProcessor {
@@ -874,6 +879,18 @@ void validateCheckedFragments(List<CheckedFragmentValidationBuildItem> validatio
         }
     }
 
+    @BuildStep(onlyIf = IsTest.class)
+    SyntheticBeanBuildItem registerRenderedResults(QuteConfig config) {
+        if (config.testMode.recordRenderedResults) {
+            return SyntheticBeanBuildItem.configure(RenderedResults.class)
+                    .unremovable()
+                    .scope(Singleton.class)
+                    .creator(RenderedResultsCreator.class)
+                    .done();
+        }
+        return null;
+    }
+
     @SuppressWarnings("incomplete-switch")
     private static String getCheckedTemplateParameterTypeName(Type type) {
         switch (type.kind()) {
diff --git a/extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/test/FooTemplates.java b/extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/test/FooTemplates.java
new file mode 100644
index 0000000000000..3aa4576ca3168
--- /dev/null
+++ b/extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/test/FooTemplates.java
@@ -0,0 +1,12 @@
+package io.quarkus.qute.deployment.test;
+
+import io.quarkus.qute.CheckedTemplate;
+import io.quarkus.qute.TemplateInstance;
+
+@CheckedTemplate
+public class FooTemplates {
+
+    static native TemplateInstance foo(String name);
+
+    static native TemplateInstance foo$bar();
+}
diff --git a/extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/test/RenderedResultsDisabledTest.java b/extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/test/RenderedResultsDisabledTest.java
new file mode 100644
index 0000000000000..867778d4ee832
--- /dev/null
+++ b/extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/test/RenderedResultsDisabledTest.java
@@ -0,0 +1,33 @@
+package io.quarkus.qute.deployment.test;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import jakarta.enterprise.inject.Instance;
+import jakarta.inject.Inject;
+
+import org.jboss.shrinkwrap.api.asset.StringAsset;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import io.quarkus.qute.RenderedResults;
+import io.quarkus.test.QuarkusUnitTest;
+
+public class RenderedResultsDisabledTest {
+
+    @RegisterExtension
+    static final QuarkusUnitTest config = new QuarkusUnitTest()
+            .withApplicationRoot(root -> root
+                    .addClasses(SimpleBean.class)
+                    .addAsResource(new StringAsset("quarkus.qute.test-mode.record-rendered-results=false"),
+                            "application.properties")
+                    .addAsResource(new StringAsset("{name}"), "templates/foo.txt"));
+
+    @Inject
+    Instance<RenderedResults> renderedResults;
+
+    @Test
+    public void testRenderedResultsNotRegistered() {
+        assertTrue(renderedResults.isUnsatisfied());
+    }
+
+}
diff --git a/extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/test/RenderedResultsTest.java b/extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/test/RenderedResultsTest.java
new file mode 100644
index 0000000000000..3c15c854ebc24
--- /dev/null
+++ b/extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/test/RenderedResultsTest.java
@@ -0,0 +1,98 @@
+package io.quarkus.qute.deployment.test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Supplier;
+
+import jakarta.inject.Inject;
+
+import org.jboss.shrinkwrap.api.asset.StringAsset;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import io.quarkus.qute.RenderedResults;
+import io.quarkus.qute.RenderedResults.RenderedResult;
+import io.quarkus.qute.TemplateInstance;
+import io.quarkus.qute.Variant;
+import io.quarkus.test.QuarkusUnitTest;
+
+public class RenderedResultsTest {
+
+    @RegisterExtension
+    static final QuarkusUnitTest config = new QuarkusUnitTest()
+            .withApplicationRoot(root -> root
+                    .addClasses(SimpleBean.class, FooTemplates.class)
+                    .addAsResource(new StringAsset("quarkus.qute.suffixes=txt,html"), "application.properties")
+                    .addAsResource(new StringAsset("{name}{#fragment id=bar rendered=false}bar{/fragment}"),
+                            "templates/foo.txt")
+                    .addAsResource(new StringAsset("<h1>{name}{#fragment id=bar rendered=false}bar{/fragment}</h1>"),
+                            "templates/foo.html"));
+
+    @Inject
+    RenderedResults renderedResults;
+
+    @Inject
+    SimpleBean bean;
+
+    @Test
+    public void testInjectedTemplate() throws InterruptedException {
+        assertResults(() -> bean.fooInstance().data("name", "oof").render(), "foo.txt", "oof");
+    }
+
+    @Test
+    public void testInjectedTemplateSelectedVariant() throws InterruptedException {
+        assertResults(() -> bean.fooInstance()
+                .setAttribute(TemplateInstance.SELECTED_VARIANT, Variant.forContentType(Variant.TEXT_HTML))
+                .data("name", "oof")
+                .render(), "foo.html", "<h1>oof</h1>");
+    }
+
+    @Test
+    public void testTypesafeTemplate() throws InterruptedException {
+        assertResults(() -> FooTemplates.foo("oof").render(), "foo.txt", "oof");
+    }
+
+    @Test
+    public void testTypesafeFragment() throws InterruptedException {
+        assertResults(() -> FooTemplates.foo$bar().render(), "foo.txt$bar", "bar");
+    }
+
+    @Test
+    public void testTypesafeTemplateSelectedVariant() throws InterruptedException {
+        assertResults(
+                () -> FooTemplates.foo("oof")
+                        .setAttribute(TemplateInstance.SELECTED_VARIANT, Variant.forContentType(Variant.TEXT_HTML)).render(),
+                "foo.html", "<h1>oof</h1>");
+    }
+
+    @Test
+    public void testTypesafeFragmentSelectedVariant() throws InterruptedException {
+        assertResults(
+                () -> FooTemplates.foo$bar()
+                        .setAttribute(TemplateInstance.SELECTED_VARIANT, Variant.forContentType(Variant.TEXT_HTML)).render(),
+                "foo.html$bar", "bar");
+    }
+
+    private void assertResults(Supplier<String> renderAction, String templateId, String expectedResult)
+            throws InterruptedException {
+        renderedResults.clear();
+        assertEquals(expectedResult, renderAction.get());
+        // Wait a little so that we can test the RenderedResult#timeout()
+        // Note that LocalDateTime.now() has precision of the system clock and it seems that windows has millisecond precision
+        TimeUnit.MILLISECONDS.sleep(50);
+        List<RenderedResult> results = renderedResults.getResults(templateId);
+        assertEquals(1, results.size(), renderedResults.toString());
+        assertEquals(expectedResult, results.get(0).result());
+        assertEquals(expectedResult, renderAction.get());
+        results = renderedResults.getResults(templateId);
+        assertEquals(2, results.size(), renderedResults.toString());
+        assertEquals(expectedResult, results.get(1).result());
+        assertTrue(results.get(0).timestamp().isBefore(results.get(1).timestamp()));
+        renderedResults.clear();
+        assertTrue(renderedResults.getResults(templateId).isEmpty());
+    }
+
+}
diff --git a/extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/test/SimpleBean.java b/extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/test/SimpleBean.java
new file mode 100644
index 0000000000000..04439289c7450
--- /dev/null
+++ b/extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/test/SimpleBean.java
@@ -0,0 +1,19 @@
+package io.quarkus.qute.deployment.test;
+
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
+
+import io.quarkus.qute.Template;
+import io.quarkus.qute.TemplateInstance;
+
+@Singleton
+public class SimpleBean {
+
+    @Inject
+    Template foo;
+
+    public TemplateInstance fooInstance() {
+        return foo.instance();
+    }
+
+}
diff --git a/extensions/qute/runtime/src/main/java/io/quarkus/qute/runtime/QuteConfig.java b/extensions/qute/runtime/src/main/java/io/quarkus/qute/runtime/QuteConfig.java
index 5849bb84a5fdd..ad59c9a174406 100644
--- a/extensions/qute/runtime/src/main/java/io/quarkus/qute/runtime/QuteConfig.java
+++ b/extensions/qute/runtime/src/main/java/io/quarkus/qute/runtime/QuteConfig.java
@@ -89,9 +89,15 @@ public class QuteConfig {
     public Charset defaultCharset;
 
     /**
-     * Dev mode configuration.
+     * Development mode configuration.
      */
     @ConfigItem
     public QuteDevModeConfig devMode;
 
+    /**
+     * Test mode configuration.
+     */
+    @ConfigItem
+    public QuteTestModeConfig testMode;
+
 }
diff --git a/extensions/qute/runtime/src/main/java/io/quarkus/qute/runtime/QuteTestModeConfig.java b/extensions/qute/runtime/src/main/java/io/quarkus/qute/runtime/QuteTestModeConfig.java
new file mode 100644
index 0000000000000..13d4dfa30d294
--- /dev/null
+++ b/extensions/qute/runtime/src/main/java/io/quarkus/qute/runtime/QuteTestModeConfig.java
@@ -0,0 +1,17 @@
+package io.quarkus.qute.runtime;
+
+import io.quarkus.qute.RenderedResults;
+import io.quarkus.runtime.annotations.ConfigGroup;
+import io.quarkus.runtime.annotations.ConfigItem;
+
+@ConfigGroup
+public class QuteTestModeConfig {
+
+    /**
+     * By default, the rendering results of injected and type-safe templates are recorded in the managed
+     * {@link RenderedResults} which is registered as a CDI bean.
+     */
+    @ConfigItem(defaultValue = "true")
+    public boolean recordRenderedResults;
+
+}
\ No newline at end of file
diff --git a/extensions/qute/runtime/src/main/java/io/quarkus/qute/runtime/TemplateProducer.java b/extensions/qute/runtime/src/main/java/io/quarkus/qute/runtime/TemplateProducer.java
index 6f15bfa4bca36..1a7c6256a1664 100644
--- a/extensions/qute/runtime/src/main/java/io/quarkus/qute/runtime/TemplateProducer.java
+++ b/extensions/qute/runtime/src/main/java/io/quarkus/qute/runtime/TemplateProducer.java
@@ -18,6 +18,7 @@
 import java.util.function.Predicate;
 import java.util.function.Supplier;
 
+import jakarta.enterprise.inject.Instance;
 import jakarta.enterprise.inject.Produces;
 import jakarta.enterprise.inject.spi.AnnotatedParameter;
 import jakarta.enterprise.inject.spi.InjectionPoint;
@@ -30,6 +31,8 @@
 import io.quarkus.qute.Expression;
 import io.quarkus.qute.Location;
 import io.quarkus.qute.ParameterDeclaration;
+import io.quarkus.qute.RenderedResults;
+import io.quarkus.qute.ResultsCollectingTemplateInstance;
 import io.quarkus.qute.Template;
 import io.quarkus.qute.TemplateInstance;
 import io.quarkus.qute.TemplateInstanceBase;
@@ -51,7 +54,10 @@ public class TemplateProducer {
     // In the dev mode, we need to keep track of injected templates so that we can clear the cached values
     private final List<WeakReference<InjectableTemplate>> injectedTemplates;
 
-    TemplateProducer(Engine engine, QuteContext context, ContentTypes contentTypes, LaunchMode launchMode) {
+    private final RenderedResults renderedResults;
+
+    TemplateProducer(Engine engine, QuteContext context, ContentTypes contentTypes, LaunchMode launchMode,
+            Instance<RenderedResults> renderedResults) {
         this.engine = engine;
         Map<String, TemplateVariants> templateVariants = new HashMap<>();
         for (Entry<String, List<String>> entry : context.getVariants().entrySet()) {
@@ -60,6 +66,7 @@ public class TemplateProducer {
             templateVariants.put(entry.getKey(), var);
         }
         this.templateVariants = Collections.unmodifiableMap(templateVariants);
+        this.renderedResults = launchMode == LaunchMode.TEST ? renderedResults.get() : null;
         this.injectedTemplates = launchMode == LaunchMode.DEVELOPMENT ? Collections.synchronizedList(new ArrayList<>()) : null;
         LOGGER.debugf("Initializing Qute variant templates: %s", templateVariants);
     }
@@ -122,7 +129,7 @@ public void clearInjectedTemplates() {
     }
 
     private Template newInjectableTemplate(String path) {
-        InjectableTemplate template = new InjectableTemplate(path, templateVariants, engine);
+        InjectableTemplate template = new InjectableTemplate(path, templateVariants, engine, renderedResults);
         if (injectedTemplates != null) {
             injectedTemplates.add(new WeakReference<>(template));
         }
@@ -142,8 +149,10 @@ static class InjectableTemplate implements Template {
         private final Engine engine;
         // Some methods may only work if a single template variant is found
         private final LazyValue<Template> unambiguousTemplate;
+        private final RenderedResults renderedResults;
 
-        public InjectableTemplate(String path, Map<String, TemplateVariants> templateVariants, Engine engine) {
+        InjectableTemplate(String path, Map<String, TemplateVariants> templateVariants, Engine engine,
+                RenderedResults renderedResults) {
             this.path = path;
             this.variants = templateVariants.get(path);
             this.engine = engine;
@@ -158,11 +167,13 @@ public Template get() {
             } else {
                 unambiguousTemplate = null;
             }
+            this.renderedResults = renderedResults;
         }
 
         @Override
         public TemplateInstance instance() {
-            return new InjectableTemplateInstanceImpl();
+            TemplateInstance instance = new InjectableTemplateInstanceImpl();
+            return renderedResults != null ? new ResultsCollectingTemplateInstance(instance, renderedResults) : instance;
         }
 
         @Override
@@ -290,7 +301,8 @@ public Set<String> getFragmentIds() {
 
             @Override
             public TemplateInstance instance() {
-                return new InjectableFragmentTemplateInstanceImpl(identifier);
+                TemplateInstance instance = new InjectableFragmentTemplateInstanceImpl(identifier);
+                return renderedResults != null ? new ResultsCollectingTemplateInstance(instance, renderedResults) : instance;
             }
 
         }
diff --git a/extensions/qute/runtime/src/main/java/io/quarkus/qute/runtime/test/RenderedResultsCreator.java b/extensions/qute/runtime/src/main/java/io/quarkus/qute/runtime/test/RenderedResultsCreator.java
new file mode 100644
index 0000000000000..370c282e95782
--- /dev/null
+++ b/extensions/qute/runtime/src/main/java/io/quarkus/qute/runtime/test/RenderedResultsCreator.java
@@ -0,0 +1,14 @@
+package io.quarkus.qute.runtime.test;
+
+import io.quarkus.arc.BeanCreator;
+import io.quarkus.arc.SyntheticCreationalContext;
+import io.quarkus.qute.RenderedResults;
+
+public class RenderedResultsCreator implements BeanCreator<RenderedResults> {
+
+    @Override
+    public RenderedResults create(SyntheticCreationalContext<RenderedResults> context) {
+        return new RenderedResults();
+    }
+
+}
diff --git a/independent-projects/qute/core/src/main/java/io/quarkus/qute/ForwardingTemplateInstance.java b/independent-projects/qute/core/src/main/java/io/quarkus/qute/ForwardingTemplateInstance.java
new file mode 100644
index 0000000000000..545b5ec9da043
--- /dev/null
+++ b/independent-projects/qute/core/src/main/java/io/quarkus/qute/ForwardingTemplateInstance.java
@@ -0,0 +1,82 @@
+package io.quarkus.qute;
+
+import java.util.concurrent.CompletionStage;
+import java.util.function.Consumer;
+
+import io.smallrye.mutiny.Multi;
+import io.smallrye.mutiny.Uni;
+
+public abstract class ForwardingTemplateInstance implements TemplateInstance {
+
+    protected abstract TemplateInstance delegate();
+
+    @Override
+    public TemplateInstance data(Object data) {
+        delegate().data(data);
+        return this;
+    }
+
+    @Override
+    public TemplateInstance data(String key, Object data) {
+        delegate().data(key, data);
+        return this;
+    }
+
+    @Override
+    public TemplateInstance setAttribute(String key, Object value) {
+        delegate().setAttribute(key, value);
+        return this;
+    }
+
+    @Override
+    public Object getAttribute(String key) {
+        return delegate().getAttribute(key);
+    }
+
+    @Override
+    public String render() {
+        return delegate().render();
+    }
+
+    @Override
+    public CompletionStage<String> renderAsync() {
+        return delegate().renderAsync();
+    }
+
+    @Override
+    public Multi<String> createMulti() {
+        return delegate().createMulti();
+    }
+
+    @Override
+    public Uni<String> createUni() {
+        return delegate().createUni();
+    }
+
+    @Override
+    public CompletionStage<Void> consume(Consumer<String> consumer) {
+        return delegate().consume(consumer);
+    }
+
+    @Override
+    public long getTimeout() {
+        return delegate().getTimeout();
+    }
+
+    @Override
+    public Template getTemplate() {
+        return delegate().getTemplate();
+    }
+
+    @Override
+    public Template getFragment(String id) {
+        return delegate().getFragment(id);
+    }
+
+    @Override
+    public TemplateInstance onRendered(Runnable action) {
+        delegate().onRendered(action);
+        return this;
+    }
+
+}
diff --git a/independent-projects/qute/core/src/main/java/io/quarkus/qute/RenderedResults.java b/independent-projects/qute/core/src/main/java/io/quarkus/qute/RenderedResults.java
new file mode 100644
index 0000000000000..d6b54351b6582
--- /dev/null
+++ b/independent-projects/qute/core/src/main/java/io/quarkus/qute/RenderedResults.java
@@ -0,0 +1,145 @@
+package io.quarkus.qute;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.BiConsumer;
+import java.util.function.BiPredicate;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import org.jboss.logging.Logger;
+
+import io.quarkus.qute.RenderedResults.RenderedResult;
+import io.quarkus.qute.Template.Fragment;
+
+/**
+ * This helper class can be used to collect rendering results and assert the results in a test.
+ * <p>
+ * You can obtain the results for a specific template with {@link #getResults(String)}. This class also implements iterable -
+ * the entry key is the template id and the value is a copy of the list of all results. Finally, it's also possible to filter
+ * the results with {@link #setFilter(BiPredicate)} and remove some results with {@link #remove(Predicate)}.
+ *
+ * @see ResultsCollectingTemplateInstance
+ */
+public class RenderedResults implements BiConsumer<TemplateInstance, String>, Iterable<Entry<String, List<RenderedResult>>> {
+
+    private static final Logger LOG = Logger.getLogger(RenderedResults.class);
+
+    private final ConcurrentMap<String, List<RenderedResult>> idToResults;
+
+    private final Function<TemplateInstance, String> idExtractor;
+
+    private final AtomicReference<BiPredicate<TemplateInstance, RenderedResult>> filter;
+
+    public RenderedResults() {
+        this(new Function<TemplateInstance, String>() {
+
+            @Override
+            public String apply(TemplateInstance templateInstance) {
+                try {
+                    Template template = templateInstance.getTemplate();
+                    if (template.isFragment()) {
+                        return ((Fragment) template).getOriginalTemplate().getId() + "$" + template.getId();
+                    }
+                    return templateInstance.getTemplate().getId();
+                } catch (Exception e) {
+                    return null;
+                }
+            }
+        });
+    }
+
+    public RenderedResults(Function<TemplateInstance, String> keyExtractor) {
+        this.idToResults = new ConcurrentHashMap<>();
+        this.idExtractor = Objects.requireNonNull(keyExtractor);
+        this.filter = new AtomicReference<>();
+    }
+
+    @Override
+    public void accept(TemplateInstance templateInstance, String result) {
+        String id = idExtractor.apply(templateInstance);
+        if (id == null) {
+            LOG.warnf("Unable to extract the id from the template instance: %s", templateInstance.toString());
+            return;
+        }
+        List<RenderedResult> results = idToResults.computeIfAbsent(id, e -> Collections.synchronizedList(new ArrayList<>()));
+        RenderedResult r = new RenderedResult(id, result, LocalDateTime.now());
+        BiPredicate<TemplateInstance, RenderedResult> filter = this.filter.get();
+        if (filter == null || filter.test(templateInstance, r)) {
+            results.add(r);
+        }
+    }
+
+    /**
+     * The returned list is an immutable copy of the results for the given template id.
+     * <p>
+     * For fragments the template id is the template id of the original template followed by the {@code $} and the name of the
+     * fragment.
+     *
+     * @param templateId
+     * @return the results for the given template id
+     * @see Template#getId()
+     */
+    public List<RenderedResult> getResults(String templateId) {
+        List<RenderedResult> results = idToResults.get(templateId);
+        if (results == null || results.isEmpty()) {
+            return List.of();
+        }
+        return List.copyOf(results);
+    }
+
+    @Override
+    public Iterator<Entry<String, List<RenderedResult>>> iterator() {
+        return idToResults.entrySet().stream().map(e -> Map.entry(e.getKey(), List.copyOf(e.getValue()))).iterator();
+    }
+
+    /**
+     * Remove all results.
+     */
+    public void clear() {
+        idToResults.clear();
+    }
+
+    /**
+     * Remove all results that match the given predicate.
+     *
+     * @param predicate
+     */
+    public void remove(Predicate<RenderedResult> predicate) {
+        idToResults.values().forEach(l -> l.removeIf(predicate));
+    }
+
+    /**
+     * Only results that match the given predicate are stored.
+     *
+     * @param filter
+     */
+    public void setFilter(BiPredicate<TemplateInstance, RenderedResult> filter) {
+        this.filter.set(filter);
+    }
+
+    @Override
+    public String toString() {
+        return "RenderedResults [" + (idToResults != null ? "idToResults=" + idToResults : "") + "]";
+    }
+
+    /**
+     *
+     * @param id The template id
+     * @param result The rendered content
+     * @param timestamp The timestamp this result was created at
+     */
+    public record RenderedResult(String templateId, String result, LocalDateTime timestamp) {
+
+    }
+
+}
diff --git a/independent-projects/qute/core/src/main/java/io/quarkus/qute/ResultsCollectingTemplateInstance.java b/independent-projects/qute/core/src/main/java/io/quarkus/qute/ResultsCollectingTemplateInstance.java
new file mode 100644
index 0000000000000..13bd9ed7f6e69
--- /dev/null
+++ b/independent-projects/qute/core/src/main/java/io/quarkus/qute/ResultsCollectingTemplateInstance.java
@@ -0,0 +1,71 @@
+package io.quarkus.qute;
+
+import java.util.concurrent.CompletionStage;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+
+import io.smallrye.mutiny.Multi;
+import io.smallrye.mutiny.Uni;
+
+/**
+ * Collects all rendering results for the specified template instance.
+ *
+ * @see RenderedResults
+ */
+public class ResultsCollectingTemplateInstance extends ForwardingTemplateInstance {
+
+    private final TemplateInstance delegate;
+
+    private final BiConsumer<TemplateInstance, String> resultConsumer;
+
+    public ResultsCollectingTemplateInstance(TemplateInstance delegate, BiConsumer<TemplateInstance, String> resultConsumer) {
+        this.delegate = delegate;
+        this.resultConsumer = resultConsumer;
+    }
+
+    @Override
+    protected TemplateInstance delegate() {
+        return delegate;
+    }
+
+    @Override
+    public String render() {
+        String result = delegate.render();
+        resultConsumer.accept(delegate, result);
+        return result;
+    }
+
+    @Override
+    public CompletionStage<String> renderAsync() {
+        return delegate.renderAsync().thenApply(r -> {
+            resultConsumer.accept(delegate, r);
+            return r;
+        });
+    }
+
+    @Override
+    public Multi<String> createMulti() {
+        Multi<String> multi = delegate.createMulti();
+        StringBuilder builder = new StringBuilder();
+        return multi.onItem().invoke(builder::append).onCompletion()
+                .invoke(() -> resultConsumer.accept(delegate, builder.toString()));
+    }
+
+    @Override
+    public Uni<String> createUni() {
+        Uni<String> uni = delegate.createUni();
+        uni = uni.onItem().invoke(r -> resultConsumer.accept(delegate, r));
+        return uni;
+    }
+
+    @Override
+    public CompletionStage<Void> consume(Consumer<String> consumer) {
+        StringBuilder builder = new StringBuilder();
+        CompletionStage<Void> cs = delegate.consume(consumer.andThen(builder::append));
+        return cs.thenApply(v -> {
+            resultConsumer.accept(delegate, builder.toString());
+            return v;
+        });
+    }
+
+}
diff --git a/independent-projects/qute/core/src/test/java/io/quarkus/qute/ResultsCollectingTemplateInstanceTest.java b/independent-projects/qute/core/src/test/java/io/quarkus/qute/ResultsCollectingTemplateInstanceTest.java
new file mode 100644
index 0000000000000..de2668c06b855
--- /dev/null
+++ b/independent-projects/qute/core/src/test/java/io/quarkus/qute/ResultsCollectingTemplateInstanceTest.java
@@ -0,0 +1,126 @@
+package io.quarkus.qute;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import org.junit.jupiter.api.Test;
+
+import io.quarkus.qute.RenderedResults.RenderedResult;
+
+public class ResultsCollectingTemplateInstanceTest {
+
+    @Test
+    public void testRender() throws InterruptedException {
+        assertResults(t -> t.render());
+    }
+
+    @Test
+    public void testRenderAsync() throws InterruptedException {
+        assertResults(t -> {
+            try {
+                return t.renderAsync().toCompletableFuture().get();
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
+        });
+    }
+
+    @Test
+    public void testCreateUni() throws InterruptedException {
+        assertResults(t -> t.createUni().await().indefinitely());
+    }
+
+    @Test
+    public void testCreateMulti() throws InterruptedException {
+        assertResults(t -> t.createMulti().subscribe().asStream().collect(Collectors.joining()));
+    }
+
+    @Test
+    public void testConsume() throws InterruptedException {
+        assertResults(t -> {
+            try {
+                StringBuilder builder = new StringBuilder();
+                t.consume(builder::append).toCompletableFuture().get();
+                return builder.toString();
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
+        });
+    }
+
+    @Test
+    public void testRemove() {
+        Engine engine = Engine.builder().addDefaults().build();
+        RenderedResults renderedResults = new RenderedResults();
+        ResultsCollectingTemplateInstance collectingInstance = new ResultsCollectingTemplateInstance(
+                engine.parse("{name}", null, "foo").instance().data("name", "oof"),
+                renderedResults);
+        assertEquals("oof", collectingInstance.render());
+        renderedResults.remove(r -> r.result().contains("of"));
+        assertTrue(renderedResults.getResults("foo").isEmpty());
+    }
+
+    @Test
+    public void testIterator() {
+        Engine engine = Engine.builder().addDefaults().build();
+        RenderedResults renderedResults = new RenderedResults();
+        ResultsCollectingTemplateInstance collectingInstance = new ResultsCollectingTemplateInstance(
+                engine.parse("{name}", null, "foo").instance().data("name", "oof"),
+                renderedResults);
+        for (int i = 0; i < 10; i++) {
+            assertEquals("oof", collectingInstance.render());
+        }
+        for (Entry<String, List<RenderedResult>> e : renderedResults) {
+            assertEquals(e.getKey(), "foo");
+            assertEquals(10, e.getValue().size());
+        }
+    }
+
+    @Test
+    public void testFilter() {
+        Engine engine = Engine.builder().addDefaults().build();
+        RenderedResults renderedResults = new RenderedResults();
+        renderedResults.setFilter((t, r) -> r.templateId().equals("foo"));
+        assertEquals("foo", new ResultsCollectingTemplateInstance(
+                engine.parse("foo", null, "foo").instance(),
+                renderedResults).render());
+        assertEquals("bar", new ResultsCollectingTemplateInstance(
+                engine.parse("bar", null, "bar").instance(),
+                renderedResults).render());
+        List<RenderedResult> fooResults = renderedResults.getResults("foo");
+        assertEquals(1, fooResults.size());
+        assertEquals("foo", fooResults.get(0).result());
+        List<RenderedResult> barResults = renderedResults.getResults("bar");
+        assertTrue(barResults.isEmpty());
+    }
+
+    private void assertResults(Function<TemplateInstance, String> renderAction) throws InterruptedException {
+        Engine engine = Engine.builder().addDefaults().build();
+        RenderedResults renderedResults = new RenderedResults();
+        ResultsCollectingTemplateInstance collectingInstance = new ResultsCollectingTemplateInstance(
+                engine.parse("{name}", null, "foo").instance().data("name", "oof"),
+                renderedResults);
+        assertEquals("foo", collectingInstance.getTemplate().getId());
+        assertEquals("oof", renderAction.apply(collectingInstance));
+        List<RenderedResult> results = renderedResults.getResults("foo");
+        assertEquals(1, results.size());
+        assertEquals("oof", results.get(0).result());
+        // Wait a little so that we can test the RenderedResult#timeout()
+        // Note that LocalDateTime.now() has precision of the system clock and it seems that windows has millisecond precision
+        TimeUnit.MILLISECONDS.sleep(50);
+        assertEquals("oof", renderAction.apply(collectingInstance));
+        results = renderedResults.getResults("foo");
+        assertEquals(2, results.size());
+        assertEquals("oof", results.get(1).result());
+        assertTrue(results.get(0).timestamp().isBefore(results.get(1).timestamp()));
+        renderedResults.clear();
+        assertTrue(renderedResults.getResults("foo").isEmpty());
+    }
+
+}