Fix dev deployments

Name of deployment is now <branch name>@<target branch number>, to know
precisely what the transient build is, but also where it would land.

Issue: ZENKO-5132

Author: francoisferrand

.github/scripts/resolve-base-branch.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+# Print the closest origin/development/* branch that HEAD descends from via
+# --first-parent (e.g. "development/2.14"), or nothing if none is found.
+set -eu
+
+dev_refs=$(git for-each-ref --format='%(refname:short)' 'refs/remotes/origin/development/*')
+[[ -z "${dev_refs}" ]] && exit 0
+
+# Walk HEAD's first-parent backward, excluding anything reachable from a dev
+# branch. The --boundary commit (prefixed '-') is where HEAD first meets a dev
+# branch's reachable set — the fork point.
+fork=$(git rev-list --first-parent --boundary HEAD --not ${dev_refs} \
+  | sed -n 's/^-//p;/^-/q' | head -1)
+
+# Empty output means HEAD is itself reachable from a dev branch (no feature
+# commits ahead), so HEAD itself is the fork point.
+fork=${fork:-HEAD}
+
+# name-rev's BFS penalises second-parent hops, so for waterfalled commits the
+# native origin dev (reached via first-parent) beats downstream ones (reached
+# via the merge's second parent).
+name=$(git name-rev --refs='refs/remotes/origin/development/*' --name-only "${fork}")
+[[ "${name}" == "undefined" ]] && exit 0
+
+name=${name%%[~^]*}
+echo "${name##*origin/}"

.github/workflows/end2end.yaml

@@ -691,20 +691,23 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+          filter: blob:none
       - name: Determine target environment
         id: env
         env:
-          GH_TOKEN: ${{ github.token }}
           REF_NAME: ${{ github.ref_name }}
         run: |
-          base_ref=$(gh pr list --head "$REF_NAME" --state open \
-            --json baseRefName --jq '.[0].baseRefName // empty')
-          if [[ -n "$base_ref" && "$base_ref" == development/* ]]; then
-            echo "environment=zenko/$base_ref" >> "$GITHUB_OUTPUT"
+          base_ref=$(./.github/scripts/resolve-base-branch.sh)
+
+          if [[ -n "$base_ref" ]]; then
+            environment="zenko/$REF_NAME@${base_ref#development/}"
+            echo "environment=$environment" >> "$GITHUB_OUTPUT"
             echo "target_branch=$base_ref" >> "$GITHUB_OUTPUT"
-            echo "Target environment: zenko/$base_ref"
+            echo "Target environment: $environment"
           else
-            echo "No open PR targeting a development branch found, skipping deployments"
+            echo "No development branch ancestor found, skipping deployments"
           fi
       - name: Create transient deployments
         if: steps.env.outputs.environment != ''

tests/workflows/resolve-base-branch.spec.ts

@@ -0,0 +1,118 @@
+import { MockGithub } from "@kie/mock-github";
+import path from "path";
+import { exec as execCb } from "node:child_process";
+import { promisify } from "node:util";
+
+const exec = promisify(execCb);
+
+const SCRIPT = path.resolve(__dirname, "../..", ".github/scripts/resolve-base-branch.sh");
+
+let github: MockGithub;
+let repoPath: string;
+const devChain: string[] = [];
+
+async function git(args: string): Promise<string> {
+    const { stdout } = await exec(`git -C "${repoPath}" ${args}`);
+    return stdout.trim();
+}
+
+async function createDev(name: string) {
+    const base = devChain[devChain.length - 1];
+    await git(base ? `checkout -b ${name} ${base}` : `checkout -b ${name}`);
+    devChain.push(name);
+}
+
+async function commitOn(branch: string, message: string) {
+    await git(`checkout ${branch}`);
+    await git(`commit --allow-empty -m "${message}"`);
+
+    // Waterfall to every newer dev branch in the chain
+    const idx = devChain.indexOf(branch);
+    if (idx < 0) {
+        return;
+    }
+
+    let prev = branch;
+    for (let i = idx + 1; i < devChain.length; i++) {
+        const next = devChain[i];
+        await git(`checkout ${next}`);
+        await git(`merge --no-ff ${prev}`);
+        prev = next;
+    }
+}
+
+async function branchFrom(name: string, base: string, message: string) {
+    await git(`checkout -b ${name} ${base}`);
+    await git(`commit --allow-empty -m "${message}"`);
+}
+
+async function runScript(): Promise<string> {
+    const { stdout } = await exec(SCRIPT, { cwd: repoPath });
+    return stdout.trim();
+}
+
+beforeAll(async () => {
+    github = new MockGithub({
+        repo: { zenko: {} },
+    });
+
+    await github.setup();
+    repoPath = github.repo.getPath("zenko") as string;
+
+    await createDev("development/2.11");
+    await commitOn("development/2.11", "2.11: A1");
+    await createDev("development/2.12");
+    await createDev("development/2.13");
+
+    await commitOn("development/2.11", "2.11: A2");
+    await commitOn("development/2.12", "2.12: B1");
+    await branchFrom("feat-on-outdated-2.12", "development/2.12", "feat-outdated: K1");
+    await commitOn("development/2.13", "2.13: C1");
+
+    await commitOn("development/2.11", "2.11: A3");
+    await commitOn("development/2.12", "2.12: B2");
+    await commitOn("development/2.13", "2.13: C2");
+
+    await git("push origin development/2.11 development/2.12 development/2.13");
+
+    await branchFrom("feat-on-2.13", "development/2.13", "feat-on-2.13: F1");
+    await branchFrom("stacked-on-2.13", "feat-on-2.13", "stacked: H1");
+    await branchFrom("feat-on-2.12", "development/2.12", "feat-on-2.12: G1");
+    await branchFrom("feat-on-2.11", "development/2.11", "feat-on-2.11: I1");
+});
+
+afterAll(async () => {
+    await github.teardown();
+});
+
+describe("resolve-base-branch.sh", () => {
+    it("resolves feature branched off latest dev", async () => {
+        await git("checkout feat-on-2.13");
+        expect(await runScript()).toBe("development/2.13");
+    });
+
+    it("resolves feature branched off middle dev", async () => {
+        await git("checkout feat-on-2.12");
+        expect(await runScript()).toBe("development/2.12");
+    });
+
+    it("resolves feature branched off oldest dev", async () => {
+        await git("checkout feat-on-2.11");
+        expect(await runScript()).toBe("development/2.11");
+    });
+
+    it("resolves stacked branch (feature off feature off dev)", async () => {
+        await git("checkout stacked-on-2.13");
+        expect(await runScript()).toBe("development/2.13");
+    });
+
+    it("resolves a dev branch itself to itself", async () => {
+        await git("checkout development/2.12");
+        expect(await runScript()).toBe("development/2.12");
+    });
+
+    it("resolves feature branched off an outdated dev commit", async () => {
+        await git("checkout feat-on-outdated-2.12");
+        expect(await runScript()).toBe("development/2.12");
+    });
+});