WildFly JUnit Extension

<dependency>
    <groupId>org.wildfly.testing</groupId>
    <artifactId>wildfly-junit-extension</artifactId>
    <version>${version.org.wildfly.testing}</version>
    <scope>test</scope>
</dependency>

@WildFlyTest
public class HelloWorldTest {

    @GenerateDeployment
    public static void createDeployment(final WebArchive deployment) {
        deployment.addClass(HelloServlet.class);
    }

    @Test
    public void testHello(@ServerResource URI uri) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(uri.resolve("hello"))
                .build();
        HttpResponse<String> response = client.send(request,
                HttpResponse.BodyHandlers.ofString());
        Assertions.assertEquals(200, response.statusCode());
    }
}

@WildFlyTest
public class MyTest {
    @Test
    public void test() {
        // WildFly server is automatically started
    }
}

# Run only standalone tests
mvn test -Dgroups=wildfly-standalone

# Run only domain tests
mvn test -Dgroups=wildfly-domain

# Run only manual mode tests
mvn test -Dgroups=wildfly-manual

# Run standalone automatic mode tests (not manual)
mvn test -Dgroups=wildfly-standalone -DexcludedGroups=wildfly-manual

# Run all non-domain tests
mvn test -DexcludedGroups=wildfly-domain

@WildFlyTest
public class DeploymentTest {

    @DeploymentProducer
    public static WebArchive deployment() {
        return ShrinkWrap.create(WebArchive.class, "test.war")
                .addClass(TestServlet.class)
                .addAsWebInfResource(EmptyAsset.INSTANCE, "beans.xml");
    }

    @Test
    public void test() {
        // Test against deployed application
    }
}

@WildFlyTest
public class GenerateTest {

    @GenerateDeployment
    public static void generate(final WebArchive war) {
        war.addClass(TestServlet.class)
           .addAsWebInfResource(EmptyAsset.INSTANCE, "beans.xml");
    }

    @Test
    public void test() {
        // Test implementation
    }
}

@WildFlyTest
public class ResourceTest {

    @ServerResource
    private ServerManager serverManager;

    @ServerResource
    private URI uri;

    @Test
    public void test() {
        Assertions.assertTrue(serverManager.isRunning());
        Assertions.assertNotNull(uri);
    }
}

@WildFlyTest
@ManualMode
public class ManualTest {

    @ServerResource
    private static ServerManager serverManager;  // Must be static for @BeforeAll/@AfterAll

    @BeforeAll
    static void startServer() {
        serverManager.start();
    }

    @AfterAll
    static void stopServer() {
        serverManager.shutdown();
    }

    @Test
    public void test() {
        // Test with running server
        Assertions.assertTrue(serverManager.isRunning());
    }
}

// Start the server
serverManager.start();

// Check if server is running
boolean running = serverManager.isRunning();

// Shutdown the server
serverManager.shutdown();

// Kill the server process (forceful)
serverManager.kill();

// Deploy an archive
DeploymentResult result = serverManager.deploy(archive);

// Undeploy by name
serverManager.undeploy(deploymentName);

// Redeploy
serverManager.redeploy(archive);

// Read an attribute
ModelNode op = Operations.createReadAttributeOperation(
    Operations.createAddress("subsystem", "logging"),
    "add-logging-api-dependencies"
);
ModelNode result = serverManager.executeOperation(op);

// Write an attribute
op = Operations.createWriteAttributeOperation(
    Operations.createAddress("system-property", "my.property"),
    "value",
    "my-value"
);
serverManager.executeOperation(op);

// Reload the server
serverManager.reload();

// Wait for server to be ready
serverManager.waitFor(30, TimeUnit.SECONDS);

// Take a configuration snapshot
String snapshotName = serverManager.takeSnapshot();

# HTTP on custom port
mvn test -Dwildfly.http.port=8180

# HTTPS with default port
mvn test -Dwildfly.http.protocol=https

# HTTPS on custom port
mvn test -Dwildfly.http.protocol=https -Dwildfly.http.port=9443

# src/test/resources/junit-platform.properties
jboss.home=/opt/wildfly-38.0.1.Final
wildfly.timeout=60

<!-- pom.xml -->
<properties>
    <jboss.home>${project.build.directory}/wildfly</jboss.home>
    <wildfly.timeout>180</wildfly.timeout>
</properties>

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <configuration>
                <systemPropertyVariables>
                    <jboss.home>${jboss.home}</jboss.home>
                    <wildfly.timeout>${wildfly.timeout}</wildfly.timeout>
                </systemPropertyVariables>
            </configuration>
        </plugin>
    </plugins>
</build>

# Custom HTTP port
mvn test -Dwildfly.http.port=8180

# HTTPS on custom port
mvn test -Dwildfly.http.protocol=https -Dwildfly.http.port=9443

wildfly.http.protocol=https
wildfly.http.port=8443

mvn test -Dwildfly.debug

mvn test -Dwildfly.java.home=/usr/lib/jvm/java-21-openjdk

@MetaInfServices
public class CustomStandaloneConfig implements StandaloneConfigurationFactory {

    @Override
    public ServerConfiguration create(ExtensionContext context) {
        return ServerConfiguration.builder()
                .configFile("standalone-custom.xml")
                .jvmArgs("-Xmx2g", "-XX:+UseG1GC")
                .build();
    }
}

@MetaInfServices
public class CustomDomainConfig implements DomainConfigurationFactory {

    @Override
    public ServerConfiguration create(ExtensionContext context) {
        return ServerConfiguration.builder()
                .configFile("domain-custom.xml")
                .hostConfigFile("host-custom.xml")
                .build();
    }
}

mvn test -Dwildfly.debug