Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

12.8 KB
Raw Blame
import { createHash } from "node:crypto"
import { execFileSync } from "node:child_process"
import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"
import { tmpdir } from "node:os"
import { join, resolve } from "node:path"
import { describe, expect, it } from "vitest"
import { buildExecutionPlan as createExecutionPlan, queryNativeTasks, stablePlanJson } from "./changed-scopes.mjs"
import { runCli, verifyCoveragePlan } from "./verify-coverage-plan.mjs"

const baseSha = "a".repeat(40)
const headSha = "b".repeat(40)

let nativeInventory: ReturnType<typeof queryNativeTasks>["inventory"]
function buildExecutionPlan(changes, options) {
  if (!nativeInventory) {
    const head = execFileSync("git", ["rev-parse", "HEAD"], { encoding: "utf8" }).trim()
    nativeInventory = queryNativeTasks({ baseSha: head, headSha: head }).inventory
  }
  const selected = changes.every(change => change.path.startsWith("src/web/")) ? ["@alook/web"]
    : changes.every(change => change.path.startsWith("src/email-worker/")) ? ["@alook/email-worker"] : null
  return createExecutionPlan(changes, {
    ...options,
    nativeTasks: { inventory: nativeInventory, affected: nativeInventory.filter(task => !selected || selected.includes(task.package.name)) },
  })
}

function coveredFile(path: string, covered = true) {
  return {
    path,
    statementMap: { "0": { start: { line: 1, column: 0 }, end: { line: 1, column: 1 } } },
    s: { "0": covered ? 1 : 0 },
    fnMap: {},
    f: {},
    branchMap: {},
    b: {},
  }
}

function resignPlan(value) {
  const { plan_hash: _ignored, ...unsigned } = value
  return {
    ...value,
    plan_hash: createHash("sha256").update(stablePlanJson(unsigned)).digest("hex"),
  }
}

