By default, CDI discovery is enabled:

• CDI beans and extensions in the classpath are added automatically

• If disabled, the CDI beans and extensions must be added manually

CDI discovery can be disabled using @DisableDiscovery.

@DisableDiscovery 
@AddBean(MyBean.class) 
@HelidonTest
class MyTest {
}

• Disable CDI discovery
• Add a bean class

When disabling discovery, it can be difficult to identify the CDI extensions needed to activate the desired features.

JAXRS (Jersey) support can be added easily using @AddJaxRs.

@DisableDiscovery
@AddJaxRs 
@AddBean(MyResource.class) 
@HelidonTest
class MyTest {
}

• Add JAX-RS (Jersey) support
• Add a resource class to the CDI container

Note the following Helidon CDI extensions:

By default, one CDI container is created per test class and is shared by all test methods.

However, test methods can also require a dedicated CDI container:

• By forcing a reset of the CDI container between methods

• By customizing the CDI container per test method

@HelidonTest(resetPerTest = true)
class MyTest {

    @Test
    void testOne() { 
    }

    @Test
    void testTwo() { 
    }
}

• testOne executes in a dedicated CDI container
• testTwo also executes in a dedicated CDI container

@HelidonTest
class MyTest {

    @Test
    void testOne() { 
    }

    @Test
    @DisableDiscovery
    @AddBean(MyBean.class)
    void testTwo() { 
    }
}

• testOne executes in the shared CDI container
• testTwo executes in a dedicated CDI container

The test configuration can be set up in two exclusive ways:

• Using the "synthetic" configuration expressed with annotations (default)

• Using the "existing" configuration of the current environment

Use @Configuration to switch to the "existing" configuration.

@Configuration(useExisting = true)
@HelidonTest
class MyTest {
}

Synthetic Configuration

@AddConfig(key = "foo", value = "bar")
@HelidonTest
class MyTest {
}

@AddConfigBlock("""
        foo=bar
        bob=alice
        """)
@HelidonTest
class MyTest {
}

@AddConfigBlock(type = "yaml", value = """
        my-test:
          foo: bar
          bob: alice
        """)
@HelidonTest
class MyTest {
}

@HelidonTest
class MyTest {

    @AddConfigSource
    static ConfigSource config() {
        return MpConfigSources.create(Map.of(
                "foo", "bar",
                "bob", "alice"));
    }
}

@Configuration(configSources = {
        "my-test1.yaml",
        "my-test2.yaml"
})
@HelidonTest
class MyTest {
}

Configuration Ordering

@AddConfigBlock(value = """
        config_ordinal=120
        foo=bar
        """)
@HelidonTest
class MyTest {
}

Helidon provides injection support for types that reflect the current server. E.g. JAXRS client.

Here are all the built-in types that can be injected:

@HelidonTest
class MyTest {

    @Inject
    WebTarget target;
}

Use @Socket to specify the socket for the clients and URIs.

@HelidonTest
class MyTest {

    @Inject
    @Socket("admin")
    WebTarget target;
}

@HelidonTest
class MyTest {

    @Inject
    @Socket("@default")
    URI uri;
}

The following example demonstrates how to enable the use of @ConfigProperty without CDI discovery.

@HelidonTest
@DisableDiscovery 
@AddBean(MyBean.class) 
@AddExtension(ConfigCdiExtension.class) 
@AddConfig(key = "app.greeting", value = "TestHello") 
class MyTest {
    @Inject
    MyBean myBean;

    @Test
    void testGreeting() {
        assertThat(myBean, notNullValue());
        assertThat(myBean.greeting(), is("TestHello"));
    }
}

@ApplicationScoped
class MyBean {

    @ConfigProperty(name = "app.greeting") 
    String greeting;

    String greeting() {
        return greeting;
    }
}

• CDI discovery is disabled
• Add MyBean to the CDI container
• Add ConfigCdiExtension to the CDI container
• Define test configuration
• Inject the configuration

The following example demonstrates how to use @RequestScoped with JAXRS without CDI discovery.

@HelidonTest
@DisableDiscovery 
@AddJaxRs 
@AddBean(MyResource.class) 
class MyTest {

    @Inject
    WebTarget target;

    @Test
    void testGet() {
        String greeting = target.path("/greeting")
                .request().get(String.class);
        assertThat(greeting, is("Hallo!"));
    }
}

@Path("/greeting")
@RequestScoped
class MyResource {
    @GET
    Response get() {
        return Response.ok("Hallo!").build();
    }
}

• CDI discovery is disabled
• Add JAXRS (Jersey) support
• Add MyResource to the CDI container

To enable mock mupport add the following dependency to your project’s pom.xml.

<dependency>
    <groupId>io.helidon.microprofile.testing</groupId>
    <artifactId>helidon-microprofile-testing-mocking</artifactId>
    <scope>test</scope>
</dependency>

Use the @MockBean annotation to inject an instrumented CDI bean in your test, and customize it in the test method.

Example

@HelidonTest
@AddBean(MyResource.class)
@AddBean(MyService.class)
class MyTest {

    @MockBean(answer = Answers.CALLS_REAL_METHODS) 
    MyService myService;

    @Inject
    WebTarget target;

    @Test
    void testService() {
        Mockito.when(myService.test()).thenReturn("Mocked"); 
        String response = target.path("/test").request().get(String.class);
        assertThat(response, is("Mocked"));
    }
}

@Path("/test")
class MyResource {

    @Inject
    MyService myService;

    @GET
    String test() {
        return myService.test();
    }
}

@ApplicationScoped
class MyService {

    String test() {
        return "Not Mocked";
    }
}