@quinteroac/agents-coding-toolkit 0.1.0-preview → 0.2.0

package/src/commands/approve-refactor-plan.test.ts

@@ -0,0 +1,254 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { RefactorPrdSchema } from "../../scaffold/schemas/tmpl_refactor-prd";
+import { readState, writeState } from "../state";
+import { parseRefactorPlan, runApproveRefactorPlan } from "./approve-refactor-plan";
+
+async function createProjectRoot(): Promise<string> {
+  return mkdtemp(join(tmpdir(), "nvst-approve-refactor-plan-"));
+}
+
+async function withCwd<T>(cwd: string, fn: () => Promise<T>): Promise<T> {
+  const previous = process.cwd();
+  process.chdir(cwd);
+  try {
+    return await fn();
+  } finally {
+    process.chdir(previous);
+  }
+}
+
+async function seedState(
+  projectRoot: string,
+  status: "pending" | "pending_approval" | "approved",
+  file: string | null,
+) {
+  await mkdir(join(projectRoot, ".agents", "flow"), { recursive: true });
+  await writeState(projectRoot, {
+    current_iteration: "000013",
+    current_phase: "refactor",
+    phases: {
+      define: {
+        requirement_definition: { status: "approved", file: "it_000013_product-requirement-document.md" },
+        prd_generation: { status: "completed", file: "it_000013_PRD.json" },
+      },
+      prototype: {
+        project_context: { status: "created", file: ".agents/PROJECT_CONTEXT.md" },
+        test_plan: { status: "created", file: "it_000013_test-plan.md" },
+        tp_generation: { status: "created", file: "it_000013_TP.json" },
+        prototype_build: { status: "created", file: "it_000013_progress.json" },
+        test_execution: { status: "completed", file: "it_000013_test-execution-report.json" },
+        prototype_approved: true,
+      },
+      refactor: {
+        evaluation_report: { status: "created", file: "it_000013_evaluation-report.md" },
+        refactor_plan: { status, file },
+        refactor_execution: { status: "pending", file: null },
+        changelog: { status: "pending", file: null },
+      },
+    },
+    last_updated: "2026-02-26T00:00:00.000Z",
+    updated_by: "seed",
+    history: [],
+  });
+}
+
+const createdRoots: string[] = [];
+
+afterEach(async () => {
+  process.exitCode = 0;
+  await Promise.all(createdRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+
+describe("approve refactor-plan command", () => {
+  test("registers approve refactor-plan command in CLI dispatch", async () => {
+    const source = await readFile(join(process.cwd(), "src", "cli.ts"), "utf8");
+
+    expect(source).toContain('import { runApproveRefactorPlan } from "./commands/approve-refactor-plan";');
+    expect(source).toContain('if (subcommand === "refactor-plan") {');
+    expect(source).toContain("await runApproveRefactorPlan({ force });");
+  });
+
+  test("requires refactor.refactor_plan.status to be pending_approval", async () => {
+    const projectRoot = await createProjectRoot();
+    createdRoots.push(projectRoot);
+    await seedState(projectRoot, "pending", "it_000013_refactor-plan.md");
+
+    await withCwd(projectRoot, async () => {
+      await expect(runApproveRefactorPlan()).rejects.toThrow(
+        "Cannot approve refactor plan from status 'pending'. Expected pending_approval.",
+      );
+    });
+  });
+
+  test("rejects when refactor.refactor_plan.file is missing", async () => {
+    const projectRoot = await createProjectRoot();
+    createdRoots.push(projectRoot);
+    await seedState(projectRoot, "pending_approval", null);
+
+    await withCwd(projectRoot, async () => {
+      await expect(runApproveRefactorPlan()).rejects.toThrow(
+        "Cannot approve refactor plan: refactor.refactor_plan.file is missing.",
+      );
+    });
+  });
+
+  test("rejects when refactor plan file does not exist on disk", async () => {
+    const projectRoot = await createProjectRoot();
+    createdRoots.push(projectRoot);
+    await seedState(projectRoot, "pending_approval", "it_000013_refactor-plan.md");
+
+    await withCwd(projectRoot, async () => {
+      await expect(runApproveRefactorPlan()).rejects.toThrow(
+        "Cannot approve refactor plan: file not found at",
+      );
+    });
+  });
+
+  test("approves refactor plan, generates refactor-prd JSON via write-json, and updates state fields", async () => {
+    const projectRoot = await createProjectRoot();
+    createdRoots.push(projectRoot);
+    await seedState(projectRoot, "pending_approval", "it_000013_refactor-plan.md");
+
+    const refactorPlanPath = join(projectRoot, ".agents", "flow", "it_000013_refactor-plan.md");
+    await writeFile(
+      refactorPlanPath,
+      [
+        "# Refactor Plan",
+        "## Refactor Items",
+        "### RI-001: Consolidate state updates",
+        "**Description:** Move scattered state mutation into a single helper.",
+        "**Rationale:** Reduces duplication and lowers the risk of inconsistent transitions.",
+        "### RI-002: Improve command dependency injection",
+        "**Description:**",
+        "Allow command helpers to accept overrideable I/O dependencies for tests.",
+        "**Rationale:**",
+        "Improves testability and keeps behavior deterministic in unit tests.",
+      ].join("\n"),
+      "utf8",
+    );
+
+    let capturedSchema = "";
+    let capturedOutPath = "";
+    let capturedPayload = "";
+
+    await withCwd(projectRoot, async () => {
+      await runApproveRefactorPlan({
+        invokeWriteJsonFn: async (_root, schemaName, outPath, data) => {
+          capturedSchema = schemaName;
+          capturedOutPath = outPath;
+          capturedPayload = data;
+          await writeFile(join(projectRoot, outPath), data, "utf8");
+          return { exitCode: 0, stderr: "" };
+        },
+        nowFn: () => new Date("2026-02-26T12:00:00.000Z"),
+      });
+    });
+
+    expect(capturedSchema).toBe("refactor-prd");
+    expect(capturedOutPath).toBe(".agents/flow/it_000013_refactor-prd.json");
+
+    const parsedPayload = JSON.parse(capturedPayload) as unknown;
+    const validation = RefactorPrdSchema.safeParse(parsedPayload);
+    expect(validation.success).toBe(true);
+    if (!validation.success) {
+      throw new Error("Expected refactor-prd payload to be valid");
+    }
+    expect(validation.data.refactorItems).toEqual([
+      {
+        id: "RI-001",
+        title: "Consolidate state updates",
+        description: "Move scattered state mutation into a single helper.",
+        rationale: "Reduces duplication and lowers the risk of inconsistent transitions.",
+      },
+      {
+        id: "RI-002",
+        title: "Improve command dependency injection",
+        description: "Allow command helpers to accept overrideable I/O dependencies for tests.",
+        rationale: "Improves testability and keeps behavior deterministic in unit tests.",
+      },
+    ]);
+
+    const state = await readState(projectRoot);
+    expect(state.phases.refactor.refactor_plan.status).toBe("approved");
+    expect(state.last_updated).toBe("2026-02-26T12:00:00.000Z");
+    expect(state.updated_by).toBe("nvst:approve-refactor-plan");
+  });
+
+  test("prints an error and keeps refactor plan pending_approval when write-json fails", async () => {
+    const projectRoot = await createProjectRoot();
+    createdRoots.push(projectRoot);
+    await seedState(projectRoot, "pending_approval", "it_000013_refactor-plan.md");
+
+    const refactorPlanPath = join(projectRoot, ".agents", "flow", "it_000013_refactor-plan.md");
+    await writeFile(
+      refactorPlanPath,
+      [
+        "# Refactor Plan",
+        "## Refactor Items",
+        "### RI-001: Keep pending on write-json failure",
+        "**Description:** Simulate a downstream write-json error.",
+        "**Rationale:** State must not mutate when serialization/validation fails.",
+      ].join("\n"),
+      "utf8",
+    );
+
+    const capturedErrors: string[] = [];
+    const originalConsoleError = console.error;
+    console.error = (...args: unknown[]) => {
+      capturedErrors.push(args.map((arg) => String(arg)).join(" "));
+    };
+
+    try {
+      await withCwd(projectRoot, async () => {
+        await runApproveRefactorPlan({
+          invokeWriteJsonFn: async () => ({
+            exitCode: 1,
+            stderr: "mock write-json failure",
+          }),
+        });
+      });
+    } finally {
+      console.error = originalConsoleError;
+    }
+
+    expect(process.exitCode).toBe(1);
+    expect(capturedErrors[0]).toContain(
+      "Refactor PRD JSON generation failed. Refactor plan remains pending_approval.",
+    );
+    expect(capturedErrors[1]).toContain("mock write-json failure");
+
+    const state = await readState(projectRoot);
+    expect(state.phases.refactor.refactor_plan.status).toBe("pending_approval");
+    expect(state.last_updated).toBe("2026-02-26T00:00:00.000Z");
+    expect(state.updated_by).toBe("seed");
+  });
+
+  test("parseRefactorPlan extracts items from markdown sections", () => {
+    const parsed = parseRefactorPlan(
+      [
+        "# Refactor Plan",
+        "## Refactor Items",
+        "### ri-007: Normalize line endings",
+        "**Description:** Convert generated markdown outputs to LF only.",
+        "**Rationale:** Avoid cross-platform diff noise in CI.",
+      ].join("\n"),
+    );
+
+    expect(parsed).toEqual({
+      refactorItems: [
+        {
+          id: "RI-007",
+          title: "Normalize line endings",
+          description: "Convert generated markdown outputs to LF only.",
+          rationale: "Avoid cross-platform diff noise in CI.",
+        },
+      ],
+    });
+    const validation = RefactorPrdSchema.safeParse(parsed);
+    expect(validation.success).toBe(true);
+  });
+});

package/src/commands/approve-refactor-plan.ts

@@ -0,0 +1,200 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { $ } from "bun";
+
+import { CLI_PATH } from "../cli-path";
+import { assertGuardrail } from "../guardrail";
+import type { RefactorPrd } from "../../scaffold/schemas/tmpl_refactor-prd";
+import { exists, FLOW_REL_DIR, readState, writeState } from "../state";
+
+interface WriteJsonResult {
+  exitCode: number;
+  stderr: string;
+}
+
+interface ApproveRefactorPlanDeps {
+  existsFn: (path: string) => Promise<boolean>;
+  invokeWriteJsonFn: (
+    projectRoot: string,
+    schemaName: string,
+    outPath: string,
+    data: string,
+  ) => Promise<WriteJsonResult>;
+  nowFn: () => Date;
+  readFileFn: typeof readFile;
+}
+
+const defaultDeps: ApproveRefactorPlanDeps = {
+  existsFn: exists,
+  invokeWriteJsonFn: runWriteJsonCommand,
+  nowFn: () => new Date(),
+  readFileFn: readFile,
+};
+
+export function parseRefactorPlan(markdown: string): RefactorPrd {
+  const refactorItems: RefactorPrd["refactorItems"] = [];
+  const lines = markdown.split("\n");
+
+  let inRefactorItems = false;
+  let currentField: "description" | "rationale" | null = null;
+  let currentItem: RefactorPrd["refactorItems"][number] | null = null;
+
+  const flushCurrentItem = () => {
+    if (!currentItem) return;
+    refactorItems.push(currentItem);
+    currentItem = null;
+    currentField = null;
+  };
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    if (/^##\s+Refactor Items$/i.test(trimmed)) {
+      inRefactorItems = true;
+      currentField = null;
+      continue;
+    }
+
+    if (!inRefactorItems) {
+      continue;
+    }
+
+    if (/^##\s+/.test(trimmed) && !/^##\s+Refactor Items$/i.test(trimmed)) {
+      flushCurrentItem();
+      inRefactorItems = false;
+      continue;
+    }
+
+    const itemMatch = trimmed.match(/^###\s+(RI-\d{3}):\s+(.+)$/i);
+    if (itemMatch) {
+      flushCurrentItem();
+      currentItem = {
+        id: itemMatch[1].toUpperCase(),
+        title: itemMatch[2].trim(),
+        description: "",
+        rationale: "",
+      };
+      currentField = null;
+      continue;
+    }
+
+    if (!currentItem) {
+      continue;
+    }
+
+    const descriptionMatch = trimmed.match(/^\*\*Description:\*\*\s*(.*)$/i);
+    if (descriptionMatch) {
+      currentItem.description = descriptionMatch[1].trim();
+      currentField = "description";
+      continue;
+    }
+
+    const rationaleMatch = trimmed.match(/^\*\*Rationale:\*\*\s*(.*)$/i);
+    if (rationaleMatch) {
+      currentItem.rationale = rationaleMatch[1].trim();
+      currentField = "rationale";
+      continue;
+    }
+
+    if (trimmed.length === 0 || !currentField) {
+      continue;
+    }
+
+    if (currentField === "description") {
+      currentItem.description = [currentItem.description, trimmed].filter(Boolean).join(" ");
+      continue;
+    }
+
+    currentItem.rationale = [currentItem.rationale, trimmed].filter(Boolean).join(" ");
+  }
+
+  flushCurrentItem();
+
+  return { refactorItems };
+}
+
+async function runWriteJsonCommand(
+  projectRoot: string,
+  schemaName: string,
+  outPath: string,
+  data: string,
+): Promise<WriteJsonResult> {
+  const result =
+    await $`bun ${CLI_PATH} write-json --schema ${schemaName} --out ${outPath} --data ${data}`
+      .cwd(projectRoot)
+      .nothrow()
+      .quiet();
+
+  return {
+    exitCode: result.exitCode,
+    stderr: result.stderr.toString().trim(),
+  };
+}
+
+export async function runApproveRefactorPlan(
+  optsOrDeps: { force?: boolean } | Partial<ApproveRefactorPlanDeps> = {},
+  maybeDeps: Partial<ApproveRefactorPlanDeps> = {},
+): Promise<void> {
+  const isDepsArg =
+    typeof optsOrDeps === "object"
+    && optsOrDeps !== null
+    && (
+      "existsFn" in optsOrDeps
+      || "invokeWriteJsonFn" in optsOrDeps
+      || "nowFn" in optsOrDeps
+      || "readFileFn" in optsOrDeps
+    );
+  const force = isDepsArg ? false : ((optsOrDeps as { force?: boolean }).force ?? false);
+  const projectRoot = process.cwd();
+  const state = await readState(projectRoot);
+  const deps = isDepsArg ? optsOrDeps : maybeDeps;
+  const mergedDeps: ApproveRefactorPlanDeps = { ...defaultDeps, ...deps };
+
+  const refactorPlan = state.phases.refactor.refactor_plan;
+  await assertGuardrail(
+    state,
+    refactorPlan.status !== "pending_approval",
+    `Cannot approve refactor plan from status '${refactorPlan.status}'. Expected pending_approval.`,
+    { force },
+  );
+
+  const refactorPlanFile = refactorPlan.file;
+  if (!refactorPlanFile) {
+    throw new Error("Cannot approve refactor plan: refactor.refactor_plan.file is missing.");
+  }
+
+  const refactorPlanPath = join(projectRoot, FLOW_REL_DIR, refactorPlanFile);
+  if (!(await mergedDeps.existsFn(refactorPlanPath))) {
+    throw new Error(`Cannot approve refactor plan: file not found at ${refactorPlanPath}`);
+  }
+
+  const markdown = await mergedDeps.readFileFn(refactorPlanPath, "utf-8");
+  const refactorPrdData = parseRefactorPlan(markdown);
+  const refactorPrdJsonFileName = `it_${state.current_iteration}_refactor-prd.json`;
+  const refactorPrdJsonRelPath = join(FLOW_REL_DIR, refactorPrdJsonFileName);
+
+  const writeResult = await mergedDeps.invokeWriteJsonFn(
+    projectRoot,
+    "refactor-prd",
+    refactorPrdJsonRelPath,
+    JSON.stringify(refactorPrdData),
+  );
+
+  if (writeResult.exitCode !== 0) {
+    console.error("Refactor PRD JSON generation failed. Refactor plan remains pending_approval.");
+    if (writeResult.stderr) {
+      console.error(writeResult.stderr);
+    }
+    process.exitCode = 1;
+    return;
+  }
+
+  refactorPlan.status = "approved";
+  state.last_updated = mergedDeps.nowFn().toISOString();
+  state.updated_by = "nvst:approve-refactor-plan";
+
+  await writeState(projectRoot, state);
+
+  console.log("Refactor plan approved.");
+  console.log(`Refactor PRD JSON written to ${refactorPrdJsonRelPath}`);
+}

package/src/commands/approve-requirement.test.ts

@@ -0,0 +1,224 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { PrdSchema } from "../../scaffold/schemas/tmpl_prd";
+import { readState, writeState } from "../state";
+import { runApproveRequirement } from "./approve-requirement";
+
+async function createProjectRoot(): Promise<string> {
+  return mkdtemp(join(tmpdir(), "nvst-approve-requirement-"));
+}
+
+async function withCwd<T>(cwd: string, fn: () => Promise<T>): Promise<T> {
+  const previous = process.cwd();
+  process.chdir(cwd);
+  try {
+    return await fn();
+  } finally {
+    process.chdir(previous);
+  }
+}
+
+async function seedState(
+  projectRoot: string,
+  status: "pending" | "in_progress" | "approved",
+  file: string | null,
+) {
+  await mkdir(join(projectRoot, ".agents", "flow"), { recursive: true });
+  await writeState(projectRoot, {
+    current_iteration: "000001",
+    current_phase: "define",
+    phases: {
+      define: {
+        requirement_definition: { status, file },
+        prd_generation: { status: "pending", file: null },
+      },
+      prototype: {
+        project_context: { status: "pending", file: null },
+        test_plan: { status: "pending", file: null },
+        tp_generation: { status: "pending", file: null },
+        prototype_build: { status: "pending", file: null },
+        test_execution: { status: "pending", file: null },
+        prototype_approved: false,
+      },
+      refactor: {
+        evaluation_report: { status: "pending", file: null },
+        refactor_plan: { status: "pending", file: null },
+        refactor_execution: { status: "pending", file: null },
+        changelog: { status: "pending", file: null },
+      },
+    },
+    last_updated: "2026-02-20T00:00:00.000Z",
+    updated_by: "seed",
+    history: [],
+  });
+}
+
+const MINIMAL_PRD_MARKDOWN = [
+  "# Product Requirement Document",
+  "## Goals",
+  "- Ship the feature",
+  "## User Stories",
+  "### US-001: Core feature",
+  "As a developer, I want to build the feature.",
+  "**Acceptance Criteria:**",
+  "- [ ] Feature is built",
+  "## Functional Requirements",
+  "- FR-1: The system must do something",
+].join("\n");
+
+const createdRoots: string[] = [];
+
+afterEach(async () => {
+  process.exitCode = 0;
+  await Promise.all(createdRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+
+describe("approve requirement command", () => {
+  test("registers approve requirement command in CLI dispatch", async () => {
+    const source = await readFile(join(process.cwd(), "src", "cli.ts"), "utf8");
+
+    expect(source).toContain('import { runApproveRequirement } from "./commands/approve-requirement";');
+    expect(source).toContain('if (subcommand === "requirement") {');
+    expect(source).toContain("await runApproveRequirement({ force });");
+  });
+
+  test("rejects when requirement_definition.status is not in_progress", async () => {
+    const projectRoot = await createProjectRoot();
+    createdRoots.push(projectRoot);
+    await seedState(projectRoot, "pending", "it_000001_product-requirement-document.md");
+
+    await withCwd(projectRoot, async () => {
+      await expect(runApproveRequirement()).rejects.toThrow(
+        "Cannot approve requirement from status 'pending'. Expected in_progress.",
+      );
+    });
+  });
+
+  test("rejects when requirement_definition.file is null", async () => {
+    const projectRoot = await createProjectRoot();
+    createdRoots.push(projectRoot);
+    await seedState(projectRoot, "in_progress", null);
+
+    await withCwd(projectRoot, async () => {
+      await expect(runApproveRequirement()).rejects.toThrow(
+        "Cannot approve requirement: define.requirement_definition.file is missing.",
+      );
+    });
+  });
+
+  test("rejects when requirement file does not exist on disk", async () => {
+    const projectRoot = await createProjectRoot();
+    createdRoots.push(projectRoot);
+    await seedState(projectRoot, "in_progress", "it_000001_product-requirement-document.md");
+
+    await withCwd(projectRoot, async () => {
+      await expect(runApproveRequirement()).rejects.toThrow(
+        "Cannot approve requirement: file not found at",
+      );
+    });
+  });
+
+  test("approves requirement, generates PRD JSON via write-json, and updates state fields", async () => {
+    const projectRoot = await createProjectRoot();
+    createdRoots.push(projectRoot);
+    await seedState(projectRoot, "in_progress", "it_000001_product-requirement-document.md");
+
+    const requirementPath = join(
+      projectRoot,
+      ".agents",
+      "flow",
+      "it_000001_product-requirement-document.md",
+    );
+    await writeFile(requirementPath, MINIMAL_PRD_MARKDOWN, "utf8");
+
+    let capturedSchema = "";
+    let capturedOutPath = "";
+    let capturedPayload = "";
+
+    await withCwd(projectRoot, async () => {
+      await runApproveRequirement({
+        invokeWriteJsonFn: async (_root, schemaName, outPath, data) => {
+          capturedSchema = schemaName;
+          capturedOutPath = outPath;
+          capturedPayload = data;
+          await writeFile(join(projectRoot, outPath), data, "utf8");
+          return { exitCode: 0, stderr: "" };
+        },
+        nowFn: () => new Date("2026-02-20T08:00:00.000Z"),
+      });
+    });
+
+    expect(capturedSchema).toBe("prd");
+    expect(capturedOutPath).toBe(".agents/flow/it_000001_PRD.json");
+
+    const parsedPayload = JSON.parse(capturedPayload) as unknown;
+    const validation = PrdSchema.safeParse(parsedPayload);
+    expect(validation.success).toBe(true);
+    if (!validation.success) {
+      throw new Error("Expected PRD payload to be valid");
+    }
+    expect(validation.data.goals).toEqual(["Ship the feature"]);
+    expect(validation.data.userStories[0]).toMatchObject({
+      id: "US-001",
+      title: "Core feature",
+    });
+    expect(validation.data.functionalRequirements[0]).toEqual({
+      id: "FR-1",
+      description: "The system must do something",
+    });
+
+    const state = await readState(projectRoot);
+    expect(state.phases.define.requirement_definition.status).toBe("approved");
+    expect(state.phases.define.prd_generation.status).toBe("completed");
+    expect(state.phases.define.prd_generation.file).toBe("it_000001_PRD.json");
+    expect(state.last_updated).toBe("2026-02-20T08:00:00.000Z");
+    expect(state.updated_by).toBe("nvst:approve-requirement");
+  });
+
+  test("prints error and keeps status in_progress when write-json fails", async () => {
+    const projectRoot = await createProjectRoot();
+    createdRoots.push(projectRoot);
+    await seedState(projectRoot, "in_progress", "it_000001_product-requirement-document.md");
+
+    const requirementPath = join(
+      projectRoot,
+      ".agents",
+      "flow",
+      "it_000001_product-requirement-document.md",
+    );
+    await writeFile(requirementPath, MINIMAL_PRD_MARKDOWN, "utf8");
+
+    const capturedErrors: string[] = [];
+    const originalConsoleError = console.error;
+    console.error = (...args: unknown[]) => {
+      capturedErrors.push(args.map((arg) => String(arg)).join(" "));
+    };
+
+    try {
+      await withCwd(projectRoot, async () => {
+        await runApproveRequirement({
+          invokeWriteJsonFn: async () => ({
+            exitCode: 1,
+            stderr: "mock write-json failure",
+          }),
+        });
+      });
+    } finally {
+      console.error = originalConsoleError;
+    }
+
+    expect(process.exitCode).toBe(1);
+    expect(capturedErrors[0]).toContain(
+      "PRD JSON generation failed. Requirement remains in_progress.",
+    );
+    expect(capturedErrors[1]).toContain("mock write-json failure");
+
+    const state = await readState(projectRoot);
+    expect(state.phases.define.requirement_definition.status).toBe("in_progress");
+    expect(state.last_updated).toBe("2026-02-20T00:00:00.000Z");
+    expect(state.updated_by).toBe("seed");
+  });
+});