describe("verifyCoveragePlan", () => {
  it("rejects corrupt counters independently of informational coverage percentages", () => {
    const changed = "src/email-worker/src/index.ts"
    const plan = buildExecutionPlan([{ status: "M", path: changed }], { baseSha, headSha })
    const corrupt = coveredFile(changed)
    corrupt.s["0"] = Number.NaN
    expect(() => verifyCoveragePlan(plan, { [changed]: corrupt })).toThrow("invalid Istanbul s counter")
    expect(() => verifyCoveragePlan(plan, { [changed]: { path: changed } })).toThrow("invalid Istanbul s map")
  })
  it("audits the type-only navigation model without waiving the project denominator", () => {
    const changed = "src/web/src/lib/community/models/navigation.ts"
    const runtime = "src/web/src/lib/config.ts"
    const plan = buildExecutionPlan([{ status: "M", path: changed }], { baseSha, headSha })
    expect(verifyCoveragePlan(plan, { [runtime]: coveredFile(runtime) }))
      .toMatchObject({ type_only_changed_files: [changed] })
    expect(() => verifyCoveragePlan(plan, {})).toThrow("nonempty denominator")
  })

  it.each([
    ["extra empty statement", "import type { Foo } from './foo'; export type Bar = Foo; export interface Item { id: string };", false],
    ["type exports", "export type { Foo } from './foo'; export type * from './bar';", true],
    ["types and interfaces", "import type { Foo } from './foo'; export type Bar = Foo; export interface Item { id: string }", true],
    ["runtime value", "export type Foo = string; export const value = 1;", false],
    ["side-effect import", "import './setup'; export type Foo = string;", false],
    ["value import", "import { Foo } from './foo'; export type Bar = Foo;", false],
    ["enum", "export enum Foo { Bar }", false],
    ["namespace", "export namespace Foo { export const bar = 1 }", false],
    ["invalid syntax", "export type Foo = ;", false],
    ["empty source", "", false],
  ])("handles %s conservatively", (_name, source, typeOnly) => {
    const root = mkdtempSync(join(tmpdir(), "alook-coverage-types-"))
    const changed = "src/web/src/types.ts"
    const runtime = "src/web/src/lib/config.ts"
    const plan = buildExecutionPlan([{ status: "M", path: changed }], { baseSha, headSha })
    try {
      mkdirSync(join(root, "src/web/src"), { recursive: true })
      writeFileSync(join(root, changed), source)
      const verify = () => verifyCoveragePlan(plan, { [runtime]: coveredFile(runtime) }, { root })
      if (typeOnly) expect(verify().type_only_changed_files).toEqual([changed])
      else expect(verify).toThrow(`required changed coverage file is missing from merged report: ${changed}`)
    } finally {
      rmSync(root, { recursive: true, force: true })
    }
  })

  it.each([
    ["named alias", '"use client"; export { start as download } from "./owner";', true],
    ["star", 'export * from "./owner";', true],
    ["namespace re-export", 'export * as owner from "./owner";', true],
    ["types with forwarding", 'export interface Item { id: string } export { start } from "./owner";', true],
    ["side-effect import", 'import "./setup"; export * from "./owner";', false],
    ["local bindings", 'import { start } from "./owner"; export { start };', false],
    ["executable initializer", 'export * from "./owner"; export const value = run();', false],
    ["function body", 'export * from "./owner"; export function start() {}', false],
    ["export expression", 'export default run();', false],
    ["local export", 'export {};', false],
    ["only directive", '"use client";', false],
    ["late directive", 'export * from "./owner"; "use client";', false],
    ["malformed", 'export { from "./owner";', false],
  ])("audits forwarding modules: %s", (_name, source, forwardingOnly) => {
    const root = mkdtempSync(join(tmpdir(), "alook-coverage-forwarding-"))
    const changed = "src/web/src/barrel.ts"
    const runtime = "src/web/src/owner.ts"
    const plan = buildExecutionPlan([{ status: "M", path: changed }], { baseSha, headSha })
    try {
      mkdirSync(join(root, "src/web/src"), { recursive: true })
      writeFileSync(join(root, changed), source)
      const verify = () => verifyCoveragePlan(plan, { [runtime]: coveredFile(runtime) }, { root })
      if (forwardingOnly) {
        expect(verify()).toMatchObject({ re_export_changed_files: [changed], type_only_changed_files: [] })
        expect(() => verifyCoveragePlan(plan, {}, { root })).toThrow("nonempty denominator")
      } else expect(verify).toThrow(`required changed coverage file is missing from merged report: ${changed}`)
    } finally { rmSync(root, { recursive: true, force: true }) }
  })

  it("does not let a forwarding barrel hide a missing changed implementation", () => {
    const root = mkdtempSync(join(tmpdir(), "alook-coverage-owner-"))
    const barrel = "src/web/src/barrel.ts", owner = "src/web/src/owner.ts"
    const plan = buildExecutionPlan([{ status: "M", path: barrel }, { status: "M", path: owner }], { baseSha, headSha })
    try {
      mkdirSync(join(root, "src/web/src"), { recursive: true })
      writeFileSync(join(root, barrel), '"use client"; export { run } from "./owner";')
      writeFileSync(join(root, owner), 'export function run() { return 1 }')
      expect(() => verifyCoveragePlan(plan, {}, { root })).toThrow(`missing from merged report: ${owner}`)
      expect(verifyCoveragePlan(plan, { [owner]: coveredFile(owner) }, { root })).toMatchObject({ re_export_changed_files: [barrel] })
    } finally { rmSync(root, { recursive: true, force: true }) }
  })

  it("permits an excluded E2E fixture without hiding missing product coverage", () => {
    const fixture = "src/web/src/test/e2e-ui/_fixtures/community-notification-requests.ts"
    const product = "src/web/src/lib/community/message-dispatcher.ts"
    const plan = buildExecutionPlan([
      { status: "A", path: fixture },
      { status: "M", path: product },
    ], { baseSha, headSha })
    const report = { [resolve(product)]: coveredFile(resolve(product)) }
    expect(verifyCoveragePlan(plan, report).required_changed_files).toEqual([product])
    expect(() => verifyCoveragePlan(plan, {
      [resolve("src/web/src/lib/config.ts")]: coveredFile(resolve("src/web/src/lib/config.ts")),
    })).toThrow(`required changed coverage file is missing from merged report: ${product}`)
    const fixtureOnly = buildExecutionPlan([{ status: "A", path: fixture }], { baseSha, headSha })
    expect(() => verifyCoveragePlan(fixtureOnly, {})).toThrow("nonempty denominator")
  })

  it("proves required changed files and a nonempty Codecov project denominator", () => {
    const changed = "src/email-worker/src/index.ts"
    const plan = buildExecutionPlan([{ status: "M", path: changed }], { baseSha, headSha })
    const report = {
      [resolve(changed)]: coveredFile(resolve(changed)),
      [resolve("src/email-worker/src/lib/imap-client.ts")]: coveredFile(resolve("src/email-worker/src/lib/imap-client.ts")),
    }

    const result = verifyCoveragePlan(plan, report)

    expect(result.required_changed_files).toEqual([changed])
    expect(result.targets["email-worker"]).toMatchObject({ files: 2, statements: 2, covered: 2, percent: 100 })
  })

  it("rejects a required surviving changed file missing from the merged report", () => {
    const changed = "src/email-worker/src/index.ts"
    const plan = buildExecutionPlan([{ status: "M", path: changed }], { baseSha, headSha })

    expect(() => verifyCoveragePlan(plan, {
      [resolve("src/email-worker/src/lib/imap-client.ts")]: coveredFile(resolve("src/email-worker/src/lib/imap-client.ts")),
    })).toThrow("required changed coverage file")
  })

  it("rejects a required changed file that is absent from the checked-out head", () => {
    const changed = "src/email-worker/src/index.ts"
    const plan = buildExecutionPlan([{ status: "M", path: changed }], { baseSha, headSha })
    const root = mkdtempSync(join(tmpdir(), "alook-coverage-head-"))
    try {
      expect(() => verifyCoveragePlan(plan, {
        [changed]: coveredFile(changed),
      }, { root })).toThrow("does not exist at head")
    } finally {
      rmSync(root, { recursive: true, force: true })
    }
  })

  it("reports zero project percentages but rejects empty instrumentation", () => {
    const changed = "src/shared/src/semver.ts"
    const plan = buildExecutionPlan([{ status: "M", path: changed }], { baseSha, headSha })
    const testOnlyPlan = buildExecutionPlan(
      [{ status: "M", path: "src/shared/src/logger.test.ts" }],
      { baseSha, headSha },
    )

    expect(() => verifyCoveragePlan(testOnlyPlan, {})).toThrow("nonempty denominator")
    const result = verifyCoveragePlan(plan, {
      [resolve("src/email-worker/src/lib/imap-client.ts")]: coveredFile(resolve("src/email-worker/src/lib/imap-client.ts"), false),
      [resolve("src/email-worker/src/index.ts")]: coveredFile(resolve("src/email-worker/src/index.ts"), false),
      [resolve(changed)]: coveredFile(resolve(changed), false),
      [resolve("src/web/src/lib/config.ts")]: coveredFile(resolve("src/web/src/lib/config.ts"), false),
      [resolve("src/ws-do/src/index.ts")]: coveredFile(resolve("src/ws-do/src/index.ts"), false),
    })
    expect(Object.keys(result.targets).sort()).toEqual(["email-worker", "shared", "web", "ws-do"])
    for (const target of Object.values(result.targets)) {
      expect(target).toMatchObject({ covered: 0, percent: 0 })
      expect(target.statements).toBeGreaterThan(0)
    }
  })

  it("rejects targets absent from the Codecov contract", () => {
    const changed = "src/email-worker/src/index.ts"
    const plan = buildExecutionPlan([{ status: "M", path: changed }], { baseSha, headSha })
    const invalid = structuredClone(plan)
    invalid.coverage.targets = ["future"]

    expect(() => verifyCoveragePlan(resignPlan(invalid), {
      [resolve(changed)]: coveredFile(resolve(changed)),
    })).toThrow("execution plan projections do not match native tasks and event policy")
  })

  it("writes a zero-coverage report through the real CLI without a percentage failure", () => {
    const changed = "src/email-worker/src/index.ts"
    const plan = buildExecutionPlan([{ status: "M", path: changed }], { baseSha, headSha })
    const directory = mkdtempSync(join(tmpdir(), "alook-coverage-plan-"))
    const planPath = join(directory, "plan.json")
    const reportPath = join(directory, "coverage.json")
    const outputPath = join(directory, "manifest.json")
    try {
      writeFileSync(planPath, JSON.stringify(plan))
      writeFileSync(reportPath, JSON.stringify({
        [resolve(changed)]: coveredFile(resolve(changed), false),
      }))
      const args = [
        "--plan", planPath,
        "--report", reportPath,
        "--output", outputPath,
        "--unused-value", "ignored",
      ]
      execFileSync(process.execPath, ["scripts/ci/verify-coverage-plan.mjs", ...args], { stdio: "pipe" })
      expect(JSON.parse(readFileSync(outputPath, "utf8"))).toMatchObject({
        plan_hash: plan.plan_hash,
        required_changed_files: [changed],
        targets: { "email-worker": { statements: 1, covered: 0, percent: 0 } },
      })
    } finally {
      rmSync(directory, { recursive: true, force: true })
    }
  })

  it("requires every CLI input path", () => {
    expect(() => runCli([])).toThrow("--plan, --report, and --output")
  })
})