Red Hat Summit Red Hat SummitSupportConsoleDevelopersStart a trialContact

Getting started with developing applications for JBoss EAP deployment

Red Hat JBoss Enterprise Application Platform 8.0

Get started creating applications for JBoss EAP deployment.

Red Hat Customer Content Services

Abstract

Get started creating applications for JBoss EAP deployment by using Maven as the project management tool.Deploy your applications to JBoss EAP runing on bare metal or on OpenShift Container Platform.

Providing feedback on JBoss EAP documentation
Copy link

To report an error or to improve our documentation, log in to your Red Hat Jira account and submit an issue. If you do not have a Red Hat Jira account, then you will be prompted to create an account.

Procedure

  1. Click the following link to create a ticket.
  2. Enter a brief description of the issue in the Summary.
  3. Provide a detailed description of the issue or enhancement in the Description. Include a URL to where the issue occurs in the documentation.
  4. Clicking Submit creates and routes the issue to the appropriate documentation team.

Making open source more inclusive
Copy link

Red Hat is committed to replacing problematic language in our code, documentation, and web properties. We are beginning with these four terms: master, slave, blacklist, and whitelist. Because of the enormity of this endeavor, these changes will be implemented gradually over several upcoming releases. For more details, see our CTO Chris Wright’s message.

The best way to become familiar with a new programming language or a technology is to create a "Hello World" application. You can create a "Hello World" application for JBoss EAP by using Maven as the project management tool.

To create a Hello World application, deploy it and test the deployment, follow these procedures:

Bare metal deployment
OpenShift Container Platform deployment

A Maven project contains a pom.xml configuration file and has the directory structure required for creating an application. You can configure the pom.xml configuration file to add dependencies for your application.

To create a Maven project for a hello world application, follow these procedures:

Use the maven-archetype-webapp archetype to create a Maven project for building applications for JBoss EAP deployment. Maven provides different archetypes for creating projects based on templates specific to project types. The maven-archetype-webapp creates a project with the structure required to develop simple web-applications.

Prerequisites

Procedure

  1. Set up a Maven project by using the mvn command. The command creates the directory structure for the project and the pom.xml configuration file. 

    $ mvn archetype:generate                          \
-DgroupId=org.jboss.as.quickstarts                \
    1 
    
-DartifactId=helloworld                           \
    2 
    
-DarchetypeGroupId=org.apache.maven.archetypes    \
    3 
    
-DarchetypeArtifactId=maven-archetype-webapp      \
    4 
    
-DinteractiveMode=false
    5
    Copy to Clipboard Toggle word wrap
    1
    groupID uniquely identifies the project.
    2
    artifactID is the name for the generated jar archive.
    3
    The groupID of maven-archetype-webapp.
    4
    The artifactID of maven-archetype-webapp.
    5
    Tell Maven to use the supplied parameters rather than starting interactive mode.

  2. Navigate to the generated directory. 

    $ cd helloworld
    Copy to Clipboard Toggle word wrap
  3. Open the generated pom.xml configuration file in a text editor.

  4. Remove the content inside the <project> section of pom.xml configuration file after the <name>helloworld Maven Webapp</name> line.

    Ensure that the file looks like this: 

    <?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.jboss.as.quickstarts</groupId>
    <artifactId>helloworld</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>
    <name>helloworld Maven Webapp</name>

</project>
    Copy to Clipboard Toggle word wrap

    The content was removed because it is not required for the application.

1.2. Defining properties in a Maven project
Copy link

You can define properties in a Maven pom.xml configuration file as place holders for values. Define the value for JBoss EAP server as a property to use the value consistently in the configuration.

Prerequisites

Procedure

  • Define a property <version.server> as the JBoss EAP version on which you will deploy the configured application. 

    <project>
    ...
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
        <version.server>8.0.0.GA-redhat-00009</version.server>
    </properties>
</project>
    Copy to Clipboard Toggle word wrap

1.3. Defining the repositories in a Maven project
Copy link

Define the artifact and plug-in repositories in which Maven looks for artifacts and plug-ins to download.

Prerequisites

