Injection of web target with correct endpoint. (helidon-io#2380)

* Injection of web target with correct endpoint.
* Support for junit5 tests already in MP Config implementation
* Support for inherited repeating annotations.

Signed-off-by: Tomas Langer <tomas.langer@oracle.com>

Author: tomas-langer

docs/mp/testing/01_testing.adoc

@@ -41,6 +41,11 @@ A test can be annotated with `io.helidon.microprofile.tests.junit5.HelidonTest`
 CDI test. This annotation will start the CDI container before any test method is invoked, and stop it after
 the last method is invoked. This annotation also enables injection into the test class itself.
 
+The annotations described in this section are inherited (for the non-repeatable ones), and additive (for repeatable).
+So if you declare `@DisableDiscovery` on abstract class, all implementations will have discovery disabled, unless you
+annotate the implementation class with `@DisableDiscovery(false)`.
+If you declare `@AddBean` on both abstract class and implementation class, both beans will be added.
+
 In addition to this simplification, the following annotations are supported:
 
 - `io.helidon.microprofile.tests.junit5.AddBean` - to add one or more beans to the container
@@ -49,6 +54,7 @@ In addition to this simplification, the following annotations are supported:
         (if not added through service loader, or when discovery is disabled)
 - `io.helidon.microprofile.tests.junit5.AddConfig` - to add one or more configuration properties to MicroProfile config
         without the need of creating a `microprofile-config.properties` file
+- `io.helidon.microprofile.tests.junit5.DisableDiscovery` - to disable automated discovery of beans and extensions
 
 [source,java]
 .Code sample
@@ -84,10 +90,23 @@ This will change the behavior as follows:
 
 == Usage - configuration
 In addition to the `@AddConfig` annotation, you can also use
- `@Configuration`.
+ `@Configuration` to configure additional classpath properties config sources using `configSources`, and to
+mark that a custom configuration is desired.
+You can set up config in `@BeforeAll` method and register it with `ConfigProviderResolver` using MP Config APIs, and declare
+`@Configuration(useExisting=true)`.
+Note that this is not compatible with repeatable tests that use method sources that access CDI, as we must delay the CDI
+startup to the test class instantiation (which is too late, as the method sources are already invoked by this time).
+
+*If you want to use method sources that use CDI with repeatable tests, please do not use `@Configuration(useExisting=true)`*
+
+== Usage - added parameters and injection types
+The following types are available for injection (when a single CDI container is used per test class):
+
+- `WebTarget` - a JAX-RS client's target configured for the current hostname and port when `helidon-micorprofile-server` is on
+        the classpath
 
-This allows you to do the following:
+The following types are available as method parameters (in any type of Helidon tests):
 
-- when `useExisting` is set to `true`, the configuration will not be changed
-        and current MP configuration will be used
-- you can configure additional classpath properties config sources using `configSources`
+- `WebTarget` - a JAX-RS client's target configured for the current hostname and port when `helidon-micorprofile-server` is on
+        the classpath
+- `SeContainer` - the current container instance

fault-tolerance/src/test/java/io/helidon/faulttolerance/RetryTest.java

@@ -36,9 +36,8 @@
 import static org.hamcrest.CoreMatchers.instanceOf;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.isOneOf;
 import static org.hamcrest.Matchers.contains;
-import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.hamcrest.Matchers.isOneOf;
 
 class RetryTest {
     @Test

microprofile/config/pom.xml

@@ -86,5 +86,10 @@
             <version>${project.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>io.helidon.microprofile.tests</groupId>
+            <artifactId>helidon-microprofile-tests-junit5</artifactId>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 </project>

microprofile/config/src/test/java/io/helidon/microprofile/config/MpConfigInjectionTest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2020 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.
@@ -18,30 +18,23 @@
 
 import java.lang.annotation.Retention;
 import java.lang.annotation.Target;
-import java.util.Map;
 
 import javax.enterprise.context.Dependent;
-import javax.enterprise.inject.se.SeContainer;
-import javax.enterprise.inject.se.SeContainerInitializer;
-import javax.enterprise.inject.spi.CDI;
-import javax.enterprise.util.AnnotationLiteral;
 import javax.inject.Inject;
 import javax.inject.Qualifier;
 
-import io.helidon.config.test.infra.RestoreSystemPropertiesExt;
 import io.helidon.microprofile.config.Converters.Ctor;
 import io.helidon.microprofile.config.Converters.Of;
 import io.helidon.microprofile.config.Converters.Parse;
 import io.helidon.microprofile.config.Converters.ValueOf;
+import io.helidon.microprofile.tests.junit5.AddBean;
+import io.helidon.microprofile.tests.junit5.AddConfig;
+import io.helidon.microprofile.tests.junit5.HelidonTest;
 
 import org.eclipse.microprofile.config.inject.ConfigProperty;
-import org.eclipse.microprofile.config.spi.ConfigProviderResolver;
-import org.eclipse.microprofile.config.spi.ConfigSource;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
 
+import static java.lang.annotation.ElementType.FIELD;
 import static java.lang.annotation.ElementType.TYPE;
 import static java.lang.annotation.RetentionPolicy.RUNTIME;
 import static org.hamcrest.MatcherAssert.assertThat;
@@ -51,41 +44,23 @@
 /**
  * Unit test for MP config injection.
  */
-@ExtendWith(RestoreSystemPropertiesExt.class)
+@HelidonTest
+@AddConfig(key = "inject.of", value = "of")
+@AddConfig(key = "inject.valueOf", value = "valueOf")
+@AddConfig(key = "inject.parse", value = "parse")
+@AddConfig(key = "inject.ctor", value = "ctor")
+@AddBean(value = MpConfigInjectionTest.Bean.class, scope = Dependent.class)
+@AddBean(value = MpConfigInjectionTest.SubBean.class, scope = Dependent.class)
 class MpConfigInjectionTest {
-    private static SeContainer container;
+    @Inject
+    private Bean bean;
 
-    @BeforeAll
-    static void initClass() {
-
-        // Removed use of system properties, as those stay around after test is finished
-        ConfigProviderResolver configProvider = ConfigProviderResolver.instance();
-
-        configProvider.registerConfig(configProvider.getBuilder()
-                                              .addDefaultSources()
-                                              .withSources(new TestSource())
-                                              .build(),
-                                      Thread.currentThread().getContextClassLoader());
-
-
-        // CDI container
-        container = SeContainerInitializer.newInstance()
-                .addBeanClasses(Bean.class, SubBean.class)
-                .initialize();
-    }
-
-    @AfterAll
-    static void destroyClass() {
-        if (null != container) {
-            container.close();
-        }
-    }
+    @Inject
+    @Specific
+    private SubBean subBean;
 
     @Test
     public void testImplicitConversion() {
-
-        Bean bean = CDI.current().select(Bean.class).get();
-
         assertAll("Implicit conversion injection",
                   () -> assertThat("of", bean.of, is(Of.of("of"))),
                   () -> assertThat("valueOf", bean.valueOf, is(ValueOf.valueOf("valueOf"))),
@@ -96,22 +71,15 @@ public void testImplicitConversion() {
 
     @Test
     public void testImplicitConversionSubclass() {
-
-        Bean bean = CDI.current().select(SubBean.class,
-                new AnnotationLiteral<Specific>() {
-                }).get();
-
         assertAll("Implicit conversion injection",
-                () -> assertThat("of", bean.of, is(Of.of("of"))),
-                () -> assertThat("valueOf", bean.valueOf, is(ValueOf.valueOf("valueOf"))),
-                () -> assertThat("parse", bean.parse, is(Parse.parse("parse"))),
-                () -> assertThat("ctor", bean.ctor, is(new Ctor("ctor")))
+                  () -> assertThat("of", subBean.of, is(Of.of("of"))),
+                  () -> assertThat("valueOf", subBean.valueOf, is(ValueOf.valueOf("valueOf"))),
+                  () -> assertThat("parse", subBean.parse, is(Parse.parse("parse"))),
+                  () -> assertThat("ctor", subBean.ctor, is(new Ctor("ctor")))
         );
     }
 
-    @Dependent
     public static class Bean {
-
         @Inject
         @ConfigProperty(name = "inject.of")
         public Of of;
@@ -131,36 +99,11 @@ public static class Bean {
 
     @Qualifier
     @Retention(RUNTIME)
-    @Target(TYPE)
+    @Target({TYPE, FIELD})
     public @interface Specific {
     }
 
-    @Dependent
     @Specific
     public static class SubBean extends Bean {
     }
-
-    private static class TestSource implements ConfigSource {
-        private final Map<String, String> properties = Map.of(
-                "inject.of", "of",
-                "inject.valueOf", "valueOf",
-                "inject.parse", "parse",
-                "inject.ctor", "ctor"
-        );
-
-        @Override
-        public Map<String, String> getProperties() {
-            return properties;
-        }
-
-        @Override
-        public String getValue(String propertyName) {
-            return properties.get(propertyName);
-        }
-
-        @Override
-        public String getName() {
-            return getClass().getName();
-        }
-    }
 }

microprofile/config/src/test/java/io/helidon/microprofile/config/MutableMpTest.java

@@ -22,22 +22,25 @@
 
 import javax.enterprise.context.Dependent;
 import javax.enterprise.inject.se.SeContainer;
-import javax.enterprise.inject.se.SeContainerInitializer;
-import javax.enterprise.inject.spi.CDI;
 import javax.inject.Inject;
 
+import io.helidon.microprofile.tests.junit5.AddBean;
+import io.helidon.microprofile.tests.junit5.Configuration;
+import io.helidon.microprofile.tests.junit5.HelidonTest;
+
 import org.eclipse.microprofile.config.inject.ConfigProperty;
 import org.eclipse.microprofile.config.spi.ConfigProviderResolver;
 import org.eclipse.microprofile.config.spi.ConfigSource;
-import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
 
-public class MutableMpTest {
-    private static SeContainer container;
+@HelidonTest
+@Configuration(useExisting = true)
+@AddBean(value = MutableMpTest.Bean.class, scope = Dependent.class)
+class MutableMpTest {
     private static MutableSource source;
 
     @BeforeAll
@@ -50,35 +53,21 @@ static void initClass() {
                                               .withSources(source)
                                               .build(),
                                       Thread.currentThread().getContextClassLoader());
-
-        // CDI container
-        container = SeContainerInitializer.newInstance()
-                .addBeanClasses(Bean.class)
-                .initialize();
-    }
-
-    @AfterAll
-    static void destroyClass() {
-        if (null != container) {
-            container.close();
-        }
-        source = null;
     }
 
     @Test
-    public void testMutable() {
-        Bean bean = CDI.current().select(Bean.class).get();
+    public void testMutable(SeContainer cdi) {
+        Bean bean = cdi.select(Bean.class).get();
 
         assertThat(bean.value, is("initial"));
 
         source.setValue("updated");
 
-        bean = CDI.current().select(Bean.class).get();
+        bean = cdi.select(Bean.class).get();
 
         assertThat(bean.value, is("updated"));
     }
 
-    @Dependent
     public static class Bean {
         @Inject
         @ConfigProperty(name = "value")

microprofile/cors/pom.xml

@@ -71,5 +71,10 @@
             <artifactId>helidon-microprofile-server</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>io.helidon.microprofile.tests</groupId>
+            <artifactId>helidon-microprofile-tests-junit5</artifactId>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 </project>