Fix MockBean to work with ArgumentMatcher

- Use Singleton instead of ApplicationScoped to avoid client proxies
- Use produceWith instead of createWith
- Use addTransitiveTypeClosure instead of addType to support more than just one type
- Minor refactoring of the processMockBean method
- Add unit test

Fixes #9397

microprofile/testing/mocking/src/main/java/io/helidon/microprofile/testing/mocking/MockBeansCdiExtension.java

@@ -17,20 +17,16 @@
 
 import java.lang.reflect.Field;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
-import java.util.Set;
 
-import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.enterprise.event.Observes;
+import jakarta.enterprise.inject.Instance;
 import jakarta.enterprise.inject.literal.InjectLiteral;
 import jakarta.enterprise.inject.spi.AfterBeanDiscovery;
-import jakarta.enterprise.inject.spi.AnnotatedParameter;
-import jakarta.enterprise.inject.spi.Bean;
-import jakarta.enterprise.inject.spi.BeanManager;
 import jakarta.enterprise.inject.spi.Extension;
 import jakarta.enterprise.inject.spi.ProcessAnnotatedType;
 import jakarta.enterprise.inject.spi.WithAnnotations;
+import jakarta.inject.Singleton;
 import org.mockito.MockSettings;
 import org.mockito.Mockito;
 
@@ -41,52 +37,40 @@ public class MockBeansCdiExtension implements Extension {
 
     private final Map<Class<?>, MockBean> mocks = new HashMap<>();
 
-    void processMockBean(@Observes @WithAnnotations(MockBean.class) ProcessAnnotatedType<?> obj) throws Exception {
+    void processMockBean(@Observes @WithAnnotations(MockBean.class) ProcessAnnotatedType<?> obj) {
         var configurator = obj.configureAnnotatedType();
         configurator.fields().forEach(field -> {
             MockBean mockBean = field.getAnnotated().getAnnotation(MockBean.class);
             if (mockBean != null) {
                 Field f = field.getAnnotated().getJavaMember();
-                // Adds @Inject to be more user friendly
+                // Adds @Inject to be more user-friendly
                 field.add(InjectLiteral.INSTANCE);
                 Class<?> fieldType = f.getType();
                 mocks.put(fieldType, mockBean);
             }
         });
-        configurator.constructors().forEach(constructor -> {
-            processMockBeanParameters(constructor.getAnnotated().getParameters());
-        });
-    }
-
-    private void processMockBeanParameters(List<? extends AnnotatedParameter<?>> parameters) {
-        parameters.stream().forEach(parameter -> {
+        configurator.constructors().forEach(ctor -> ctor.getAnnotated().getParameters().forEach(parameter -> {
             MockBean mockBean = parameter.getAnnotation(MockBean.class);
             if (mockBean != null) {
                 Class<?> parameterType = parameter.getJavaParameter().getType();
                 mocks.put(parameterType, mockBean);
             }
-        });
+        }));
     }
 
-    void registerOtherBeans(@Observes AfterBeanDiscovery event, BeanManager beanManager) {
+    void registerOtherBeans(@Observes AfterBeanDiscovery event) {
         // Register all mocks
-        mocks.entrySet().forEach(entry -> {
-            event.addBean()
-                .addType(entry.getKey())
-                .scope(ApplicationScoped.class)
+        mocks.forEach((key, value) -> event.addBean()
+                .addTransitiveTypeClosure(key)
+                .scope(Singleton.class)
                 .alternative(true)
-                .createWith(inst -> {
-                    Set<Bean<?>> beans = beanManager.getBeans(MockSettings.class);
-                    if (!beans.isEmpty()) {
-                        Bean<?> bean = beans.iterator().next();
-                        MockSettings mockSettings = (MockSettings) beanManager.getReference(bean, MockSettings.class,
-                                beanManager.createCreationalContext(null));
-                        return Mockito.mock(entry.getKey(), mockSettings);
-                    } else {
-                        return Mockito.mock(entry.getKey(), Mockito.withSettings().defaultAnswer(entry.getValue().answer()));
-                    }
+                .produceWith(i -> {
+                    Instance<MockSettings> msi = i.select(MockSettings.class);
+                    MockSettings settings = msi.isUnsatisfied()
+                            ? Mockito.withSettings().defaultAnswer(value.answer())
+                            : msi.get();
+                    return Mockito.mock(key, settings);
                 })
-                .priority(0);
-        });
+                .priority(0));
     }
 }

microprofile/tests/testing/junit5/src/test/java/io/helidon/microprofile/tests/testing/junit5/TestMockBeanArgumentMatcher.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.helidon.microprofile.tests.testing.junit5;
+
+import io.helidon.microprofile.testing.junit5.AddBean;
+import io.helidon.microprofile.testing.junit5.HelidonTest;
+import io.helidon.microprofile.testing.mocking.MockBean;
+
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.inject.Inject;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.QueryParam;
+import jakarta.ws.rs.client.WebTarget;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.mockito.ArgumentMatchers.anyString;
+
+@HelidonTest
+@AddBean(TestMockBeanArgumentMatcher.Resource.class)
+@AddBean(TestMockBeanArgumentMatcher.Service.class)
+class TestMockBeanArgumentMatcher {
+
+    @MockBean
+    private Service service;
+
+    @Test
+    void testArgumentMatcher(WebTarget target) {
+        Mockito.when(service.test(anyString())).thenReturn("Mocked");
+        String response = target.path("/test")
+                .queryParam("str", "anything")
+                .request()
+                .get(String.class);
+        assertThat(response, is("Mocked"));
+    }
+
+    @Path("/test")
+    public static class Resource {
+
+        @Inject
+        private Service service;
+
+        @GET
+        public String post(@QueryParam("str") String str) {
+            return service.test(str);
+        }
+    }
+
+    @ApplicationScoped
+    static class Service {
+
+        String test(String str) {
+            return "Not Mocked: " + str;
+        }
+    }
+}