Procedure

  1. Define the artifacts repository. 

    <project>
    ...
    <repositories>
        <repository>
    1 
    
            <id>jboss-public-maven-repository</id>
            <name>JBoss Public Maven Repository</name>
            <url>https://repository.jboss.org/nexus/content/groups/public/</url>
            <releases>
                <enabled>true</enabled>
                <updatePolicy>never</updatePolicy>
            </releases>
            <snapshots>
                <enabled>true</enabled>
                <updatePolicy>never</updatePolicy>
            </snapshots>
            <layout>default</layout>
        </repository>
        <repository>
    2 
    
            <id>redhat-ga-maven-repository</id>
            <name>Red Hat GA Maven Repository</name>
            <url>https://maven.repository.redhat.com/ga/</url>
            <releases>
                <enabled>true</enabled>
                <updatePolicy>never</updatePolicy>
            </releases>
            <snapshots>
                <enabled>true</enabled>
                <updatePolicy>never</updatePolicy>
            </snapshots>
            <layout>default</layout>
        </repository>
    </repositories>
</project>
    Copy to Clipboard Toggle word wrap
    1
    The Red Hat GA Maven repository provides all the productized JBoss EAP and other Red Hat artifacts.
    2
    The JBoss Public Maven Repository provides artifacts such as WildFly Maven plug-ins

  2. Define the plug-ins repository. 

    <project>
    ...
    <pluginRepositories>
        <pluginRepository>
            <id>jboss-public-maven-repository</id>
            <name>JBoss Public Maven Repository</name>
            <url>https://repository.jboss.org/nexus/content/groups/public/</url>
            <releases>
               <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </pluginRepository>
        <pluginRepository>
            <id>redhat-ga-maven-repository</id>
            <name>Red Hat GA Maven Repository</name>
            <url>https://maven.repository.redhat.com/ga/</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>
</project>
    Copy to Clipboard Toggle word wrap

Import the JBoss EAP EE With Tools Bill of materials (BOM) to control the versions of runtime Maven dependencies. When you specify a BOM in the <dependencyManagement> section, you do not need to individually specify the versions of the Maven dependencies defined in the provided scope.

Prerequisites

Procedure

  1. Add a property for the BOM version in the properties section of the pom.xml configuration file. 

    <properties>
    ....
    <version.bom.ee>${version.server}</version.bom.ee>
</properties>
    Copy to Clipboard Toggle word wrap

    The value defined in the property <version.server> is used as the value for BOM version.

  2. Import the JBoss EAP BOMs dependency management. 

    <project>
    ...
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.jboss.bom</groupId>
    1 
    
                <artifactId>jboss-eap-ee-with-tools</artifactId>
    2 
    
                <version>${version.bom.ee}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>
    Copy to Clipboard Toggle word wrap
    1
    GroupID of the JBoss EAP-provided BOM.
    2
    ArtifactID of the JBoss EAP-provided BOM that provides supported JBoss EAP Java EE APIs plus additional JBoss EAP API JARs and client BOMs, and development tools such as Arquillian.

1.5. Adding plug-in management in a Maven project
Copy link

Add Maven plug-in management section to the pom.xml configuration file to get plug-ins required for Maven CLI commands.

Prerequisites

Procedure

  1. Define the versions for wildfly-maven-plugin and maven-war-plugin, in the <properties> section. 

    <properties>
    ...
    <version.plugin.wildfly>4.1.1.Final</version.plugin.wildfly>
    <version.plugin.war>3.3.2</version.plugin.war>
</properties>
    Copy to Clipboard Toggle word wrap

  2. Add <pluginManagement> in <build> section inside the <project> section. 

    <project>
    ...
    <build>
        <pluginManagement>
            <plugins>
                <plugin>
    1 
    
                    <groupId>org.wildfly.plugins</groupId>
                    <artifactId>wildfly-maven-plugin</artifactId>
                    <version>${version.plugin.wildfly}</version>
                </plugin>
                <plugin>
    2 
    
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>${version.plugin.war}</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>
    Copy to Clipboard Toggle word wrap
    1
    You can use the wildfly-maven-plugin to deploy an application to JBoss EAP using the wildfly:deploy command.
    2
    You need to manage the war plugin version to ensure compatibility with JDK17+.

1.6. Verifying a maven project
Copy link

Verify that the Maven project you configured builds.

Prerequisites

Procedure

  • Install the Maven dependencies added in the pom.xml locally. 

    $ mvn package
    Copy to Clipboard Toggle word wrap

    You get an output similar to the following: 

    ...
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
...
    Copy to Clipboard Toggle word wrap

Chapter 2. Creating a hello world servlet
Copy link

Create a servlet that returns "Hello world!" when accessed.

In this procedure, <application_home> refers to the directory that contains the pom.xml configuration file for the application.

Prerequisites

