@intentius/chant-lexicon-terraform 0.57.0

package/src/composites/terraform-apply-op.test.ts

@@ -0,0 +1,193 @@
+/**
+ * TerraformApplyOp composite tests (#2086) — the phase names, the gate, the
+ * plan-to-apply reference, and the compensation refusal.
+ */
+
+import { describe, test, expect } from "vitest";
+import {
+  findGate,
+  isStepOutputRef,
+  runOpLocally,
+  LocalGateUnsupportedError,
+  type ActivityStep,
+  type GateStep,
+  type OpConfig,
+  type StepDefinition,
+} from "@intentius/chant/op";
+import { TerraformApplyOp } from "./terraform-apply-op";
+
+/** The Op's declared config, which is what `chant build` serializes. */
+function props(config: Parameters<typeof TerraformApplyOp>[0]): OpConfig {
+  return (TerraformApplyOp(config).op as unknown as { props: OpConfig }).props;
+}
+
+const phaseNames = (op: OpConfig): string[] => op.phases.map((p) => p.name);
+const isActivity = (s: StepDefinition): s is ActivityStep => s.kind === "activity";
+const isGate = (s: StepDefinition): s is GateStep => s.kind === "gate";
+
+describe("TerraformApplyOp phases (#2086)", () => {
+  test("default gate mode is on-destroy: Init, Plan, Gate, Apply", () => {
+    expect(phaseNames(props({ name: "app-apply", root: "app" }))).toEqual([
+      "Init",
+      "Plan",
+      "Gate",
+      "Apply",
+    ]);
+  });
+
+  test('gate: "always" builds the same four phases', () => {
+    expect(phaseNames(props({ name: "app-apply", root: "app", gate: "always" }))).toEqual([
+      "Init",
+      "Plan",
+      "Gate",
+      "Apply",
+    ]);
+  });
+
+  test('gate: "never" emits no Gate phase, which is what makes the Op runnable locally', () => {
+    const op = props({ name: "app-apply", root: "app", gate: "never" });
+    expect(phaseNames(op)).toEqual(["Init", "Plan", "Apply"]);
+    expect(op.phases.flatMap((p) => p.steps).some(isGate)).toBe(false);
+  });
+
+  test("each phase runs the activity it is named for, with the root threaded through", () => {
+    const op = props({ name: "app-apply", root: "app", gate: "never" });
+    const fns = op.phases.flatMap((p) => p.steps.filter(isActivity)).map((s) => s.fn);
+    expect(fns).toEqual(["terraformInit", "terraformPlan", "terraformApply"]);
+    for (const step of op.phases.flatMap((p) => p.steps.filter(isActivity))) {
+      expect(step.args?.root).toBe("app");
+    }
+  });
+
+  test("Init and Apply carry longInfra; the gate's show step is fastIdempotent", () => {
+    const op = props({ name: "app-apply", root: "app" });
+    const byPhase = Object.fromEntries(op.phases.map((p) => [p.name, p.steps.filter(isActivity)]));
+    expect(byPhase.Init[0].profile).toBe("longInfra");
+    expect(byPhase.Plan[0].profile).toBe("longInfra");
+    expect(byPhase.Gate[0].profile).toBe("fastIdempotent");
+    expect(byPhase.Apply[0].profile).toBe("longInfra");
+  });
+});
+
+describe("TerraformApplyOp gate (#2086)", () => {
+  test("signal name defaults to approve-<name>", () => {
+    const op = props({ name: "prod-apply", root: "app" });
+    const gate = op.phases.find((p) => p.name === "Gate")!.steps.find(isGate)!;
+    expect(gate.signalName).toBe("approve-prod-apply");
+  });
+
+  test("an explicit signalName, timeout and description win", () => {
+    const op = props({
+      name: "prod-apply",
+      root: "app",
+      signalName: "approve-terraform",
+      gateTimeout: "72h",
+      gateDescription: "Change window only",
+    });
+    const gate = op.phases.find((p) => p.name === "Gate")!.steps.find(isGate)!;
+    expect(gate).toMatchObject({
+      signalName: "approve-terraform",
+      timeout: "72h",
+      description: "Change window only",
+    });
+  });
+
+  test("the Gate phase reports the plan's destroy count before it waits", () => {
+    // GateStep has no condition field, so "on-destroy" cannot branch at build
+    // time. The approver is told instead: a `show` of the saved plan runs
+    // first and surfaces `destroys` as a search attribute.
+    const op = props({ name: "prod-apply", root: "app" });
+    const steps = op.phases.find((p) => p.name === "Gate")!.steps;
+    const show = steps[0] as ActivityStep;
+    expect(show.fn).toBe("terraformShow");
+    expect(show.outcomeAttribute).toEqual({ name: "Destroys", from: "destroys" });
+    expect(steps[1].kind).toBe("gate");
+    expect(isStepOutputRef(show.args?.planFile)).toBe(true);
+  });
+});
+
+describe("TerraformApplyOp plan-to-apply reference (#2086)", () => {
+  test("Plan surfaces `changed`, and Apply applies that step's own plan file", () => {
+    const op = props({ name: "app-apply", root: "app", gate: "never" });
+    const plan = op.phases.find((p) => p.name === "Plan")!.steps[0] as ActivityStep;
+    const apply = op.phases.find((p) => p.name === "Apply")!.steps[0] as ActivityStep;
+
+    expect(plan.id).toBe("plan");
+    expect(plan.outcomeAttribute).toEqual({ name: "Changed", from: "changed" });
+    expect(plan.args?.planFile).toBe("chant.tfplan");
+
+    const ref = apply.args?.planFile;
+    expect(isStepOutputRef(ref)).toBe(true);
+    expect(ref).toMatchObject({ step: "plan", path: "planFile" });
+  });
+
+  test("an explicit planFile is what Plan writes and Apply reads back by reference", () => {
+    const op = props({ name: "app-apply", root: "app", gate: "never", planFile: "prod.tfplan" });
+    const plan = op.phases.find((p) => p.name === "Plan")!.steps[0] as ActivityStep;
+    expect(plan.args?.planFile).toBe("prod.tfplan");
+  });
+
+  test("upgrade is opt-in on the Init step", () => {
+    const withUpgrade = props({ name: "a", root: "app", gate: "never", upgrade: true });
+    const without = props({ name: "a", root: "app", gate: "never" });
+    expect((withUpgrade.phases[0].steps[0] as ActivityStep).args).toEqual({ root: "app", upgrade: true });
+    expect((without.phases[0].steps[0] as ActivityStep).args).toEqual({ root: "app" });
+  });
+});
+
+describe("TerraformApplyOp compensation — total or refused (#2086)", () => {
+  test("compensate: true throws at build time, naming the Op and terraform's lack of rollback", () => {
+    expect(() => TerraformApplyOp({ name: "prod-apply", root: "app", compensate: true })).toThrow(
+      /TerraformApplyOp "prod-apply".*no automatic rollback/s,
+    );
+  });
+
+  test("an object without a command is refused the same way", () => {
+    expect(() => TerraformApplyOp({ name: "prod-apply", root: "app", compensate: {} })).toThrow(
+      /TerraformApplyOp "prod-apply"/,
+    );
+  });
+
+  test("compensate: false and the default build no onFailure phase", () => {
+    expect(props({ name: "a", root: "app", compensate: false }).onFailure).toBeUndefined();
+    expect(props({ name: "a", root: "app" }).onFailure).toBeUndefined();
+  });
+
+  test("compensate: { command } builds an onFailure Rollback phase running that command", () => {
+    const op = props({
+      name: "a",
+      root: "app",
+      compensate: { command: "terraform apply -input=false rollback.tfplan" },
+    });
+    expect(op.onFailure?.map((p) => p.name)).toEqual(["Rollback"]);
+    expect(op.onFailure![0].steps[0]).toMatchObject({
+      kind: "activity",
+      fn: "shellCmd",
+      args: { cmd: "terraform apply -input=false rollback.tfplan" },
+    });
+  });
+});
+
+describe("TerraformApplyOp on the local executor (#2086)", () => {
+  test("a gated Op is refused up front, naming the signal the local executor cannot wait for", async () => {
+    const op = props({ name: "prod-apply", root: "app" });
+    await expect(runOpLocally(op, new Map(), {})).rejects.toBeInstanceOf(LocalGateUnsupportedError);
+  });
+
+  test('gate: "never" clears that refusal, which is what makes `chant run` viable', () => {
+    expect(findGate(props({ name: "prod-apply", root: "app", gate: "never" }))).toBeUndefined();
+  });
+});
+
+describe("TerraformApplyOp Op metadata (#2086)", () => {
+  test("task queue defaults to the name and search attributes name the root", () => {
+    const op = props({ name: "app-apply", root: "app" });
+    expect(op.name).toBe("app-apply");
+    expect(op.taskQueue).toBe("app-apply");
+    expect(op.searchAttributes).toEqual({ Apply: "true", TerraformRoot: "app" });
+  });
+
+  test("an explicit taskQueue wins", () => {
+    expect(props({ name: "app-apply", root: "app", taskQueue: "infra" }).taskQueue).toBe("infra");
+  });
+});

