Weld-2772 Allow to register BCE in Weld SE without discovery

weld · May 15, 2024 · 7b16c24 · 7b16c24
1 parent 70ee338
commit 7b16c24
Show file tree

Hide file tree

Showing 8 changed files with 219 additions and 7 deletions.
diff --git a/environments/se/core/src/main/java/org/jboss/weld/environment/se/Weld.java b/environments/se/core/src/main/java/org/jboss/weld/environment/se/Weld.java
@@ -51,6 +51,7 @@
 import jakarta.enterprise.context.spi.CreationalContext;
 import jakarta.enterprise.inject.UnsatisfiedResolutionException;
 import jakarta.enterprise.inject.Vetoed;
+import jakarta.enterprise.inject.build.compatible.spi.BuildCompatibleExtension;
 import jakarta.enterprise.inject.se.SeContainerInitializer;
 import jakarta.enterprise.inject.spi.Bean;
 import jakarta.enterprise.inject.spi.BeanManager;
@@ -279,6 +280,8 @@ public class Weld extends SeContainerInitializer implements ContainerInstanceFac
 
     private final Set<Metadata<Extension>> extensions;
 
+    private final Set<Class<? extends BuildCompatibleExtension>> buildCompatibleExtensions;
+
     private final Map<String, Object> properties;
 
     private final Set<PackInfo> packages;