Procedure

  1. Add the required dependency to pom.xml configuration file after the <dependencyManagement> section. 

    <project>
    ...
    <dependencies>
        <dependency>
    1 
    
            <groupId>jakarta.servlet</groupId>
            <artifactId>jakarta.servlet-api</artifactId>
            <scope>provided</scope>
    2 
    
        </dependency>
    </dependencies>
    Copy to Clipboard Toggle word wrap
    1
    jakarta.servlet-api dependency provides Jakarta Servlet API.
    2
    Define the scope as provided so that the dependency is not included in the application. The reason for not including the dependency in the application is that this dependency is managed by the jboss-eap-ee-with-tools BOM and such dependencies are are included with JBoss EAP.
    Note

    The dependency is defined without a version because jboss-eap-ee-with-tools BOM was imported in the <dependencyManagement> section.

  2. Navigate to the <application_home> directory.

  3. Create a directory to store the Java files. 

    $ mkdir -p src/main/java/org/jboss/as/quickstarts/helloworld
    Copy to Clipboard Toggle word wrap

  4. Navigate to the new directory. 

    $ cd src/main/java/org/jboss/as/quickstarts/helloworld
    Copy to Clipboard Toggle word wrap

  5. Create the Servlet HelloWorldServlet.java that returns "Hello World!". 

    package org.jboss.as.quickstarts.helloworld;

import java.io.IOException;
import java.io.PrintWriter;
import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

@WebServlet("/HelloWorld")
    1 
    
public class HelloWorldServlet extends HttpServlet {

    static String PAGE_HEADER = "<html><head><title>helloworld</title></head><body>";

    static String PAGE_FOOTER = "</body></html>";

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html");
        PrintWriter writer = resp.getWriter();
        writer.println(PAGE_HEADER);
        writer.println("<h1> Hello World! </h1>");
        writer.println(PAGE_FOOTER);
        writer.close();
    }
}
    Copy to Clipboard Toggle word wrap
    1
    The @WebServlet("/HelloWorld") annotation provides the following information to JBoss EAP:
    • This class is a servlet.

    • Make the servlet available at the URL "<application_URL>/HelloWorld".

      For example, if JBoss EAP is running on the localhost and is available at the default HTTP port, 8080, the URL is http://localhost:8080/helloworld/HelloWorld.

  6. Navigate to the <application_home>/src/main/webapp directory.

    You find the file "index.jsp" that Maven created. This file prints "Hello World!" when you access the application.

  7. Update the "index.jsp" file to redirect to the Hello World servlet by replacing its content with the following content: 

    <html>
    <head>
        <meta http-equiv="Refresh" content="0; URL=HelloWorld">
    </head>
</html>
    Copy to Clipboard Toggle word wrap
  8. Navigate to the <application_home> directory.

  9. Compile and package the application as a web archive (WAR) with the following command: 

    $ mvn package
    Copy to Clipboard Toggle word wrap

    Example output

    ...
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
...
    Copy to Clipboard Toggle word wrap

Chapter 3. Deploying an application to the server
Copy link

You can deploy your application on a JBoss EAP server running on bare metal or on OpenShift Container Platform.

To deploy your application on a JBoss EAP server running on bare metal, follow this procedure:

To deploy your application on a JBoss EAP server running on OpenShift Container Platform, follow these procedures:

You can deploy an application to JBoss EAP by using the JBoss EAP deploy plug-in.

Prerequisites

Procedure

  1. Navigate to the application root directory.

    The application root directory contains the pom.xml configuration file.

  2. Add the following build configuration to the pom.xml configuration file in the <project> section to define the application archive filename. 

    <build>
    ...
    <finalName>${project.artifactId}</finalName>
    1 
    
</build>
    Copy to Clipboard Toggle word wrap
    1
    Set the name of the deployment to the project’s artifact ID.

  3. Build and deploy the application by using the JBoss EAP deploy plug-in. 

    $ mvn package wildfly:deploy
    Copy to Clipboard Toggle word wrap

Verification

You can use the source-to-image (S2I) workflow to deploy your applications to JBoss EAP on OpenShift Container Platform. The S2I workflow takes source code from a Git repository and injects it into a container that’s based on the language and framework you want to use. After the S2I workflow is completed, the src code is compiled, the application is packaged and is deployed to the JBoss EAP server.

OpenShift Container Platform uses application hosted on a Git repository. To deploy your application on OpenShift, you must first push your application to a Git repository. After that, you can use JBoss EAP helm chart to configure your application deployment.

Prerequisites

