f1c9907
@@ -0,0 +1,199 @@
/**
 * The `variant` tool through `/mcp` with real tokens (#7166): like or dislike
 * only, a later vote replaces the earlier, a dislike closes the pull with its
 * reason as its one comment; a pull that is not a variant, or one the caller
 * cannot read, is refused with nothing changed.
 */
import { afterAll, beforeAll, describe, expect, test } from "bun:test";
import { mkdtemp, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { createApp, type App } from "../src/app.ts";
import { openPull } from "../src/actions/pulls.ts";
import { commitToBranch, createRepo } from "../src/actions/repos.ts";
import { listDecisions } from "../src/core/decisions.ts";
import { listComments } from "../src/core/issues.ts";
import { getPull } from "../src/core/pulls.ts";
import type { Repo } from "../src/core/repos.ts";
import { createToken } from "../src/core/tokens.ts";
import { createUser, type User } from "../src/core/users.ts";
import { serve, type Servers } from "../src/http/server.ts";
import { quietLogs } from "./helpers/globals.ts";
import { promote } from "./helpers/members.ts";
quietLogs();
describe("MCP variant", () => {
  let dataDir: string;
  let app: App;
  let servers: Servers;
  let cy: User;
  let pub: Repo;
  let hid: Repo;
  let cyToken = "";
  let eveToken = "";
  let id = 1;
  let n = 0;
  const call = async (token: string, args: Record<string, unknown>) => {
    const res = await fetch(`${servers.url}/mcp`, {
      method: "POST",
      headers: {
        "content-type": "application/json",
        accept: "application/json, text/event-stream",
        authorization: `Bearer ${token}`,
      },
      body: JSON.stringify({
        jsonrpc: "2.0",
        id: id++,
        method: "tools/call",
        params: { name: "variant", arguments: args },
      }),
    });
    const body = (await res.json()) as any;
    if (body.error) return { text: body.error.message as string, error: true };
    return { text: body.result.content[0].text as string, error: body.result.isError === true };
  };
  const pull = async (repo: Repo, group: string | null) => {
    const branch = `b${++n}`;
    const c = await commitToBranch(app, cy, repo, {
      branch,
      message: branch,
      files: [{ path: `${branch}.md`, content: "x\n" }],
    });
    if (!c.ok) throw new Error(JSON.stringify(c.error));
    const o = await openPull(app, cy, repo, {
      title: `Try ${branch}`,
      baseBranch: "main",
      headBranch: branch,
      ...(group === null ? {} : { variantGroup: group }),
    });
    if (!o.ok) throw new Error(String(o.error));
    return o.value;
  };
  const votes = (repo: Repo, issueId: string) =>
    listDecisions(app.db, repo.id, { kind: "lean" }).filter((r) => r.issueId === issueId);
  const comments = (issueId: string) => listComments(app.db, issueId);
  beforeAll(async () => {
    dataDir = await mkdtemp(join(tmpdir(), "forge-mcp-variant-"));
    app = createApp({ dataDir, port: 0, host: "forge.test" });
    servers = await serve(app);
    const make = async (username: string, adminIfFirst = false): Promise<User> => {
      const made = await createUser(app.db, {
        origin: "seed",
        trusted: true,
        username,
        email: `${username}@forge.local`,
        password: "a-good-passphrase",
        adminIfFirst,
      });
      if (!made.ok) throw new Error(made.error);
      return made.value;
    };
    await make("ada", true);
    cy = await make("cy");
    promote(app.db, cy);
    const eve = await make("eve");
    const mk = async (name: string, visibility: "public" | "private") => {
      const made = await createRepo(app, cy, { name, visibility, description: "" });
      if (!made.ok) throw new Error(String(made.error));
      const seed = await commitToBranch(app, cy, made.value, {
        message: "seed",
        files: [{ path: "README.md", content: `# ${name}\n` }],
      });
      if (!seed.ok) throw new Error(JSON.stringify(seed.error));
      return made.value;
    };
    pub = await mk("lib", "public");
    hid = await mk("vault", "private");
    cyToken = createToken(app.db, cy.id, "admin", "admin").token;
    eveToken = createToken(app.db, eve.id, "admin", "admin").token;
  }, 60_000);
  afterAll(async () => {
    servers.stop();
    app.close();
    await rm(dataDir, { recursive: true, force: true });
  });
  test("like then dislike leaves one vote, and the pull closed with the reason as its one comment", async () => {
    const sibling = await pull(pub, "g1");
    const target = await pull(pub, "g1");
    const before = comments(target.id).length;
    const liked = await call(cyToken, { repo: "cy/lib", number: target.number, answer: "like" });
    expect(liked.error).toBe(false);
    expect(JSON.parse(liked.text)).toEqual({ answer: "like", closed: false });
    expect(getPull(app.db, pub.id, target.number)!.state).toBe("open");
    expect(votes(pub, target.id).map((v) => v.answer)).toEqual(["like"]);
    const disliked = await call(cyToken, {
      repo: "cy/lib",
      number: target.number,
      answer: "dislike",
      reason: "too noisy",
    });
    expect(disliked.error).toBe(false);
    expect(JSON.parse(disliked.text)).toEqual({ answer: "dislike", closed: true });
    expect(getPull(app.db, pub.id, target.number)!.state).toBe("closed");
    const rows = votes(pub, target.id);
    expect(rows).toHaveLength(1);
    expect(rows[0]!.answer).toBe("dislike");
    const added = comments(target.id).slice(before);
    expect(added).toHaveLength(1);
    expect(added[0]!.body).toContain("too noisy");
    // The sibling is untouched.
    expect(getPull(app.db, pub.id, sibling.number)!.state).toBe("open");
    expect(votes(pub, sibling.id)).toHaveLength(0);
  });
  test("an answer other than like or dislike is invalid_answer and stores no vote", async () => {
    const target = await pull(pub, "g2");
    const before = comments(target.id).length;
    for (const answer of ["meh", "", "LIKE"]) {
      const r = await call(cyToken, { repo: "cy/lib", number: target.number, answer });
      expect(r.error).toBe(true);
      expect(r.text).toContain("invalid_answer");
    }
    expect(votes(pub, target.id)).toHaveLength(0);
    expect(getPull(app.db, pub.id, target.number)!.state).toBe("open");
    expect(comments(target.id).length).toBe(before);
  });
  test("a pull that is not a variant is refused and nothing changes", async () => {
    const plain = await pull(pub, null);
    const before = comments(plain.id).length;
    const r = await call(cyToken, {
      repo: "cy/lib",
      number: plain.number,
      answer: "dislike",
      reason: "no",
    });
    expect(r.error).toBe(true);
    expect(r.text).toContain("not_variant");
    expect(getPull(app.db, pub.id, plain.number)!.state).toBe("open");
    expect(votes(pub, plain.id)).toHaveLength(0);
    expect(comments(plain.id).length).toBe(before);
  });
  test("a pull the caller cannot read is refused and nothing changes", async () => {
    const secret = await pull(hid, "g3");
    const before = comments(secret.id).length;
    const r = await call(eveToken, {
      repo: "cy/vault",
      number: secret.number,
      answer: "dislike",
      reason: "no",
    });
    expect(r.error).toBe(true);
    expect(getPull(app.db, hid.id, secret.number)!.state).toBe("open");
    expect(votes(hid, secret.id)).toHaveLength(0);
    expect(comments(secret.id).length).toBe(before);
    // A pull number that does not exist is refused the same way.
    const missing = await call(cyToken, { repo: "cy/lib", number: 9999, answer: "like" });
    expect(missing.error).toBe(true);
    expect(missing.text).toContain("no_such_pull");
  });
});
		@@ -0,0 +1,199 @@
	1	/**
	2	* The `variant` tool through `/mcp` with real tokens (#7166): like or dislike
	3	* only, a later vote replaces the earlier, a dislike closes the pull with its
	4	* reason as its one comment; a pull that is not a variant, or one the caller
	5	* cannot read, is refused with nothing changed.
	6	*/
	7	import { afterAll, beforeAll, describe, expect, test } from "bun:test";
	8	import { mkdtemp, rm } from "node:fs/promises";
	9	import { tmpdir } from "node:os";
	10	import { join } from "node:path";
	11	import { createApp, type App } from "../src/app.ts";
	12	import { openPull } from "../src/actions/pulls.ts";
	13	import { commitToBranch, createRepo } from "../src/actions/repos.ts";
	14	import { listDecisions } from "../src/core/decisions.ts";
	15	import { listComments } from "../src/core/issues.ts";
	16	import { getPull } from "../src/core/pulls.ts";
	17	import type { Repo } from "../src/core/repos.ts";
	18	import { createToken } from "../src/core/tokens.ts";
	19	import { createUser, type User } from "../src/core/users.ts";
	20	import { serve, type Servers } from "../src/http/server.ts";
	21	import { quietLogs } from "./helpers/globals.ts";
	22	import { promote } from "./helpers/members.ts";
	23
	24	quietLogs();
	25
	26	describe("MCP variant", () => {
	27	let dataDir: string;
	28	let app: App;
	29	let servers: Servers;
	30	let cy: User;
	31	let pub: Repo;
	32	let hid: Repo;
	33	let cyToken = "";
	34	let eveToken = "";
	35	let id = 1;
	36	let n = 0;
	37
	38	const call = async (token: string, args: Record<string, unknown>) => {
	39	const res = await fetch(`${servers.url}/mcp`, {
	40	method: "POST",
	41	headers: {
	42	"content-type": "application/json",
	43	accept: "application/json, text/event-stream",
	44	authorization: `Bearer ${token}`,
	45	},
	46	body: JSON.stringify({
	47	jsonrpc: "2.0",
	48	id: id++,
	49	method: "tools/call",
	50	params: { name: "variant", arguments: args },
	51	}),
	52	});
	53	const body = (await res.json()) as any;
	54	if (body.error) return { text: body.error.message as string, error: true };
	55	return { text: body.result.content[0].text as string, error: body.result.isError === true };
	56	};
	57	const pull = async (repo: Repo, group: string \| null) => {
	58	const branch = `b${++n}`;
	59	const c = await commitToBranch(app, cy, repo, {
	60	branch,
	61	message: branch,
	62	files: [{ path: `${branch}.md`, content: "x\n" }],
	63	});
	64	if (!c.ok) throw new Error(JSON.stringify(c.error));
	65	const o = await openPull(app, cy, repo, {
	66	title: `Try ${branch}`,
	67	baseBranch: "main",
	68	headBranch: branch,
	69	...(group === null ? {} : { variantGroup: group }),
	70	});
	71	if (!o.ok) throw new Error(String(o.error));
	72	return o.value;
	73	};
	74	const votes = (repo: Repo, issueId: string) =>
	75	listDecisions(app.db, repo.id, { kind: "lean" }).filter((r) => r.issueId === issueId);
	76	const comments = (issueId: string) => listComments(app.db, issueId);
	77
	78	beforeAll(async () => {
	79	dataDir = await mkdtemp(join(tmpdir(), "forge-mcp-variant-"));
	80	app = createApp({ dataDir, port: 0, host: "forge.test" });
	81	servers = await serve(app);
	82	const make = async (username: string, adminIfFirst = false): Promise<User> => {
	83	const made = await createUser(app.db, {
	84	origin: "seed",
	85	trusted: true,
	86	username,
	87	email: `${username}@forge.local`,
	88	password: "a-good-passphrase",
	89	adminIfFirst,
	90	});
	91	if (!made.ok) throw new Error(made.error);
	92	return made.value;
	93	};
	94	await make("ada", true);
	95	cy = await make("cy");
	96	promote(app.db, cy);
	97	const eve = await make("eve");
	98	const mk = async (name: string, visibility: "public" \| "private") => {
	99	const made = await createRepo(app, cy, { name, visibility, description: "" });
	100	if (!made.ok) throw new Error(String(made.error));
	101	const seed = await commitToBranch(app, cy, made.value, {
	102	message: "seed",
	103	files: [{ path: "README.md", content: `# ${name}\n` }],
	104	});
	105	if (!seed.ok) throw new Error(JSON.stringify(seed.error));
	106	return made.value;
	107	};
	108	pub = await mk("lib", "public");
	109	hid = await mk("vault", "private");
	110	cyToken = createToken(app.db, cy.id, "admin", "admin").token;
	111	eveToken = createToken(app.db, eve.id, "admin", "admin").token;
	112	}, 60_000);
	113
	114	afterAll(async () => {
	115	servers.stop();
	116	app.close();
	117	await rm(dataDir, { recursive: true, force: true });
	118	});
	119
	120	test("like then dislike leaves one vote, and the pull closed with the reason as its one comment", async () => {
	121	const sibling = await pull(pub, "g1");
	122	const target = await pull(pub, "g1");
	123	const before = comments(target.id).length;
	124
	125	const liked = await call(cyToken, { repo: "cy/lib", number: target.number, answer: "like" });
	126	expect(liked.error).toBe(false);
	127	expect(JSON.parse(liked.text)).toEqual({ answer: "like", closed: false });
	128	expect(getPull(app.db, pub.id, target.number)!.state).toBe("open");
	129	expect(votes(pub, target.id).map((v) => v.answer)).toEqual(["like"]);
	130
	131	const disliked = await call(cyToken, {
	132	repo: "cy/lib",
	133	number: target.number,
	134	answer: "dislike",
	135	reason: "too noisy",
	136	});
	137	expect(disliked.error).toBe(false);
	138	expect(JSON.parse(disliked.text)).toEqual({ answer: "dislike", closed: true });
	139	expect(getPull(app.db, pub.id, target.number)!.state).toBe("closed");
	140	const rows = votes(pub, target.id);
	141	expect(rows).toHaveLength(1);
	142	expect(rows[0]!.answer).toBe("dislike");
	143	const added = comments(target.id).slice(before);
	144	expect(added).toHaveLength(1);
	145	expect(added[0]!.body).toContain("too noisy");
	146	// The sibling is untouched.
	147	expect(getPull(app.db, pub.id, sibling.number)!.state).toBe("open");
	148	expect(votes(pub, sibling.id)).toHaveLength(0);
	149	});
	150
	151	test("an answer other than like or dislike is invalid_answer and stores no vote", async () => {
	152	const target = await pull(pub, "g2");
	153	const before = comments(target.id).length;
	154	for (const answer of ["meh", "", "LIKE"]) {
	155	const r = await call(cyToken, { repo: "cy/lib", number: target.number, answer });
	156	expect(r.error).toBe(true);
	157	expect(r.text).toContain("invalid_answer");
	158	}
	159	expect(votes(pub, target.id)).toHaveLength(0);
	160	expect(getPull(app.db, pub.id, target.number)!.state).toBe("open");
	161	expect(comments(target.id).length).toBe(before);
	162	});
	163
	164	test("a pull that is not a variant is refused and nothing changes", async () => {
	165	const plain = await pull(pub, null);
	166	const before = comments(plain.id).length;
	167	const r = await call(cyToken, {
	168	repo: "cy/lib",
	169	number: plain.number,
	170	answer: "dislike",
	171	reason: "no",
	172	});
	173	expect(r.error).toBe(true);
	174	expect(r.text).toContain("not_variant");
	175	expect(getPull(app.db, pub.id, plain.number)!.state).toBe("open");
	176	expect(votes(pub, plain.id)).toHaveLength(0);
	177	expect(comments(plain.id).length).toBe(before);
	178	});
	179
	180	test("a pull the caller cannot read is refused and nothing changes", async () => {
	181	const secret = await pull(hid, "g3");
	182	const before = comments(secret.id).length;
	183	const r = await call(eveToken, {
	184	repo: "cy/vault",
	185	number: secret.number,
	186	answer: "dislike",
	187	reason: "no",
	188	});
	189	expect(r.error).toBe(true);
	190	expect(getPull(app.db, hid.id, secret.number)!.state).toBe("open");
	191	expect(votes(hid, secret.id)).toHaveLength(0);
	192	expect(comments(secret.id).length).toBe(before);
	193
	194	// A pull number that does not exist is refused the same way.
	195	const missing = await call(cyToken, { repo: "cy/lib", number: 9999, answer: "like" });
	196	expect(missing.error).toBe(true);
	197	expect(missing.text).toContain("no_such_pull");
	198	});
	199	});