@@ -307,6 +310,7 @@ public Weld(String containerId) {
         this.enabledInterceptors = new ArrayList<Metadata<String>>();
         this.enabledDecorators = new ArrayList<Metadata<String>>();
         this.extensions = new HashSet<Metadata<Extension>>();
+        this.buildCompatibleExtensions = new HashSet<>();
         this.properties = new HashMap<String, Object>();
         this.packages = new HashSet<PackInfo>();
         this.containerLifecycleObservers = new LinkedList<>();
@@ -482,6 +486,13 @@ public Weld addExtensions(Class<? extends Extension>... extensionClasses) {
         return this;
     }
 
+    public Weld addBuildCompatibleExtensions(Class<? extends BuildCompatibleExtension>... extensionClasses) {
+        for (Class<? extends BuildCompatibleExtension> extension : extensionClasses) {
+            buildCompatibleExtensions.add(extension);
+        }
+        return this;
+    }
+
     /**
      * Add a synthetic container lifecycle event observer.
      *
@@ -748,6 +759,7 @@ public Weld reset() {
         enabledInterceptors.clear();
         enabledDecorators.clear();
         extensions.clear();
+        buildCompatibleExtensions.clear();
         containerLifecycleObservers.clear();
         additionalServices.clear();
         return this;
@@ -1163,9 +1175,13 @@ protected Iterable<Metadata<Extension>> getExtensions() {
         }
         // Register org.jboss.weld.lite.extension.translator.LiteExtensionTranslator in order to be able to execute build compatible extensions
         // Note that we only register this if we detect any BuildCompatibleExtension implementations
-        if (!BuildCompatibleExtensionLoader.getBuildCompatibleExtensions().isEmpty()) {
+        Set<Class<? extends BuildCompatibleExtension>> allBce = new HashSet<>();
+        allBce.addAll(BuildCompatibleExtensionLoader.getBuildCompatibleExtensions());
+        allBce.addAll(buildCompatibleExtensions);
+        if (!allBce.isEmpty()) {
             try {
-                result.add(new MetadataImpl<Extension>(SecurityActions.newInstance(LiteExtensionTranslator.class),
+                result.add(new MetadataImpl<Extension>(
+                        new LiteExtensionTranslator(allBce, Thread.currentThread().getContextClassLoader()),
                         SYNTHETIC_LOCATION_PREFIX + LiteExtensionTranslator.class.getName()));
             } catch (Exception e) {
                 throw new RuntimeException(e);

diff --git a/...compatible/none/TestNoExtensionFound.java → ...compatible/none/NoExtensionFoundTest.java b/...compatible/none/TestNoExtensionFound.java → ...compatible/none/NoExtensionFoundTest.java
@@ -17,8 +17,6 @@
 
 package org.jboss.weld.environment.se.test.extension.build.compatible.none;
 
-import jakarta.enterprise.inject.spi.Extension;
-
 import org.jboss.arquillian.container.se.api.ClassPath;
 import org.jboss.arquillian.container.test.api.Deployment;
 import org.jboss.arquillian.junit.Arquillian;
@@ -38,13 +36,13 @@
  * added to the deployment.
  */
 @RunWith(Arquillian.class)
-public class TestNoExtensionFound {
+public class NoExtensionFoundTest {
 
     @Deployment
     public static Archive<?> getDeployment() {
         return ClassPath.builder()
-                .add(ShrinkWrap.create(BeanArchive.class, Utils.getDeploymentNameAsHash(TestNoExtensionFound.class))
-                        .addPackage(TestNoExtensionFound.class.getPackage()))
+                .add(ShrinkWrap.create(BeanArchive.class, Utils.getDeploymentNameAsHash(NoExtensionFoundTest.class))
+                        .addPackage(NoExtensionFoundTest.class.getPackage()))
                 .build();
     }
 

diff --git a/...g/jboss/weld/environment/se/test/extension/build/compatible/registered/DiscoveredBce.java b/...g/jboss/weld/environment/se/test/extension/build/compatible/registered/DiscoveredBce.java
@@ -0,0 +1,39 @@
+package org.jboss.weld.environment.se.test.extension.build.compatible.registered;
+
+import jakarta.enterprise.inject.build.compatible.spi.BeanInfo;
+import jakarta.enterprise.inject.build.compatible.spi.BuildCompatibleExtension;
+import jakarta.enterprise.inject.build.compatible.spi.Discovery;
+import jakarta.enterprise.inject.build.compatible.spi.Enhancement;
+import jakarta.enterprise.inject.build.compatible.spi.Registration;
+import jakarta.enterprise.inject.build.compatible.spi.Synthesis;
+import jakarta.enterprise.inject.build.compatible.spi.Validation;
+import jakarta.enterprise.lang.model.declarations.ClassInfo;
+
+public class DiscoveredBce implements BuildCompatibleExtension {
+    public static int TIMES_INVOKED = 0;
+
+    @Discovery
+    public void discovery() {
+        TIMES_INVOKED++;
+    }
+
+    @Enhancement(types = SomeBean.class)
+    public void enhancement(ClassInfo c) {
+        TIMES_INVOKED++;
+    }
+
+    @Registration(types = SomeBean.class)
+    public void registration(BeanInfo b) {
+        TIMES_INVOKED++;
+    }
+
+    @Synthesis
+    public void synthesis() {
+        TIMES_INVOKED++;
+    }
+
+    @Validation
+    public void validation() {
+        TIMES_INVOKED++;
+    }
+}
diff --git a/...onment/se/test/extension/build/compatible/registered/ExtensionRegisteredManuallyTest.java b/...onment/se/test/extension/build/compatible/registered/ExtensionRegisteredManuallyTest.java
@@ -0,0 +1,40 @@
+package org.jboss.weld.environment.se.test.extension.build.compatible.registered;
+
+import org.jboss.arquillian.container.se.api.ClassPath;
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.shrinkwrap.api.Archive;
+import org.jboss.shrinkwrap.api.BeanArchive;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.weld.environment.se.Weld;
+import org.jboss.weld.environment.se.WeldContainer;
+import org.jboss.weld.lite.extension.translator.LiteExtensionTranslator;
+import org.jboss.weld.test.util.Utils;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(Arquillian.class)
+public class ExtensionRegisteredManuallyTest {
+
+    @Deployment
+    public static Archive<?> getDeployment() {
+        return ClassPath.builder()
+                .add(ShrinkWrap.create(BeanArchive.class, Utils.getDeploymentNameAsHash(ExtensionRegisteredManuallyTest.class))
+                        .addPackage(ExtensionRegisteredManuallyTest.class.getPackage()))
+                .build();
+    }
+
+    @Test
+    public void testManuallyAddedBce() {
+        ManuallyRegisteredBce.TIMES_INVOKED = 0;
+        try (WeldContainer container = new Weld().addBuildCompatibleExtensions(ManuallyRegisteredBce.class).initialize()) {
+            // assert the deployment is fine, DummyBean should be resolvable
+            Assert.assertTrue(container.select(SomeBean.class).isResolvable());
+            // LiteExtensionTranslator should be present
+            Assert.assertTrue(container.select(LiteExtensionTranslator.class).isResolvable());
+            // assert that BCE was invoked correctly
+            Assert.assertEquals(5, ManuallyRegisteredBce.TIMES_INVOKED);
+        }
+    }
+}
diff --git a/...weld/environment/se/test/extension/build/compatible/registered/ManuallyRegisteredBce.java b/...weld/environment/se/test/extension/build/compatible/registered/ManuallyRegisteredBce.java
@@ -0,0 +1,39 @@
+package org.jboss.weld.environment.se.test.extension.build.compatible.registered;
+
+import jakarta.enterprise.inject.build.compatible.spi.BeanInfo;
+import jakarta.enterprise.inject.build.compatible.spi.BuildCompatibleExtension;
+import jakarta.enterprise.inject.build.compatible.spi.Discovery;
+import jakarta.enterprise.inject.build.compatible.spi.Enhancement;
+import jakarta.enterprise.inject.build.compatible.spi.Registration;
+import jakarta.enterprise.inject.build.compatible.spi.Synthesis;
+import jakarta.enterprise.inject.build.compatible.spi.Validation;
+import jakarta.enterprise.lang.model.declarations.ClassInfo;
+
+public class ManuallyRegisteredBce implements BuildCompatibleExtension {
+    public static int TIMES_INVOKED = 0;
+
+    @Discovery
+    public void discovery() {
+        TIMES_INVOKED++;
+    }
+
+    @Enhancement(types = SomeBean.class)
+    public void enhancement(ClassInfo c) {
+        TIMES_INVOKED++;
+    }
+
+    @Registration(types = SomeBean.class)
+    public void registration(BeanInfo b) {
+        TIMES_INVOKED++;
+    }
+
+    @Synthesis
+    public void synthesis() {
+        TIMES_INVOKED++;
+    }
+
+    @Validation
+    public void validation() {
+        TIMES_INVOKED++;
+    }
+}
diff --git a/.../se/test/extension/build/compatible/registered/RegisteredAndDiscoveredExtensionsTest.java b/.../se/test/extension/build/compatible/registered/RegisteredAndDiscoveredExtensionsTest.java
@@ -0,0 +1,63 @@
+package org.jboss.weld.environment.se.test.extension.build.compatible.registered;
+
+import jakarta.enterprise.inject.build.compatible.spi.BuildCompatibleExtension;
+
+import org.jboss.arquillian.container.se.api.ClassPath;
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.shrinkwrap.api.Archive;
+import org.jboss.shrinkwrap.api.BeanArchive;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.weld.environment.se.Weld;
+import org.jboss.weld.environment.se.WeldContainer;
+import org.jboss.weld.lite.extension.translator.LiteExtensionTranslator;
+import org.jboss.weld.test.util.Utils;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(Arquillian.class)
+public class RegisteredAndDiscoveredExtensionsTest {
+
+    @Deployment
+    public static Archive<?> getDeployment() {
+        return ClassPath.builder()
+                .add(ShrinkWrap.create(BeanArchive.class, Utils.getDeploymentNameAsHash(ExtensionRegisteredManuallyTest.class))
+                        .addPackage(ExtensionRegisteredManuallyTest.class.getPackage())
+                        .addAsServiceProvider(BuildCompatibleExtension.class, DiscoveredBce.class))
+                .build();
+    }
+
+    @Test
+    public void testDiscoveryAndExplicitAddition() {
+        ManuallyRegisteredBce.TIMES_INVOKED = 0;
+        DiscoveredBce.TIMES_INVOKED = 0;
+        try (WeldContainer container = new Weld().addBuildCompatibleExtensions(ManuallyRegisteredBce.class).initialize()) {
+            // assert the deployment is fine, DummyBean should be resolvable
+            Assert.assertTrue(container.select(SomeBean.class).isResolvable());
+            // LiteExtensionTranslator should be present
+            Assert.assertTrue(container.select(LiteExtensionTranslator.class).isResolvable());
+            // assert that manually added BCE was invoked correctly
+            Assert.assertEquals(5, ManuallyRegisteredBce.TIMES_INVOKED);
+            // assert that discovered BCE was invoked correctly
+            Assert.assertEquals(5, DiscoveredBce.TIMES_INVOKED);
+        }
+    }
+
+    @Test
+    public void testAddingAlreadyDiscoveredExtension() {
+        ManuallyRegisteredBce.TIMES_INVOKED = 0;
+        DiscoveredBce.TIMES_INVOKED = 0;
+        try (WeldContainer container = new Weld().addBuildCompatibleExtensions(DiscoveredBce.class, ManuallyRegisteredBce.class)
+                .initialize()) {
+            // assert the deployment is fine, DummyBean should be resolvable
+            Assert.assertTrue(container.select(SomeBean.class).isResolvable());
+            // LiteExtensionTranslator should be present
+            Assert.assertTrue(container.select(LiteExtensionTranslator.class).isResolvable());
+            // assert that manually added BCE was invoked correctly
+            Assert.assertEquals(5, ManuallyRegisteredBce.TIMES_INVOKED);
+            // despite being added manually and also discovered, it should only use a single instance of this extension
+            Assert.assertEquals(5, DiscoveredBce.TIMES_INVOKED);
+        }
+    }
+}
diff --git a/...va/org/jboss/weld/environment/se/test/extension/build/compatible/registered/SomeBean.java b/...va/org/jboss/weld/environment/se/test/extension/build/compatible/registered/SomeBean.java
@@ -0,0 +1,7 @@
+package org.jboss.weld.environment.se.test.extension.build.compatible.registered;
+
+import jakarta.enterprise.context.Dependent;
+
+@Dependent
+public class SomeBean {
+}
diff --git a/...lator/src/main/java/org/jboss/weld/lite/extension/translator/LiteExtensionTranslator.java b/...lator/src/main/java/org/jboss/weld/lite/extension/translator/LiteExtensionTranslator.java
@@ -3,6 +3,7 @@
 import java.lang.annotation.Annotation;
 import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 
 import jakarta.annotation.Priority;
@@ -42,7 +43,16 @@ public LiteExtensionTranslator() {
         this(BuildCompatibleExtensionLoader.getBuildCompatibleExtensions(), Thread.currentThread().getContextClassLoader());
     }
 
+    /**
+     * Deprecated, use {@link LiteExtensionTranslator#LiteExtensionTranslator(Collection, ClassLoader)}
+     */
+    @Deprecated
     public LiteExtensionTranslator(List<Class<? extends BuildCompatibleExtension>> buildCompatibleExtensions, ClassLoader cl) {
+        this((Collection<Class<? extends BuildCompatibleExtension>>) buildCompatibleExtensions, cl);
+    }
+
+    public LiteExtensionTranslator(Collection<Class<? extends BuildCompatibleExtension>> buildCompatibleExtensions,
+            ClassLoader cl) {
         this.util = new ExtensionInvoker(buildCompatibleExtensions);
         this.cl = cl;
         // clear out information about extensions we found, this is to prevent issues in test environments where this