Add the @TestTransaction annotation

This allows you to run tests in a rollback only transaction.

Fixes quarkusio#6463

docs/src/main/asciidoc/getting-started-testing.adoc

@@ -415,6 +415,13 @@ public class TestStereotypeTestCase {
 }
 ----
 
+== Tests and Transactions
+
+You can use the standard Quarkus `@Transactional` annotation on tests, but this means that the changes your
+test makes to the database will be persistent. If you want any changes made to be rolled back at the end of
+the test you can use the `io.quarkus.test.TestTransaction` annotation. This will run the test method in a
+transaction, but roll it back once the test method is complete to revert any database changes.
+
 == Enrichment via QuarkusTest*Callback
 
 Alternatively or additionally to an interceptor, you can enrich *all* your `@QuarkusTest` classes by implementing the following callback interfaces:

extensions/hibernate-orm/deployment/src/main/java/io/quarkus/hibernate/orm/deployment/test/HibernateTestTransactionCallback.java

@@ -0,0 +1,21 @@
+package io.quarkus.hibernate.orm.deployment.test;
+
+import javax.enterprise.inject.spi.CDI;
+import javax.persistence.EntityManager;
+
+import io.quarkus.narayana.jta.runtime.test.TestTransactionCallback;
+
+public class HibernateTestTransactionCallback implements TestTransactionCallback {
+    @Override
+    public void postBegin() {
+
+    }
+
+    @Override
+    public void preRollback() {
+        for (EntityManager i : CDI.current().select(EntityManager.class)) {
+            i.flush();
+        }
+
+    }
+}

extensions/hibernate-orm/deployment/src/main/resources/META-INF/services/io.quarkus.narayana.jta.runtime.test.TestTransactionCallback

@@ -0,0 +1 @@
+io.quarkus.hibernate.orm.deployment.test.HibernateTestTransactionCallback

extensions/narayana-jta/deployment/src/main/java/io/quarkus/narayana/jta/deployment/NarayanaJtaProcessor.java

@@ -2,9 +2,16 @@
 
 import static io.quarkus.deployment.annotations.ExecutionTime.RUNTIME_INIT;
 
+import java.lang.reflect.Modifier;
 import java.util.Properties;
 
+import javax.annotation.Priority;
+import javax.inject.Inject;
+import javax.interceptor.AroundInvoke;
+import javax.interceptor.Interceptor;
+import javax.interceptor.InvocationContext;
 import javax.transaction.TransactionScoped;
+import javax.transaction.UserTransaction;
 
 import com.arjuna.ats.arjuna.common.ObjectStoreEnvironmentBean;
 import com.arjuna.ats.internal.arjuna.coordinator.CheckedActionFactoryImple;
@@ -17,7 +24,12 @@
 
 import io.quarkus.arc.deployment.AdditionalBeanBuildItem;
 import io.quarkus.arc.deployment.ContextRegistrarBuildItem;
+<<<<<<< HEAD
 import io.quarkus.arc.deployment.UnremovableBeanBuildItem;
+=======
+import io.quarkus.arc.deployment.GeneratedBeanBuildItem;
+import io.quarkus.arc.deployment.GeneratedBeanGizmoAdaptor;
+>>>>>>> Add the @TestTransaction annotation
 import io.quarkus.arc.processor.ContextRegistrar;
 import io.quarkus.deployment.Capability;
 import io.quarkus.deployment.Feature;
@@ -26,21 +38,30 @@
 import io.quarkus.deployment.annotations.Record;
 import io.quarkus.deployment.builditem.CapabilityBuildItem;
 import io.quarkus.deployment.builditem.FeatureBuildItem;
+import io.quarkus.deployment.builditem.LaunchModeBuildItem;
 import io.quarkus.deployment.builditem.nativeimage.NativeImageSystemPropertyBuildItem;
 import io.quarkus.deployment.builditem.nativeimage.ReflectiveClassBuildItem;
 import io.quarkus.deployment.builditem.nativeimage.RuntimeInitializedClassBuildItem;
+import io.quarkus.gizmo.ClassCreator;
+import io.quarkus.gizmo.FieldCreator;
+import io.quarkus.gizmo.FieldDescriptor;
+import io.quarkus.gizmo.MethodCreator;
+import io.quarkus.gizmo.MethodDescriptor;
+import io.quarkus.gizmo.ResultHandle;
 import io.quarkus.narayana.jta.runtime.CDIDelegatingTransactionManager;
 import io.quarkus.narayana.jta.runtime.NarayanaJtaProducers;
 import io.quarkus.narayana.jta.runtime.NarayanaJtaRecorder;
 import io.quarkus.narayana.jta.runtime.TransactionManagerConfiguration;
 import io.quarkus.narayana.jta.runtime.context.TransactionContext;
+import io.quarkus.narayana.jta.runtime.interceptor.TestTransactionInterceptor;
 import io.quarkus.narayana.jta.runtime.interceptor.TransactionalInterceptorMandatory;
 import io.quarkus.narayana.jta.runtime.interceptor.TransactionalInterceptorNever;
 import io.quarkus.narayana.jta.runtime.interceptor.TransactionalInterceptorNotSupported;
 import io.quarkus.narayana.jta.runtime.interceptor.TransactionalInterceptorRequired;
 import io.quarkus.narayana.jta.runtime.interceptor.TransactionalInterceptorRequiresNew;
 import io.quarkus.narayana.jta.runtime.interceptor.TransactionalInterceptorSupports;
 import io.smallrye.context.jta.context.propagation.JtaContextProvider;
