Use Gradle Wrapper if specified without Gradle version

Signed-off-by: Anders Fischer-Nielsen <andersfischern@me.com>

src/cache-cleaner.ts

@@ -7,10 +7,12 @@ import path from 'path'
 export class CacheCleaner {
     private readonly gradleUserHome: string
     private readonly tmpDir: string
+    private readonly gradleVersion?: string
 
-    constructor(gradleUserHome: string, tmpDir: string) {
+    constructor(gradleUserHome: string, tmpDir: string, gradleVersion?: string) {
         this.gradleUserHome = gradleUserHome
         this.tmpDir = tmpDir
+        this.gradleVersion = gradleVersion
     }
 
     async prepare(): Promise<void> {
@@ -42,9 +44,15 @@ export class CacheCleaner {
         )
         fs.writeFileSync(path.resolve(cleanupProjectDir, 'build.gradle'), 'task("noop") {}')
 
-        await exec.exec(`gradle -g ${this.gradleUserHome} --no-daemon --build-cache --no-scan --quiet noop`, [], {
+        const gradleExecutable = this.gradleVersion === 'wrapper' ? './gradlew' : 'gradle'
-            cwd: cleanupProjectDir
+
-        })
+        await exec.exec(
+            `${gradleExecutable} -g ${this.gradleUserHome} --no-daemon --build-cache --no-scan --quiet noop`,
+            [],
+            {
+                cwd: cleanupProjectDir
+            }
+        )
     }
 
     private async ageAllFiles(fileName = '*'): Promise<void> {

src/caches.ts

@@ -6,6 +6,7 @@ import {GradleStateCache} from './cache-base'
 import {CacheCleaner} from './cache-cleaner'
 
 const CACHE_RESTORED_VAR = 'GRADLE_BUILD_ACTION_CACHE_RESTORED'
+const GRADLE_VERSION = 'GRADLE_VERSION'
 
 export async function restore(gradleUserHome: string, cacheListener: CacheListener): Promise<void> {
     // Bypass restore cache on all but first action step in workflow.
@@ -48,7 +49,8 @@ export async function restore(gradleUserHome: string, cacheListener: CacheListen
 
     if (isCacheCleanupEnabled() && !isCacheReadOnly()) {
         core.info('Preparing cache for cleanup.')
-        const cacheCleaner = new CacheCleaner(gradleUserHome, process.env['RUNNER_TEMP']!)
+        const gradleVersion = core.getState(GRADLE_VERSION)
+        const cacheCleaner = new CacheCleaner(gradleUserHome, process.env['RUNNER_TEMP']!, gradleVersion)
         await cacheCleaner.prepare()
     }
 }
@@ -78,7 +80,8 @@ export async function save(
 
     if (isCacheCleanupEnabled()) {
         core.info('Forcing cache cleanup.')
-        const cacheCleaner = new CacheCleaner(gradleUserHome, process.env['RUNNER_TEMP']!)
+        const gradleVersion = core.getState(GRADLE_VERSION)
+        const cacheCleaner = new CacheCleaner(gradleUserHome, process.env['RUNNER_TEMP']!, gradleVersion)
         await cacheCleaner.forceCleanup()
     }
 

src/main.ts

@@ -6,6 +6,8 @@ import * as setupGradle from './setup-gradle'
 import * as execution from './execution'
 import * as provision from './provision'
 
+const GRADLE_VERSION = 'GRADLE_VERSION'
+
 /**
  * The main entry point for the action, called by Github Actions for the step.
  */
@@ -39,6 +41,10 @@ run()
 
 async function provisionGradle(workspaceDirectory: string): Promise<string | undefined> {
     const gradleVersion = core.getInput('gradle-version')
+
+    // Save the Gradle version for use in the post-action step.
+    core.saveState(GRADLE_VERSION, gradleVersion)
+
     if (gradleVersion !== '' && gradleVersion !== 'wrapper') {
         return path.resolve(await provision.gradleVersion(gradleVersion))
     }

test/jest/cache-cleanup.test.ts

@@ -62,6 +62,36 @@ test('will cleanup unused gradle versions', async () => {
     expect(fs.existsSync(gradleCurrent)).toBe(true)
 })
 
+test('will use Gradle Wrapper for cleanup if specified', async () => {
+    const projectRoot = prepareTestProject()
+    const gradleUserHome = path.resolve(projectRoot, 'HOME')
+    const tmpDir = path.resolve(projectRoot, 'tmp')
+    const cacheCleaner = new CacheCleaner(gradleUserHome, tmpDir, 'wrapper')
+
+    // Initialize HOME with 2 different Gradle versions
+    await runGradleWrapperBuild(projectRoot, 'build')
+    await runGradleBuild(projectRoot, 'build')
+    
+    await cacheCleaner.prepare()
+
+    // Run with only one of these versions
+    await runGradleBuild(projectRoot, 'build')
+
+    const gradle733 = path.resolve(gradleUserHome, "caches/7.3.3")
+    const wrapper733 = path.resolve(gradleUserHome, "wrapper/dists/gradle-7.3.3-bin")
+    const gradleCurrent = path.resolve(gradleUserHome, "caches/7.5.1")
+
+    expect(fs.existsSync(gradle733)).toBe(true)
+    expect(fs.existsSync(wrapper733)).toBe(true)
+    expect(fs.existsSync(gradleCurrent)).toBe(true)
+
+    await cacheCleaner.forceCleanup()
+
+    expect(fs.existsSync(gradle733)).toBe(false)
+    expect(fs.existsSync(wrapper733)).toBe(false)
+    expect(fs.existsSync(gradleCurrent)).toBe(true)
+})
+
 async function runGradleBuild(projectRoot: string, args: string, version: string = '3.1'): Promise<void> {
     const status31 = await exec.exec(`gradle -g HOME --no-daemon --build-cache -Dcommons_math3_version="${version}" ${args}`, [], {
         cwd: projectRoot