https://github.com/quarkusio/resteasy-reactive-testsuite
https://github.com/quarkusio/resteasy-reactive-testsuite
Last synced: 4 months ago
JSON representation
- Host: GitHub
- URL: https://github.com/quarkusio/resteasy-reactive-testsuite
- Owner: quarkusio
- License: other
- Created: 2020-10-29T11:58:22.000Z (over 4 years ago)
- Default Branch: main
- Last Pushed: 2024-11-14T06:36:50.000Z (7 months ago)
- Last Synced: 2025-01-29T18:38:19.375Z (5 months ago)
- Language: Java
- Size: 63 MB
- Stars: 2
- Watchers: 20
- Forks: 7
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE.md
Awesome Lists containing this project
README
# JakartaEE TCK Jenkins Jobs
The Jenkins jobs required for certifying Eclipse GlassFish nightly builds using the latest Jakarta EE TCK bundles are hosted in the Eclipse CloudBees Infrastructure and are available under
https://jenkins.eclipse.org/jakartaee-tck/
For information regarding the various JakartaEE TCK related jobs, Please refer to the wiki page below
https://github.com/eclipse-ee4j/jakartaee-tck/wiki/Jakarta-EE-TCK-Jenkins-jobs
# Steps required to run CTS against Standalone RI changes
1. Build the individual project and release it to Eclipse Maven repositories.
2. Integrate the individual project to GlassFish.
Sample steps done for JTA:
```git clone https://github.com/eclipse-ee4j/glassfish.git
git checkout -b EE4J_8
find . -name \pom.xml -exec sed -i "s/javax.transaction-bin.zip
2. Change to the directory in which you want to install Apache Ant and
extract the bundle
```
unzip apache-ant--bin.zip
```
or
```
tar zxvf apache-ant--bin.tar.gz
```
3. Set `ANT_HOME` environment variable to point to the apache-ant-
directory.
4. Set `PATH` environment variable to use the installed ant.
## Setup and Configuration
### Allowed Modifications
You can modify the following test suite components only:
* Your implementation of the porting package
* `ts.jte` environment file
* The vendor-specific SQL files in `/sql`
* Any files in `/bin` and `/bin/xml` (except for `ts.*` files)
### Configuring the Jakarta EE 8 RI as the VI
To configure the Jakarta EE 8 RI as the server under test (that is, to use the
Jakarta EE 8 RI as the VI) follow the steps listed below.
In this scenario, the goal is simply to test the Jakarta EE 8 RI against
the CTS for the purposes of familiarizing yourself with CTS test procedures.
You may also want to refer to the Quick Start guides included with
the Jakarta EE 8 CTS for similar instructions.
1. Set server properties in your `/bin/ts.jte` file to suit your test
environment.
Be sure to set the following properties:
a. Set the `webServerHost` property to the name of the host on which your Web
server is running that is configured with the RI.
The default setting is `localhost`.
b. Set the `webServerPort` property to the port number of the host on which the
Web server is running and configured with the RI.
The default setting is `8001`.
c. Set the `wsgen.ant.classname` property to the Vendor's implementation class
that mimics the RI Ant task that in turn calls the wsgen Java-to-WSDL tool.
The default setting is `com.sun.tools.ws.ant.WsGen`.
d. Set the `wsimport.ant.classname` property to the Vendor's implementation
class that mimics the RI Ant task that in turn calls the `wsimport` WSDL-to-Java
tool.
The default setting is `com.sun.tools.ws.ant.WsImport`.
e. Set the `porting.ts.url.class` property to your porting implementation class
that is used for obtaining URLs.
The default setting for the RI porting implementation is `com.sun.ts.lib.implementation.sun.common.SunRIURL`.
f. Set the database-related properties in the `/bin/ts.jte` file.
g. Add the following JVM option to the `command.testExecuteAppClient`
property to enable the Security Manager in the application client container:
`-Djava.security.manager`
Add this option to the list of other `-D` JVM options for this property.
As mentioned previously, these settings can vary, but must match whatever you
used when setting up the Jakarta EE 8 RI server.
2. Install the Jakarta EE 8 RI and configure basic settings, as described in
3. Start the Jakarta EE 8 RI application server.
Refer to the application server documentation for complete instructions.
4. Enable the Security Manager.
If you are using the Jakarta EE 8 RI, execute the following command from the
command line:
```
asadmin create-jvm-options -Djava.security.manager
```
5. Stop and restart your application server so it is running with the Security
Manager enabled.
6. Change to the `/bin` directory.
7. Start your backend database.
If you are using Derby as your backend database, execute the start.javadb Ant
target:
```
ant -f xml/impl/glassfish/s1as.xml start.javadb
```
Otherwise, refer to your backend database administration documentation for
information about starting your database server.
8. Initialize your backend database.
If you are using Derby as your backend database, execute the `init.derby` Ant
target:
```
ant -f xml/init.xml init.derby
```
9. Run the configuration Ant target.
```
ant config.vi
```
10. Build the special web services clients.
The special webservices tests under the `webservices12/specialcases` directory
have prebuilt endpoints, but the clients are not prebuilt. The clients will be
built after the endpoints are first predeployed to the application server under
test. During the build, the clients import the WSDLs (by means of the Jakarta EE
`wsimport` and `wsgen` tools) from the predeployed webservices endpoints. This process
verifies that importing a WSDL from a predeployed webservice endpoint works
properly.
To build the special webservices clients, the following command must be executed:
```
ant build.special.webservices.clients
```
## Executing tests
### Running tests in CLI mode
1. Set the `TS_HOME` environment variable to the directory in which Jakarta EE 8 CTS was
installed.
2. Set the `JAVA_HOME` environment variable to the latest version of JDK 8
3. Set the `ANT_HOME` environment variable to the latest version of Apache Ant installed.
4. Set the `PATH` environment to use the latest binaries.
```
export PATH=$ANT_HOME/bin:$JAVA_HOME/bin:$PATH
```
5. Change to any subdirectory under /src/com/sun/ts/tests.
6. Ensure that the ts.jte file contains information relevant to your setup.
7. Execute the runclient Ant target to start the JavaTest:
```
ant runclient
```
This runs all tests in the current directory and any subdirectories.
8. To run the Jakarta EE 8 CTS signature tests, enter the following commands:
```
cd /src/com/sun/ts/tests/signaturetest/javaee
ant runclient
```
9. To run a single test directory in the forward direction, enter the following commands:
```
cd /src/com/sun/ts/tests/jaxws/api/jakarta_xml_ws/Dispatch
ant -Dkeywords=forward runclient
```
10. To run a subset of test directories in the reverse direction, enter the following
commands:
```
cd /src/com/sun/ts/tests/jaxws/api
ant -Dkeywords=reverse runclient
```