+import io.quarkus.runtime.LaunchMode;
 
 class NarayanaJtaProcessor {
 
@@ -98,6 +119,40 @@ public void build(NarayanaJtaRecorder recorder,
         recorder.setDefaultTimeout(transactions);
     }
 
+    @BuildStep
+    void testTx(LaunchModeBuildItem lm, BuildProducer<GeneratedBeanBuildItem> generatedBeanBuildItemBuildProducer) {
+        if (lm.getLaunchMode() != LaunchMode.TEST) {
+            return;
+        }
+        //generate the annotated interceptor with gizmo
+        //all the logic is in the parent, but we don't have access to the
+        //binding annotation here
+        try (ClassCreator c = new ClassCreator(new GeneratedBeanGizmoAdaptor(generatedBeanBuildItemBuildProducer),
+                TestTransactionInterceptor.class.getName() + "Generated", null, TestTransactionInterceptor.class.getName())) {
+            c.addAnnotation("io.quarkus.test.TestTransaction");
+            c.addAnnotation(Interceptor.class.getName());
+            c.addAnnotation(Priority.class).addValue("value", Interceptor.Priority.PLATFORM_BEFORE + 200);
+
+            FieldCreator field = c.getFieldCreator("ut", UserTransaction.class);
+            field.setModifiers(Modifier.PUBLIC);
+            field
+                    .addAnnotation(Inject.class);
+
+            MethodCreator m = c.getMethodCreator("work", Object.class, InvocationContext.class);
+            m.addAnnotation(AroundInvoke.class);
+            m.addException(Exception.class);
+
+            ResultHandle ut = m.readInstanceField(FieldDescriptor.of(c.getClassName(), "ut", UserTransaction.class),
+                    m.getThis());
+            ResultHandle result = m
+                    .invokeStaticMethod(MethodDescriptor.ofMethod(TestTransactionInterceptor.class, "intercept", Object.class,
+                            UserTransaction.class, InvocationContext.class), ut, m.getMethodParam(0));
+
+            m.returnValue(result);
+        }
+
+    }
+
     @BuildStep
     public void transactionContext(
             BuildProducer<ContextRegistrarBuildItem> contextRegistry) {

extensions/narayana-jta/runtime/src/main/java/io/quarkus/narayana/jta/runtime/interceptor/TestTransactionInterceptor.java

@@ -0,0 +1,41 @@
+package io.quarkus.narayana.jta.runtime.interceptor;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.ServiceLoader;
+
+import javax.interceptor.InvocationContext;
+import javax.transaction.UserTransaction;
+
+import io.quarkus.narayana.jta.runtime.test.TestTransactionCallback;
+
+public class TestTransactionInterceptor {
+
+    static final List<TestTransactionCallback> CALLBACKS;
+
+    static {
+        List<TestTransactionCallback> callbacks = new ArrayList<>();
+        for (TestTransactionCallback i : ServiceLoader.load(TestTransactionCallback.class)) {
+            callbacks.add(i);
+        }
+        CALLBACKS = callbacks;
+    }
+
+    public static Object intercept(UserTransaction userTransaction, InvocationContext context) throws Exception {
+        try {
+            userTransaction.begin();
+            for (TestTransactionCallback i : CALLBACKS) {
+                i.postBegin();
+            }
+            Object result = context.proceed();
+            for (TestTransactionCallback i : CALLBACKS) {
+                i.preRollback();
+            }
+            return result;
+        } finally {
+            userTransaction.rollback();
+        }
+
+    }
+
+}

extensions/narayana-jta/runtime/src/main/java/io/quarkus/narayana/jta/runtime/test/TestTransactionCallback.java

@@ -0,0 +1,9 @@
+package io.quarkus.narayana.jta.runtime.test;
+
+public interface TestTransactionCallback {
+
+    void postBegin();
+
+    void preRollback();
+
+}

integration-tests/hibernate-orm-panache/src/test/java/io/quarkus/it/panache/TestTransactionTest.java

@@ -0,0 +1,33 @@
+package io.quarkus.it.panache;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import io.quarkus.test.TestTransaction;
+import io.quarkus.test.junit.QuarkusTest;
+
+/**
+ * Tests that @TestTransaction works as expected
+ */
+@QuarkusTest
+@TestTransaction
+public class TestTransactionTest {
+
+    @Test
+    @TestTransaction
+    public void test1() {
+        Assertions.assertEquals(0, Beer.find("name", "Lager").count());
+        Beer b = new Beer();
+        b.name = "Lager";
+        Beer.persist(b);
+    }
+
+    @Test
+    @TestTransaction
+    public void test2() {
+        Assertions.assertEquals(0, Beer.find("name", "Lager").count());
+        Beer b = new Beer();
+        b.name = "Lager";
+        Beer.persist(b);
+    }
+}

test-framework/common/src/main/java/io/quarkus/test/TestTransaction.java

@@ -0,0 +1,21 @@
+package io.quarkus.test;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import javax.interceptor.InterceptorBinding;
+
+/**
+ * Indicates that this method should be run in a rollback only transaction.
+ *
+ * This allows the test method to modify the database as required, and then have
+ * these changes reverted at the end of the method.
+ *
+ */
+@InterceptorBinding
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ ElementType.TYPE, ElementType.METHOD })
+public @interface TestTransaction {
+}