@invarn/cibuild 2.8.0 → 2.8.2

package/dist/src/commands/a-properties-stand-in-declares-the-keys-the-build-reads.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=a-properties-stand-in-declares-the-keys-the-build-reads.test.d.ts.map

package/dist/src/commands/a-properties-stand-in-declares-the-keys-the-build-reads.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"a-properties-stand-in-declares-the-keys-the-build-reads.test.d.ts","sourceRoot":"","sources":["../../../src/commands/a-properties-stand-in-declares-the-keys-the-build-reads.test.ts"],"names":[],"mappings":""}

package/dist/src/commands/a-properties-stand-in-declares-the-keys-the-build-reads.test.js

@@ -0,0 +1,354 @@
+/**
+ * An empty properties file fixes "file missing", not "field missing".
+ *
+ * The Secrets Gradle plugin turns each key of the properties file it loads
+ * into a `BuildConfig` constant and a manifest placeholder. A checkout without
+ * that file gets neither, so handing the build an empty stand-in clears the
+ * plugin's own throw and then fails one step later, inside Gradle, at the first
+ * reference to a constant that was never generated.
+ *
+ * `missingPropertyKeys` is the list a stand-in has to declare for that
+ * reference to resolve: what the build reads, read off the build files and the
+ * source under the modules that apply the plugin.
+ */
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { scanAndroidProject } from "./android-scanner.js";
+let root;
+beforeEach(() => {
+    root = mkdtempSync(join(tmpdir(), "cibuild-props-"));
+});
+afterEach(() => {
+    rmSync(root, { recursive: true, force: true });
+});
+function write(relative, content) {
+    const path = join(root, relative);
+    mkdirSync(join(path, ".."), { recursive: true });
+    writeFileSync(path, content);
+}
+async function keys() {
+    return (await scanAndroidProject(root)).missingPropertyKeys;
+}
+/**
+ * The shape the whole thing is for: one module applying the plugin, no
+ * properties file anywhere, and the root declaring the plugin without
+ * applying it — which is where a version catalog alias is nearly always named.
+ */
+function projectApplyingTheSecretsPlugin(appBuildFileExtra = "") {
+    write("settings.gradle.kts", 'include(":app")\n');
+    write("build.gradle.kts", "plugins {\n  alias(libs.plugins.secrets) apply false\n}\n");
+    write("app/build.gradle.kts", `plugins {\n  id("com.android.application")\n  alias(libs.plugins.secrets)\n}\n\nandroid {\n  namespace = "com.example.app"\n${appBuildFileExtra}}\n`);
+    write(".gitignore", "local.properties\n");
+}
+describe("the keys a generated properties file has to declare", () => {
+    test("names a BuildConfig field referenced from Kotlin source", async () => {
+        projectApplyingTheSecretsPlugin();
+        write("app/src/main/java/com/example/app/Maps.kt", "package com.example.app\n\nval key: String = BuildConfig.MAPS_API_KEY\n");
+        expect(await keys()).toEqual(["MAPS_API_KEY"]);
+    });
+    test("names one referenced from Java source", async () => {
+        projectApplyingTheSecretsPlugin();
+        write("app/src/main/java/com/example/app/Maps.java", "package com.example.app;\n\nclass Maps { String k = BuildConfig.MAPS_API_KEY; }\n");
+        expect(await keys()).toEqual(["MAPS_API_KEY"]);
+    });
+    test("names a manifestPlaceholders key — Kotlin DSL, indexed", async () => {
+        projectApplyingTheSecretsPlugin('  defaultConfig {\n    manifestPlaceholders["mapsApiKey"] = "unused"\n  }\n');
+        expect(await keys()).toEqual(["mapsApiKey"]);
+    });
+    test("names a manifestPlaceholders key — Kotlin DSL, whole map", async () => {
+        projectApplyingTheSecretsPlugin('  defaultConfig {\n    manifestPlaceholders += mapOf("mapsApiKey" to "u", "adsAppId" to "u")\n  }\n');
+        expect(await keys()).toEqual(["adsAppId", "mapsApiKey"]);
+    });
+    test("names a manifestPlaceholders key — Groovy map literal", async () => {
+        write("settings.gradle", "include ':app'\n");
+        write("build.gradle", "// root\n");
+        write("app/build.gradle", "plugins {\n  id 'com.google.android.libraries.mapsplatform.secrets-gradle-plugin'\n}\n" +
+            "android {\n  defaultConfig {\n" +
+            "    manifestPlaceholders = [mapsApiKey: \"unused\", 'adsAppId': \"unused\"]\n" +
+            "  }\n}\n");
+        expect(await keys()).toEqual(["adsAppId", "mapsApiKey"]);
+    });
+    test("names a manifestPlaceholders key — Groovy put", async () => {
+        write("settings.gradle", "include ':app'\n");
+        write("build.gradle", "// root\n");
+        write("app/build.gradle", "plugins {\n  id 'com.google.android.libraries.mapsplatform.secrets-gradle-plugin'\n}\n" +
+            "android {\n  defaultConfig {\n" +
+            "    manifestPlaceholders.put('mapsApiKey', 'unused')\n" +
+            "  }\n}\n");
+        expect(await keys()).toEqual(["mapsApiKey"]);
+    });
+    test("merges both sources, sorted and deduplicated", async () => {
+        projectApplyingTheSecretsPlugin('  defaultConfig {\n    manifestPlaceholders["MAPS_API_KEY"] = "u"\n  }\n');
+        write("app/src/main/java/com/example/app/Keys.kt", "val a = BuildConfig.MAPS_API_KEY\nval b = BuildConfig.ADS_APP_ID\nval c = BuildConfig.MAPS_API_KEY\n");
+        expect(await keys()).toEqual(["ADS_APP_ID", "MAPS_API_KEY"]);
+    });
+});
+describe("what it deliberately leaves out", () => {
+    /**
+     * `BuildConfig.DEBUG` is the most-referenced constant in Android source, and
+     * AGP generates it whether or not a properties file exists. Declaring it
+     * would make the Secrets plugin generate a `String DEBUG` beside AGP's
+     * `boolean DEBUG` — the file meant to rescue the build breaking it instead.
+     */
+    test("the fields AGP generates by itself", async () => {
+        projectApplyingTheSecretsPlugin();
+        write("app/src/main/java/com/example/app/Env.kt", [
+            "val d = BuildConfig.DEBUG",
+            "val a = BuildConfig.APPLICATION_ID",
+            "val t = BuildConfig.BUILD_TYPE",
+            "val f = BuildConfig.FLAVOR",
+            "val fd = BuildConfig.FLAVOR_environment",
+            "val vc = BuildConfig.VERSION_CODE",
+            "val vn = BuildConfig.VERSION_NAME",
+            "val lp = BuildConfig.LIBRARY_PACKAGE_NAME",
+            "val mine = BuildConfig.MAPS_API_KEY",
+        ].join("\n"));
+        expect(await keys()).toEqual(["MAPS_API_KEY"]);
+    });
+    test("a project that applies no Secrets plugin", async () => {
+        write("settings.gradle.kts", 'include(":app")\n');
+        write("build.gradle.kts", "// root\n");
+        write("app/build.gradle.kts", 'plugins {\n  id("com.android.application")\n}\n');
+        write("app/src/main/java/com/example/app/Maps.kt", "val k = BuildConfig.MAPS_API_KEY\n");
+        expect(await keys()).toEqual([]);
+    });
+    /**
+     * `apply false` names the plugin's version for the modules that will apply
+     * it; the root project loads no properties file of its own. Reading it as an
+     * application would aim the source walk at the whole repository — every
+     * module's source, on the strength of a line that applies nothing.
+     */
+    test("a root that declares the plugin with apply false", async () => {
+        write("settings.gradle.kts", 'include(":app", ":other")\n');
+        write("build.gradle.kts", "plugins {\n  alias(libs.plugins.secrets) apply false\n}\n");
+        write("app/build.gradle.kts", 'plugins {\n  id("com.android.application")\n}\n');
+        write("other/build.gradle.kts", "// nothing\n");
+        write("other/src/main/java/Other.kt", "val k = BuildConfig.ELSEWHERE\n");
+        expect(await keys()).toEqual([]);
+    });
+    test("generated sources under build/", async () => {
+        projectApplyingTheSecretsPlugin();
+        write("app/build/generated/source/buildConfig/debug/com/example/app/BuildConfig.java", "public final class BuildConfig { public static final String STALE = BuildConfig.STALE; }\n");
+        write("app/src/main/java/com/example/app/Maps.kt", "val k = BuildConfig.MAPS_API_KEY\n");
+        expect(await keys()).toEqual(["MAPS_API_KEY"]);
+    });
+});
+describe("the module boundary", () => {
+    test("reads source of the module that applies the plugin, not its siblings", async () => {
+        write("settings.gradle.kts", 'include(":app", ":other")\n');
+        write("build.gradle.kts", "// root\n");
+        write("app/build.gradle.kts", 'plugins {\n  alias(libs.plugins.secrets)\n}\n');
+        write("app/src/main/java/App.kt", "val k = BuildConfig.MAPS_API_KEY\n");
+        write("other/build.gradle.kts", "// nothing\n");
+        write("other/src/main/java/Other.kt", "val k = BuildConfig.ELSEWHERE\n");
+        expect(await keys()).toEqual(["MAPS_API_KEY"]);
+    });
+    test("a root module that really applies the plugin covers the whole tree", async () => {
+        write("settings.gradle.kts", 'include(":app")\n');
+        write("build.gradle.kts", 'plugins {\n  id("com.android.application")\n  alias(libs.plugins.secrets)\n}\n');
+        write("app/build.gradle.kts", "// nothing\n");
+        write("app/src/main/java/App.kt", "val k = BuildConfig.MAPS_API_KEY\n");
+        expect(await keys()).toEqual(["MAPS_API_KEY"]);
+    });
+});
+/**
+ * The warnings a customer already sees. This scan adds a field and reads more
+ * files; it must not add, drop or reword a single warning, so the two paths
+ * that emit a `secrets-plugin` warning are asserted whole.
+ */
+describe("the Secrets-plugin warning path is unchanged", () => {
+    test("with no companion defaults file, the one file-absent warning", async () => {
+        projectApplyingTheSecretsPlugin();
+        write("app/src/main/java/com/example/app/Maps.kt", "val k = BuildConfig.MAPS_API_KEY\n");
+        const result = await scanAndroidProject(root);
+        expect(result.warnings.filter((w) => w.category === "secrets-plugin")).toEqual([
+            {
+                category: "secrets-plugin",
+                severity: "warning",
+                message: "Google Secrets Gradle Plugin reads 'local.properties' which is absent in CI",
+                hint: "Inject 'local.properties' as a file step using a secret variable",
+                // The root build file, which is where the version-catalog alias is
+                // named with `apply false`. The warning path counts that as an
+                // application and always has; `missingPropertyKeys` does not, which is
+                // why the two ask the question through different functions.
+                location: "build.gradle.kts",
+            },
+        ]);
+        // And the new field is populated in the same scan, from the same files.
+        expect(result.missingPropertyKeys).toEqual(["MAPS_API_KEY"]);
+    });
+    test("with a companion defaults file, one warning per expected key", async () => {
+        projectApplyingTheSecretsPlugin();
+        write("secrets.defaults.properties", "MAPS_API_KEY=\nADS_APP_ID=\n");
+        write("app/src/main/java/com/example/app/Maps.kt", "val k = BuildConfig.MAPS_API_KEY\n");
+        const result = await scanAndroidProject(root);
+        expect(result.warnings.filter((w) => w.category === "secrets-plugin")).toEqual([
+            {
+                category: "secrets-plugin",
+                severity: "warning",
+                message: "Secrets plugin key: MAPS_API_KEY",
+                hint: "Add via: ci secrets add MAPS_API_KEY",
+                location: "local.properties",
+            },
+            {
+                category: "secrets-plugin",
+                severity: "warning",
+                message: "Secrets plugin key: ADS_APP_ID",
+                hint: "Add via: ci secrets add ADS_APP_ID",
+                location: "local.properties",
+            },
+        ]);
+    });
+    test("a properties file that is present but not gitignored warns about neither", async () => {
+        write("settings.gradle.kts", 'include(":app")\n');
+        write("build.gradle.kts", "// root\n");
+        write("app/build.gradle.kts", "plugins {\n  alias(libs.plugins.secrets)\n}\n");
+        write("local.properties", "sdk.dir=/opt/android\n");
+        write("app/src/main/java/App.kt", "val k = BuildConfig.MAPS_API_KEY\n");
+        const result = await scanAndroidProject(root);
+        expect(result.warnings.filter((w) => w.category === "secrets-plugin")).toEqual([]);
+        // The keys are still reported. `invarn`-style callers run this scan on a
+        // developer's own checkout, where the file is nearly always present and
+        // holds nothing but `sdk.dir` — gating the keys on its absence would
+        // return nothing in exactly the case they are needed for.
+        expect(result.missingPropertyKeys).toEqual(["MAPS_API_KEY"]);
+    });
+});
+/**
+ * The commonest shape of all, and the one the first three sources missed.
+ *
+ * The Secrets plugin's own documentation, and every Google Maps setup guide,
+ * puts the key in the manifest and nowhere else. There is no `BuildConfig`
+ * reference and no `manifestPlaceholders` block — the plugin substitutes the
+ * value during manifest merging. A scan reading only build files and source
+ * returns nothing for such a repository, which is the majority of them.
+ */
+describe("a key referenced only in AndroidManifest.xml", () => {
+    test("names a placeholder the plugin fills", async () => {
+        projectApplyingTheSecretsPlugin();
+        write("app/src/main/AndroidManifest.xml", '<manifest xmlns:android="http://schemas.android.com/apk/res/android">\n' +
+            "  <application>\n" +
+            '    <meta-data android:name="com.google.android.geo.API_KEY"\n' +
+            '               android:value="${MAPS_API_KEY}" />\n' +
+            "  </application>\n</manifest>\n");
+        expect(await keys()).toEqual(["MAPS_API_KEY"]);
+    });
+    // AGP supplies this one from the variant, so it is not a value anybody owes.
+    test("ignores ${applicationId}", async () => {
+        projectApplyingTheSecretsPlugin();
+        write("app/src/main/AndroidManifest.xml", '<manifest>\n  <provider android:authorities="${applicationId}.provider" />\n</manifest>\n');
+        expect(await keys()).toEqual([]);
+    });
+    test("finds them in flavor source sets too", async () => {
+        projectApplyingTheSecretsPlugin();
+        write("app/src/main/AndroidManifest.xml", '<manifest a="${BASE_KEY}" />\n');
+        write("app/src/prod/AndroidManifest.xml", '<manifest a="${PROD_KEY}" />\n');
+        expect(await keys()).toEqual(["BASE_KEY", "PROD_KEY"]);
+    });
+    test("skips a merged manifest under build/", async () => {
+        projectApplyingTheSecretsPlugin();
+        write("app/src/main/AndroidManifest.xml", '<manifest a="${REAL_KEY}" />\n');
+        write("app/build/intermediates/merged_manifest/AndroidManifest.xml", '<manifest a="${STALE}" />\n');
+        expect(await keys()).toEqual(["REAL_KEY"]);
+    });
+});
+/**
+ * A build that loads the properties file itself, with no Secrets plugin
+ * anywhere. The file existing is not the fix for these — only the file
+ * existing *with the key in it* is, because `getProperty` on an absent key
+ * returns null whether or not the file is there.
+ */
+describe("a build that reads the properties file directly", () => {
+    test("names a getProperty key, with no plugin applied", async () => {
+        write("settings.gradle.kts", 'include(":app")\n');
+        write("build.gradle.kts", "// root\n");
+        write("app/build.gradle.kts", 'import com.android.build.gradle.internal.cxx.configure.gradleLocalProperties\n' +
+            'val url: String = gradleLocalProperties(rootDir).getProperty("api.url.release")\n');
+        expect(await keys()).toEqual(["api.url.release"]);
+    });
+    test("keeps dotted keys, which a direct reader may use freely", async () => {
+        write("settings.gradle", "include ':app'\n");
+        write("build.gradle", "// root\n");
+        write("app/build.gradle", "def props = new Properties()\n" +
+            "props.load(rootProject.file('local.properties').newDataInputStream())\n" +
+            "def a = props.getProperty('api.url.debug')\n" +
+            "def b = props.getProperty('tv.isDebug')\n");
+        expect(await keys()).toEqual(["api.url.debug", "tv.isDebug"]);
+    });
+    test("honours a default argument without treating it as a key", async () => {
+        write("settings.gradle.kts", 'include(":app")\n');
+        write("build.gradle.kts", "// root\n");
+        write("app/build.gradle.kts", 'val p = java.util.Properties()\n' +
+            'p.load(rootProject.file("local.properties").reader())\n' +
+            'val u = p.getProperty("api.url.release", "")\n');
+        expect(await keys()).toEqual(["api.url.release"]);
+    });
+    /**
+     * The idiom that hides every key behind a name the repository chose. Without
+     * following it, a repository like this reads as having no keys at all.
+     */
+    test("follows a hand-rolled accessor to its call sites", async () => {
+        write("settings.gradle", "include ':app'\n");
+        write("build.gradle", "// root\n");
+        write("app/build.gradle", "def getProps(String propName) {\n" +
+            "    def propsFile = rootProject.file('local.properties')\n" +
+            "    if (propsFile.exists()) {\n" +
+            "        def props = new Properties()\n" +
+            "        props.load(new FileInputStream(propsFile))\n" +
+            "        return props[propName]\n" +
+            "    } else {\n" +
+            "        return \"\";\n" +
+            "    }\n" +
+            "}\n" +
+            "\n" +
+            "String signFilePath = getProps(\"sign.file\")\n" +
+            "Boolean noObfuscate = getProps(\"app.dontobfuscate\")?.toBoolean() ?: false\n");
+        expect(await keys()).toEqual(["app.dontobfuscate", "sign.file"]);
+    });
+    test("does not follow a function that reads something else", async () => {
+        write("settings.gradle", "include ':app'\n");
+        write("build.gradle", "// root\n");
+        write("app/build.gradle", "def getProps(String n) {\n" +
+            "    def p = new Properties()\n" +
+            "    p.load(rootProject.file('local.properties').newDataInputStream())\n" +
+            "    return p[n]\n" +
+            "}\n" +
+            "def version(String n) {\n" +
+            "    def p = new Properties()\n" +
+            "    p.load(rootProject.file('version.properties').newDataInputStream())\n" +
+            "    return p[n]\n" +
+            "}\n" +
+            "def a = getProps('wanted')\n" +
+            "def b = version('unwanted')\n");
+        expect(await keys()).toEqual(["wanted"]);
+    });
+    /**
+     * `properties["x"]` is the Gradle *project* property channel —
+     * `gradle.properties` and `-P` — which the scan already reports separately.
+     * Declaring those in a properties file would be the wrong file entirely.
+     */
+    test("does not confuse Gradle project properties for properties-file keys", async () => {
+        write("settings.gradle.kts", 'include(":app")\n');
+        write("build.gradle.kts", "// root\n");
+        write("app/build.gradle.kts", 'val p = java.util.Properties()\n' +
+            'p.load(rootProject.file("local.properties").reader())\n' +
+            'val a = p.getProperty("wanted")\n' +
+            'val b = properties["projectScoped"]\n' +
+            'val c = findProperty("alsoProjectScoped")\n');
+        expect(await keys()).toEqual(["wanted"]);
+    });
+    /** A developer's own SDK path is not a value anybody owes the build. */
+    test("never names a machine-local key", async () => {
+        write("settings.gradle.kts", 'include(":app")\n');
+        write("build.gradle.kts", "// root\n");
+        write("app/build.gradle.kts", 'val p = java.util.Properties()\n' +
+            'p.load(rootProject.file("local.properties").reader())\n' +
+            'val sdk = p.getProperty("sdk.dir")\n' +
+            'val ndk = p.getProperty("ndk.dir")\n' +
+            'val cmake = p.getProperty("cmake.dir")\n' +
+            'val real = p.getProperty("api.key")\n');
+        expect(await keys()).toEqual(["api.key"]);
+    });
+});
+//# sourceMappingURL=a-properties-stand-in-declares-the-keys-the-build-reads.test.js.map

