@intentius/chant 0.124.78 → 0.124.80
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/action-pins.d.ts.map +1 -1
- package/dist/action-pins.js +1 -2
- package/dist/change-set.d.ts +10 -1
- package/dist/change-set.d.ts.map +1 -1
- package/dist/change-set.js +4 -1
- package/dist/ci-agent.d.ts +16 -2
- package/dist/ci-agent.d.ts.map +1 -1
- package/dist/ci-agent.js +6 -1
- package/dist/ci-commit.d.ts.map +1 -1
- package/dist/ci-commit.js +2 -3
- package/dist/ci-note-commands.d.ts +199 -0
- package/dist/ci-note-commands.d.ts.map +1 -0
- package/dist/ci-note-commands.js +372 -0
- package/dist/ci-product.d.ts +6 -2
- package/dist/ci-product.d.ts.map +1 -1
- package/dist/ci-product.js +5 -1
- package/dist/cli/handlers/build.d.ts.map +1 -1
- package/dist/cli/handlers/build.js +7 -1
- package/dist/cli/handlers/pr-notes.d.ts +13 -0
- package/dist/cli/handlers/pr-notes.d.ts.map +1 -0
- package/dist/cli/handlers/pr-notes.js +73 -0
- package/dist/cli/handlers/release.d.ts +8 -0
- package/dist/cli/handlers/release.d.ts.map +1 -1
- package/dist/cli/handlers/release.js +64 -2
- package/dist/cli/handlers/run-wave.js +1 -0
- package/dist/cli/main.d.ts.map +1 -1
- package/dist/cli/main.js +17 -1
- package/dist/cli/mcp/product-tools.d.ts +6 -0
- package/dist/cli/mcp/product-tools.d.ts.map +1 -1
- package/dist/cli/mcp/product-tools.js +6 -0
- package/dist/cli/mcp/read-only.d.ts +12 -0
- package/dist/cli/mcp/read-only.d.ts.map +1 -1
- package/dist/cli/mcp/read-only.js +16 -0
- package/dist/cli/mcp/server.d.ts +11 -0
- package/dist/cli/mcp/server.d.ts.map +1 -1
- package/dist/cli/mcp/server.js +26 -5
- package/dist/cli/mcp/types.d.ts +5 -1
- package/dist/cli/mcp/types.d.ts.map +1 -1
- package/dist/cli/parse-args.d.ts.map +1 -1
- package/dist/cli/parse-args.js +10 -0
- package/dist/cli/registry.d.ts +4 -0
- package/dist/cli/registry.d.ts.map +1 -1
- package/dist/components/capability.d.ts +53 -0
- package/dist/components/capability.d.ts.map +1 -1
- package/dist/components/group-digest.d.ts +17 -0
- package/dist/components/group-digest.d.ts.map +1 -0
- package/dist/components/group-digest.js +18 -0
- package/dist/components/groups.d.ts +2 -11
- package/dist/components/groups.d.ts.map +1 -1
- package/dist/components/groups.js +2 -12
- package/dist/components/index.d.ts +1 -1
- package/dist/components/index.d.ts.map +1 -1
- package/dist/components/pr-pipeline.d.ts +22 -0
- package/dist/components/pr-pipeline.d.ts.map +1 -1
- package/dist/components/pr-pipeline.js +26 -0
- package/dist/components/product-pipeline.d.ts +12 -0
- package/dist/components/product-pipeline.d.ts.map +1 -1
- package/dist/components/product-pipeline.js +5 -1
- package/dist/config.d.ts +14 -0
- package/dist/config.d.ts.map +1 -1
- package/dist/config.js +5 -0
- package/dist/lexicon.d.ts.map +1 -1
- package/dist/lexicon.js +1 -2
- package/dist/lifecycle/release-cut.d.ts +7 -1
- package/dist/lifecycle/release-cut.d.ts.map +1 -1
- package/dist/lifecycle/release-cut.js +1 -0
- package/dist/lifecycle/release-images.d.ts +12 -3
- package/dist/lifecycle/release-images.d.ts.map +1 -1
- package/dist/lifecycle/release-images.js +6 -7
- package/dist/lifecycle/release-publish.d.ts +8 -1
- package/dist/lifecycle/release-publish.d.ts.map +1 -1
- package/dist/lifecycle/release-publish.js +30 -3
- package/dist/lifecycle/release-version.d.ts +86 -0
- package/dist/lifecycle/release-version.d.ts.map +1 -0
- package/dist/lifecycle/release-version.js +208 -0
- package/dist/mcp/types.d.ts +26 -0
- package/dist/mcp/types.d.ts.map +1 -1
- package/dist/notify-product.d.ts.map +1 -1
- package/dist/notify-product.js +1 -2
- package/dist/op/activities/review-product.d.ts.map +1 -1
- package/dist/op/activities/review-product.js +1 -2
- package/dist/op/gate.d.ts +17 -0
- package/dist/op/gate.d.ts.map +1 -1
- package/dist/op/gate.js +36 -0
- package/dist/op/index.d.ts +8 -6
- package/dist/op/index.d.ts.map +1 -1
- package/dist/op/index.js +5 -4
- package/dist/op/op-waves-after-plan.d.ts +109 -1
- package/dist/op/op-waves-after-plan.d.ts.map +1 -1
- package/dist/op/op-waves-after-plan.js +180 -3
- package/dist/op/op-waves-capability-spec.js +1 -2
- package/dist/op/op-waves-capability.d.ts +93 -3
- package/dist/op/op-waves-capability.d.ts.map +1 -1
- package/dist/op/op-waves-capability.js +218 -10
- package/dist/op/op-waves-run-hooks.d.ts +104 -0
- package/dist/op/op-waves-run-hooks.d.ts.map +1 -0
- package/dist/op/op-waves-run-hooks.js +145 -0
- package/dist/op/op-waves-run.d.ts +21 -0
- package/dist/op/op-waves-run.d.ts.map +1 -1
- package/dist/op/op-waves-run.js +307 -21
- package/dist/op/op-waves.d.ts +11 -1
- package/dist/op/op-waves.d.ts.map +1 -1
- package/dist/op/op-waves.js +7 -1
- package/dist/op/runtime.d.ts +2 -0
- package/dist/op/runtime.d.ts.map +1 -1
- package/dist/pr-forge-reads.d.ts +151 -1
- package/dist/pr-forge-reads.d.ts.map +1 -1
- package/dist/pr-forge-reads.js +265 -1
- package/dist/pr-plan-note.d.ts.map +1 -1
- package/dist/pr-plan-note.js +1 -2
- package/dist/release-floors.d.ts +19 -1
- package/dist/release-floors.d.ts.map +1 -1
- package/dist/release-floors.js +23 -5
- package/dist/wave-runtime.mjs +312 -312
- package/dist/workspace/change-set.schema.json +7 -0
- package/dist/workspace/release-workflow.d.ts +7 -0
- package/dist/workspace/release-workflow.d.ts.map +1 -1
- package/dist/workspace/release-workflow.js +11 -1
- package/package.json +1 -1
- package/src/action-pins.test.ts +1 -2
- package/src/action-pins.ts +1 -3
- package/src/change-set.test.ts +20 -0
- package/src/change-set.ts +11 -1
- package/src/ci-agent.test.ts +9 -0
- package/src/ci-agent.ts +15 -2
- package/src/ci-commit.test.ts +2 -3
- package/src/ci-commit.ts +2 -3
- package/src/ci-note-commands.test.ts +377 -0
- package/src/ci-note-commands.ts +479 -0
- package/src/ci-product.ts +6 -2
- package/src/cli/handlers/build.ts +7 -1
- package/src/cli/handlers/pr-notes.ts +70 -0
- package/src/cli/handlers/release.ts +55 -2
- package/src/cli/handlers/run-wave.ts +1 -0
- package/src/cli/main.ts +17 -1
- package/src/cli/mcp/product-tools.test.ts +49 -0
- package/src/cli/mcp/product-tools.ts +7 -0
- package/src/cli/mcp/read-only.ts +19 -0
- package/src/cli/mcp/server.test.ts +30 -0
- package/src/cli/mcp/server.ts +28 -5
- package/src/cli/mcp/types.ts +6 -1
- package/src/cli/parse-args.ts +8 -0
- package/src/cli/registry.ts +4 -0
- package/src/components/capability.ts +52 -0
- package/src/components/group-digest.ts +20 -0
- package/src/components/groups.ts +3 -13
- package/src/components/index.ts +2 -0
- package/src/components/pr-pipeline.ts +35 -0
- package/src/components/product-pipeline.test.ts +14 -0
- package/src/components/product-pipeline.ts +13 -1
- package/src/config.ts +15 -0
- package/src/lexicon.ts +1 -2
- package/src/lifecycle/release-cut.ts +11 -0
- package/src/lifecycle/release-images-dockerfile.test.ts +10 -2
- package/src/lifecycle/release-images.ts +12 -8
- package/src/lifecycle/release-publish.ts +34 -3
- package/src/lifecycle/release-version.test.ts +155 -0
- package/src/lifecycle/release-version.ts +226 -0
- package/src/mcp/types.ts +27 -0
- package/src/notify-message-words.test.ts +1 -2
- package/src/notify-product.ts +1 -2
- package/src/op/activities/review-product.ts +1 -2
- package/src/op/gate.ts +46 -0
- package/src/op/index.ts +10 -4
- package/src/op/op-waves-after-plan-wave.test.ts +225 -0
- package/src/op/op-waves-after-plan.ts +228 -5
- package/src/op/op-waves-capability-spec.ts +1 -1
- package/src/op/op-waves-capability.test.ts +9 -1
- package/src/op/op-waves-capability.ts +246 -13
- package/src/op/op-waves-gate-port.test.ts +232 -0
- package/src/op/op-waves-run-hooks.test.ts +183 -0
- package/src/op/op-waves-run-hooks.ts +194 -0
- package/src/op/op-waves-run.ts +313 -25
- package/src/op/op-waves-step-wave.test.ts +276 -0
- package/src/op/op-waves.ts +15 -2
- package/src/op/runtime.ts +2 -0
- package/src/pr-forge-reads-compare.test.ts +145 -0
- package/src/pr-forge-reads.test.ts +203 -0
- package/src/pr-forge-reads.ts +398 -1
- package/src/pr-plan-note.ts +1 -2
- package/src/release-floors.ts +32 -5
- package/src/workspace/change-set.schema.json +7 -0
- package/src/workspace/release-workflow.test.ts +18 -0
- package/src/workspace/release-workflow.ts +21 -1
|
@@ -0,0 +1,276 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* A wave planned as one through a step (#4842): a `discover` wave whose
|
|
3
|
+
* runs the step's capability finds at plan time (a Terragrunt layer), and a
|
|
4
|
+
* `together` wave planned and applied in one call of the capability (a
|
|
5
|
+
* Terragrunt `run --all`, a composed run of roots).
|
|
6
|
+
*/
|
|
7
|
+
|
|
8
|
+
import { describe, expect, test } from "vitest";
|
|
9
|
+
import { mkdtempSync, readFileSync, rmSync } from "node:fs";
|
|
10
|
+
import { join } from "node:path";
|
|
11
|
+
import { tmpdir } from "node:os";
|
|
12
|
+
import { assertOpWavesSpec, type OpWavesSpec } from "./op-waves";
|
|
13
|
+
import { runOpWave, opWavePlanPath, type OpWaveShowAtBase } from "./op-waves-run";
|
|
14
|
+
import { memoryGateLedgerPort } from "./gate";
|
|
15
|
+
import { CapabilityRegistry, type Capability, type CapabilityGroupOutcome, type DeployContext, type GroupContext, type GroupMember, type GroupRun, type RunDiscoveryContext } from "../components/capability";
|
|
16
|
+
import type { ChangeSetPart } from "../change-set";
|
|
17
|
+
import { groupDigest } from "../components/groups";
|
|
18
|
+
import { waveSetDigest } from "../wave-engine";
|
|
19
|
+
import type { OpWaveRunHooks } from "./op-waves-run-hooks";
|
|
20
|
+
|
|
21
|
+
const digest = (n: string) => `sha256:${n.repeat(64)}`;
|
|
22
|
+
|
|
23
|
+
const part = (member: string, action = "create"): ChangeSetPart => ({
|
|
24
|
+
member: { member, lexicon: "terraform", planner: "chant", status: "planned", planDigest: digest("9"), holes: [] },
|
|
25
|
+
entries: [{ member, address: `aws_s3_bucket.${member.replace(/\//g, "_")}`, type: "aws_s3_bucket", action } as ChangeSetPart["entries"][number]],
|
|
26
|
+
});
|
|
27
|
+
|
|
28
|
+
interface Seen {
|
|
29
|
+
discovered: Array<{ ctx: RunDiscoveryContext; input: Record<string, unknown> }>;
|
|
30
|
+
planned: string[];
|
|
31
|
+
groups: Array<{ ctx: GroupContext; members: Array<{ component: string; input: unknown; dependsOn?: string[]; env?: Record<string, string> }> }>;
|
|
32
|
+
runs: Array<{ run: GroupRun; members: Array<{ component: string; plans?: Record<string, unknown>; env?: Record<string, string> }> }>;
|
|
33
|
+
applied: string[];
|
|
34
|
+
order: string[];
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
/** A Terragrunt-shaped capability: `layers[k-1]` is what wave k finds; each unit's digest is `digests[unit]`. */
|
|
38
|
+
function capability(
|
|
39
|
+
layers: string[][],
|
|
40
|
+
digests: Record<string, string>,
|
|
41
|
+
opts: { group?: boolean; discover?: boolean; outcome?: (members: string[]) => CapabilityGroupOutcome; throwOnRun?: Error } = {},
|
|
42
|
+
): { registry: CapabilityRegistry; seen: Seen } {
|
|
43
|
+
const seen: Seen = { discovered: [], planned: [], groups: [], runs: [], applied: [], order: [] };
|
|
44
|
+
const cap: Capability<Record<string, unknown>, unknown> = {
|
|
45
|
+
kind: "fake-terragrunt",
|
|
46
|
+
async plan(_ctx: DeployContext, input) {
|
|
47
|
+
const unit = String(input.unit);
|
|
48
|
+
seen.planned.push(unit);
|
|
49
|
+
return { member: unit, planDigest: digests[unit]!, artifact: { unit }, changeSet: part(unit) };
|
|
50
|
+
},
|
|
51
|
+
async run(_ctx: DeployContext, input) {
|
|
52
|
+
seen.applied.push(String(input.unit));
|
|
53
|
+
return { unit: input.unit };
|
|
54
|
+
},
|
|
55
|
+
...(opts.discover === false
|
|
56
|
+
? {}
|
|
57
|
+
: {
|
|
58
|
+
async discoverRuns(ctx: RunDiscoveryContext, input: Record<string, unknown>) {
|
|
59
|
+
seen.discovered.push({ ctx, input });
|
|
60
|
+
return { targets: layers[ctx.wave.number - 1] ?? [], waves: layers.length };
|
|
61
|
+
},
|
|
62
|
+
}),
|
|
63
|
+
...(opts.group === false
|
|
64
|
+
? {}
|
|
65
|
+
: {
|
|
66
|
+
async planGroup(ctx: GroupContext, members: readonly GroupMember<Record<string, unknown>>[]) {
|
|
67
|
+
seen.order.push("planGroup");
|
|
68
|
+
for (const m of members) await m.ctx.afterInit?.();
|
|
69
|
+
seen.groups.push({ ctx, members: members.map((m) => ({ component: m.component, input: m.input, ...(m.dependsOn ? { dependsOn: m.dependsOn } : {}), ...(m.ctx.processEnv ? { env: m.ctx.processEnv } : {}) })) });
|
|
70
|
+
return {
|
|
71
|
+
members: Object.fromEntries(members.map((m) => [m.component, { member: m.component, planDigest: digests[m.component]!, artifact: { planJson: `json/${m.component}/tfplan.json` }, changeSet: part(m.component) }])),
|
|
72
|
+
digest: digest("c"),
|
|
73
|
+
artifact: { workDir: ".chant/tg/wave", units: members.map((m) => m.component) },
|
|
74
|
+
};
|
|
75
|
+
},
|
|
76
|
+
async runGroup(ctx: GroupContext, run: GroupRun, members: readonly GroupMember<Record<string, unknown>>[]) {
|
|
77
|
+
seen.order.push("runGroup");
|
|
78
|
+
seen.runs.push({ run, members: members.map((m) => ({ component: m.component, ...(m.ctx.plans ? { plans: m.ctx.plans } : {}), ...(m.ctx.processEnv ? { env: m.ctx.processEnv } : {}) })) });
|
|
79
|
+
if (opts.throwOnRun) throw opts.throwOnRun;
|
|
80
|
+
const names = members.map((m) => m.component);
|
|
81
|
+
seen.applied.push(...names);
|
|
82
|
+
return opts.outcome?.(names) ?? { members: Object.fromEntries(names.map((n) => [n, { status: "applied" as const, outputs: { id: `${n}-1` } }])) };
|
|
83
|
+
},
|
|
84
|
+
}),
|
|
85
|
+
};
|
|
86
|
+
return { registry: new CapabilityRegistry().register(cap), seen };
|
|
87
|
+
}
|
|
88
|
+
|
|
89
|
+
const digests = { "live/a": digest("1"), "live/b": digest("2"), "live/c": digest("3") };
|
|
90
|
+
|
|
91
|
+
const discovering: OpWavesSpec = {
|
|
92
|
+
name: "tf-apply",
|
|
93
|
+
op: "tf-apply",
|
|
94
|
+
gateName: "wave-{k}",
|
|
95
|
+
step: { kind: "fake-terragrunt", unit: "{target}", dir: ".", wave: "{wave}" },
|
|
96
|
+
waves: [
|
|
97
|
+
{ name: "layer", runs: [], discover: true, gate: "never" },
|
|
98
|
+
{ name: "rest", runs: [], discover: true, rest: true, gate: "never" },
|
|
99
|
+
],
|
|
100
|
+
};
|
|
101
|
+
|
|
102
|
+
function harness(s: OpWavesSpec) {
|
|
103
|
+
const cwd = mkdtempSync(join(tmpdir(), "op-waves-step-wave-"));
|
|
104
|
+
const show: OpWaveShowAtBase = () => ({ sha: "b".repeat(40), text: JSON.stringify(s) });
|
|
105
|
+
return { cwd, show, done: () => rmSync(cwd, { recursive: true, force: true }) };
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
const run = (h: ReturnType<typeof harness>, s: OpWavesSpec, registry: CapabilityRegistry, wave = 1, runHooks?: OpWaveRunHooks | OpWaveRunHooks[]) =>
|
|
109
|
+
runOpWave({ spec: s, specFile: "waves.json", wave, cwd: h.cwd, show: h.show, gates: memoryGateLedgerPort(), capabilities: registry, log: () => {}, ...(runHooks ? { runHooks } : {}) });
|
|
110
|
+
|
|
111
|
+
describe("a wave planned as one through a step (#4842)", () => {
|
|
112
|
+
test("the spec takes discover with a step and checks together", () => {
|
|
113
|
+
expect(() => assertOpWavesSpec(discovering)).not.toThrow();
|
|
114
|
+
const together: OpWavesSpec = { ...discovering, waves: [{ name: "w", runs: [{ target: "a" }], together: true }] };
|
|
115
|
+
expect(() => assertOpWavesSpec(together)).not.toThrow();
|
|
116
|
+
const { step: _s, ...commands } = together;
|
|
117
|
+
expect(() => assertOpWavesSpec({ ...commands, plan: ["p", "{plan}"] })).toThrow(/plans its runs together, which only a `step`'s capability does/);
|
|
118
|
+
expect(() => assertOpWavesSpec({ ...together, waves: [{ name: "w", runs: [{ target: "a" }], together: true, parallelism: 2 }] })).toThrow(/no parallelism over 1/);
|
|
119
|
+
expect(() => assertOpWavesSpec({ ...together, waves: [{ name: "w", runs: [{ target: "a" }], together: "yes" as never }] })).toThrow(/has together "yes"/);
|
|
120
|
+
});
|
|
121
|
+
|
|
122
|
+
test("a discovering wave plans the runs its capability finds, one at a time, and a rest wave walks to the waves found", async () => {
|
|
123
|
+
const h = harness(discovering);
|
|
124
|
+
const { registry, seen } = capability([["live/a", "live/b"], ["live/c"]], digests, { group: false });
|
|
125
|
+
const result = await run(h, discovering, registry, 2);
|
|
126
|
+
expect(result.exitCode).toBe(0);
|
|
127
|
+
// The input has {op} and {wave} filled and {target} as written; the wave number is the one planned.
|
|
128
|
+
expect(seen.discovered.map((d) => d.ctx)).toEqual([
|
|
129
|
+
{ env: "rest", cwd: h.cwd, wave: { name: "rest", number: 2 } },
|
|
130
|
+
]);
|
|
131
|
+
expect(seen.discovered[0]!.input).toEqual({ unit: "{target}", dir: ".", wave: "rest" });
|
|
132
|
+
expect(seen.planned).toEqual(["live/c"]);
|
|
133
|
+
expect(seen.applied).toEqual(["live/c"]);
|
|
134
|
+
expect(result.decision?.discovered).toEqual({ waves: 2 });
|
|
135
|
+
expect(result.decision?.members.map((m) => m.member)).toEqual(["live/c"]);
|
|
136
|
+
h.done();
|
|
137
|
+
});
|
|
138
|
+
|
|
139
|
+
test("a discovering rest wave goes on through every wave found", async () => {
|
|
140
|
+
const s: OpWavesSpec = { ...discovering, waves: [discovering.waves[1]!] };
|
|
141
|
+
const h = harness(s);
|
|
142
|
+
const { registry, seen } = capability([["live/a"], ["live/b"], ["live/c"]], digests, { group: false });
|
|
143
|
+
const result = await run(h, s, registry, 1);
|
|
144
|
+
expect(result.exitCode).toBe(0);
|
|
145
|
+
expect(seen.discovered.map((d) => d.ctx.wave.number)).toEqual([1, 2, 3]);
|
|
146
|
+
expect(seen.applied).toEqual(["live/a", "live/b", "live/c"]);
|
|
147
|
+
expect(result.rest?.map((r) => r.wave)).toEqual([1, 2, 3]);
|
|
148
|
+
h.done();
|
|
149
|
+
});
|
|
150
|
+
|
|
151
|
+
test("a wave number past the ones found finds no runs and applies nothing", async () => {
|
|
152
|
+
const h = harness(discovering);
|
|
153
|
+
const { registry, seen } = capability([["live/a"]], digests, { group: false });
|
|
154
|
+
const result = await run(h, { ...discovering, waves: [{ name: "layer", runs: [], discover: true, gate: "never" }, { name: "two", runs: [], discover: true, gate: "never" }] }, registry, 2);
|
|
155
|
+
expect(result.exitCode).toBe(0);
|
|
156
|
+
expect(result.applied).toEqual([]);
|
|
157
|
+
expect(seen.planned).toEqual([]);
|
|
158
|
+
h.done();
|
|
159
|
+
});
|
|
160
|
+
|
|
161
|
+
test("a capability that cannot find runs fails the wave before anything plans", async () => {
|
|
162
|
+
const h = harness(discovering);
|
|
163
|
+
const { registry, seen } = capability([["live/a"]], digests, { discover: false });
|
|
164
|
+
await expect(run(h, discovering, registry)).rejects.toThrow('wave 1 (layer) discovers its runs, and the capability "fake-terragrunt" cannot find them (it has no discoverRuns)');
|
|
165
|
+
expect(seen.planned).toEqual([]);
|
|
166
|
+
h.done();
|
|
167
|
+
});
|
|
168
|
+
|
|
169
|
+
test("a together wave plans in one call and applies in one, the group digest a member of its own", async () => {
|
|
170
|
+
const s: OpWavesSpec = { ...discovering, waves: [{ name: "layer", runs: [], discover: true, together: true, gate: "never" }] };
|
|
171
|
+
const h = harness(s);
|
|
172
|
+
const { registry, seen } = capability([["live/a", "live/b"]], digests);
|
|
173
|
+
const result = await run(h, s, registry);
|
|
174
|
+
expect(result.exitCode).toBe(0);
|
|
175
|
+
expect(seen.planned).toEqual([]);
|
|
176
|
+
expect(seen.groups).toHaveLength(1);
|
|
177
|
+
expect(seen.groups[0]!.ctx).toEqual({ env: "layer", cwd: h.cwd, components: ["live/a", "live/b"] });
|
|
178
|
+
expect(seen.groups[0]!.members.map((m) => m.input)).toEqual([
|
|
179
|
+
{ unit: "live/a", dir: ".", wave: "layer" },
|
|
180
|
+
{ unit: "live/b", dir: ".", wave: "layer" },
|
|
181
|
+
]);
|
|
182
|
+
// runGroup gets the group's artifact and each member's own plan back.
|
|
183
|
+
expect(seen.runs).toHaveLength(1);
|
|
184
|
+
expect(seen.runs[0]!.run.artifact).toEqual({ workDir: ".chant/tg/wave", units: ["live/a", "live/b"] });
|
|
185
|
+
expect(seen.runs[0]!.members.map((m) => m.plans)).toEqual([{ "live/a": { planJson: "json/live/a/tfplan.json" } }, { "live/b": { planJson: "json/live/b/tfplan.json" } }]);
|
|
186
|
+
expect(result.applied).toEqual(["live/a", "live/b"]);
|
|
187
|
+
const group = groupDigest("fake-terragrunt", [{ component: "live/a", member: "live/a", planDigest: digests["live/a"] }, { component: "live/b", member: "live/b", planDigest: digests["live/b"] }], digest("c"));
|
|
188
|
+
expect(seen.runs[0]!.run.digest).toBe(group);
|
|
189
|
+
expect(result.decision?.digest).toBe(waveSetDigest([{ member: "(wave plan)", planDigest: group }, { member: "live/a", planDigest: digests["live/a"] }, { member: "live/b", planDigest: digests["live/b"] }]));
|
|
190
|
+
// Each run has its plan file, as a per-run plan writes it.
|
|
191
|
+
const file = JSON.parse(readFileSync(join(h.cwd, opWavePlanPath(s, 1, "live/a")), "utf-8")) as { planDigest: string; artifact: unknown };
|
|
192
|
+
expect(file).toMatchObject({ planDigest: digests["live/a"], artifact: { planJson: "json/live/a/tfplan.json" } });
|
|
193
|
+
h.done();
|
|
194
|
+
});
|
|
195
|
+
|
|
196
|
+
test("a together wave of listed runs keeps their order within the wave, and each run's hooks reach its member", async () => {
|
|
197
|
+
const s: OpWavesSpec = { ...discovering, waves: [{ name: "w", runs: [{ target: "live/a" }, { target: "live/b", dependsOn: ["live/a"] }], together: true, gate: "never" }] };
|
|
198
|
+
const h = harness(s);
|
|
199
|
+
const { registry, seen } = capability([], digests);
|
|
200
|
+
const files: string[] = [];
|
|
201
|
+
const result = await run(h, s, registry, 1, {
|
|
202
|
+
name: "roles",
|
|
203
|
+
beforePlan: (r) => ({ env: { ROLE: r.target }, afterInit: async () => void seen.order.push(`check ${r.target}`) }),
|
|
204
|
+
beforeApply: (r) => void seen.order.push(`before ${r.target}`),
|
|
205
|
+
afterApply: (r) => {
|
|
206
|
+
seen.order.push(`after ${r.target} ${r.outcome}`);
|
|
207
|
+
files.push(r.target);
|
|
208
|
+
return { files: [`report/${r.target.replace("/", "_")}.json`] };
|
|
209
|
+
},
|
|
210
|
+
});
|
|
211
|
+
expect(result.exitCode).toBe(0);
|
|
212
|
+
expect(seen.groups[0]!.members).toEqual([
|
|
213
|
+
{ component: "live/a", input: { unit: "live/a", dir: ".", wave: "w" }, env: { ROLE: "live/a" } },
|
|
214
|
+
{ component: "live/b", input: { unit: "live/b", dir: ".", wave: "w" }, dependsOn: ["live/a"], env: { ROLE: "live/b" } },
|
|
215
|
+
]);
|
|
216
|
+
expect(seen.runs[0]!.members.map((m) => m.env)).toEqual([{ ROLE: "live/a" }, { ROLE: "live/b" }]);
|
|
217
|
+
expect(seen.order).toEqual(["planGroup", "check live/a", "check live/b", "before live/a", "before live/b", "runGroup", "after live/a applied", "after live/b applied"]);
|
|
218
|
+
expect(files).toEqual(["live/a", "live/b"]);
|
|
219
|
+
h.done();
|
|
220
|
+
});
|
|
221
|
+
|
|
222
|
+
test("a before-apply hook that stops one run of a together wave applies none of them", async () => {
|
|
223
|
+
const s: OpWavesSpec = { ...discovering, waves: [{ name: "w", runs: [{ target: "live/a" }, { target: "live/b" }], together: true, gate: "never" }] };
|
|
224
|
+
const h = harness(s);
|
|
225
|
+
const { registry, seen } = capability([], digests);
|
|
226
|
+
const result = await run(h, s, registry, 1, { name: "freeze", beforeApply: (r) => { if (r.target === "live/b") throw new Error("change freeze"); } });
|
|
227
|
+
expect(result.exitCode).toBe(1);
|
|
228
|
+
expect(seen.runs).toEqual([]);
|
|
229
|
+
expect(result.failed).toEqual(["live/a", "live/b"]);
|
|
230
|
+
h.done();
|
|
231
|
+
});
|
|
232
|
+
|
|
233
|
+
test("each run of a together wave ends as its part of the apply did", async () => {
|
|
234
|
+
const s: OpWavesSpec = { ...discovering, waves: [{ name: "w", runs: [{ target: "live/a" }, { target: "live/b" }, { target: "live/c" }], together: true, gate: "never" }] };
|
|
235
|
+
const h = harness(s);
|
|
236
|
+
const { registry } = capability([], digests, {
|
|
237
|
+
outcome: () => ({ members: { "live/a": { status: "no-changes", outputs: {} }, "live/b": { status: "failed", error: "Error: AccessDenied" } } }),
|
|
238
|
+
});
|
|
239
|
+
const result = await run(h, s, registry);
|
|
240
|
+
expect(result.exitCode).toBe(1);
|
|
241
|
+
expect(result.applied).toEqual(["live/a"]);
|
|
242
|
+
expect(result.failed).toEqual(["live/b", "live/c"]);
|
|
243
|
+
expect(Object.fromEntries(Object.entries(result.targets ?? {}).map(([t, o]) => [t, o.error]))).toEqual({
|
|
244
|
+
"live/a": undefined,
|
|
245
|
+
"live/b": "its part of the wave's apply failed: Error: AccessDenied",
|
|
246
|
+
"live/c": "fake-terragrunt said nothing of it",
|
|
247
|
+
});
|
|
248
|
+
h.done();
|
|
249
|
+
});
|
|
250
|
+
|
|
251
|
+
test("a together wave whose plan moved applies nothing and exits 4", async () => {
|
|
252
|
+
const s: OpWavesSpec = { ...discovering, waves: [{ name: "w", runs: [{ target: "live/a" }, { target: "live/b" }], together: true, gate: "never" }] };
|
|
253
|
+
const h = harness(s);
|
|
254
|
+
const moved = Object.assign(new Error("the composed plan moved since it was approved"), { planMoved: true });
|
|
255
|
+
const { registry } = capability([], digests, { throwOnRun: moved });
|
|
256
|
+
const result = await run(h, s, registry);
|
|
257
|
+
expect(result.exitCode).toBe(4);
|
|
258
|
+
expect(result.moved).toEqual(["live/a", "live/b"]);
|
|
259
|
+
expect(result.applied).toEqual([]);
|
|
260
|
+
h.done();
|
|
261
|
+
});
|
|
262
|
+
|
|
263
|
+
test("a together wave through a capability with no group methods fails before anything plans", async () => {
|
|
264
|
+
const s: OpWavesSpec = { ...discovering, waves: [{ name: "w", runs: [{ target: "live/a" }], together: true, gate: "never" }] };
|
|
265
|
+
const h = harness(s);
|
|
266
|
+
const { registry, seen } = capability([], digests, { group: false });
|
|
267
|
+
await expect(run(h, s, registry)).rejects.toThrow('wave "w" plans its runs together, and the capability "fake-terragrunt" cannot (it needs planGroup and runGroup)');
|
|
268
|
+
expect(seen.planned).toEqual([]);
|
|
269
|
+
h.done();
|
|
270
|
+
});
|
|
271
|
+
|
|
272
|
+
test("the floor is the next release", async () => {
|
|
273
|
+
const entry = await import("./index");
|
|
274
|
+
expect(entry.OP_WAVE_STEP_WAVE_FLOOR).toBe("0.124.79");
|
|
275
|
+
});
|
|
276
|
+
});
|
package/src/op/op-waves.ts
CHANGED
|
@@ -360,9 +360,19 @@ export interface OpWave {
|
|
|
360
360
|
* The runs come from the product at plan time (#3821): `planWave` gets a
|
|
361
361
|
* runs file with no runs and `discover: true`, and plans the runs it finds
|
|
362
362
|
* for wave k (a Terragrunt repo's dependency layer from `terragrunt find`).
|
|
363
|
-
* Needs `planWave
|
|
363
|
+
* Needs `planWave`, or a `step` whose capability has `discoverRuns`
|
|
364
|
+
* (#4842).
|
|
364
365
|
*/
|
|
365
366
|
discover?: boolean;
|
|
367
|
+
/**
|
|
368
|
+
* With a `step` (#4842): plan the wave's runs in one call of the step's
|
|
369
|
+
* capability (`planGroup`) and apply them in one (`runGroup`), in place
|
|
370
|
+
* of one plan and one apply per run. For a tool that plans a wave as one,
|
|
371
|
+
* such as Terragrunt's `run --all` over a layer's units or a composed run
|
|
372
|
+
* of roots that read each other. The capability's digest of the whole is
|
|
373
|
+
* a digest member of its own, `(wave plan)`. Not with `parallelism` over 1.
|
|
374
|
+
*/
|
|
375
|
+
together?: boolean;
|
|
366
376
|
/**
|
|
367
377
|
* The last wave only, with `discover` (#3821): once it applies, the job
|
|
368
378
|
* goes on to wave k+1, k+2, ... while `planWave` reports more waves
|
|
@@ -1067,8 +1077,11 @@ export function assertOpWavesSpec(spec: OpWavesSpec): void {
|
|
|
1067
1077
|
if (wave.jobs !== undefined) assertOpWaveJobGroups(where, wave);
|
|
1068
1078
|
if (wave.discover !== undefined && typeof wave.discover !== "boolean") throw new Error(`${where}: wave "${wave.name}" has discover ${JSON.stringify(wave.discover)}; use true or false.`);
|
|
1069
1079
|
if (wave.rest !== undefined && typeof wave.rest !== "boolean") throw new Error(`${where}: wave "${wave.name}" has rest ${JSON.stringify(wave.rest)}; use true or false.`);
|
|
1080
|
+
if (wave.together !== undefined && typeof wave.together !== "boolean") throw new Error(`${where}: wave "${wave.name}" has together ${JSON.stringify(wave.together)}; use true or false.`);
|
|
1081
|
+
if (wave.together && spec.step === undefined) throw new Error(`${where}: wave "${wave.name}" plans its runs together, which only a \`step\`'s capability does. Give step.`);
|
|
1082
|
+
if (wave.together && (wave.parallelism ?? 1) > 1) throw new Error(`${where}: wave "${wave.name}" plans and applies its runs together in one call, so it has no parallelism over 1.`);
|
|
1070
1083
|
if (wave.discover) {
|
|
1071
|
-
if (spec.planWave === undefined) throw new Error(`${where}: wave "${wave.name}" discovers its runs, which only \`planWave\` can report. Give planWave.`);
|
|
1084
|
+
if (spec.planWave === undefined && spec.step === undefined) throw new Error(`${where}: wave "${wave.name}" discovers its runs, which only \`planWave\` can report. Give planWave.`);
|
|
1072
1085
|
if ((wave.runs ?? []).length > 0) throw new Error(`${where}: wave "${wave.name}" discovers its runs, so it lists none.`);
|
|
1073
1086
|
}
|
|
1074
1087
|
if (wave.rest) {
|
package/src/op/runtime.ts
CHANGED
|
@@ -298,6 +298,8 @@ export interface OpRunWaveTarget {
|
|
|
298
298
|
error?: string;
|
|
299
299
|
/** The resources the engine reported failed (#4629), by name or id. */
|
|
300
300
|
failedResources?: string[];
|
|
301
|
+
/** Files a run hook wrote after the apply (#4842), relative to the job's directory. */
|
|
302
|
+
files?: string[];
|
|
301
303
|
}
|
|
302
304
|
|
|
303
305
|
/** The first chant that writes {@link OpRunRecord.wave}, a run record per op wave job (#4551). */
|
|
@@ -0,0 +1,145 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* The forge reads of a comparison, a job and a job's artifact file (#4862),
|
|
3
|
+
* against a loopback fake of each forge: the calls each makes on GitHub,
|
|
4
|
+
* Forgejo and GitLab, and what each reads back.
|
|
5
|
+
*/
|
|
6
|
+
|
|
7
|
+
import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
|
|
8
|
+
import { createServer, type Server } from "node:http";
|
|
9
|
+
import type { AddressInfo } from "node:net";
|
|
10
|
+
import { forgejoReads, githubReads, gitlabReads } from "./pr-forge-reads";
|
|
11
|
+
|
|
12
|
+
const SHA = "a".repeat(40);
|
|
13
|
+
|
|
14
|
+
/** A route answers JSON, a status, or `{ raw }`, a body sent as it is. */
|
|
15
|
+
type Answer = unknown;
|
|
16
|
+
let routes: Record<string, Answer> = {};
|
|
17
|
+
let calls: { method: string; url: string; headers: Record<string, string | string[] | undefined> }[] = [];
|
|
18
|
+
let server: Server;
|
|
19
|
+
let origin = "";
|
|
20
|
+
|
|
21
|
+
beforeAll(async () => {
|
|
22
|
+
server = createServer((req, res) => {
|
|
23
|
+
calls.push({ method: req.method ?? "", url: req.url ?? "", headers: req.headers });
|
|
24
|
+
const path = new URL(req.url ?? "/", "http://x").pathname;
|
|
25
|
+
const found = routes[`${req.method} ${path}`];
|
|
26
|
+
if (found === undefined) {
|
|
27
|
+
res.writeHead(404, { "content-type": "application/json" });
|
|
28
|
+
res.end('{"message":"404 Not Found"}');
|
|
29
|
+
return;
|
|
30
|
+
}
|
|
31
|
+
if (typeof found === "number") {
|
|
32
|
+
res.writeHead(found);
|
|
33
|
+
res.end();
|
|
34
|
+
return;
|
|
35
|
+
}
|
|
36
|
+
if (typeof found === "object" && found !== null && "raw" in found) {
|
|
37
|
+
res.writeHead(200, { "content-type": "application/octet-stream" });
|
|
38
|
+
res.end(String((found as { raw: string }).raw));
|
|
39
|
+
return;
|
|
40
|
+
}
|
|
41
|
+
res.writeHead(200, { "content-type": "application/json" });
|
|
42
|
+
res.end(JSON.stringify(found));
|
|
43
|
+
});
|
|
44
|
+
await new Promise<void>((r) => server.listen(0, "127.0.0.1", () => r()));
|
|
45
|
+
origin = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
|
|
46
|
+
});
|
|
47
|
+
|
|
48
|
+
afterAll(() => new Promise<void>((r) => server.close(() => r())));
|
|
49
|
+
|
|
50
|
+
beforeEach(() => {
|
|
51
|
+
routes = {};
|
|
52
|
+
calls = [];
|
|
53
|
+
});
|
|
54
|
+
|
|
55
|
+
const urls = () => calls.map((c) => `${c.method} ${c.url}`);
|
|
56
|
+
const gh = () => githubReads({ apiBase: origin, repo: "acme/infra", token: "t0k" });
|
|
57
|
+
const fj = () => forgejoReads({ apiBase: `${origin}/api/v1`, repo: "acme/infra", token: "t0k" });
|
|
58
|
+
const gl = () => gitlabReads({ apiBase: `${origin}/api/v4`, project: "acme/infra", token: "glpat" });
|
|
59
|
+
const P = "/api/v4/projects/acme%2Finfra";
|
|
60
|
+
|
|
61
|
+
describe("compare", () => {
|
|
62
|
+
test("github: the files a head changes since its merge base, a rename with its old path", async () => {
|
|
63
|
+
routes[`GET /repos/acme/infra/compare/main...${SHA}`] = {
|
|
64
|
+
behind_by: 1,
|
|
65
|
+
files: [{ filename: "a.tf", status: "modified" }, { filename: ".github/workflows/ci.yml", previous_filename: "ci.yml", status: "renamed" }],
|
|
66
|
+
};
|
|
67
|
+
expect(await gh().compare("main", SHA)).toEqual({ files: [{ path: "a.tf" }, { path: ".github/workflows/ci.yml", previousPath: "ci.yml" }], truncated: false });
|
|
68
|
+
expect(urls()).toEqual([`GET /repos/acme/infra/compare/main...${SHA}`]);
|
|
69
|
+
expect(calls[0]!.headers.authorization).toBe("Bearer t0k");
|
|
70
|
+
});
|
|
71
|
+
|
|
72
|
+
test("github: a list of 300 files is the most GitHub lists, so it says it may be cut short", async () => {
|
|
73
|
+
routes[`GET /repos/acme/infra/compare/release%2F1...${SHA}`] = { files: Array.from({ length: 300 }, (_, i) => ({ filename: `f${i}` })) };
|
|
74
|
+
const got = await gh().compare("release/1", SHA);
|
|
75
|
+
expect(got.files).toHaveLength(300);
|
|
76
|
+
expect(got.truncated).toBe(true);
|
|
77
|
+
});
|
|
78
|
+
|
|
79
|
+
test("forgejo: the files its commits change, once each, cut short when it lists fewer commits than it counts", async () => {
|
|
80
|
+
routes[`GET /api/v1/repos/acme/infra/compare/main...${SHA}`] = {
|
|
81
|
+
total_commits: 2,
|
|
82
|
+
commits: [{ sha: SHA, files: [{ filename: "a.tf", status: "modified" }, { filename: ".forgejo/workflows/ci.yml", status: "added" }] }, { sha: "b".repeat(40), files: [{ filename: "a.tf", status: "modified" }] }],
|
|
83
|
+
};
|
|
84
|
+
expect(await fj().compare("main", SHA)).toEqual({ files: [{ path: "a.tf" }, { path: ".forgejo/workflows/ci.yml" }], truncated: false });
|
|
85
|
+
expect(calls[0]!.headers.authorization).toBe("token t0k");
|
|
86
|
+
routes[`GET /api/v1/repos/acme/infra/compare/main...${SHA}`] = { total_commits: 3, commits: [{ sha: SHA, files: [{ filename: "a.tf" }] }] };
|
|
87
|
+
expect((await fj().compare("main", SHA)).truncated).toBe(true);
|
|
88
|
+
routes[`GET /api/v1/repos/acme/infra/compare/main...${SHA}`] = { total_commits: 1, commits: [{ sha: SHA }] };
|
|
89
|
+
expect((await fj().compare("main", SHA)).truncated).toBe(true);
|
|
90
|
+
});
|
|
91
|
+
|
|
92
|
+
test("gitlab: the diffs' paths from the merge base, cut short when the compare timed out", async () => {
|
|
93
|
+
routes[`GET ${P}/repository/compare`] = { diffs: [{ old_path: "a.tf", new_path: "a.tf" }, { old_path: "ci.yml", new_path: ".gitlab-ci.yml", renamed_file: true }], compare_timeout: false };
|
|
94
|
+
expect(await gl().compare("main", SHA)).toEqual({ files: [{ path: "a.tf" }, { path: ".gitlab-ci.yml", previousPath: "ci.yml" }], truncated: false });
|
|
95
|
+
expect(urls()).toEqual([`GET ${P}/repository/compare?from=main&to=${SHA}&straight=false`]);
|
|
96
|
+
expect(calls[0]!.headers["private-token"]).toBe("glpat");
|
|
97
|
+
routes[`GET ${P}/repository/compare`] = { diffs: [], compare_timeout: true };
|
|
98
|
+
expect((await gl().compare("main", SHA)).truncated).toBe(true);
|
|
99
|
+
});
|
|
100
|
+
});
|
|
101
|
+
|
|
102
|
+
describe("a job by id, and the jobs' URLs", () => {
|
|
103
|
+
test("github: a job with its run, branch and URL; undefined when missing", async () => {
|
|
104
|
+
routes["GET /repos/acme/infra/actions/jobs/5"] = { id: 5, run_id: 10, name: "review", status: "completed", conclusion: "success", head_branch: "main", html_url: "https://github.com/acme/infra/actions/runs/10/job/5" };
|
|
105
|
+
expect(await gh().job(5)).toEqual({ id: 5, name: "review", status: "completed", conclusion: "success", done: true, run: 10, ref: "main", url: "https://github.com/acme/infra/actions/runs/10/job/5" });
|
|
106
|
+
expect(await gh().job(6)).toBeUndefined();
|
|
107
|
+
expect(urls()).toEqual(["GET /repos/acme/infra/actions/jobs/5", "GET /repos/acme/infra/actions/jobs/6"]);
|
|
108
|
+
});
|
|
109
|
+
|
|
110
|
+
test("forgejo: a job by id", async () => {
|
|
111
|
+
routes["GET /api/v1/repos/acme/infra/actions/jobs/5"] = { id: 5, run_id: 10, name: "review", status: "running", head_branch: "main", html_url: "https://code.acme.io/acme/infra/actions/runs/3/jobs/0" };
|
|
112
|
+
expect(await fj().job(5)).toEqual({ id: 5, name: "review", status: "running", done: false, run: 10, ref: "main", url: "https://code.acme.io/acme/infra/actions/runs/3/jobs/0" });
|
|
113
|
+
});
|
|
114
|
+
|
|
115
|
+
test("gitlab: a job with its pipeline, ref, tag and URL; a pipeline's jobs with their URLs", async () => {
|
|
116
|
+
routes[`GET ${P}/jobs/5`] = { id: 5, name: "review", status: "success", ref: "main", tag: false, web_url: "https://gitlab.com/acme/infra/-/jobs/5", pipeline: { id: 10, sha: SHA } };
|
|
117
|
+
routes[`GET ${P}/jobs/6`] = { id: 6, name: "plan", status: "failed", ref: "v1", tag: true, pipeline: { id: 11 } };
|
|
118
|
+
expect(await gl().job(5)).toEqual({ id: 5, name: "review", status: "success", done: true, run: 10, ref: "main", tag: false, url: "https://gitlab.com/acme/infra/-/jobs/5" });
|
|
119
|
+
expect(await gl().job(6)).toEqual({ id: 6, name: "plan", status: "failed", done: true, run: 11, ref: "v1", tag: true });
|
|
120
|
+
expect(await gl().job(7)).toBeUndefined();
|
|
121
|
+
routes[`GET ${P}/pipelines/10/jobs`] = [{ id: 4, name: "plan", status: "success", ref: "refs/merge-requests/3/head", tag: false, web_url: "https://gitlab.com/acme/infra/-/jobs/4", pipeline: { id: 10 } }];
|
|
122
|
+
expect(await gl().runJobs(10)).toEqual([{ id: 4, name: "plan", status: "success", done: true, run: 10, ref: "refs/merge-requests/3/head", tag: false, url: "https://gitlab.com/acme/infra/-/jobs/4" }]);
|
|
123
|
+
});
|
|
124
|
+
});
|
|
125
|
+
|
|
126
|
+
describe("a job's artifact file", () => {
|
|
127
|
+
test("gitlab: one file of a job's artifacts as text, each path segment encoded; undefined when there is none", async () => {
|
|
128
|
+
routes[`GET ${P}/jobs/5/artifacts/terragucci-report/plan%20note.md`] = { raw: "## plan\n\nno changes\n" };
|
|
129
|
+
const reads = gl();
|
|
130
|
+
expect(await reads.artifactFile!(5, "terragucci-report/plan note.md")).toBe("## plan\n\nno changes\n");
|
|
131
|
+
expect(await reads.artifactFile!(5, "terragucci-report/status")).toBeUndefined();
|
|
132
|
+
expect(urls()).toEqual([`GET ${P}/jobs/5/artifacts/terragucci-report/plan%20note.md`, `GET ${P}/jobs/5/artifacts/terragucci-report/status`]);
|
|
133
|
+
expect(calls[0]!.headers["private-token"]).toBe("glpat");
|
|
134
|
+
});
|
|
135
|
+
|
|
136
|
+
test("gitlab: another error throws", async () => {
|
|
137
|
+
routes[`GET ${P}/jobs/5/artifacts/r/x`] = 500;
|
|
138
|
+
await expect(gl().artifactFile!(5, "r/x")).rejects.toThrow(/500/);
|
|
139
|
+
});
|
|
140
|
+
|
|
141
|
+
test("github and forgejo hand an artifact out as one archive, so they read no file of one", () => {
|
|
142
|
+
expect(gh().artifactFile).toBeUndefined();
|
|
143
|
+
expect(fj().artifactFile).toBeUndefined();
|
|
144
|
+
});
|
|
145
|
+
});
|