Procedure

  1. Move the application to your local Git repository, if it already is not in it. 

    $ mv -r helloworld/ <your_git_repo>
    Copy to Clipboard Toggle word wrap

  2. Define the following property in the pom.xml configuration file: 

    <properties>
    ...
    <version.plugin.eap>1.0.0.Final-redhat-00013</version.plugin.eap>
    1 
    
</properties>
    Copy to Clipboard Toggle word wrap
    1
    <version.plugin.eap> defines the version for JBoss EAP Maven plug-in.

  3. Add the JBoss EAP maven plugin to <pluginManagement>, in <build> section inside the <project> section. 

    <project>
    ...
    <build>
        <pluginManagement>
            <plugins>
                ...
                <plugin>
                    <groupId>org.jboss.eap.plugins</groupId>
                    <artifactId>eap-maven-plugin</artifactId>
                    <version>${version.plugin.eap}</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>
    Copy to Clipboard Toggle word wrap

  4. Create a profile "openshift" in the pom.xml configuration file.

    This profile defines the plug-ins, feature packs, and layers required for deployment on OpenShift Container Platform. 

    <profiles>
    <profile>
        <id>openshift</id>
        <build>
            <plugins>
                <plugin>
                     <groupId>org.jboss.eap.plugins</groupId>
                     <artifactId>eap-maven-plugin</artifactId>
    1 
    
                     <configuration>
                         <channels>
                             <channel>
                                 <manifest>
                                     <groupId>org.jboss.eap.channels</groupId>
                                     <artifactId>eap-8.0</artifactId>
                                 </manifest>
                             </channel>
                         </channels>
                         <feature-packs>
                             <feature-pack>
    2 
    
                                 <location>org.jboss.eap:wildfly-ee-galleon-pack</location>
                             </feature-pack>
                             <feature-pack>
                                 <location>org.jboss.eap.cloud:eap-cloud-galleon-pack</location>
                             </feature-pack>
                         </feature-packs>
                         <layers>
    3 
    
                             <layer>cloud-server</layer>
                         </layers>
                         <name>ROOT.war</name>
    4 
    
                     </configuration>
                     <executions>
                         <execution>
                             <goals>
                                 <goal>package</goal>
                             </goals>
                         </execution>
                     </executions>
                </plugin>
            </plugins>
        </build>
    </profile>
</profiles>
    Copy to Clipboard Toggle word wrap
    1
    wildfly-maven-plugin is a JBoss EAP plug-in for provisioning a JBoss EAP instance, with the application deployed, on OpenShift Container Platform.
    2
    feature-packs defines the feature-packs (zipped files that contains features to dynamically provision a server). In this case we need the feature-packs org.wildfly:wildfly-galleon-pack and org.wildfly.cloud:wildfly-cloud-galleon-pack.
    3
    layers defines the layers (from the configured feature-packs) to include in the provisioned server. Each layer identifies one or more server capabilities that can be installed on its own, or in combination with other layers. In our case we opt for the cloud-server layer, which provisions just the basic features of JBoss EAP, well suited for a cloud server.
    4
    <name>ROOT.war</name>: Defines the resulting name of the application’s web archive (WAR). If ROOT.war is specified then the application is deployed at the root path of the server, otherwise it is deployed at <name/> relative path.

  5. Verify that the applications compiles. 

    $ mvn package -Popenshift
    Copy to Clipboard Toggle word wrap
  6. Push the changes to your repository.

Use the JBoss EAP Helm chart to configure and deploy application to JBoss EAP on OpenShift with Helm.

Prerequisites

Procedure

  1. Create a directory called charts in the application root directoy and navigate to it. Application root directory is the one that contains pom.xml configuration file. 

    $ mkdir charts; cd charts
    Copy to Clipboard Toggle word wrap

  2. Create a file helm.yaml with the following content: 

    build:
  uri: https://github.com/<user>/<repository>.git
    1 
    
  ref: <branch_name>
    2 
    
  contextDir: helloworld
    3 
    
deploy:
  replicas: 1
    4
    Copy to Clipboard Toggle word wrap
    1
    Specify the URL for your Git repository that contains the application to deploy on OpenShift Container Platform.
    2
    Specify the Git branch that contains your application.
    3
    Specify the directory containing the application.
    4
    Specify the number of pods to create.

  3. Configure the JBoss EAP repository in Helm.

    • If you haven’t added the JBoss EAP repository to Helm before, add it. 

      $ helm repo add jboss-eap https://jbossas.github.io/eap-charts/
      Copy to Clipboard Toggle word wrap

    • If you already have added the JBoss EAP repository to Helm, update it. 

      $ helm repo update jboss-eap
      Copy to Clipboard Toggle word wrap

  4. Deploy the application using helm. 

    $ helm install helloworld -f helm.yaml jboss-eap/eap8
    Copy to Clipboard Toggle word wrap

    The deployment can take a few minutes to complete.