package/src/composites/terraform-apply-op.ts

@@ -0,0 +1,166 @@
+/**
+ * TerraformApplyOp composite (#2086) — init, plan, approve, apply for one root
+ * module named in `terraform.roots`.
+ *
+ * Authority stays with terraform: chant runs the binary, reads its plan, and
+ * hands the same saved plan to apply. The Apply step never re-plans, because
+ * it takes the Plan step's own `planFile` as a `StepOutputRef` — whatever was
+ * approved is what runs.
+ *
+ * Phases: Init, Plan, Gate, Apply.
+ *
+ * The gate is durable-runtime work, so an Op that emits one needs Temporal;
+ * `packages/core/src/op/local-executor.ts` refuses any Op containing a gate.
+ * `gate: "never"` is what makes the Op runnable with `chant run` locally.
+ *
+ * @example
+ * ```typescript
+ * import { TerraformApplyOp } from "@intentius/chant-lexicon-terraform";
+ *
+ * export const { op } = TerraformApplyOp({ name: "app-apply", root: "app" });
+ * ```
+ */
+
+import { Op, phase, gate, activity, OpResource } from "@intentius/chant/op";
+import { DEFAULT_PLAN_FILE } from "../op/activities/terraform";
+import {
+  terraformInit as initStep,
+  terraformPlan as planStep,
+  terraformApply as applyStep,
+  terraformShow as showStep,
+} from "../op/builders";
+
+/**
+ * When to pause for a human before applying.
+ *
+ * `GateStep` (`packages/core/src/op/types.ts`) carries a signal name, a
+ * timeout and a description, and nothing conditional — so `"on-destroy"`
+ * cannot branch at build time on a count the plan only produces at run time.
+ * The workable v1 is that `"on-destroy"` and `"always"` emit the same Gate
+ * phase, and the approver is told what is at stake instead: the phase reports
+ * the plan's `destroys` count as the `Destroys` search attribute before it
+ * waits, and the gate description says so. A gate that skips itself when the
+ * plan turns out additive is a new step kind, out of scope here.
+ */
+export type TerraformGateMode = "on-destroy" | "always" | "never";
+
+export interface TerraformApplyOpConfig {
+  /** Op name (kebab-case). Also the default task queue and gate signal suffix. */
+  name: string;
+  /** Key into the project's `terraform.roots`. The root carries dir, workspace, var files and backend config. */
+  root: string;
+  /** Plan file written by Plan and consumed by Apply, relative to the root dir. Default: `chant.tfplan`. */
+  planFile?: string;
+  /**
+   * When to emit the approval gate. Default: `"on-destroy"`. See
+   * {@link TerraformGateMode} for why `"on-destroy"` and `"always"` build the
+   * same phase.
+   */
+  gate?: TerraformGateMode;
+  /** Gate signal name. Default: `approve-<name>`, as `ApplyOp` does. */
+  signalName?: string;
+  /** Temporal duration the gate waits before timing out. Default: core's own (48h). */
+  gateTimeout?: string;
+  /** Override the gate description shown to the approver. */
+  gateDescription?: string;
+  /** `-upgrade` on the Init step: re-resolve provider and module versions. */
+  upgrade?: boolean;
+  /**
+   * Directory each step starts the `chant.config.*` search from, which is
+   * what `terraform.roots` and the root's relative `dir` resolve against.
+   * Default: the running process's cwd, which is the project root under
+   * `chant run`.
+   */
+  cwd?: string;
+  /**
+   * Saga-style rollback on a failed apply, run as an `onFailure` phase.
+   *
+   * Terraform has no automatic rollback: a half-applied plan is undone by
+   * planning and applying the inverse, which is a decision about the estate
+   * rather than something chant can synthesize. So compensation here is
+   * total or refused, the same stance `ApplyOp` takes (`lexicons/temporal/src/
+   * composites/apply-op.ts`) — `true`, or an object with no `command`, throws
+   * when the Op is built, naming the Op, rather than warning at the moment a
+   * rollback is already needed. Supply `compensate: { command: "..." }` with a
+   * rollback of your own, or leave it unset.
+   */
+  compensate?: boolean | { command?: string };
+  /** Override the task queue. Defaults to `name`. */
+  taskQueue?: string;
+}
+
+export interface TerraformApplyOpResources {
+  /** Op resource — generates the Init/Plan/[Gate]/Apply workflow. */
+  op: InstanceType<typeof OpResource>;
+}
+
+export function TerraformApplyOp(config: TerraformApplyOpConfig): TerraformApplyOpResources {
+  const taskQueue = config.taskQueue ?? config.name;
+  const planFile = config.planFile ?? DEFAULT_PLAN_FILE;
+  const gateMode: TerraformGateMode = config.gate ?? "on-destroy";
+
+  // Terraform has no rollback to run, so asking for one without supplying it
+  // fails here, at build time, with the Op named — not as a warning when the
+  // apply has already half-run. Same shape as ApplyOp's refusal (#1449).
+  const compensateCommand = typeof config.compensate === "object" ? config.compensate.command : undefined;
+  if (config.compensate !== undefined && config.compensate !== false && compensateCommand === undefined) {
+    throw new Error(
+      `TerraformApplyOp "${config.name}": compensate is enabled, but terraform has no automatic ` +
+        `rollback — undoing a partial apply means planning and applying the inverse, which is a ` +
+        `decision about the estate rather than something chant can synthesize. Either supply ` +
+        `compensate: { command: "..." } with a rollback of your own, or set compensate: false.`,
+    );
+  }
+
+  // Every step resolves the root through the same project config, so the cwd
+  // travels with each of them rather than being read off the process once.
+  const where = config.cwd ? { cwd: config.cwd } : {};
+
+  // `id` is what makes `plan.out` legal, and `plan.out.planFile` is how the
+  // Apply step below names this step's saved plan.
+  const plan = planStep(config.root, { planFile, ...where, id: "plan" });
+  plan.outcomeAttribute = { name: "Changed", from: "changed" };
+
+  const phases = [
+    phase("Init", [initStep(config.root, { ...where, ...(config.upgrade ? { upgrade: true } : {}) })]),
+    phase("Plan", [plan]),
+  ];
+
+  if (gateMode !== "never") {
+    // Re-render the saved plan just before the wait, so the approver's
+    // `Destroys` attribute comes off the plan that will actually apply.
+    // `show` against a plan file calls no provider.
+    const show = showStep(config.root, { ...where, planFile: plan.out.planFile });
+    show.outcomeAttribute = { name: "Destroys", from: "destroys" };
+    phases.push(
+      phase("Gate", [
+        show,
+        gate(config.signalName ?? `approve-${config.name}`, {
+          ...(config.gateTimeout ? { timeout: config.gateTimeout } : {}),
+          description:
+            config.gateDescription ??
+            `Approve terraform apply of root "${config.root}" (gate: ${gateMode}). ` +
+              `The Destroys search attribute on this phase is the plan's destroy count.`,
+        }),
+      ]),
+    );
+  }
+
+  phases.push(phase("Apply", [applyStep(config.root, { ...where, planFile: plan.out.planFile })]));
+
+  const op = Op({
+    name: config.name,
+    overview: `Init, plan and apply the "${config.root}" terraform root`,
+    taskQueue,
+    searchAttributes: {
+      Apply: "true",
+      TerraformRoot: config.root,
+    },
+    phases,
+    ...(compensateCommand
+      ? { onFailure: [phase("Rollback", [activity("shellCmd", { cmd: compensateCommand })])] }
+      : {}),
+  });
+
+  return { op };
+}

