This is an automated email from the ASF dual-hosted git repository.
jungm pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/tomee-tck.git
The following commit(s) were added to refs/heads/main by this push:
new d873ff6 Run the TCK against a chosen TomEE ref and flavour
d873ff6 is described below
commit d873ff6918d9e2185f1885a07b9b6209248935d3
Author: Markus Jung <[email protected]>
AuthorDate: Sun Jul 26 16:11:50 2026 +0200
Run the TCK against a chosen TomEE ref and flavour
Add environment/tomee/build-tomee.sh, which builds Apache TomEE from any
tag, branch, or commit and installs every distribution ZIP and the
Arquillian adapter into a Maven repository. The Jenkins pipeline takes
TOMEE_REF, TOMEE_REPO_URL, and TOMEE_CLASSIFIER, builds that ref once, and
stashes the org/apache/tomee repository slice for every branch to unstash
and test.
Carry TOMEE_VERSION and TOMEE_CLASSIFIER through all three runner scripts.
The smoke runner ignored both, and the security, authentication, and faces
runners hardcoded a distribution in the tomee-remote profile they inject
into the downloaded TCK, so they ignored the classifier entirely.
---
Jenkinsfile | 111 +++++++++++++++-
README.md | 95 +++++++++++---
environment/README.md | 22 ++++
environment/tomee/build-tomee.sh | 144 +++++++++++++++++++++
runner-smoke/run-smoke-suite.sh | 13 ++
runner-standalone/README.md | 19 ++-
.../src/test/resources/tomee-remote-profile.xml | 4 +-
.../src/test/resources/tomee-remote-profile.xml | 4 +-
runner-standalone/run-standalone-suite.sh | 12 +-
runner-standalone/security/pom.xml | 20 ++-
.../security/src/test/resources/arquillian.xml | 7 +-
.../src/test/resources/tomee-remote-profile.xml | 4 +-
runner-webprofile/README.md | 13 ++
runner-webprofile/run-platform-suite.sh | 17 ++-
14 files changed, 438 insertions(+), 47 deletions(-)
diff --git a/Jenkinsfile b/Jenkinsfile
index 78c1058..d57cd4a 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -8,6 +8,12 @@
def platformPartitions = []
+// The version of the TomEE built by the 'Build TomEE' stage, read out of its
+// reactor rather than derived from the ref: a tomee-11.0.0 tag builds 11.0.0
+// and a branch builds whatever -SNAPSHOT it carries. Every downstream branch
+// passes it back in as -Dtomee.version so the whole pipeline tests one build.
+def tomeeVersion = ''
+
// Every test branch runs its suite inside a container so each TomEE, Derby,
// LDAP and JavaTest port binds a container-private network namespace: nothing
// else on the host can collide with a chosen port, and no foreign server can
@@ -28,6 +34,30 @@ def smokeImages = [
pipeline {
agent none
+ parameters {
+ string(
+ name: 'TOMEE_REF',
+ defaultValue: 'main',
+ description: 'Git tag, branch, or commit of apache/tomee to build and
test. ' +
+ 'The build stage clones this ref, builds the distributions
and the ' +
+ 'Arquillian adapter, and feeds them to every branch below.'
+ )
+ string(
+ name: 'TOMEE_REPO_URL',
+ defaultValue: 'https://github.com/apache/tomee.git',
+ description: 'Repository to clone TOMEE_REF from. Point at a fork to
test an ' +
+ 'unmerged branch.'
+ )
+ choice(
+ name: 'TOMEE_CLASSIFIER',
+ choices: ['plume', 'webprofile', 'microprofile', 'plus'],
+ description: 'TomEE distribution to test. The Platform catalog manifest
and ' +
+ 'the reviewed exclusion lists describe plume and
webprofile; a ' +
+ 'microprofile or plus run falls back to the plume
expectations, ' +
+ 'so read its failures against that distribution\'s scope.'
+ )
+ }
+
options {
buildDiscarder(logRotator(daysToKeepStr: '14', numToKeepStr: '10'))
disableConcurrentBuilds()
@@ -55,6 +85,7 @@ pipeline {
sh -n environment/database/require-derby-port-free.sh
sh -n environment/database/wait-for-derby.sh
sh -n environment/tomee/require-tomee-ports-free.sh
+ sh -n environment/tomee/build-tomee.sh
sh -n environment/ports/select-free-port.sh
sh -n environment/certificates/generate-test-certificates.sh
sh -n runner-webprofile/run-platform-suite.sh
@@ -83,6 +114,64 @@ from xml.etree import ElementTree
}
}
+ // Build the TomEE under test once, from the requested ref, and hand the
+ // result to every branch below. The harness needs more than the
+ // distribution ZIP -- arquillian-tomee-remote and its TomEE dependencies,
+ // jakartaee-api for the signature tests -- so the stage installs the whole
+ // reactor into a workspace-local repository and stashes the
+ // org/apache/tomee slice of it. Each branch unstashes that slice into its
+ // own workspace repository before running, which is why every branch sets
+ // HOME to its workspace: the Maven wrapper's ${HOME}/.m2/repository is
+ // then the directory the slice lands in. Nothing is deployed anywhere, so
+ // concurrent jobs and workstation repositories are untouched.
+ //
+ // The slice is ~1.6 GB, so the stash is the pipeline's one large artifact
+ // transfer; it is deliberately scoped to org/apache/tomee rather than the
+ // whole repository, since every other dependency each branch needs is
+ // resolvable from Maven Central and Apache snapshots.
+ //
+ // The git clone and the TomEE build run on the node rather than in a
+ // container: the build needs no fixed ports and produces artifacts the
+ // node must stash afterwards.
+ stage('Build TomEE') {
+ agent { label 'ubuntu' }
+ tools { jdk 'jdk_21_latest' }
+ options { timeout(time: 90, unit: 'MINUTES') }
+ steps {
+ deleteDir()
+ checkout scm
+
+ script {
+ def output = sh(
+ returnStdout: true,
+ script: """
+ TOMEE_REPO_URL='${params.TOMEE_REPO_URL}' \
+ sh environment/tomee/build-tomee.sh '${params.TOMEE_REF}'
"\${WORKSPACE}/.m2/repository"
+ """
+ ).trim()
+
+ // The script prints diagnostics to stderr and the version to
+ // stdout, so this reads the one line the pipeline consumes. Plain
+ // string work rather than a java.util.regex.Matcher, which is not
+ // serializable and would break the CPS transform.
+ tomeeVersion = output.readLines()
+ .findAll { it.startsWith('TOMEE_VERSION=') }
+ .collect { it.substring('TOMEE_VERSION='.length()).trim() }
+ .find { it }
+ if (!tomeeVersion) {
+ error("build-tomee.sh did not report a TOMEE_VERSION; output
was:\n${output}")
+ }
+ echo "Built TomEE ${tomeeVersion} from ${params.TOMEE_REF}
(${params.TOMEE_REPO_URL})"
+ currentBuild.description = "TomEE ${tomeeVersion} @
${params.TOMEE_REF} (${params.TOMEE_CLASSIFIER})"
+ }
+
+ stash(name: 'tomee-repo', includes:
'.m2/repository/org/apache/tomee/**')
+ }
+ post {
+ always { deleteDir() }
+ }
+ }
+
// Each branch requests a single-executor ephemeral agent and runs its
// suite inside a pinned JDK container (see the digests above) whose
// private network namespace rules out port collisions with anything else
@@ -110,11 +199,14 @@ from xml.etree import ElementTree
steps {
deleteDir()
checkout scm
+ unstash 'tomee-repo'
script {
docker.image(smokeImages[SMOKE_JDK]).inside {
withEnv(["HOME=${env.WORKSPACE}",
'JAVA_HOME=/opt/java/openjdk',
- 'PATH+JDK=/opt/java/openjdk/bin']) {
+ 'PATH+JDK=/opt/java/openjdk/bin',
+ "TOMEE_VERSION=${tomeeVersion}",
+ "TOMEE_CLASSIFIER=${params.TOMEE_CLASSIFIER}"]) {
sh 'runner-smoke/run-smoke-suite.sh'
}
}
@@ -134,6 +226,7 @@ from xml.etree import ElementTree
node('ubuntu && ephemeral') {
deleteDir()
checkout scm
+ unstash 'tomee-repo'
try {
timeout(time: 360, unit: 'MINUTES') {
@@ -141,6 +234,7 @@ from xml.etree import ElementTree
withEnv(["HOME=${env.WORKSPACE}",
'JAVA_HOME=/opt/java/openjdk',
'PATH+JDK=/opt/java/openjdk/bin',
+ "TOMEE_VERSION=${tomeeVersion}",
"TOMEE_CLASSIFIER=${classifier}"]) {
sh "runner-webprofile/run-platform-suite.sh
${protocol} ${partition}"
}
@@ -159,10 +253,11 @@ from xml.etree import ElementTree
}
}
- // The EclipseLink-based Plume distribution is the target under test.
+ // Every partition runs against the distribution TOMEE_CLASSIFIER
+ // selects (the EclipseLink-based Plume by default).
def branches = platformPartitions.collectEntries { entry ->
def branchName = "${entry.protocol} - ${entry.partition}"
- [(branchName): catalogBranch(branchName, entry.protocol,
entry.partition, 'plume')]
+ [(branchName): catalogBranch(branchName, entry.protocol,
entry.partition, params.TOMEE_CLASSIFIER)]
}
// Standalone specification TCK runners. Every suite runs with its
@@ -191,13 +286,16 @@ from xml.etree import ElementTree
node('ubuntu && ephemeral') {
deleteDir()
checkout scm
+ unstash 'tomee-repo'
try {
timeout(time: timeoutMinutes, unit: 'MINUTES') {
docker.image(jdk21Image).inside {
withEnv(["HOME=${env.WORKSPACE}",
'JAVA_HOME=/opt/java/openjdk',
- 'PATH+JDK=/opt/java/openjdk/bin']) {
+ 'PATH+JDK=/opt/java/openjdk/bin',
+ "TOMEE_VERSION=${tomeeVersion}",
+
"TOMEE_CLASSIFIER=${params.TOMEE_CLASSIFIER}"]) {
sh "runner-standalone/run-standalone-suite.sh ${id}"
}
}
@@ -244,13 +342,16 @@ from xml.etree import ElementTree
node('ubuntu && ephemeral') {
deleteDir()
checkout scm
+ unstash 'tomee-repo'
try {
timeout(time: timeoutMinutes, unit: 'MINUTES') {
docker.image(facesImage).inside('--shm-size=2g') {
withEnv(["HOME=${env.WORKSPACE}",
'JAVA_HOME=/opt/java/openjdk',
- 'PATH+JDK=/opt/java/openjdk/bin']) {
+ 'PATH+JDK=/opt/java/openjdk/bin',
+ "TOMEE_VERSION=${tomeeVersion}",
+
"TOMEE_CLASSIFIER=${params.TOMEE_CLASSIFIER}"]) {
sh 'runner-standalone/run-standalone-suite.sh faces'
}
}
diff --git a/README.md b/README.md
index b4c3b14..12c8dfc 100644
--- a/README.md
+++ b/README.md
@@ -2,8 +2,12 @@
This repository is the harness for running the Jakarta EE TCKs against Apache
TomEE — currently the Jakarta EE 11 Web Profile TCK against TomEE 11. Runs
-target the TomEE Plume distribution by default; set
-`TOMEE_CLASSIFIER=webprofile` to test the Web Profile distribution instead.
+target the TomEE Plume distribution by default; set `TOMEE_CLASSIFIER` to
+`webprofile`, `microprofile`, or `plus` to test another distribution.
+
+A run can test either a TomEE already published to a Maven repository or one
+built from a specific tag, branch, or commit of apache/tomee — see
+[Test a specific TomEE ref](#test-a-specific-tomee-ref).
The harness uses the TCK's published Maven artifacts, JUnit 5 and Arquillian;
there is no Ant launcher, `TSDeployment`, or checked-in TCK distribution. A
@@ -26,16 +30,16 @@ The build uses these centrally managed inputs:
| Jakarta EE API | `jakarta.platform:jakarta.jakartaee-api:11.0.0` | Maven
Central transport and repository checksums |
| Platform TCK artifacts | `jakarta.tck:artifacts-bom:11.0.3` | SHA-256 in
`environment/versions.env` |
| TCK Arquillian porting library |
`jakarta.tck.arquillian:tck-porting-lib:11.1.3` | version selected by the
11.0.3 BOM |
-| TomEE Plume (default target under test) |
`org.apache.tomee:apache-tomee:11.0.0-SNAPSHOT:plume:zip` | mutable development
snapshot; not locked yet |
-| TomEE Web Profile (opt-in via `TOMEE_CLASSIFIER=webprofile`) |
`org.apache.tomee:apache-tomee:11.0.0-SNAPSHOT:webprofile:zip` | mutable
development snapshot; not locked yet |
-| TomEE remote adapter |
`org.apache.tomee:arquillian-tomee-remote:11.0.0-SNAPSHOT` | mutable
development snapshot; not locked yet |
+| TomEE distribution under test |
`org.apache.tomee:apache-tomee:${tomee.version}:${tomee.classifier}:zip` | git
commit when built from a ref; otherwise a mutable development snapshot |
+| TomEE remote adapter |
`org.apache.tomee:arquillian-tomee-remote:${tomee.version}` | git commit when
built from a ref; otherwise a mutable development snapshot |
| Derby runtime | `derbyclient`, `derbynet`, `derbyshared`, and `derbytools`
`10.15.2.0` | per-jar SHA-256 values in `environment/versions.env` |
-TomEE is sourced from the snapshot repository while the harness tracks active
-TomEE 11 development after the 11.0.0-M1 milestone. Maven always
-uses the current `11.0.0-SNAPSHOT`; CI does not pin or checksum those changing
-bytes. A timestamped version and checksum should only be added when the harness
-needs a stable qualification candidate.
+TomEE comes from one of two places. Built from a git ref, the exact commit
+identifies the bytes and no checksum is needed. Resolved from the snapshot
+repository instead — the default when `TOMEE_VERSION` is unset — Maven uses
+the current `11.0.0-SNAPSHOT` and neither pins nor checksums those changing
+bytes. Build from a tag when the harness needs a stable qualification
+candidate.
Verify the immutable TCK BOM metadata only (a plain
`sh environment/verify-inputs.sh` also downloads and verifies the pinned
@@ -75,15 +79,65 @@ on OpenJPA. Test the OpenJPA-based `webprofile` ZIP instead
with:
TOMEE_CLASSIFIER=webprofile runner-webprofile/run-platform-suite.sh javatest
persistence-javatest
```
+`TOMEE_CLASSIFIER` accepts `plume`, `webprofile`, `microprofile`, and `plus`,
+and every runner script rejects anything else. The Platform catalog manifest
+and the reviewed exclusion lists describe `plume` and `webprofile`; a
+`microprofile` or `plus` run reuses the `plume` expectations, so read its
+failures against that distribution's own scope rather than as regressions.
+
+## Test a specific TomEE ref
+
+`environment/tomee/build-tomee.sh` builds Apache TomEE from any tag, branch,
+or commit and installs every distribution ZIP and the `arquillian-tomee-remote`
+adapter into a Maven repository, so the suites can run against a build that
+was never deployed:
+
+```sh
+environment/tomee/build-tomee.sh tomee-project-9.1.3
+```
+
+It prints the built version as a single `TOMEE_VERSION=<version>` line — read
+from the reactor, so a tag builds its release version and a branch builds
+whatever `-SNAPSHOT` it carries. Pass that version and the flavour back to any
+runner:
+
+```sh
+TOMEE_VERSION=11.0.0-SNAPSHOT TOMEE_CLASSIFIER=plume \
+ runner-webprofile/run-platform-suite.sh servlet rest
+```
+
+Both variables are optional: unset, `TOMEE_VERSION` leaves the pom's snapshot
+version in place and `TOMEE_CLASSIFIER` defaults to `plume`. Set
+`TOMEE_REPO_URL` to build from a fork, and `TOMEE_SRC_DIR` to place the clone
+somewhere other than `target/tomee-src`. The build skips TomEE's own tests and
+uses its `quick` profile, which drops the examples, itests, and TomEE's own
+tck modules while still assembling all four distributions.
+
## ASF Jenkins pipeline
The root `Jenkinsfile` is the authoritative CI definition. It targets the ASF
-Jenkins `ubuntu` agents. The pipeline validates the environment, runs the
-smoke gate on JDK 17 and JDK 21 in parallel, and then fans out every manifest
-partition as an independent JDK 21 branch against the default TomEE Plume
-distribution. One additional branch runs the Jakarta Persistence javatest
-partition against the OpenJPA-based webprofile distribution to track its
-reviewed exclusion list. Test reports and TomEE logs are archived for 14 days.
+Jenkins `ubuntu` agents. The pipeline validates the environment, builds the
+TomEE under test, runs the smoke gate on JDK 17 and JDK 21 in parallel, and
+then fans out every manifest partition and every standalone suite as an
+independent JDK 21 branch. Test reports and TomEE logs are archived for 14
+days.
+
+Three build parameters select what is tested:
+
+| Parameter | Default | Meaning |
+| --- | --- | --- |
+| `TOMEE_REF` | `main` | Tag, branch, or commit of apache/tomee to build and
test |
+| `TOMEE_REPO_URL` | `https://github.com/apache/tomee.git` | Clone source;
point at a fork for an unmerged branch |
+| `TOMEE_CLASSIFIER` | `plume` | Distribution to test: `plume`, `webprofile`,
`microprofile`, or `plus` |
+
+The `Build TomEE` stage runs `environment/tomee/build-tomee.sh` for the chosen
+ref, installs the result into a workspace-local Maven repository, and stashes
+the `org/apache/tomee` slice of it. Every downstream branch unstashes that
+slice into its own workspace repository and passes the built version and the
+selected flavour to its runner, so the whole pipeline reports on one TomEE
+build. Nothing is deployed to a shared repository, so concurrent jobs and
+workstation repositories are untouched. The build description records the ref,
+version, and flavour each run tested.
Parallel branches request `ubuntu && ephemeral` agents and run their suites
inside digest-pinned containers (`eclipse-temurin` JDK images; a
@@ -104,10 +158,11 @@ populated from scratch every build.
See `runner-webprofile/README.md` for the available artifact profiles and the
coverage gaps that remain before this can produce a certification result.
-For a locally built TomEE snapshot, install the distribution under test (Plume
-by default) and the remote Arquillian adapter into the same Maven repository
-first. Development runs intentionally consume the mutable snapshot without a
-checksum lock.
+To test a TomEE checkout you already have locally, install the distribution
+under test and the remote Arquillian adapter into the same Maven repository
+first, or let `environment/tomee/build-tomee.sh` do it from a git ref.
+Development runs that resolve the snapshot instead intentionally consume the
+mutable bytes without a checksum lock.
## Standalone specification TCKs
diff --git a/environment/README.md b/environment/README.md
index f9478fb..4cd98f8 100644
--- a/environment/README.md
+++ b/environment/README.md
@@ -58,3 +58,25 @@ release tree and is passed as the adapter's
additional-property statement file.
`persistence-derby.ddl.sql` is derived from the Jakarta EE 11 Platform TCK
`jakartaeetck-11.0.1` GlassFish runner, with only clean-database `DROP`
statements and the runner-specific procedure-jar installation removed.
+
+## Building the TomEE under test
+
+`tomee/build-tomee.sh <git-ref> [repository-directory]` builds Apache TomEE
+from any tag, branch, or commit and installs every distribution ZIP plus the
+`arquillian-tomee-remote` adapter into a Maven repository, so a suite can test
+a build that was never deployed. The clone lives in `target/tomee-src`
+(override with `TOMEE_SRC_DIR`) and the source is `apache/tomee` (override
+with `TOMEE_REPO_URL`).
+
+apache/tomee ships no Maven wrapper, so the build runs through this
+repository's wrapper pointed at the TomEE reactor. It skips TomEE's own tests
+— the TCK suites are what validate the build — and uses TomEE's `quick`
+profile, the narrowest one that still assembles all four distributions and
+builds the adapter.
+
+The script writes diagnostics to stderr and a single `TOMEE_VERSION=<version>`
+line to stdout, read from the reactor rather than derived from the ref, so a
+caller can capture it with a plain command substitution and pass it to the
+runners as `TOMEE_VERSION`. It fails if the build did not install all four
+distribution ZIPs and the adapter, rather than letting each suite fail later
+on an unresolvable artifact.
diff --git a/environment/tomee/build-tomee.sh b/environment/tomee/build-tomee.sh
new file mode 100755
index 0000000..21d1cb2
--- /dev/null
+++ b/environment/tomee/build-tomee.sh
@@ -0,0 +1,144 @@
+#!/bin/sh
+
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0.
+
+# Builds Apache TomEE from source at a given git ref and installs the
+# artifacts the harness consumes -- every apache-tomee distribution ZIP and
+# the arquillian-tomee-remote adapter -- into a Maven local repository.
+#
+# build-tomee.sh <git-ref> [repository-directory]
+#
+# <git-ref> is any tag, branch, or commit of apache/tomee (override the clone
+# source with TOMEE_REPO_URL). The repository directory defaults to the
+# Maven local repository the calling environment already uses; pass an
+# explicit path to populate a repository slice for stashing.
+#
+# The script echoes the built version to stdout as a single
+# TOMEE_VERSION=<version> line and writes the same line to
+# <repository-directory>/../tomee-build.env, so callers can feed the version
+# back into the runners with -Dtomee.version=... . All other output goes to
+# stderr, so a caller can capture the version with a plain command
+# substitution.
+#
+# apache/tomee ships no Maven wrapper, so the build runs through this
+# harness's wrapper (pointed at the TomEE reactor with -f). Tests are skipped:
+# the harness validates the build through the TCK suites, not through TomEE's
+# own unit tests.
+
+set -eu
+
+SCRIPT_DIR=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+ROOT_DIR=$(CDPATH= cd -- "$SCRIPT_DIR/../.." && pwd)
+
+REF=${1:-}
+if [ -z "$REF" ]; then
+ echo "usage: $0 <git-ref> [repository-directory]" >&2
+ exit 2
+fi
+
+TOMEE_REPO_URL=${TOMEE_REPO_URL:-https://github.com/apache/tomee.git}
+# Where the built artifacts land. Everything downstream resolves against this
+# same directory, so the distribution ZIP, the adapter and the transitive
+# TomEE modules stay consistent with one another.
+LOCAL_REPO=${2:-}
+if [ -z "$LOCAL_REPO" ]; then
+ LOCAL_REPO="${HOME:-.}/.m2/repository"
+fi
+case "$LOCAL_REPO" in
+ /*) ;;
+ *) LOCAL_REPO=$(CDPATH= cd -- "$(dirname -- "$LOCAL_REPO")" &&
pwd)/$(basename -- "$LOCAL_REPO") ;;
+esac
+
+# The clone lives outside the harness tree so a `deleteDir()` of the runner
+# workspace or a stray `mvn clean` cannot take it with it, and so repeated
+# local runs can reuse it.
+SRC_DIR=${TOMEE_SRC_DIR:-$ROOT_DIR/target/tomee-src}
+
+echo "build-tomee: ref=$REF url=$TOMEE_REPO_URL src=$SRC_DIR repo=$LOCAL_REPO"
>&2
+
+# Fetch just the requested ref rather than the full history: apache/tomee is
+# large and CI clones it from scratch every build. A ref that is already
+# checked out from a previous local run is re-fetched so a moving branch
+# tip is picked up rather than silently reused.
+if [ ! -d "$SRC_DIR/.git" ]; then
+ mkdir -p "$(dirname -- "$SRC_DIR")"
+ git init -q "$SRC_DIR"
+ git -C "$SRC_DIR" remote add origin "$TOMEE_REPO_URL"
+fi
+git -C "$SRC_DIR" remote set-url origin "$TOMEE_REPO_URL"
+git -C "$SRC_DIR" fetch --depth 1 --tags origin "$REF" >&2
+git -C "$SRC_DIR" -c advice.detachedHead=false checkout -q --force FETCH_HEAD
+# A ref switch leaves the previous ref's build output behind; TomEE's reactor
+# would happily package stale modules over it.
+git -C "$SRC_DIR" clean -qxdf
+
+echo "build-tomee: checked out $(git -C "$SRC_DIR" rev-parse HEAD)" >&2
+
+# The version to hand the runners. Read it from the reactor rather than
+# deriving it from the ref: a tag named tomee-11.0.0 builds version 11.0.0,
+# and a branch builds whatever -SNAPSHOT it carries.
+TOMEE_VERSION=$("$ROOT_DIR/mvnw" -B -ntp -q -f "$SRC_DIR/pom.xml" \
+ -Dexec.executable=echo -Dexec.args='${project.version}' \
+ --non-recursive org.codehaus.mojo:exec-maven-plugin:3.5.0:exec \
+ -Dmaven.repo.local="$LOCAL_REPO" </dev/null | tail -n 1 | tr -d '[:space:]')
+
+if [ -z "$TOMEE_VERSION" ]; then
+ echo "build-tomee: ERROR: could not determine the TomEE version at $REF" >&2
+ exit 1
+fi
+echo "build-tomee: building TomEE $TOMEE_VERSION" >&2
+
+# Build and install the reactor. The harness pulls more than the distribution
+# ZIPs -- arquillian-tomee-remote and the TomEE modules it depends on -- and
+# those must all come from this same build, so a narrow -pl list would leave
+# the rest resolving against whatever stale snapshot is in the repository.
+# (jakartaee-api, which the signature tests check against, is not part of this
+# reactor: it is released from apache/tomee-jakartaee-api and pinned
+# separately by the runners that need it.)
+#
+# TomEE's own 'quick' profile is the narrowest one that still carries
+# everything the harness consumes (assembly, arquillian, tomee); it drops the
+# examples, itests and TomEE's own tck modules, none of which this harness
+# resolves and all of which cost build time. Naming it deactivates the root
+# pom's activeByDefault 'main' profile, which is the point; the distribution
+# module's own 'all' profile lives in a different pom and stays active, so all
+# four classifiers are still assembled.
+#
+# Only test *execution* is skipped, never test compilation: the distribution
+# module generates its BOMs by running org.apache.tomee.bootstrap.GenerateBoms
+# through exec-maven-plugin with classpathScope=test, so -Dmaven.test.skip
+# leaves that class uncompiled and the build dies on ClassNotFoundException.
+"$ROOT_DIR/mvnw" -B -ntp -f "$SRC_DIR/pom.xml" -Pquick \
+ -DskipTests -Dsurefire.skip=true -DfailIfNoTests=false \
+ -Dmaven.javadoc.skip=true -Dsource.skip=true \
+ -Drat.skip=true -Dcheckstyle.skip=true -Dlicense.skip=true \
+ -Dmaven.repo.local="$LOCAL_REPO" \
+ install </dev/null >&2
+
+# Fail loudly here rather than letting each of ~25 downstream branches fail
+# with an opaque "could not resolve" halfway through its suite.
+missing=
+for classifier in webprofile microprofile plus plume; do
+
zip="$LOCAL_REPO/org/apache/tomee/apache-tomee/$TOMEE_VERSION/apache-tomee-$TOMEE_VERSION-$classifier.zip"
+ if [ -f "$zip" ]; then
+ echo "build-tomee: installed $zip" >&2
+ else
+ missing="$missing $classifier"
+ fi
+done
+adapter="$LOCAL_REPO/org/apache/tomee/arquillian-tomee-remote/$TOMEE_VERSION/arquillian-tomee-remote-$TOMEE_VERSION.jar"
+if [ -f "$adapter" ]; then
+ echo "build-tomee: installed $adapter" >&2
+else
+ missing="$missing arquillian-tomee-remote"
+fi
+if [ -n "$missing" ]; then
+ echo "build-tomee: ERROR: the build did not install:$missing" >&2
+ exit 1
+fi
+
+echo "TOMEE_VERSION=$TOMEE_VERSION" > "$(dirname --
"$LOCAL_REPO")/tomee-build.env"
+echo "TOMEE_VERSION=$TOMEE_VERSION"
diff --git a/runner-smoke/run-smoke-suite.sh b/runner-smoke/run-smoke-suite.sh
index 1187be4..80e2162 100755
--- a/runner-smoke/run-smoke-suite.sh
+++ b/runner-smoke/run-smoke-suite.sh
@@ -8,11 +8,22 @@
# Selects free HTTP and shutdown ports and runs the smoke suite on them. The
# stock plume distribution ships the TLS and AJP connectors commented out, so
# the smoke run binds only these two host ports.
+#
+# TOMEE_CLASSIFIER selects the distribution (default: plume) and TOMEE_VERSION
+# a specific TomEE build, typically one environment/tomee/build-tomee.sh
+# produced from a tag or branch (default: the pom's snapshot version).
set -eu
SCRIPT_DIR=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
ROOT_DIR=$(CDPATH= cd -- "$SCRIPT_DIR/.." && pwd)
+TOMEE_CLASSIFIER=${TOMEE_CLASSIFIER:-plume}
+case "$TOMEE_CLASSIFIER" in
+ webprofile|microprofile|plus|plume) ;;
+ *)
+ echo "Unknown TOMEE_CLASSIFIER '$TOMEE_CLASSIFIER'; supported: webprofile,
microprofile, plus, plume" >&2
+ exit 2 ;;
+esac
SELECT_PORT="$ROOT_DIR/environment/ports/select-free-port.sh"
TOMEE_HTTP_PORT=$(sh "$SELECT_PORT" 8080)
TOMEE_SHUTDOWN_PORT=$(sh "$SELECT_PORT" 8005 "$TOMEE_HTTP_PORT")
@@ -24,4 +35,6 @@ echo "Using ports: http=$TOMEE_HTTP_PORT
shutdown=$TOMEE_SHUTDOWN_PORT"
sh "$ROOT_DIR/environment/tomee/require-tomee-ports-free.sh"
"$TOMEE_HTTP_PORT" "" "$TOMEE_SHUTDOWN_PORT"
exec "$ROOT_DIR/mvnw" -B -ntp -pl runner-smoke -am verify \
+ ${TOMEE_VERSION:+"-Dtomee.version=$TOMEE_VERSION"} \
+ "-Dtomee.classifier=$TOMEE_CLASSIFIER" \
"-Dtomee.http.port=$TOMEE_HTTP_PORT"
"-Dtomee.shutdown.port=$TOMEE_SHUTDOWN_PORT" "$@"
diff --git a/runner-standalone/README.md b/runner-standalone/README.md
index 22fe717..1d40755 100644
--- a/runner-standalone/README.md
+++ b/runner-standalone/README.md
@@ -34,9 +34,20 @@ TomEE. Its `SeBootstrapIT` tests boot their own embedded
Jetty on the
SeBootstrap default port the spec mandates and cannot be pointed elsewhere,
so the runner selects TomEE's HTTP port around 8080 and leaves it free.
-`TOMEE_CLASSIFIER` selects the distribution, default `plume`. The default
-Maven build compiles these modules but runs nothing; execution requires
-`-Dtck.standalone=true` (the script passes it).
+`TOMEE_CLASSIFIER` selects the distribution, default `plume`; it accepts
+`plume`, `webprofile`, `microprofile`, and `plus`, and the script rejects
+anything else. The three source-reactor runners (`security`, `authentication`,
+`faces`) carry it into the `tomee-remote` profile they inject into the
+downloaded TCK, so it reaches those suites too. The recorded result counts
+below were taken on the distribution each row names; apache/tomee validates
+the Security TCK against Plus.
+
+`TOMEE_VERSION` selects the TomEE build to test, typically one
+`environment/tomee/build-tomee.sh` produced from a tag or branch. Unset, the
+pom's snapshot version applies.
+
+The default Maven build compiles these modules but runs nothing; execution
+requires `-Dtck.standalone=true` (the script passes it).
The JavaTest-harness suites (`transactions`, `security-old`, `faces-old`)
report through the JT Harness work/report directories instead of surefire.
@@ -74,7 +85,7 @@ derived from; with the default exclusions applied these
suites run green.
| Pages 4.0 | EFTL zip (installed as `jakarta.tck:jakarta-pages-tck:4.0.0`) |
`pages` | **Passes 682/682 (0 failures, 0 errors, signature test included, no
exclusions)** (2026-07-18). Needs the Central
`jakarta.tck:common`/`signaturetest` support line at 11.1.1 with sigtest 2.6
(the TCK pom's own pins depend on the unpublished JavaTest harness), and the
overlay removes TomEE's global UTF-8 default encodings from conf/web.xml
because the TCK asserts the spec default ISO-8859-1. Its TomEE/ [...]
| Validation 3.1 | EFTL zip (installed as
`jakarta.validation:validation-tck-tests:3.1.1`) | `validation` | **Runs: 1,049
tests, 0 failures, no exclusions; the mandatory API signature test runs and
passes** against the `jakarta.validation` packages the Plume distribution
ships. Needs AssertJ 3.7.0 pinned (the published TCK jar is compiled against
its covariant signatures) |
| WebSocket 2.2 | EFTL zip (installed as
`jakarta.tck:websocket-tck-spec-tests:2.2.0`) | `websocket` | **Runs: 737
tests, 0 failures, 3 errors** (2026-07-18) against Tomcat's WebSocket
implementation, driven through the `tomcat-websocket` client container; the
signature test passes. The negative-deployment classes run and pass: an invalid
server endpoint aborts the whole webapp deployment as the spec requires, and
the runner's Arquillian extension (`NegativeDeploymentToleranceObserver`) [...]
-| Security 4.0 | Source reactor zip 4.0.1 | `security` (Maven module) |
**Runs: 26 app modules plus the signature test, 132 tests, 5 failures, 2 errors
at baseline; green with the reviewed exclusions (all 27 invoker projects pass,
verified end-to-end 2026-07-18)**. The runner downloads and patches the
reactor, injects a tomee-remote profile (including the
`trustStore.path`/`trustStore.password` properties the OpenID modules' keytool
steps read), and drives every module through the Maven [...]
+| Security 4.0 | Source reactor zip 4.0.1 | `security` (Maven module) |
**Runs: 26 app modules plus the signature test, 132 tests, 5 failures, 2 errors
at baseline; green with the reviewed exclusions (all 27 invoker projects pass,
verified end-to-end 2026-07-18)**. The runner downloads and patches the
reactor, injects a tomee-remote profile (including the
`trustStore.path`/`trustStore.password` properties the OpenID modules' keytool
steps read), and drives every module through the Maven [...]
| Security 4.0 (legacy old-tck) | Source reactor zip 4.0.1 (old-tck built from
bundled sources) | `security-old` (Maven module) | **Baseline 83 tests, 82
pass, 1 failure (Plume, JDK 21, 2026-07-19); green with the reviewed
exclusion.** The legacy JavaTest half exercises ~65
`com.sun.ts.tests.securityapi` Client classes across the idstore (in-war,
database, LDAP), ham (HTTP authentication mechanism) and securitycontext trees.
It deploys through the TCK's own `tomcat` handler (WAR copy int [...]
| Authentication 3.1 | Source reactor zip 3.1.2 | `authentication` (Maven
module) | **Runs: 10 Web Profile modules plus the signature test; green with
the reviewed exclusions (all 11 invoker projects pass, 0 failures)**. The spi
module registers the TCK's test `AuthConfigProvider` under Tomcat's JASPIC
app-context naming (`Catalina/localhost /spitests_servlet_web`), so
`ServletProfileSPITest` runs against Tomcat's `AuthConfigFactory` and passes 56
of its 57 assertions; the runner patches [...]
| Faces 4.1 | Source reactor zip 4.1.2 | `faces` (Maven module) | **Runs:
modern Arquillian modules (faces22/23/40/41) plus the Chrome/Selenium
`old-tck-selenium` modules (ajax, commandLink, protectedViews) — 298 tests, 0
failures, 0 errors, 17 skipped** on Plume's Mojarra, with
`exclusions/faces.txt` applied. The 10 excluded classes are one TomEE product
gap (faces-config.xml unmarshaller rejecting the nonstandard *https*
`xsi:schemaLocation`, `Spec1760IT`) and Mojarra/TomEE integration [...]
diff --git
a/runner-standalone/authentication/src/test/resources/tomee-remote-profile.xml
b/runner-standalone/authentication/src/test/resources/tomee-remote-profile.xml
index aacb1b1..fc15c2b 100644
---
a/runner-standalone/authentication/src/test/resources/tomee-remote-profile.xml
+++
b/runner-standalone/authentication/src/test/resources/tomee-remote-profile.xml
@@ -45,7 +45,7 @@
<artifactId>apache-tomee</artifactId>
<version>${tomee.version}</version>
<type>zip</type>
- <classifier>plume</classifier>
+ <classifier>${tomee.classifier}</classifier>
<scope>test</scope>
</dependency>
<dependency>
@@ -82,7 +82,7 @@
<tomee.dir>target/tomee/server</tomee.dir>
<tomee.appWorkingDir>target/tomee/arquillian</tomee.appWorkingDir>
<tomee.cleanOnStartUp>true</tomee.cleanOnStartUp>
- <tomee.classifier>plume</tomee.classifier>
+
<tomee.classifier>${tomee.classifier}</tomee.classifier>
<provider.configuration.file>${authentication.tck.dir}/spi/common/ProviderConfiguration.xml</provider.configuration.file>
<vendor.authconfig.factory>org.apache.catalina.authenticator.jaspic.AuthConfigFactoryImpl</vendor.authconfig.factory>
<log.file.name.test>authentication-tck-test.log</log.file.name.test>
diff --git
a/runner-standalone/faces/src/test/resources/tomee-remote-profile.xml
b/runner-standalone/faces/src/test/resources/tomee-remote-profile.xml
index 7be3c05..9e5d46a 100644
--- a/runner-standalone/faces/src/test/resources/tomee-remote-profile.xml
+++ b/runner-standalone/faces/src/test/resources/tomee-remote-profile.xml
@@ -38,7 +38,7 @@
<artifactId>apache-tomee</artifactId>
<version>${tomee.version}</version>
<type>zip</type>
- <classifier>plume</classifier>
+ <classifier>${tomee.classifier}</classifier>
<scope>test</scope>
</dependency>
<dependency>
@@ -75,7 +75,7 @@
<tomee.cleanOnStartUp>true</tomee.cleanOnStartUp>
<!-- Plume ships Mojarra, the implementation the TCK
was developed against. -->
- <tomee.classifier>plume</tomee.classifier>
+
<tomee.classifier>${tomee.classifier}</tomee.classifier>
<tomee.properties>openejb.environment.default=true</tomee.properties>
<!-- The faces40/41 WARs bundle util-4.1.2.jar, whose
BaseITNG @Deployment method references ShrinkWrap
diff --git a/runner-standalone/run-standalone-suite.sh
b/runner-standalone/run-standalone-suite.sh
index a9aaf6e..0a4f9d0 100755
--- a/runner-standalone/run-standalone-suite.sh
+++ b/runner-standalone/run-standalone-suite.sh
@@ -18,7 +18,10 @@
# security source reactor still assumes its fixed ports. Selection matters
# because the Arquillian adapter silently attaches to any server already on
# the port, so a foreign server on 8080 would make a runner look green.
-# TOMEE_CLASSIFIER selects the distribution (default: plume).
+# TOMEE_CLASSIFIER selects the distribution (default: plume);
+# TOMEE_VERSION selects a specific TomEE build, typically one
+# environment/tomee/build-tomee.sh produced from a tag or branch (default:
+# the pom's snapshot version).
# The reviewed exclusion list in runner-standalone/exclusions/<id>.txt is
# applied by default; append -Dtck.exclusions.file=... to override (see
# exclusions/none.txt for full baseline runs).
@@ -29,6 +32,12 @@ SCRIPT_DIR=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
ROOT_DIR=$(CDPATH= cd -- "$SCRIPT_DIR/.." && pwd)
ID=${1:-}
TOMEE_CLASSIFIER=${TOMEE_CLASSIFIER:-plume}
+case "$TOMEE_CLASSIFIER" in
+ webprofile|microprofile|plus|plume) ;;
+ *)
+ echo "Unknown TOMEE_CLASSIFIER '$TOMEE_CLASSIFIER'; supported: webprofile,
microprofile, plus, plume" >&2
+ exit 2 ;;
+esac
# The security runner starts its bundled OpenID provider through Tomcat's
# startup.sh, which reads JAVA_HOME/JRE_HOME directly and ignores PATH. When
@@ -155,6 +164,7 @@ set +e
"$ROOT_DIR/mvnw" -B -ntp \
-pl "$MODULES" -am \
-Dtck.standalone=true \
+ ${TOMEE_VERSION:+"-Dtomee.version=$TOMEE_VERSION"} \
"-Dtomee.classifier=$TOMEE_CLASSIFIER" \
"$GOAL" "$@"
MVN_STATUS=$?
diff --git a/runner-standalone/security/pom.xml
b/runner-standalone/security/pom.xml
index 62d94a0..9e083c9 100644
--- a/runner-standalone/security/pom.xml
+++ b/runner-standalone/security/pom.xml
@@ -35,10 +35,12 @@
<security.tck.url>https://download.eclipse.org/jakartaee/security/4.0/jakarta-security-tck-${security.tck.version}.zip</security.tck.url>
<security.tck.sha256>87172900057200e0a30a9f30cb3a75331fe428b9dac42153a093ee5c412b7d6d</security.tck.sha256>
<tck.dir>${project.build.directory}/security-tck-${security.tck.version}/tck</tck.dir>
- <!-- The security TCK exercises full-profile features; TomEE Plus is the
- distribution apache/tomee validates it against. The plus classifier
- is set in src/test/resources/arquillian.xml and
- tomee-remote-profile.xml. -->
+ <!-- The security TCK exercises full-profile features; apache/tomee
+ validates it against TomEE Plus. The run's tomee.classifier reaches
+ the reactor through src/test/resources/arquillian.xml and
+ tomee-remote-profile.xml, both expanded by the antrun steps below,
+ so a webprofile or microprofile run tests that distribution instead
+ and its results are read against that profile's scope. -->
<!-- The artifact whose -tomcat repackaging TomEE ships as
lib/jakartaee-api-*-tomcat.jar; its jakarta.security.enterprise
classes are byte-identical to the distribution jar. Keep in sync
@@ -81,8 +83,14 @@
<fileset dir="${tck.dir}"
includes="*/target/failsafe-reports/**,*/target/surefire-reports/**"/>
</delete>
- <!-- Overlay the TomEE arquillian.xml into the TCK common
resources. -->
- <copy
file="${project.basedir}/src/test/resources/arquillian.xml"
tofile="${tck.dir}/common/src/main/resources/arquillian.xml" overwrite="true"/>
+ <!-- Overlay the TomEE arquillian.xml into the TCK common
+ resources, expanding ${tomee.classifier} so the reactor
+ starts the distribution the run selected. -->
+ <copy
file="${project.basedir}/src/test/resources/arquillian.xml"
tofile="${tck.dir}/common/src/main/resources/arquillian.xml" overwrite="true">
+ <filterchain>
+ <expandproperties/>
+ </filterchain>
+ </copy>
<!-- Inject the tomee-remote profile into the TCK parent pom.
-->
<loadfile property="tomee.remote.profile"
srcFile="${project.basedir}/src/test/resources/tomee-remote-profile.xml"
encoding="UTF-8">
diff --git a/runner-standalone/security/src/test/resources/arquillian.xml
b/runner-standalone/security/src/test/resources/arquillian.xml
index 63da888..dc52e30 100644
--- a/runner-standalone/security/src/test/resources/arquillian.xml
+++ b/runner-standalone/security/src/test/resources/arquillian.xml
@@ -23,12 +23,15 @@
<defaultProtocol type="Servlet 5.0"/>
- <container qualifier="tomee-plus" default="true">
+ <!-- ${tomee.classifier} is expanded by the antrun copy in pom.xml when
+ this file is overlaid into the TCK reactor; this is not a
+ stand-alone Arquillian descriptor. -->
+ <container qualifier="tomee" default="true">
<configuration>
<property name="httpPort">-1</property>
<property name="ajpPort">-1</property>
<property name="stopPort">-1</property>
- <property name="classifier">plus</property>
+ <property name="classifier">${tomee.classifier}</property>
<property name="debug">false</property>
<property name="cleanOnStartUp">true</property>
<property name="dir">target/tomee</property>
diff --git
a/runner-standalone/security/src/test/resources/tomee-remote-profile.xml
b/runner-standalone/security/src/test/resources/tomee-remote-profile.xml
index 4ae8ef6..5e61178 100644
--- a/runner-standalone/security/src/test/resources/tomee-remote-profile.xml
+++ b/runner-standalone/security/src/test/resources/tomee-remote-profile.xml
@@ -69,7 +69,7 @@
<artifactId>apache-tomee</artifactId>
<version>${tomee.version}</version>
<type>zip</type>
- <classifier>plus</classifier>
+ <classifier>${tomee.classifier}</classifier>
<scope>test</scope>
</dependency>
<dependency>
@@ -99,7 +99,7 @@
<tomee.dir>target/tomee/server</tomee.dir>
<tomee.appWorkingDir>target/tomee/arquillian</tomee.appWorkingDir>
<tomee.cleanOnStartUp>true</tomee.cleanOnStartUp>
- <tomee.classifier>plus</tomee.classifier>
+
<tomee.classifier>${tomee.classifier}</tomee.classifier>
<!--
SSL configuration for app-openid2/app-openid3.
Those tests deploy an OpenID provider in a separate
Tomcat with a
diff --git a/runner-webprofile/README.md b/runner-webprofile/README.md
index 80586a9..2a5fe12 100644
--- a/runner-webprofile/README.md
+++ b/runner-webprofile/README.md
@@ -24,6 +24,19 @@ OpenJPA provider blocks 249 of the 450 persistence classes
there:
TOMEE_CLASSIFIER=webprofile runner-webprofile/run-platform-suite.sh javatest
persistence-javatest
```
+`TOMEE_CLASSIFIER` also accepts `microprofile` and `plus`; the script rejects
+any other value. Those two carry no manifest overrides or exclusion
+subdirectory, so they run against the `plume` expectations and their failures
+have to be read against that distribution's own scope.
+
+`TOMEE_VERSION` selects the TomEE build to test — typically one
+`environment/tomee/build-tomee.sh` produced from a tag or branch. Unset, the
+pom's snapshot version applies:
+
+```shell
+TOMEE_VERSION=11.0.0-SNAPSHOT runner-webprofile/run-platform-suite.sh servlet
rest
+```
+
For diagnosis, run one partition and optionally one class directly:
```shell
diff --git a/runner-webprofile/run-platform-suite.sh
b/runner-webprofile/run-platform-suite.sh
index 02822e3..5b6e581 100755
--- a/runner-webprofile/run-platform-suite.sh
+++ b/runner-webprofile/run-platform-suite.sh
@@ -13,10 +13,20 @@ PROTOCOL=${1:-servlet}
ONLY_PARTITION=${2:-}
# The TomEE distribution under test. The default manifest and exclusions
-# describe the EclipseLink-based Plume ZIP; TOMEE_CLASSIFIER=webprofile
-# selects the OpenJPA-based distribution together with its
-# platform-suite-webprofile.tsv counts and exclusions/webprofile overrides.
+# describe the EclipseLink-based Plume ZIP; another TOMEE_CLASSIFIER selects
+# that distribution together with its platform-suite-<classifier>.tsv counts
+# and exclusions/<classifier> overrides, when those exist.
TOMEE_CLASSIFIER=${TOMEE_CLASSIFIER:-plume}
+case "$TOMEE_CLASSIFIER" in
+ webprofile|microprofile|plus|plume) ;;
+ *)
+ echo "Unknown TOMEE_CLASSIFIER '$TOMEE_CLASSIFIER'; supported: webprofile,
microprofile, plus, plume" >&2
+ exit 2 ;;
+esac
+
+# TOMEE_VERSION points the suite at a specific TomEE build -- typically one
+# environment/tomee/build-tomee.sh produced from a tag or branch. Unset, the
+# pom's default snapshot version applies.
MANIFEST="$SCRIPT_DIR/platform-suite.tsv"
# A classifier-specific manifest carries only the rows that differ; merge it
# over the base manifest by partition id.
@@ -70,6 +80,7 @@ while IFS="$TAB" read -r partition artifact protocol groups
source_classes expec
rm -rf "$report_dir"
"$ROOT_DIR/mvnw" \
-pl runner-webprofile/run \
+ ${TOMEE_VERSION:+"-Dtomee.version=$TOMEE_VERSION"} \
"-Dtomee.classifier=$TOMEE_CLASSIFIER" \
"-Dtck.artifact=$artifact" \
"-Dtck.partition=$partition" \