Verification

  1. Get the URL of the route to the deployment. 

    $ APPLICATION_URL=https://$(oc get route helloworld --template='{{ .spec.host }}') &&
echo "" &&
echo "Application URL: $APPLICATION_URL"
    Copy to Clipboard Toggle word wrap

  2. Navigate to the "Application URL" in a browser.

    You are redirected to the servlet at path "/HelloWorld" and you get the following message: 

    Hello World!
    Copy to Clipboard Toggle word wrap

To ensure that the Hello World application deployed on JBoss EAP is working, you can add integration tests.

To add tests for an application deployed on a JBoss EAP server running on bare metal, follow these procedures:

To add tests for an application deployed on a JBoss EAP server running on OpenShift Container Platform, follow these procedures:

To create integration tests for your applications, add the required Maven dependencies.

Prerequisites

Procedure

  1. Define the following properties in the pom.xml configuration file: 

    <properties>
    ...
    <version.plugin.failsafe>3.2.2</version.plugin.failsafe>
</properties>
    Copy to Clipboard Toggle word wrap

  2. Add the dependency required for tests. 

    <project>
    ...
    <dependencies>
        ...
        <dependency>
           <groupId>junit</groupId>
           <artifactId>junit</artifactId>
           <scope>test</scope>
        </dependency>
    </dependencies>
</project>
    Copy to Clipboard Toggle word wrap

  3. Define a profile to add the plug-ins required for integration tests. 

    <project>
    ...
    <profiles>
    ...
        <profile>
            <id>integration-testing</id>
            <build>
                <plugins>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-failsafe-plugin</artifactId>
    1 
    
                        <version>${version.plugin.failsafe}</version>
                        <configuration>
                            <includes>
                                <include>**/HelloWorldServletIT</include>
    2 
    
                            </includes>
                        </configuration>
                        <executions>
                            <execution>
                               <goals>
                                   <goal>integration-test</goal>
                                   <goal>verify</goal>
                               </goals>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
        </profile>
    </profiles>
</project>
    Copy to Clipboard Toggle word wrap
    1
    Maven plug-in for running integration tests.
    2
    The name of the Java class that tests the application.

4.2. Creating a test class to test an application
Copy link

Create an integration test that verifies that the application is deployed and running on JBoss EAP on OpenShift Container Platform, by checking that the HTTP GET of its web page returns 200 OK.

In this procedure, <application_home> refers to the directory that contains the pom.xml configuration file for the application.

Prerequisites

Procedure

  1. Navigate to the <application_home> directory.

  2. Create a directory to store the test class. 

    $ mkdir -p src/test/java/org/jboss/as/quickstarts/helloworld
    Copy to Clipboard Toggle word wrap

  3. Navigate to the new directory. 

    $ cd src/test/java/org/jboss/as/quickstarts/helloworld
    Copy to Clipboard Toggle word wrap

  4. Create a Java class HelloWorldServletIT.java that tests the deployment. 

    package org.jboss.as.quickstarts.helloworld;

import org.junit.Test;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import static org.junit.Assert.assertEquals;

public class HelloWorldServletIT {

    private static final String DEFAULT_SERVER_HOST = "http://localhost:8080/helloworld";
    1 
    

    @Test
    public void testHTTPEndpointIsAvailable() throws IOException, InterruptedException, URISyntaxException {
        String serverHost = System.getProperty("server.host");
        if (serverHost == null) {
            serverHost = DEFAULT_SERVER_HOST;
        }
        final HttpRequest request = HttpRequest.newBuilder()
                .uri(new URI(serverHost+"/HelloWorld"))
                .GET()
                .build();
    2 
    
        final HttpClient client = HttpClient.newBuilder()
                .followRedirects(HttpClient.Redirect.ALWAYS)
                .connectTimeout(Duration.ofMinutes(1))
                .build();
    3 
    
        final HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
    4 
    
        assertEquals(200, response.statusCode());
    5 
    
    }
}
    Copy to Clipboard Toggle word wrap
    1
    The URL at which the application is running. This value is used if sever.host is undefined.
    2
    Create an HttpRequest instance for the application URI.
    3
    Create an HttpClient to send requests to and receive response from the application.
    4
    Get response from the application.
    5
    Test that the response revieved from the application is "200" indicating that the application is rechable.

