Launch the JavaFX 2 project shell on Java 25 with an interactive viewport, managed Play lifecycle and project mutation guards. Preserve headless/MCP and save compatibility, and qualify exact runtime executable bundles. Separate unit JaCoCo gates from opt-in integration suites and use the internal Pong fixture for the headless visual pilot. Move maintenance and native conformance tools into tooling; retain the VS Code extension and update current navigation links. Validation: tooling make verify passed, including 1064 Studio unit tests, JaCoCo thresholds and 22 headless integration tests.
89 lines
5.2 KiB
Markdown
89 lines
5.2 KiB
Markdown
# Studio Jenkins verification
|
|
|
|
`Jenkinsfile` uses the checked-in Gradle wrapper (currently 9.3.1). A compatible
|
|
Java installation must be available to launch Gradle; project conventions select
|
|
Java 25 for compilation/tests and the product runtime. Build logic targets Java 21
|
|
bytecode independently. The pipeline retains its existing Gradle cache
|
|
location, worker limit and installed Jenkins report plugins. It does not require
|
|
a named Jenkins Gradle installation.
|
|
|
|
The build runs on a Unix agent with Java and dependency/cache access. It sets
|
|
`JAVA_TOOL_OPTIONS=-Djava.awt.headless=true` for Gradle and test JVMs. No display,
|
|
runtime binary, sibling runtime checkout, runtime download/build, or new Jenkins
|
|
plugin is required by the unit suite.
|
|
|
|
## Unit pipeline commands
|
|
|
|
```sh
|
|
export JAVA_TOOL_OPTIONS=-Djava.awt.headless=true
|
|
./gradlew clean --no-daemon --console=plain
|
|
./gradlew test jacocoTestReport --continue --parallel --max-workers=2 --build-cache --no-daemon --console=plain
|
|
```
|
|
|
|
Clean is a separate stage: when it fails, old reports must not be published as a
|
|
new test run. Gradle `--continue` lets independent tasks and reports finish after
|
|
a test failure; it does not turn a failing command into success. Runtime/desktop
|
|
opt-in test tasks are not invoked. All ordinary `test` tasks exclude the JUnit
|
|
`integration` tag. Tests involving real process, network, desktop, application
|
|
composition or cross-provider pipelines are tagged explicitly, including fixture
|
|
subprocesses. This exclusion applies even when optional environment variables are
|
|
set. Existing integration suites remain in this repository; `../tooling` prepares
|
|
their environment and orchestrates selected integration commands and builds.
|
|
No integration suite is executed by the repository pipeline.
|
|
|
|
The required packer unit report is `PackerAssetDeclarationParserTest`.
|
|
`PackerAssetContractTest` is integration-tagged and is not a prerequisite of this
|
|
unit-only pipeline. Consolidated coverage consumes only `build/jacoco/test.exec`
|
|
from each Java subproject; opt-in integration `.exec` files cannot inflate it.
|
|
|
|
## Failure reporting
|
|
|
|
The unconditional post block publishes available JUnit, consolidated JaCoCo XML,
|
|
HTML and archived test/coverage reports after a failed verification command.
|
|
Each publisher is isolated so one publisher error does not prevent the others
|
|
from being attempted. The build console retains compilation/setup diagnostics.
|
|
|
|
JUnit explicitly completes the `Test / Tests and coverage` check from the post
|
|
block. Its name must match the check required by Gitea, independently of the
|
|
publisher's stage context. The separate coverage check remains `JaCoCo Coverage`.
|
|
|
|
Coverage recording is enabled for failed builds so available coverage can still
|
|
be inspected after test failures. Coverage processing errors fail publication;
|
|
the isolated HTML and artifact publishers are still attempted. Archiving runs
|
|
even for failed or unstable builds and retains the original JUnit XML/binary
|
|
results, test HTML, coverage XML/HTML, and raw `**/build/jacoco/*.exec` files.
|
|
JUnit XML includes test failure details and captured output; the raw JaCoCo data
|
|
is retained even if consolidated XML/HTML generation fails. If no coverage data
|
|
was produced, there is no coverage artifact to recover; inspect the build console
|
|
and any available test results. Artifacts follow the Jenkins job's build/artifact
|
|
retention policy.
|
|
|
|
An otherwise successful verification must produce JUnit results, the packer
|
|
unit suite report, consolidated JaCoCo XML and HTML. Missing successful-build
|
|
evidence fails publication. The required packer report is the unit parser suite.
|
|
A failed compilation may have no reports: the
|
|
original build failure remains authoritative and available diagnostics are still
|
|
preserved. A failed clean does not publish potentially stale artifacts.
|
|
|
|
Coverage thresholds are unchanged: CLASS/METHOD/LINE/INSTRUCTION 50%, BRANCH
|
|
40%, PROJECT baseline and UNSTABLE criticality. Reports from partially failed
|
|
test runs are useful diagnostics, not a passing quality gate.
|
|
|
|
## Contract and manual verification boundary
|
|
|
|
See the packer fixture [provenance and coverage](../../prometeu-packer/prometeu-packer-v1/src/test/resources/fixtures/contracts/README.md).
|
|
The retained integration contract suite checks producer bytes and metadata against
|
|
independent expectations. It is excluded from this unit pipeline. Runtime gameplay
|
|
and installed-process verification remain separate integration/desktop checks for
|
|
the tooling repository; record their outcomes only after explicit execution.
|
|
|
|
Local Gradle checks and Groovy parsing cannot certify controller plugin behavior.
|
|
A Jenkins run is needed to observe actual report publication and coverage checks;
|
|
report any unavailable controller validation explicitly.
|
|
|
|
Jenkins behavior references: [post conditions](https://www.jenkins.io/doc/book/pipeline/syntax/#post)
|
|
and [catchError](https://www.jenkins.io/doc/pipeline/steps/workflow-basic-steps/#catcherror-catch-error-and-set-build-result-to-failure),
|
|
[JUnit check names](https://www.jenkins.io/doc/pipeline/steps/junit/),
|
|
[coverage recording on failed builds](https://www.jenkins.io/doc/pipeline/steps/coverage/),
|
|
and [artifact archiving](https://www.jenkins.io/doc/pipeline/steps/core/#archiveartifacts-archive-the-artifacts).
|