package/dist/src/commands/android-scanner.d.ts

@@ -25,6 +25,28 @@ export interface ScanResult {
     detectedGradleVersion?: string;
     /** Build types, product flavors, and all variant combinations detected in Gradle files. */
     buildVariants: BuildVariants;
+    /**
+     * The property names the build reads out of the properties file the Secrets
+     * Gradle plugin loads — sorted, deduplicated, empty when no module applies
+     * the plugin.
+     *
+     * **An empty properties file fixes "file missing", not "field missing".**
+     * The plugin turns each key of that file into a `BuildConfig` constant and a
+     * manifest placeholder, so a checkout without the file compiles neither.
+     * Supplying an empty stand-in gets the build past the plugin's own throw and
+     * then fails one step later, inside Gradle, at the first reference to a field
+     * that was never generated. These are those names: what a stand-in has to
+     * declare for the reference to resolve.
+     *
+     * Data, not prose — deliberately not more `warnings`. A warning is a sentence
+     * for a human to read; this is a list for a generator to consume, and sharing
+     * one channel between them means the generator has to parse English.
+     *
+     * Coarse on purpose. A name here that some other plugin turns out to
+     * generate costs one unused line in a properties file; a name missing from
+     * here costs the build.
+     */
+    missingPropertyKeys: string[];
 }
 export interface BuildVariants {
     /** Build types found, e.g. ["debug", "release", "staging"]. Always includes debug + release. */

package/dist/src/commands/android-scanner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"android-scanner.d.ts","sourceRoot":"","sources":["../../../src/commands/android-scanner.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"android-scanner.d.ts","sourceRoot":"","sources":["../../../src/commands/android-scanner.ts"],"names":[],"mappings":"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"}