Report EOL and maintenance status for Gradle versions (#1057)

This PR reports the support status of every Gradle version used in a
workflow:

- **End-of-life** — two or more major versions behind the latest
release.
- **Out of date** — one major version behind the latest release, or more
than two minor versions behind on the current major.

The information is surfaced as job annotations and in the Job Summary:
an icon beside the Gradle version in the build results table, and a
message below it.

| version kind | job annotation | version table | below the table |
| ------ | ----- | ---- | --------- |
| EOL | warning | ⚠️ | expandable section, pointing to the Gradle
Security Subscription |
| Out of date | notice | ℹ️ | one-line legend, pointing to the Gradle
release lifecycle docs |
| Current | none | — | — |

A single expandable section covers every end-of-life version, naming
them in its summary line and listing the affected release lines in its
body. The upgrade legend likewise appears once per job, however many
versions carry the info icon.

Notes on what is deliberately *not* reported:

- **Patch releases.** Only the major and minor version are considered,
so being on `9.7.0` when `9.7.1` exists is not flagged.
- **Pre-releases.** Release candidates, milestones and snapshots are
never reported, so testing against a nightly or an RC produces no
annotations.

The latest Gradle release is determined from the wrapper checksum data
already bundled with the action, so no network access is required. That
data is refreshed weekly, and the two-minor grace band absorbs the lag.

Note that the annotations are emitted independently of
`add-job-summary`: setting it to `never` suppresses the Job Summary
itself, but the warning and notice annotations remain.

### Examples

The `demo-job-summary` workflow has a `support-status-eol-and-outdated`
job that builds with three end-of-life versions (`6.9.4`, `7.4`,
`7.6.6`), two out-of-date versions (`8.0.2`, `8.14.5`) and the current
release, so all three statuses appear in one summary:

* **Job Summary**:
https://github.com/gradle/actions/actions/runs/34166688755#summary-101879071306
* **Annotations**:
https://github.com/gradle/actions/actions/runs/34166688755/job/101879071306
(expand annotations)

That workflow is never triggered automatically; run it manually against
a branch to review the rendering.

### Implementation

* Adds `GradleVersion`, parsing and ordering versions the same way
Gradle's own `org.gradle.util.GradleVersion` does. This replaces the
previous `versionIsAtLeast` helper and removes the `semver` dependency.
* Adds `gradle-support-status.ts`, which owns the classification policy
and both of its presentations (annotations and Job Summary section)
behind a three-function API, so `job-summary.ts` only asks for the icon
and the rendered block.

### Testing

* Unit tests for version ordering, classification, the annotations and
the rendered summary.
* `integ-test-gradle-support-status.yml`, which derives its expected
versions from the bundled release data so the assertions cannot drift
from the action's own view, then asserts against the real job log.
* The demo workflow job linked above, for reviewing the rendering by
eye.

Documented under [Build
reporting](https://github.com/gradle/actions/blob/main/docs/setup-gradle.md#gradle-version-support-status)
in `docs/setup-gradle.md`.

---------

Co-authored-by: Louis Jacomet <louis@gradle.com>
Co-authored-by: Daz DeBoer <daz@gradle.com>
Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Vlad Chesnokov
2026-09-07 16:34:26 -06:00
committed by GitHub
co-authored by Louis Jacomet Daz DeBoer Claude Opus 5
parent 575435b1ea
commit e49d0a36a8
17 changed files with 1031 additions and 211 deletions
@@ -0,0 +1,253 @@
import * as fs from 'fs'
import * as path from 'path'
import {beforeEach, describe, expect, it, jest} from '@jest/globals'
const mockWarning = jest.fn<(message: string, properties?: {title?: string}) => void>()
const mockNotice = jest.fn<(message: string, properties?: {title?: string}) => void>()
jest.unstable_mockModule('@actions/core', () => ({
warning: mockWarning,
notice: mockNotice
}))
// Mirrors the real release shape: latest 9.7.1, last 8.x minor is 8.14 with patches up to 8.14.5.
const RELEASED = [
'9.7.1',
'9.7.0',
'9.6.1',
'9.6.0',
'9.5.1',
'9.5.0',
'9.4.1',
'9.4.0',
'9.2.1',
'9.2.0',
'9.0.0',
'8.14.5',
'8.14',
'8.13',
'8.3',
'8.0.2',
'8.0',
'7.6.4',
'1.0'
]
const asChecksumEntries = (versions: string[]): {version: string; checksum: string}[] =>
versions.map(version => ({version, checksum: ''}))
let releasedVersions = asChecksumEntries(RELEASED)
jest.unstable_mockModule('../../src/wrapper-validation/wrapper-checksums.json', () => ({
get default() {
return releasedVersions
}
}))
const {renderSupportStatus, reportSupportStatus, supportStatusSign} = await import('../../src/gradle-support-status')
/** Re-imports the module so that its release index is built from `released` instead of RELEASED. */
async function withReleaseData(released: string[]): Promise<typeof import('../../src/gradle-support-status')> {
releasedVersions = asChecksumEntries(released)
jest.resetModules()
try {
return await import('../../src/gradle-support-status')
} finally {
releasedVersions = asChecksumEntries(RELEASED)
}
}
const NO_SIGN = ''
const OUT_OF_DATE = ':information_source:'
const END_OF_LIFE = ':warning:'
const DOC = 'https://docs.gradle.org/current/userguide/feature_lifecycle.html#eol_support'
const SECURITY_SUBSCRIPTION = 'https://gradle.org/security-subscription/?utm_source=github-action'
describe('supportStatusSign', () => {
it.each(['7.6.4', '1.0', '4.10.3'])('marks %s as end-of-life', version => {
expect(supportStatusSign(version)).toBe(END_OF_LIFE)
})
it.each(['8.0', '8.0.2', '8.3', '8.13', '8.14', '8.14.3', '8.14.5'])(
'marks %s as out of date, being on the previous major',
version => {
expect(supportStatusSign(version)).toBe(OUT_OF_DATE)
}
)
it.each(['8.15', '8.15.1'])(
'marks %s, a previous-major minor newer than the release data, as out of date',
version => {
expect(supportStatusSign(version)).toBe(OUT_OF_DATE)
}
)
it('marks a previous major absent from the release data as out of date', async () => {
const {supportStatusSign: sign} = await withReleaseData(['9.7.1', '7.6.4'])
expect(sign('8.0')).toBe(OUT_OF_DATE)
})
it.each(['9.0.0', '9.2.1', '9.4.1'])('marks %s as out of date, being more than 2 minors back', version => {
expect(supportStatusSign(version)).toBe(OUT_OF_DATE)
})
it.each(['9.5.0', '9.5.1', '9.6.1', '9.7.1'])('leaves %s unmarked, inside the grace band', version => {
expect(supportStatusSign(version)).toBe(NO_SIGN)
})
it('does not mark a version merely because a newer patch exists', () => {
expect(supportStatusSign('9.6.0')).toBe(NO_SIGN)
expect(supportStatusSign('9.7.0')).toBe(NO_SIGN)
})
it.each(['10.0', '10.4.2'])('leaves %s unmarked, newer than the release data', version => {
expect(supportStatusSign(version)).toBe(NO_SIGN)
})
it.each(['9.8.0-rc-1', '7.0-milestone-1', '9.8-20260101120000+0000'])(
'leaves non-final version %s unmarked',
version => {
expect(supportStatusSign(version)).toBe(NO_SIGN)
}
)
it('does not throw on an unparseable version', () => {
expect(supportStatusSign('')).toBe(NO_SIGN)
expect(supportStatusSign('unknown')).toBe(NO_SIGN)
})
})
describe('bundled release data', () => {
it('contains a final release, so the release index builds instead of failing', async () => {
const bundled: {version: string}[] = JSON.parse(
fs.readFileSync(path.resolve('src/wrapper-validation/wrapper-checksums.json'), 'utf-8')
)
const {supportStatusSign: sign} = await withReleaseData(bundled.map(entry => entry.version))
expect(sign('1.0')).toBe(END_OF_LIFE)
})
})
describe('reportSupportStatus', () => {
beforeEach(() => {
jest.clearAllMocks()
})
it('warns about an end-of-life version', () => {
reportSupportStatus(['7.6.4'])
expect(mockWarning).toHaveBeenCalledTimes(1)
expect(mockNotice).not.toHaveBeenCalled()
const [message, properties] = mockWarning.mock.calls[0]
expect(message).toBe(
`Gradle 7.6.4 is end-of-life. Gradle 7.x releases receive no further fixes, security fixes included. Update to the latest Gradle version. If you cannot upgrade, see ${SECURITY_SUBSCRIPTION} for options`
)
expect(properties?.title).toBe('End-of-life Gradle version')
})
it.each(['8.0', '8.14.3', '8.14.5', '9.2.1'])('notices %s as out of date', version => {
reportSupportStatus([version])
expect(mockWarning).not.toHaveBeenCalled()
expect(mockNotice).toHaveBeenCalledTimes(1)
const [message, properties] = mockNotice.mock.calls[0]
expect(message).toBe(
`Gradle ${version} is out of date: consider updating to the latest Gradle version. See ${DOC}`
)
expect(properties?.title).toBe('Out-of-date Gradle version')
})
it.each(['9.5.1', '9.6.1', '9.7.1'])('stays quiet about %s, inside the grace band', version => {
reportSupportStatus([version])
expect(mockWarning).not.toHaveBeenCalled()
expect(mockNotice).not.toHaveBeenCalled()
})
it('annotates each distinct version once, at the level its status warrants', () => {
reportSupportStatus(['7.6.4', '4.10.3', '7.6.4', '8.0', '9.2.1', '8.0'])
expect(mockWarning).toHaveBeenCalledTimes(2)
expect(mockNotice).toHaveBeenCalledTimes(2)
})
it('says nothing when no Gradle build ran', () => {
reportSupportStatus([])
expect(mockWarning).not.toHaveBeenCalled()
expect(mockNotice).not.toHaveBeenCalled()
})
})
describe('renderSupportStatus', () => {
const LEGEND =
`<p>${OUT_OF_DATE} Gradle version is out of date — consider upgrading. ` +
`See <a href="${DOC}">Gradle release lifecycle</a></p>`
it('folds end-of-life versions under a warning sign, linking the security subscription', () => {
const rendered = renderSupportStatus(['7.6.4'])
expect(rendered).toContain(`<summary>${END_OF_LIFE} Gradle 7.6.4 is end-of-life</summary>`)
expect(rendered).toContain(
'Gradle 7.x releases receive no further fixes, security fixes included. Update to the latest Gradle version.'
)
expect(rendered).toContain(`<a href="${SECURITY_SUBSCRIPTION}">Gradle Security Subscription</a>`)
expect(rendered).not.toContain(LEGEND)
})
it('names every end-of-life version in the summary line, and reads as a plural', () => {
const rendered = renderSupportStatus(['7.6.4', '1.0', '4.10.3'])
expect(rendered).toContain(`<summary>${END_OF_LIFE} Gradle 1.0, 4.10.3 and 7.6.4 are end-of-life</summary>`)
})
it('names every affected release line when versions span more than one', () => {
const rendered = renderSupportStatus(['7.6.4', '1.0', '4.10.3'])
expect(rendered).toContain('Gradle 1.x, 4.x and 7.x releases receive no further fixes')
})
it('names each release line once when several versions share one', () => {
const rendered = renderSupportStatus(['7.6.4', '7.6.6', '1.0'])
expect(rendered).toContain('Gradle 1.x and 7.x releases receive no further fixes')
})
it('names no version outside the versions that are end-of-life', () => {
expect(renderSupportStatus(['7.6.4'])).not.toContain('9.7.1')
})
it.each(['8.0', '8.14.3', '8.14.5', '9.2.1'])('adds only the legend for %s', version => {
expect(renderSupportStatus([version]).trim()).toBe(LEGEND)
})
it('adds the legend exactly once however many versions are flagged', () => {
const rendered = renderSupportStatus(['9.2.1', '9.4.1', '8.14.5', '8.14.3', '8.3', '8.0'])
expect(rendered.trim()).toBe(LEGEND)
})
it('emits a single section however many versions are end-of-life, plus the single legend', () => {
const rendered = renderSupportStatus(['9.6.1', '9.2.1', '8.14.5', '8.0', '7.6.4', '1.0'])
expect(rendered.match(/<details>/g)).toHaveLength(1)
expect(rendered.match(/consider upgrading/g)).toHaveLength(1)
expect(rendered).toContain(`<summary>${END_OF_LIFE} Gradle 1.0 and 7.6.4 are end-of-life</summary>`)
})
it('names no version outside the fold', () => {
const rendered = renderSupportStatus(['8.0', '9.2.1'])
expect(rendered).not.toContain('8.0')
expect(rendered).not.toContain('9.2.1')
})
it('renders nothing when every version is inside the grace band', () => {
expect(renderSupportStatus(['9.5.1', '9.6.1', '9.7.1'])).toBe('')
})
it('renders nothing when no Gradle build ran', () => {
expect(renderSupportStatus([])).toBe('')
})
})
+146 -123
View File
@@ -1,154 +1,177 @@
import {describe, expect, it} from '@jest/globals'
import {versionIsAtLeast, parseGradleVersionFromOutput} from '../../src/execution/gradle'
import {GradleVersion} from '../../src/gradle-version'
import {parseGradleVersionFromOutput} from '../../src/execution/gradle'
describe('gradle', () => {
describe('can compare versions that are', () => {
function versionsAreOrdered(versions: string[]): void {
for (let i = 0; i < versions.length; i++) {
// Compare with all other versions
for (let j = 0; j < versions.length; j++) {
if (i >= j) {
it(`${versions[i]} is at least ${versions[j]}`, () => {
expect(versionIsAtLeast(versions[i], versions[j])).toBe(true)
})
} else {
it(`${versions[i]} is NOT at least ${versions[j]}`, () => {
expect(versionIsAtLeast(versions[i], versions[j])).toBe(false)
})
}
}
}
}
function versionsAreNotOrdered(versions: string[]): void {
for (let i = 0; i < versions.length; i++) {
// Compare with all other versions
for (let j = 0; j < versions.length; j++) {
if (i !== j) {
it(`${versions[i]} is NOT at least ${versions[j]}`, () => {
expect(versionIsAtLeast(versions[i], versions[j])).toBe(false)
})
}
}
}
}
function versionsAreEqual(versions: string[]): void {
for (let i = 0; i < versions.length; i++) {
// Compare with all other versions
for (let j = 0; j < versions.length; j++) {
it(`${versions[i]} is at least ${versions[j]}`, () => {
expect(versionIsAtLeast(versions[i], versions[j])).toBe(true)
})
}
}
function order(a: string, b: string): number {
return Math.sign(GradleVersion.compare(new GradleVersion(a), new GradleVersion(b)))
}
/** Asserts every pairing of `versions`, which must be listed oldest first. */
function ascending(versions: string[]): void {
for (let i = 0; i < versions.length; i++) {
for (let j = 0; j < versions.length; j++) {
const expected = Math.sign(i - j)
it(`${versions[i]} vs ${versions[j]} is ${expected}`, () => {
expect(order(versions[i], versions[j])).toBe(expected)
})
}
}
}
describe('GradleVersion', () => {
describe('orders', () => {
describe('simple versions', () => {
versionsAreOrdered(['6.0', '6.7', '6.7.1', '6.7.2', '7.0', '7.0.1', '7.1', '8.0', '8.12.1'])
ascending(['6.0', '6.7', '6.7.1', '6.7.2', '7.0', '7.0.1', '7.1', '8.0', '8.12.1'])
})
versionsAreEqual(['7.0', '7.0.0'])
versionsAreEqual(['7.1', '7.1.0'])
describe('a shorter base is older than a longer one that extends it', () => {
ascending(['7.0', '7.0.0'])
ascending(['7.1', '7.1.0'])
})
describe('rc versions', () => {
versionsAreOrdered([
'8.10', '8.11-rc-1', '8.11-rc-2', '8.11', '8.11.1-rc-1', '8.11.1'
])
ascending(['8.10', '8.11-rc-1', '8.11-rc-2', '8.11', '8.11.1-rc-1', '8.11.1'])
})
describe('milestone versions', () => {
versionsAreOrdered([
'8.12.1', '8.12.2-milestone-1', '8.12.2', '8.13-milestone-1', '8.13-milestone-2', '8.13'
])
versionsAreOrdered([
'8.12.1', '8.12.2-milestone-1', '8.12.2-milestone-2', '8.12.2-rc-1', '8.12.2'
])
ascending(['8.12.1', '8.12.2-milestone-1', '8.12.2', '8.13-milestone-1', '8.13-milestone-2', '8.13'])
})
describe('preview versions', () => {
versionsAreOrdered([
'8.12.1', '8.12.2-preview-1', '8.12.2', '8.13-preview-1', '8.13-preview-2', '8.13'
])
versionsAreOrdered([
'8.12.1', '8.12.2-milestone-1', '8.12.2-preview-1', '8.12.2-rc-1', '8.12.2'
])
ascending(['8.12.1', '8.12.2-preview-1', '8.12.2', '8.13-preview-1', '8.13-preview-2', '8.13'])
})
describe('milestone before preview before rc before final', () => {
ascending(['8.12.2-milestone-1', '8.12.2-preview-1', '8.12.2-rc-1', '8.12.2'])
})
describe('snapshot versions', () => {
versionsAreOrdered([
'8.10.1', '8.10.2-20240828012138+0000', '8.10.2', '8.11-20240829002031+0000', '8.11'
])
versionsAreOrdered([
'9.0', '9.1-branch-provider_api_migration_public_api_changes-20240826121451+0000', '9.1'
])
versionsAreNotOrdered([
'8.10.2-20240828012138+0000', '8.10.2-20240828010000+1000', '8.10.2-milestone-1'
])
ascending(['8.10.1', '8.10.2-20240828012138+0000', '8.10.2', '8.11-20240829002031+0000', '8.11'])
ascending(['9.0', '9.1-branch-provider_api_migration_public_api_changes-20240826121451+0000', '9.1'])
})
describe('snapshots order by instant, accounting for timezone', () => {
ascending(['8.10.2-milestone-1', '8.10.2-20240828010000+1000', '8.10.2-20240828012138+0000', '8.10.2'])
})
})
describe('can parse version from output', () => {
it('major version', async () => {
const output = `
------------------------------------------------------------
Gradle 8.9
------------------------------------------------------------
`
const version = await parseGradleVersionFromOutput(output)!
expect(version).toBe('8.9')
// Gradle's `Stage.from` matches the whole stage string against /(\d+)([a-z])?/, so a stage number is
// read only when the string is entirely a number with an optional letter suffix.
describe('reads a stage number only from a fully numeric stage string', () => {
it('orders plain stage numbers numerically, not as text', () => {
// Were these compared as text, '8.11-rc-10' would sort before '8.11-rc-2'.
expect(order('8.11-rc-2', '8.11-rc-10')).toBe(-1)
})
it('patch version', async () => {
const output = `
------------------------------------------------------------
Gradle 8.9.1
------------------------------------------------------------
`
const version = await parseGradleVersionFromOutput(output)!
expect(version).toBe('8.9.1')
describe('a letter suffix orders after the bare number', () => {
ascending(['8.11-rc-1', '8.11-rc-1a', '8.11-rc-1b', '8.11-rc-2'])
})
it('rc version', async () => {
const output = `
------------------------------------------------------------
Gradle 8.9-rc-1
------------------------------------------------------------
`
const version = await parseGradleVersionFromOutput(output)!
expect(version).toBe('8.9-rc-1')
it('ignores digits embedded in a longer stage string', () => {
// 'issue10' and 'issue9' both rank as stage number 0, leaving the version string to break the
// tie; reading the digits positionally would instead sort 'issue10' after 'issue9'.
expect(order('8.0-branch-issue10-20240828012138+0000', '8.0-branch-issue9-20240828012138+0000')).toBe(-1)
})
it('milestone version', async () => {
const output = `
------------------------------------------------------------
Gradle 8.0-milestone-6
------------------------------------------------------------
`
const version = await parseGradleVersionFromOutput(output)!
expect(version).toBe('8.0-milestone-6')
})
describe('matches stage names exactly, as Gradle does', () => {
// 'RC' is not 'rc', so it ranks as unknown (1) and precedes preview (2) rather than following it.
describe('an unrecognised spelling ranks between milestone and preview', () => {
ascending(['8.0-milestone-1', '8.0-RC-1', '8.0-preview-1', '8.0-rc-1', '8.0'])
})
it('snapshot version', async () => {
const output = `
------------------------------------------------------------
Gradle 8.10.2-20240828012138+0000
------------------------------------------------------------
`
const version = await parseGradleVersionFromOutput(output)!
expect(version).toBe('8.10.2-20240828012138+0000')
})
describe('rejects a timestamp that names no real instant', () => {
it.each(['8.0-99999999999999', '8.0-20241301012138', '8.0-20240828992138', '8.0-20240828012138+9999'])(
'throws for %s',
version => {
expect(() => new GradleVersion(version)).toThrow('is not a valid Gradle snapshot timestamp')
}
)
it.each(['8.0-99999999999999', '8.0-20240828012138+9999'])(
'reports %s as unparseable rather than yielding an uncomparable version',
version => {
expect(GradleVersion.parseUntrusted(version)).toBeUndefined()
}
)
})
describe('isFinalRelease', () => {
it.each(['1.0', '8.14.5', '9.7.1'])('treats %s as final', version => {
expect(new GradleVersion(version).isFinalRelease()).toBe(true)
})
it('branch version', async () => {
const output = `
------------------------------------------------------------
Gradle 9.0-branch-provider_api_migration_public_api_changes-20240830060514+0000
------------------------------------------------------------
`
const version = await parseGradleVersionFromOutput(output)!
expect(version).toBe('9.0-branch-provider_api_migration_public_api_changes-20240830060514+0000')
it.each(['8.11-rc-1', '8.0-milestone-6', '8.10.2-20240828012138+0000', '9.0-SNAPSHOT'])(
'treats %s as not final',
version => {
expect(new GradleVersion(version).isFinalRelease()).toBe(false)
}
)
})
describe('parseUntrusted', () => {
it.each(['', 'unknown', 'v1.0'])('returns undefined for the invalid version %s', version => {
expect(GradleVersion.parseUntrusted(version)).toBeUndefined()
})
})
})
describe('parseGradleVersionFromOutput', () => {
it('major version', () => {
const output = `
------------------------------------------------------------
Gradle 8.9
------------------------------------------------------------
`
expect(parseGradleVersionFromOutput(output)).toBe('8.9')
})
it('patch version', () => {
const output = `
------------------------------------------------------------
Gradle 8.9.1
------------------------------------------------------------
`
expect(parseGradleVersionFromOutput(output)).toBe('8.9.1')
})
it('rc version', () => {
const output = `
------------------------------------------------------------
Gradle 8.9-rc-1
------------------------------------------------------------
`
expect(parseGradleVersionFromOutput(output)).toBe('8.9-rc-1')
})
it('milestone version', () => {
const output = `
------------------------------------------------------------
Gradle 8.0-milestone-6
------------------------------------------------------------
`
expect(parseGradleVersionFromOutput(output)).toBe('8.0-milestone-6')
})
it('snapshot version', () => {
const output = `
------------------------------------------------------------
Gradle 8.10.2-20240828012138+0000
------------------------------------------------------------
`
expect(parseGradleVersionFromOutput(output)).toBe('8.10.2-20240828012138+0000')
})
it('branch version', () => {
const output = `
------------------------------------------------------------
Gradle 9.0-branch-provider_api_migration_public_api_changes-20240830060514+0000
------------------------------------------------------------
`
expect(parseGradleVersionFromOutput(output)).toBe(
'9.0-branch-provider_api_migration_public_api_changes-20240830060514+0000'
)
})
})
+79 -11
View File
@@ -1,9 +1,31 @@
import dedent from 'dedent'
import * as github from '@actions/github'
import {afterEach, describe, expect, it} from '@jest/globals'
import {afterEach, describe, expect, it, jest} from '@jest/globals'
import {BuildResult} from '../../src/build-results'
import {jobMarker, renderSummaryTable} from '../../src/job-summary'
// The support-status policy itself is covered by gradle-support-status.test.ts; these tests only
// check that its output reaches the table. '8.0' is the sole release so the tables below, all of
// which build with Gradle 8.0, render without a status sign.
let releasedVersions = [{version: '8.0', checksum: ''}]
jest.unstable_mockModule('../../src/wrapper-validation/wrapper-checksums.json', () => ({
get default() {
return releasedVersions
}
}))
const {jobMarker, renderSummaryTable} = await import('../../src/job-summary')
/** Renders the summary table with the release index built from `versions` rather than the bundled data. */
async function renderWith(versions: string[], results: BuildResult[]): Promise<string> {
releasedVersions = versions.map(version => ({version, checksum: ''}))
jest.resetModules()
const {renderSummaryTable: render} = await import('../../src/job-summary')
return render(results)
}
const DOC = 'https://docs.gradle.org/current/userguide/feature_lifecycle.html#eol_support'
const SECURITY_SUBSCRIPTION = 'https://gradle.org/security-subscription/?utm_source=github-action'
const MATRIX_INPUT_ENV = 'INPUT_WORKFLOW-JOB-CONTEXT'
@@ -30,19 +52,20 @@ const failedHelpBuild: BuildResult = {
const longArgsBuild: BuildResult = {
...successfulHelpBuild,
requestedTasks: 'check publishMyLongNamePluginPublicationToMavenCentral publishMyLongNamePluginPublicationToPluginPortal',
requestedTasks:
'check publishMyLongNamePluginPublicationToMavenCentral publishMyLongNamePluginPublicationToPluginPortal'
}
const scanPublishDisabledBuild: BuildResult = {
...successfulHelpBuild,
buildScanUri: '',
buildScanFailed: false,
buildScanFailed: false
}
const scanPublishFailedBuild: BuildResult = {
...successfulHelpBuild,
buildScanUri: '',
buildScanFailed: true,
buildScanFailed: true
}
describe('renderSummaryTable', () => {
@@ -66,7 +89,7 @@ describe('renderSummaryTable', () => {
<td><a href="https://scans.gradle.com/s/abc123" rel="nofollow" target="_blank"><img src="https://img.shields.io/badge/Build%20Scan%C2%AE-06A0CE?logo=Gradle" alt="Build Scan published" /></a></td>
</tr>
</table>
`);
`)
})
it('failed build', () => {
const table = renderSummaryTable([failedHelpBuild])
@@ -87,7 +110,7 @@ describe('renderSummaryTable', () => {
<td><a href="https://scans.gradle.com/s/abc123" rel="nofollow" target="_blank"><img src="https://img.shields.io/badge/Build%20Scan%C2%AE-06A0CE?logo=Gradle" alt="Build Scan published" /></a></td>
</tr>
</table>
`);
`)
})
describe('when build scan', () => {
it('publishing disabled', () => {
@@ -109,7 +132,7 @@ describe('renderSummaryTable', () => {
<td><a href="https://scans.gradle.com" rel="nofollow" target="_blank"><img src="https://img.shields.io/badge/Not%20published-lightgrey" alt="Build Scan not published" /></a></td>
</tr>
</table>
`);
`)
})
it('publishing failed', () => {
const table = renderSummaryTable([scanPublishFailedBuild])
@@ -130,7 +153,7 @@ describe('renderSummaryTable', () => {
<td><a href="https://docs.gradle.com/develocity/gradle-plugin/#troubleshooting" rel="nofollow" target="_blank"><img src="https://img.shields.io/badge/Publish%20failed-orange" alt="Build Scan publish failed" /></a></td>
</tr>
</table>
`);
`)
})
})
it('multiple builds', () => {
@@ -159,7 +182,7 @@ describe('renderSummaryTable', () => {
<td><a href="https://scans.gradle.com/s/abc123" rel="nofollow" target="_blank"><img src="https://img.shields.io/badge/Build%20Scan%C2%AE-06A0CE?logo=Gradle" alt="Build Scan published" /></a></td>
</tr>
</table>
`);
`)
})
it('truncating long requested tasks', () => {
const table = renderSummaryTable([longArgsBuild])
@@ -180,11 +203,56 @@ describe('renderSummaryTable', () => {
<td><a href="https://scans.gradle.com/s/abc123" rel="nofollow" target="_blank"><img src="https://img.shields.io/badge/Build%20Scan%C2%AE-06A0CE?logo=Gradle" alt="Build Scan published" /></a></td>
</tr>
</table>
`);
`)
})
})
})
describe('Gradle version support status', () => {
it('warns on an end-of-life version and folds the detail below the table', async () => {
const table = await renderWith(['10.0.0', '8.0'], [successfulHelpBuild])
expect(table.trim()).toBe(dedent`
<table>
<tr>
<th>Gradle Root Project</th>
<th>Requested Tasks</th>
<th>Gradle Version</th>
<th>Build Outcome</th>
<th>Build&nbsp;Scan®</th>
</tr>
<tr>
<td>root</td>
<td>help</td>
<td align='center'>8.0 :warning:</td>
<td align='center'>:white_check_mark:</td>
<td><a href="https://scans.gradle.com/s/abc123" rel="nofollow" target="_blank"><img src="https://img.shields.io/badge/Build%20Scan%C2%AE-06A0CE?logo=Gradle" alt="Build Scan published" /></a></td>
</tr>
</table>
<details>
<summary>:warning: Gradle 8.0 is end-of-life</summary>
<p>Gradle 8.x releases receive no further fixes, security fixes included. Update to the latest Gradle version.</p>
<p>If you cannot upgrade, see the <a href="${SECURITY_SUBSCRIPTION}">Gradle Security Subscription</a> for options.</p>
</details>
`)
})
it('signs a still-supported but outdated version with the info sign and one legend', async () => {
const table = await renderWith(['9.0.0', '8.1', '8.0'], [successfulHelpBuild])
expect(table).toContain(`<td align='center'>8.0 :information_source:</td>`)
expect(table).toContain(
`<p>:information_source: Gradle version is out of date — consider upgrading. ` +
`See <a href="${DOC}">Gradle release lifecycle</a></p>`
)
expect(table).not.toContain('<details>')
})
it('adds nothing for a version inside the grace band', async () => {
const table = await renderWith(['8.2', '8.0'], [successfulHelpBuild])
expect(table).toContain(`<td align='center'>8.0</td>`)
expect(table).not.toContain(':information_source:')
expect(table).not.toContain('consider upgrading')
})
})
describe('jobMarker', () => {
const original = process.env[MATRIX_INPUT_ENV]