import {  ProjectId,  type ThreadPullRequestLink,  type ThreadPullRequestSnapshot,} from "@t3tools/contracts";import { describe, expect, it } from "vite-plus/test"; import {  legacyLinkedPullRequestOf,  legacyThreadPullRequestKey,  threadPullRequestSearchTerms,  resolveThreadCurrentPullRequest,  resolveThreadPullRequestChains,  resolveThreadPullRequestBadge,  threadPullRequestKeysEqual,} from "./threadPullRequests.ts"; function snapshot(input: Partial<ThreadPullRequestSnapshot> = {}): ThreadPullRequestSnapshot {  return {    state: "open",    title: "Change",    headBranch: "feature",    baseBranch: "main",    isDraft: false,    updatedAt: "2026-01-01T00:00:00.000Z",    syncedAt: "2026-01-01T00:00:00.000Z",    ...input,  };} function link(  number: number,  input: Partial<Omit<ThreadPullRequestLink, "number">> = {},): ThreadPullRequestLink {  return {    host: "github.com",    repository: "pingdotgg/t3code",    number,    url: `https://github.com/pingdotgg/t3code/pull/${number}`,    source: "manual",    linkedAt: `2026-01-01T00:00:${String(number).padStart(2, "0")}.000Z`,    snapshot: null,    stack: null,    ...input,  };} describe("threadPullRequestKeysEqual", () => {  it("ignores host and repository case", () => {    expect(      threadPullRequestKeysEqual(        { host: "GitHub.com", repository: "PingDotGG/t3code", number: 1 },        { host: "github.com", repository: "pingdotgg/t3code", number: 1 },      ),    ).toBe(true);    expect(      threadPullRequestKeysEqual(        { host: "github.com", repository: "pingdotgg/t3code", number: 1 },        { host: "gitlab.com", repository: "pingdotgg/t3code", number: 1 },      ),    ).toBe(false);  });}); describe("resolveThreadCurrentPullRequest", () => {  it("returns null with no visible links", () => {    expect(resolveThreadCurrentPullRequest([])).toBeNull();    expect(resolveThreadCurrentPullRequest([link(1, { source: "stack-dismissed" })])).toBeNull();  });   it("treats an unsynced link as open", () => {    expect(resolveThreadCurrentPullRequest([link(1)])).toMatchObject({      kind: "single",      link: { number: 1 },    });  });   it("prefers the single open link over terminal ones", () => {    const current = resolveThreadCurrentPullRequest([      link(1, { snapshot: snapshot({ state: "merged" }) }),      link(2, { snapshot: snapshot({ state: "open" }) }),      link(3, { snapshot: snapshot({ state: "closed" }) }),    ]);    expect(current).toMatchObject({ kind: "single", link: { number: 2 } });  });   it("reports a stack when several links are open and puts the highest layer on top", () => {    const stack = {      kind: "native" as const,      id: "s1",      number: 1,      url: "https://github.com/pingdotgg/t3code/stacks/1",      base: "main",      layers: [        { number: 10, headBranch: "a", state: "open" as const },        { number: 11, headBranch: "b", state: "open" as const },      ],    };    const current = resolveThreadCurrentPullRequest([      link(11, { snapshot: snapshot(), stack }),      link(10, { snapshot: snapshot(), stack }),    ]);    expect(current).toMatchObject({ kind: "stack", top: { number: 11 } });    if (current?.kind === "stack") {      expect(current.open.map((entry) => entry.number)).toEqual([11, 10]);    }  });   it("orders an open set without stack data by most recent link", () => {    const current = resolveThreadCurrentPullRequest([link(1), link(2)]);    expect(current).toMatchObject({ kind: "stack", top: { number: 2 } });  });   it("falls back to the most recently updated terminal link", () => {    const current = resolveThreadCurrentPullRequest([      link(1, { snapshot: snapshot({ state: "merged", updatedAt: "2026-01-03T00:00:00.000Z" }) }),      link(2, { snapshot: snapshot({ state: "closed", updatedAt: "2026-01-02T00:00:00.000Z" }) }),    ]);    expect(current).toMatchObject({ kind: "single", link: { number: 1 } });  });}); describe("legacyLinkedPullRequestOf", () => {  const identity = {    canonicalKey: "github.com/pingdotgg/t3code",    provider: "github",    displayName: "pingdotgg/t3code",    locator: {      source: "git-remote" as const,      remoteName: "origin",      remoteUrl: "https://github.com/pingdotgg/t3code.git",    },  };  it("projects only links the owning project can route without a host", () => {    expect(legacyLinkedPullRequestOf([link(7)], "project-1" as never, identity)).toEqual({      projectId: "project-1",      repository: "pingdotgg/t3code",      number: 7,      url: "https://github.com/pingdotgg/t3code/pull/7",    });    expect(legacyLinkedPullRequestOf([], "project-1" as never, identity)).toBeNull();  });  it.each([    {      host: "github.enterprise.test",      url: "https://github.enterprise.test/pingdotgg/t3code/pull/7",    },    { repository: "acme/other", url: "https://github.com/acme/other/pull/7" },  ])("omits an unsafe legacy route %j", (foreign) => {    expect(      legacyLinkedPullRequestOf([link(7, foreign)], "project-1" as never, identity),    ).toBeNull();    expect(      legacyLinkedPullRequestOf([link(7, foreign), link(8)], "project-1" as never, identity)        ?.number,    ).toBe(8);  });  it.each([    "dev.azure.com/org-a/project/_git/web",    "ssh.dev.azure.com/v3/org-a/project/web",    "org-a.visualstudio.com/DefaultCollection/project/_git/web",  ])("projects Azure links through the legacy selector for %s", (canonicalKey) => {    const azureIdentity = {      ...identity,      provider: "azure-devops",      canonicalKey,      displayName: canonicalKey.slice(canonicalKey.indexOf("/") + 1),      name: "web",    };    const own = link(7, {      host: "dev.azure.com",      repository: "org-a/project/_git/web",      url: "https://dev.azure.com/org-a/project/_git/web/pullrequest/7",    });    const foreign = link(7, {      host: "dev.azure.com",      repository: "web",      url: "https://dev.azure.com/org-b/project/_git/web/pullrequest/7",      linkedAt: "2026-01-02T00:00:00.000Z",    });    for (const repository of ["web", "org-a/project/_git/web"]) {      expect(        legacyLinkedPullRequestOf(          [{ ...own, repository }, foreign],          "project-1" as never,          azureIdentity,        ),      ).toEqual({ projectId: "project-1", repository: "web", number: 7, url: own.url });    }    expect(legacyLinkedPullRequestOf([foreign], "project-1" as never, azureIdentity)).toBeNull();    expect(legacyThreadPullRequestKey({ ...own, repository: "web" })).toEqual({      host: "dev.azure.com",      repository: "org-a/project/_git/web",      number: 7,    });    expect(      threadPullRequestKeysEqual(own, {        host: "org-a.visualstudio.com",        repository: "DefaultCollection/project/_git/web",        number: 7,      }),    ).toBe(true);  });  it("does not guess when the project identity is unavailable", () => {    expect(legacyLinkedPullRequestOf([link(7)], "project-1" as never, null)).toBeNull();  });}); describe("resolveThreadPullRequestChains", () => {  it("chains links by base → head within a repository, bottom to top", () => {    const chains = resolveThreadPullRequestChains([      link(3, { snapshot: snapshot({ headBranch: "c", baseBranch: "b" }) }),      link(1, { snapshot: snapshot({ headBranch: "a", baseBranch: "main" }) }),      link(2, { snapshot: snapshot({ headBranch: "b", baseBranch: "a" }) }),      link(9, { snapshot: snapshot({ headBranch: "solo", baseBranch: "main" }) }),    ]);    expect(chains.map((chain) => [chain.kind, chain.layers.map((layer) => layer.number)])).toEqual([      ["derived", [1, 2, 3]],      ["derived", [9]],    ]);  });   it("uses the native stack order when the host provides one", () => {    const stack = {      kind: "native" as const,      id: "s1",      number: 1,      url: "https://github.com/pingdotgg/t3code/stacks/1",      base: "main",      layers: [        { number: 5, headBranch: "a", state: "merged" as const },        { number: 6, headBranch: "b", state: "open" as const },      ],    };    const chains = resolveThreadPullRequestChains([      link(6, { snapshot: snapshot({ headBranch: "b", baseBranch: "main" }), stack }),      link(5, {        snapshot: snapshot({ state: "merged", headBranch: "a", baseBranch: "main" }),        stack,      }),      link(8),    ]);    expect(chains.map((chain) => [chain.kind, chain.layers.map((layer) => layer.number)])).toEqual([      ["native", [5, 6]],      ["derived", [8]],    ]);  });}); describe("chain selection and badge state", () => {  it.each([    ["open", false, "open", false, "open"],    ["closed", false, "closed", false, "closed"],    ["open", true, "open", true, "draft"],    ["open", false, "open", true, "open"],    ["closed", false, "open", true, "open"],    ["merged", false, "merged", false, "merged"],    ["merged", false, "closed", true, "closed"],  ] as const)(    "aggregates %s (draft %s) and %s (draft %s) as %s",    (firstState, firstDraft, secondState, secondDraft, state) => {      for (const stacked of [false, true]) {        const links = [          link(1, {            snapshot: snapshot({ state: firstState, isDraft: firstDraft, headBranch: "base" }),          }),          link(2, {            snapshot: snapshot({              state: secondState,              isDraft: secondDraft,              baseBranch: stacked ? "base" : "main",            }),          }),          link(3, { source: "stack-dismissed" }),        ];        expect(resolveThreadPullRequestBadge(links)).toEqual(          stacked            ? { kind: "stack", layers: 2, state }            : { kind: "pull-request", others: 1, state },        );      }    },  );   it.each(["open", "merged", "closed"] as const)(    "targets the top of a derived %s chain despite a later bottom update and link",    (state) => {      const bottom = link(2, {        snapshot: snapshot({ state, headBranch: "base", updatedAt: "2026-02-01T00:00:00.000Z" }),      });      const top = link(1, {        snapshot: snapshot({ state, headBranch: "top", baseBranch: "base" }),      });      expect(resolveThreadCurrentPullRequest([bottom, top])).toMatchObject(        state === "open"          ? { kind: "stack", top: { number: 1 }, open: [top, bottom] }          : { kind: "single", link: { number: 1 } },      );      expect(resolveThreadPullRequestBadge([bottom, top])).toEqual({        kind: "stack",        layers: 2,        state,      });    },  );   it("keeps the top native layer after completion and treats an unsynced layer as open", () => {    const stack = {      kind: "native" as const,      id: "native-1",      number: 1,      url: "https://github.com/pingdotgg/t3code/stacks/1",      base: "main",      layers: [        { number: 2, headBranch: "base", state: "merged" as const },        { number: 1, headBranch: "top", state: "merged" as const },      ],    };    const bottom = link(2, {      stack,      snapshot: snapshot({ state: "merged", updatedAt: "2026-02-01T00:00:00.000Z" }),    });    const top = link(1, { stack, snapshot: snapshot({ state: "merged" }) });    expect(resolveThreadCurrentPullRequest([bottom, top])).toMatchObject({      kind: "single",      link: { number: 1 },    });    expect(resolveThreadPullRequestBadge([bottom, { ...top, snapshot: null }])).toEqual({      kind: "stack",      layers: 2,      state: "open",    });  });   it("uses aggregate state and distinguishes unrelated work from a stack", () => {    const bottom = link(1, { snapshot: snapshot({ state: "merged", headBranch: "base" }) });    const top = link(2, { snapshot: snapshot({ state: "closed", baseBranch: "base" }) });    expect(resolveThreadPullRequestBadge([bottom, top])).toEqual({      kind: "stack",      layers: 2,      state: "closed",    });    expect(resolveThreadPullRequestBadge([bottom, top, link(3)])).toEqual({      kind: "pull-request",      others: 2,      state: "open",    });    expect(resolveThreadPullRequestBadge([link(3, { source: "stack-dismissed" })])).toBeNull();  });   it("keeps branch matching case-sensitive while ignoring repository case", () => {    const bottom = link(1, {      repository: "PingDotGG/T3code",      snapshot: snapshot({ headBranch: "Base" }),    });    const top = link(2, { snapshot: snapshot({ headBranch: "top", baseBranch: "base" }) });    expect(resolveThreadPullRequestChains([bottom, top])).toHaveLength(2);    expect(      resolveThreadPullRequestChains([        bottom,        { ...top, snapshot: snapshot({ headBranch: "top", baseBranch: "Base" }) },      ])[0]?.layers,    ).toEqual([bottom, { ...top, snapshot: snapshot({ headBranch: "top", baseBranch: "Base" }) }]);  });   it("preserves cyclic links without presenting a guessed stack order", () => {    const links = [      link(1, { snapshot: snapshot({ headBranch: "a", baseBranch: "b" }) }),      link(2, { snapshot: snapshot({ headBranch: "b", baseBranch: "a" }) }),    ];    expect(resolveThreadPullRequestChains(links).map((chain) => chain.layers)).toEqual(      links.map((entry) => [entry]),    );    expect(resolveThreadCurrentPullRequest(links)).toMatchObject({      kind: "stack",      top: { number: 2 },    });    expect(resolveThreadPullRequestBadge(links)).toEqual({      kind: "pull-request",      others: 1,      state: "open",    });  });   it("does not guess a parent when a head branch was reused", () => {    const links = [      link(1, { snapshot: snapshot({ state: "merged", headBranch: "reused" }) }),      link(2, { snapshot: snapshot({ headBranch: "reused" }) }),      link(3, { snapshot: snapshot({ headBranch: "top", baseBranch: "reused" }) }),    ];    expect(resolveThreadPullRequestChains(links).map((chain) => chain.layers)).toEqual(      links.map((entry) => [entry]),    );  });}); describe("threadPullRequestSearchTerms", () => {  it("includes completed and unsynced links but excludes dismissed links", () => {    const terms = threadPullRequestSearchTerms({      pullRequests: [        link(12, { snapshot: snapshot({ title: "Fix login", state: "merged" }) }),        link(34),        link(56, { source: "stack-dismissed" }),      ],    });    expect(terms).toContain("#12");    expect(terms).toContain("pingdotgg/t3code#12");    expect(terms).toContain("https://github.com/pingdotgg/t3code/pull/12");    expect(terms).toContain("Fix login");    expect(terms).toContain("#34");    expect(terms.join(" ")).not.toContain("56");  });}); it("searches the legacy projection when old environments decode to an empty links list", () => {  const linkedPullRequest = {    projectId: ProjectId.make("project"),    repository: "pingdotgg/t3code",    number: 12,    url: "https://github.com/pingdotgg/t3code/pull/12",  };  expect(threadPullRequestSearchTerms({ pullRequests: [], linkedPullRequest })).toContain("#12");  expect(    threadPullRequestSearchTerms({ pullRequests: [link(34)], linkedPullRequest }),  ).not.toContain("#12");});