Test the application deployed on JBoss EAP that is running on bare metal.

Prerequisites

Procedure

  1. Navigate to the <application_home> directory.

  2. Run the integration test by using the verify command with the integration-testing profile. 

    $ mvn verify -Pintegration-testing
    Copy to Clipboard Toggle word wrap

    Example output

    [INFO]
[INFO] Results:
[INFO]
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO]
[INFO]
[INFO] --- maven-failsafe-plugin:3.2.2:verify (default) @ helloworld ---
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  9.982 s
[INFO] Finished at: 2023-11-22T14:53:54+05:30
[INFO] ------------------------------------------------------------------------
    Copy to Clipboard Toggle word wrap

Test the application deployed to JBoss EAP on OpenShift Container Platform.

Prerequisites

Procedure

  1. Push the changes to your Git repository.
  2. Navigate to the <application_home> directory.

  3. Run the test by using the verify command, activating the integration-testing profile and specifying the URL to the application. 

    $ mvn verify -Pintegration-testing -Dserver.host=https://$(oc get route helloworld --template='{{ .spec.host }}')
    Copy to Clipboard Toggle word wrap
    Note

    The tests use SSL/TLS to connect to the deployed application. Therefore, you need the certificates to be trusted by the machine the tests are run from.

    To trust the certificates, you must add it to a Java trust store.

    Example

    $ keytool -trustcacerts -keystore _<path-to-java-truststore>_ -storepass _<trust-store-password>_ -importcert -alias _<alias-for-the-certificate>_ -file _<path-to-certificate>_/_<certificate-name>_
    Copy to Clipboard Toggle word wrap

    Example output

    [INFO] Running org.jboss.as.quickstarts.helloworld.HelloWorldServletIT
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 1.345 s -- in org.jboss.as.quickstarts.helloworld.HelloWorldServletIT
[INFO]
[INFO] Results:
[INFO]
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO]
[INFO]
[INFO] --- maven-failsafe-plugin:3.2.2:verify (default) @ helloworld ---
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  2.984 s
[INFO] Finished at: 2023-11-30T15:51:22+05:30
[INFO] ------------------------------------------------------------------------
    Copy to Clipboard Toggle word wrap





Revised on 2024-02-21 14:02:46 UTC

Legal Notice
Copy link

Copyright © 2024 Red Hat, Inc.
The text of and illustrations in this document are licensed by Red Hat under a Creative Commons Attribution–Share Alike 3.0 Unported license ("CC-BY-SA"). An explanation of CC-BY-SA is available at http://creativecommons.org/licenses/by-sa/3.0/. In accordance with CC-BY-SA, if you distribute this document or an adaptation of it, you must provide the URL for the original version.
Red Hat, as the licensor of this document, waives the right to enforce, and agrees not to assert, Section 4d of CC-BY-SA to the fullest extent permitted by applicable law.
Red Hat, Red Hat Enterprise Linux, the Shadowman logo, the Red Hat logo, JBoss, OpenShift, Fedora, the Infinity logo, and RHCE are trademarks of Red Hat, Inc., registered in the United States and other countries.
Linux® is the registered trademark of Linus Torvalds in the United States and other countries.
Java® is a registered trademark of Oracle and/or its affiliates.
XFS® is a trademark of Silicon Graphics International Corp. or its subsidiaries in the United States and/or other countries.
MySQL® is a registered trademark of MySQL AB in the United States, the European Union and other countries.
Node.js® is an official trademark of Joyent. Red Hat is not formally related to or endorsed by the official Joyent Node.js open source or commercial project.
The OpenStack® Word Mark and OpenStack logo are either registered trademarks/service marks or trademarks/service marks of the OpenStack Foundation, in the United States and other countries and are used with the OpenStack Foundation's permission. We are not affiliated with, endorsed or sponsored by the OpenStack Foundation, or the OpenStack community.
All other trademarks are the property of their respective owners.
Back to top
Red Hat logoGithubredditYoutubeTwitter

Learn

Try, buy, & sell

Communities

About Red Hat Documentation

We help Red Hat users innovate and achieve their goals with our products and services with content they can trust. Explore our recent updates.

Making open source more inclusive

Red Hat is committed to replacing problematic language in our code, documentation, and web properties. For more details, see the Red Hat Blog.

About Red Hat

We deliver hardened solutions that make it easier for enterprises to work across platforms and environments, from the core datacenter to the network edge.

Theme

© 2025 Red Hat