package/src/composites/terraform-watch-op.test.ts

@@ -0,0 +1,184 @@
+/**
+ * TerraformWatchOp composite tests (#2087): the phases, the Drift outcome
+ * attribute, the three finding modes, the schedule, and the hard rule that
+ * only the `-no-color` plan text can reach an issue or PR body.
+ */
+
+import { describe, test, expect } from "vitest";
+import {
+  isStepOutputRef,
+  collectStepOutputRefs,
+  type ActivityStep,
+  type OpConfig,
+  type StepDefinition,
+} from "@intentius/chant/op";
+
+import { TerraformWatchOp } from "./terraform-watch-op";
+
+/** The Op's declared config, which is what `chant build` serializes. */
+function props(config: Parameters<typeof TerraformWatchOp>[0]): OpConfig {
+  return (TerraformWatchOp(config).op as unknown as { props: OpConfig }).props;
+}
+
+const phaseNames = (op: OpConfig): string[] => op.phases.map((p) => p.name);
+const isActivity = (s: StepDefinition): s is ActivityStep => s.kind === "activity";
+const steps = (op: OpConfig): ActivityStep[] => op.phases.flatMap((p) => p.steps.filter(isActivity));
+
+describe("TerraformWatchOp phases (#2087)", () => {
+  test("report mode is Init then Plan, and opens nothing", () => {
+    const op = props({ name: "app-watch", root: "app" });
+    expect(phaseNames(op)).toEqual(["Init", "Plan"]);
+    expect(steps(op).map((s) => s.fn)).toEqual(["terraformInit", "terraformPlan"]);
+    expect(steps(op).some((s) => s.fn === "reconcilePr")).toBe(false);
+  });
+
+  test('"report" is the default finding mode', () => {
+    expect(phaseNames(props({ name: "app-watch", root: "app", findingMode: "report" }))).toEqual(
+      phaseNames(props({ name: "app-watch", root: "app" })),
+    );
+  });
+
+  test("every step names the configured root", () => {
+    for (const step of steps(props({ name: "app-watch", root: "app", findingMode: "issue" }))) {
+      if (step.fn === "reconcilePr") continue;
+      expect(step.args?.root).toBe("app");
+    }
+  });
+
+  test("the Plan step reports drift as a search attribute", () => {
+    const plan = props({ name: "app-watch", root: "app" }).phases[1].steps[0] as ActivityStep;
+    expect(plan.fn).toBe("terraformPlan");
+    expect(plan.id).toBe("plan");
+    // `terraformPlanCommand` always emits -detailed-exitcode, which is what
+    // makes `changed` answerable at all. See ../op/activities/terraform.ts.
+    expect(plan.outcomeAttribute).toEqual({ name: "Drift", from: "changed" });
+    expect(plan.args?.planFile).toBe("chant.tfplan");
+  });
+
+  test("cwd and upgrade ride the steps that take them", () => {
+    const op = props({ name: "app-watch", root: "app", cwd: "/repo", upgrade: true });
+    const [init, plan] = steps(op);
+    expect(init.args).toMatchObject({ root: "app", cwd: "/repo", upgrade: true });
+    expect(plan.args).toMatchObject({ root: "app", cwd: "/repo" });
+    expect(plan.args?.upgrade).toBeUndefined();
+  });
+
+  test("no cwd means no cwd arg, so each step reads the process's own", () => {
+    for (const step of steps(props({ name: "app-watch", root: "app" }))) {
+      expect(step.args && "cwd" in step.args).toBe(false);
+    }
+  });
+});
+
+describe("TerraformWatchOp finding modes (#2087)", () => {
+  const findingStep = (mode: "issue" | "pull-request"): ActivityStep => {
+    const op = props({ name: "app-watch", root: "app", findingMode: mode });
+    expect(phaseNames(op)).toEqual(["Init", "Plan", "Report"]);
+    return op.phases[2].steps[0] as ActivityStep;
+  };
+
+  test("issue mode opens an issue through reconcilePr and surfaces its URL", () => {
+    const step = findingStep("issue");
+    expect(step.fn).toBe("reconcilePr");
+    expect(step.args?.mode).toBe("issue");
+    expect(step.args?.env).toBe("app");
+    expect(step.outcomeAttribute).toEqual({ name: "Issue", from: "issueUrl" });
+  });
+
+  test("pull-request mode opens a PR through the same activity", () => {
+    const step = findingStep("pull-request");
+    expect(step.fn).toBe("reconcilePr");
+    expect(step.args?.mode).toBe("pull-request");
+    expect(step.outcomeAttribute).toEqual({ name: "PR", from: "prUrl" });
+  });
+
+  test("the finding step derives no plan of its own", () => {
+    // `entries: []` is what stops reconcilePr shelling to `chant lifecycle
+    // plan --json`: the finding is already written by the time it runs.
+    expect(findingStep("issue").args?.entries).toEqual([]);
+  });
+
+  test("title defaults to the root and can be overridden, and branch only rides when given", () => {
+    expect(findingStep("issue").args?.title).toBe('Terraform drift in root "app"');
+    const custom = props({
+      name: "app-watch",
+      root: "app",
+      findingMode: "pull-request",
+      title: "Nightly drift",
+      branch: "chant/tf-drift",
+    }).phases[2].steps[0] as ActivityStep;
+    expect(custom.args?.title).toBe("Nightly drift");
+    expect(custom.args?.branch).toBe("chant/tf-drift");
+    expect(findingStep("issue").args && "branch" in findingStep("issue").args!).toBe(false);
+  });
+});
+
+describe("TerraformWatchOp posts the human plan and never the plan JSON (#2087)", () => {
+  for (const mode of ["issue", "pull-request"] as const) {
+    test(`${mode}: the body is a reference to the Plan step's -no-color text`, () => {
+      const op = props({ name: "app-watch", root: "app", findingMode: mode });
+      const report = op.phases[2].steps[0] as ActivityStep;
+      const body = report.args?.body;
+      expect(isStepOutputRef(body)).toBe(true);
+      expect(body).toMatchObject({ step: "plan", path: "text" });
+    });
+
+    test(`${mode}: no reference to the plan JSON reaches the finding step`, () => {
+      // `TerraformPlanResult.json` is `terraform show -json` over the saved
+      // plan: every attribute value the plan touches, provider credentials
+      // included. The only other thing that could carry it is a literal, so
+      // both the references and the serialized args are checked.
+      const op = props({ name: "app-watch", root: "app", findingMode: mode });
+      const report = op.phases[2].steps[0] as ActivityStep;
+      const paths = collectStepOutputRefs(report.args).map((r) => r.path);
+      expect(paths).toEqual(["text"]);
+      expect(paths).not.toContain("json");
+      expect(JSON.stringify(report.args)).not.toContain("json");
+    });
+  }
+
+  test("the whole Op references exactly one field of the plan", () => {
+    const op = props({ name: "app-watch", root: "app", findingMode: "issue" });
+    const refs = op.phases.flatMap((p) => p.steps.filter(isActivity)).flatMap((s) => collectStepOutputRefs(s.args));
+    expect(refs).toHaveLength(1);
+    expect(refs[0]).toMatchObject({ step: "plan", path: "text" });
+  });
+});
+
+describe("TerraformWatchOp schedule (#2087)", () => {
+  test("omitting `schedule` returns no schedule", () => {
+    const result = TerraformWatchOp({ name: "app-watch", root: "app" });
+    expect(result.schedule).toBeUndefined();
+    expect(Object.prototype.hasOwnProperty.call(result, "schedule")).toBe(false);
+  });
+
+  test("a cron returns a Temporal::Schedule beside the Op", () => {
+    const { op, schedule } = TerraformWatchOp({
+      name: "app-watch",
+      root: "app",
+      schedule: "0 6 * * *",
+    });
+    expect(schedule).toBeDefined();
+    expect(schedule!.entityType).toBe("Temporal::Schedule");
+    expect(schedule!.lexicon).toBe("temporal");
+    expect((schedule as unknown as { props: Record<string, unknown> }).props).toEqual({
+      scheduleId: "app-watch-schedule",
+      spec: { cronExpressions: ["0 6 * * *"] },
+      action: { workflowType: "appWatchWorkflow", taskQueue: "app-watch" },
+    });
+    expect((op as unknown as { props: OpConfig }).props.taskQueue).toBe("app-watch");
+  });
+
+  test("an explicit taskQueue reaches both the Op and the schedule action", () => {
+    const { op, schedule } = TerraformWatchOp({
+      name: "app-watch",
+      root: "app",
+      schedule: "0 6 * * *",
+      taskQueue: "infra",
+    });
+    expect((op as unknown as { props: OpConfig }).props.taskQueue).toBe("infra");
+    expect(
+      ((schedule as unknown as { props: { action: { taskQueue: string } } }).props.action).taskQueue,
+    ).toBe("infra");
+  });
+});