@invarn/cibuild 2.9.0 → 2.9.2

package/dist/src/yaml/steps/gradle-sdk-cmake.test.js

@@ -0,0 +1,183 @@
+/**
+ * The SDK CMake a build file pins, installed before Gradle runs.
+ *
+ * IacobIonut01/ReFra pins `externalNativeBuild.cmake.version = "3.31.6"`, and
+ * its own native script (a Gradle task that runs before AGP configures CMake)
+ * requires `$SDK/cmake/3.31.6/bin/cmake`. AGP would download the pinned CMake,
+ * but only at its own configure step, which comes too late, and the build
+ * image bakes no SDK CMake. So the build failed with "cmake 3.31.6 not found".
+ *
+ * The shell under test is the one that ships: it is executed here, not
+ * re-implemented.
+ */
+import { execFileSync } from "node:child_process";
+import { chmodSync, copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { AndroidBuildForUITestingStepExecutor, AndroidLintStepExecutor, AndroidUnitTestStepExecutor, GradleBuildStepExecutor, } from "./android.js";
+import { GRADLE_SDK_CMAKE_FUNCTIONS } from "./gradle-sdk-cmake.js";
+import { testConfig } from "./test-config.js";
+const FIXTURES = join(dirname(fileURLToPath(import.meta.url)), "../../../test/fixtures/gradle-sdk-cmake");
+let dir;
+let sdk;
+beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), "cibuild-sdk-cmake-"));
+    sdk = join(dir, "sdk");
+    mkdirSync(join(dir, "project", "app"), { recursive: true });
+    mkdirSync(sdk);
+});
+afterEach(() => {
+    rmSync(dir, { recursive: true, force: true });
+});
+/** A fake sdkmanager: records its arguments and installs what it is asked for. */
+function fakeSdkmanager(exitCode = 0) {
+    const bin = join(sdk, "cmdline-tools", "latest", "bin");
+    mkdirSync(bin, { recursive: true });
+    const path = join(bin, "sdkmanager");
+    writeFileSync(path, `#!/bin/bash
+echo "$*" >> "${dir}/sdkmanager-args"
+[ ${exitCode} -eq 0 ] || { echo "Warning: Failed to find package"; exit ${exitCode}; }
+for a in "$@"; do
+  case "$a" in
+    cmake\\;*) v="\${a#cmake;}"; mkdir -p "${sdk}/cmake/$v/bin"; printf '#!/bin/sh\\n' > "${sdk}/cmake/$v/bin/cmake"; chmod +x "${sdk}/cmake/$v/bin/cmake" ;;
+  esac
+done
+`);
+    chmodSync(path, 0o755);
+    return path;
+}
+/** Run the shipped install in the project directory, with the SDK in ANDROID_HOME. */
+function install(env = { ANDROID_HOME: sdk }) {
+    const script = `${GRADLE_SDK_CMAKE_FUNCTIONS}
+cibuild_install_pinned_cmake
+echo "after: $?"`;
+    try {
+        const stdout = execFileSync("bash", ["-c", script], {
+            cwd: join(dir, "project"),
+            encoding: "utf-8",
+            env: { PATH: "/usr/bin:/bin", ...env },
+        });
+        return { status: 0, stdout };
+    }
+    catch (e) {
+        const err = e;
+        return { status: err.status, stdout: err.stdout };
+    }
+}
+function sdkmanagerArgs() {
+    const file = join(dir, "sdkmanager-args");
+    return existsSync(file) ? readFileSync(file, "utf-8").trim().split("\n") : [];
+}
+describe("cibuild_install_pinned_cmake", () => {
+    test("ReFra: the pinned cmake;3.31.6 is installed, and one line says why", () => {
+        copyFileSync(join(FIXTURES, "refra.app.build.gradle.kts"), join(dir, "project", "app", "build.gradle.kts"));
+        fakeSdkmanager();
+        const run = install();
+        expect(sdkmanagerArgs()).toEqual([`--sdk_root=${sdk} cmake;3.31.6`]);
+        expect(existsSync(join(sdk, "cmake", "3.31.6", "bin", "cmake"))).toBe(true);
+        expect(run.stdout).toContain("Android SDK: installing cmake;3.31.6, which ./app/build.gradle.kts:47 pins (externalNativeBuild cmake version) and this SDK does not have.");
+        expect(run.stdout).toContain("Android SDK: cmake;3.31.6 installed.");
+        expect(run.stdout).toContain("after: 0");
+    });
+    test("a CMake the SDK already has is left alone, and nothing is printed", () => {
+        copyFileSync(join(FIXTURES, "refra.app.build.gradle.kts"), join(dir, "project", "app", "build.gradle.kts"));
+        fakeSdkmanager();
+        mkdirSync(join(sdk, "cmake", "3.31.6", "bin"), { recursive: true });
+        writeFileSync(join(sdk, "cmake", "3.31.6", "bin", "cmake"), "#!/bin/sh\n");
+        chmodSync(join(sdk, "cmake", "3.31.6", "bin", "cmake"), 0o755);
+        const run = install();
+        expect(sdkmanagerArgs()).toEqual([]);
+        expect(run.stdout).not.toContain("Android SDK:");
+    });
+    test("Groovy's `version \"x\"`, and only inside a cmake block, and never in a comment", () => {
+        writeFileSync(join(dir, "project", "app", "build.gradle"), [
+            "version = '9.9.9'",
+            "android {",
+            "  defaultConfig {",
+            "    versionName \"1.2.3\"",
+            "    externalNativeBuild { cmake { cppFlags '-std=c++17' } }",
+            "  }",
+            "  externalNativeBuild {",
+            "    cmake {",
+            "      path 'src/main/cpp/CMakeLists.txt'",
+            "      // version '3.10.2'",
+            "      version '3.22.1'",
+            "    }",
+            "  }",
+            "  ndkVersion '27.0.12077973'",
+            "}",
+            "",
+        ].join("\n"));
+        fakeSdkmanager();
+        install();
+        expect(sdkmanagerArgs()).toEqual([`--sdk_root=${sdk} cmake;3.22.1`]);
+    });
+    test("a one-line cmake block, two modules pinning the same version, and build outputs skipped", () => {
+        writeFileSync(join(dir, "project", "app", "build.gradle.kts"), 'android { externalNativeBuild { cmake { version = "3.31.6" } } }\n');
+        mkdirSync(join(dir, "project", "lib"));
+        writeFileSync(join(dir, "project", "lib", "build.gradle.kts"), 'android {\n  externalNativeBuild {\n    cmake {\n      version = "3.31.6"\n    }\n  }\n}\n');
+        mkdirSync(join(dir, "project", "app", "build", "tmp"), { recursive: true });
+        writeFileSync(join(dir, "project", "app", "build", "tmp", "build.gradle.kts"), 'cmake { version = "3.6.0" }\n');
+        fakeSdkmanager();
+        install();
+        expect(sdkmanagerArgs()).toEqual([`--sdk_root=${sdk} cmake;3.31.6`]);
+    });
+    test("a project that pins no CMake does nothing", () => {
+        writeFileSync(join(dir, "project", "app", "build.gradle.kts"), 'android { compileSdk = 36 }\n');
+        fakeSdkmanager();
+        const run = install();
+        expect(sdkmanagerArgs()).toEqual([]);
+        expect(run.stdout).toBe("after: 0\n");
+    });
+    test("the SDK from local.properties when ANDROID_HOME is unset", () => {
+        copyFileSync(join(FIXTURES, "refra.app.build.gradle.kts"), join(dir, "project", "app", "build.gradle.kts"));
+        writeFileSync(join(dir, "project", "local.properties"), `sdk.dir=${sdk}\n`);
+        fakeSdkmanager();
+        install({});
+        expect(sdkmanagerArgs()).toEqual([`--sdk_root=${sdk} cmake;3.31.6`]);
+    });
+    test("no SDK to install into: says so, and the step goes on", () => {
+        copyFileSync(join(FIXTURES, "refra.app.build.gradle.kts"), join(dir, "project", "app", "build.gradle.kts"));
+        const run = install({});
+        expect(run.stdout).toContain("Android SDK: ./app/build.gradle.kts:47 pins cmake;3.31.6, but no Android SDK was found (ANDROID_HOME, ANDROID_SDK_ROOT, local.properties sdk.dir), so it is not installed here.");
+        expect(run.stdout).toContain("after: 0");
+    });
+    test("an SDK without sdkmanager: says so, and the step goes on", () => {
+        copyFileSync(join(FIXTURES, "refra.app.build.gradle.kts"), join(dir, "project", "app", "build.gradle.kts"));
+        const run = install();
+        expect(run.stdout).toContain(`Android SDK: ./app/build.gradle.kts:47 pins cmake;3.31.6, but ${sdk} has no sdkmanager, so it is not installed here.`);
+        expect(run.stdout).toContain("after: 0");
+    });
+    test("a failed install says so, with sdkmanager's words, and the step goes on", () => {
+        copyFileSync(join(FIXTURES, "refra.app.build.gradle.kts"), join(dir, "project", "app", "build.gradle.kts"));
+        fakeSdkmanager(1);
+        const run = install();
+        expect(run.stdout).toContain("Android SDK: installing cmake;3.31.6 failed (sdkmanager exit 1); Gradle runs anyway:");
+        expect(run.stdout).toContain("    Warning: Failed to find package");
+        expect(run.stdout).toContain("after: 0");
+    });
+});
+describe("the Gradle steps", () => {
+    test("every Gradle step installs the pinned CMake before Gradle runs", async () => {
+        const steps = [
+            await new GradleBuildStepExecutor().execute({ gradle_task: "assembleDebug" }, {}, testConfig),
+            await new AndroidLintStepExecutor().execute({}, {}, testConfig),
+            await new AndroidUnitTestStepExecutor().execute({}, {}, testConfig),
+            await new AndroidBuildForUITestingStepExecutor().execute({}, {}, testConfig),
+        ];
+        for (const step of steps) {
+            const script = step.script;
+            const at = script.indexOf("\ncibuild_install_pinned_cmake\n");
+            expect(at).toBeGreaterThan(-1);
+            expect(at).toBeLessThan(script.indexOf("$GRADLE_CMD "));
+            execFileSync("bash", ["-n", "-c", script]);
+        }
+    });
+    test("no line the functions print can be taken for a step-progress marker", () => {
+        for (const line of GRADLE_SDK_CMAKE_FUNCTIONS.split("\n")) {
+            expect(line).not.toMatch(/INVARN_STEP|\[step_/);
+        }
+    });
+});
+//# sourceMappingURL=gradle-sdk-cmake.test.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@invarn/cibuild",
-  "version": "2.9.0",
+  "version": "2.9.2",
   "description": "CI Build CLI — local pipeline orchestration and validation",
   "type": "module",
   "main": "dist/cli.cjs",