hanarang-rails/tests/migrate.test.ts

import { describe, it, expect, beforeEach, afterEach } from "vitest";
import { mkdtemp, rm, mkdir, writeFile } from "node:fs/promises";
import { join } from "node:path";
import { tmpdir } from "node:os";
import { readdir, stat } from "node:fs/promises";

/**
 * Integration-ish test for the migration scanner — we simulate a legacy
 * hanarang-harness tree and verify the report includes expected entries.
 *
 * The CLI is not exercised directly (that would require citty's run()
 * plus stdout capture); we instead validate the scanning logic by
 * replicating the minimal scanner here.
 */

async function scanArchive(root: string): Promise<{
  agents: string[];
  scripts: string[];
  workflows: string[];
  plansDirs: string[];
}> {
  const report = {
    agents: [] as string[],
    scripts: [] as string[],
    workflows: [] as string[],
    plansDirs: [] as string[],
  };

  async function walk(dir: string): Promise<void> {
    const entries = await readdir(dir, { withFileTypes: true });
    for (const e of entries) {
      const full = join(dir, e.name);
      if (e.isDirectory()) {
        if (e.name === "node_modules" || e.name === ".git") continue;
        if (e.name === ".plans") report.plansDirs.push(full);
        await walk(full);
      } else {
        if (dir.includes("/agents") && e.name.endsWith(".md")) {
          report.agents.push(e.name);
        }
        if (dir.endsWith("/scripts") && e.name.endsWith(".sh")) {
          report.scripts.push(e.name);
        }
        if (e.name.endsWith(".lobster")) {
          report.workflows.push(e.name);
        }
      }
    }
  }

  await walk(root);
  return report;
}

let testDir: string;

beforeEach(async () => {
  testDir = await mkdtemp(join(tmpdir(), "rails-migrate-test-"));
});

afterEach(async () => {
  await rm(testDir, { recursive: true, force: true });
});

describe("migration scanner", () => {
  it("discovers agents, scripts, workflows, and .plans/", async () => {
    // Simulate a legacy harness layout
    await mkdir(join(testDir, "agents"), { recursive: true });
    await mkdir(join(testDir, "scripts"), { recursive: true });
    await mkdir(join(testDir, "workflows"), { recursive: true });
    await mkdir(join(testDir, ".plans/sprints"), { recursive: true });

    await writeFile(join(testDir, "agents/planner.md"), "# planner");
    await writeFile(join(testDir, "agents/reviewer.md"), "# reviewer");
    await writeFile(join(testDir, "scripts/scaffold.sh"), "#!/bin/bash");
    await writeFile(join(testDir, "scripts/bridge.sh"), "#!/bin/bash");
    await writeFile(join(testDir, "scripts/install.sh"), "#!/bin/bash");
    await writeFile(join(testDir, "workflows/plan-sprint.lobster"), "plan");
    await writeFile(join(testDir, "workflows/review-sprint.lobster"), "review");
    await writeFile(join(testDir, ".plans/sprints/SPRINT-001.md"), "# s1");

    const report = await scanArchive(testDir);

    expect(report.agents).toContain("planner.md");
    expect(report.agents).toContain("reviewer.md");
    expect(report.scripts).toContain("scaffold.sh");
    expect(report.scripts).toContain("bridge.sh");
    expect(report.scripts).toContain("install.sh");
    expect(report.workflows).toContain("plan-sprint.lobster");
    expect(report.workflows).toContain("review-sprint.lobster");
    expect(report.plansDirs.length).toBe(1);
  });

  it("skips node_modules and .git", async () => {
    await mkdir(join(testDir, "node_modules/pkg"), { recursive: true });
    await mkdir(join(testDir, ".git"), { recursive: true });
    await mkdir(join(testDir, "agents"), { recursive: true });

    await writeFile(join(testDir, "node_modules/pkg/index.md"), "ignore");
    await writeFile(join(testDir, ".git/config"), "ignore");
    await writeFile(join(testDir, "agents/real.md"), "keep");

    const report = await scanArchive(testDir);
    expect(report.agents).toEqual(["real.md"]);
  });

  it("handles empty archive", async () => {
    const report = await scanArchive(testDir);
    expect(report.agents).toEqual([]);
    expect(report.scripts).toEqual([]);
    expect(report.workflows).toEqual([]);
    expect(report.plansDirs).toEqual([]);
  });
});

describe("scaffold structure", () => {
  it("creates expected .plans/ subdirectories", async () => {
    const expected = [
      ".plans",
      ".plans/design",
      ".plans/sprints",
      ".plans/migration",
      ".rails/contracts",
      ".rails/qa-artifacts",
    ];

    // Manually create to simulate scaffold
    for (const d of expected) {
      await mkdir(join(testDir, d), { recursive: true });
    }

    for (const d of expected) {
      const s = await stat(join(testDir, d));
      expect(s.isDirectory()).toBe(true);
    }
  });
});