import { EnvironmentId } from "@t3tools/contracts";import { describe, expect, it, vi } from "vite-plus/test"; import {  composerAttachmentUploadBlockReason,  composerAttachmentUploadKey,  composerDraftEnvironmentId,  createComposerAttachmentUploadQueue,  type ComposerAttachmentUploadRequest,  type ComposerAttachmentUploadState,} from "./composerAttachmentUploadQueue"; const environmentId = EnvironmentId.make("environment-1");function request(id: string, environment = environmentId): ComposerAttachmentUploadRequest {  return {    environmentId: environment,    attachment: {      id,      type: "file",      name: `${id}.pdf`,      mimeType: "application/pdf",      sizeBytes: 42,      fileUri: `file:///documents/${id}.pdf`,    },  };} describe("composer attachment upload queue", () => {  it("bounds concurrency, deduplicates updates, and drains all attachments", async () => {    const gates = new Map<string, ReturnType<typeof Promise.withResolvers<boolean>>>();    const fourthStarted = Promise.withResolvers<void>();    const firstThreeStarted = Promise.withResolvers<void>();    let active = 0;    let maximum = 0;    const upload = vi.fn(async (input: ComposerAttachmentUploadRequest) => {      active += 1;      maximum = Math.max(maximum, active);      const gate = Promise.withResolvers<boolean>();      gates.set(input.attachment.id, gate);      if (gates.size === 3) firstThreeStarted.resolve();      if (gates.size === 4) fourthStarted.resolve();      try {        return await gate.promise;      } finally {        active -= 1;      }    });    const queue = createComposerAttachmentUploadQueue({ upload, onChange: () => {} });    const requests = [request("one"), request("two"), request("three"), request("four")];    queue.sync(requests);    queue.sync(requests);    await firstThreeStarted.promise;    expect(upload).toHaveBeenCalledTimes(3);    gates.get("one")!.resolve(true);    await fourthStarted.promise;    for (const gate of gates.values()) gate.resolve(true);    await queue.settled();    queue.sync(requests);    await queue.settled();    expect(maximum).toBe(3);    expect(upload).toHaveBeenCalledTimes(4);    queue.dispose();  });   it("cancels on disconnect and resumes from the same local draft on reconnect", async () => {    const started = Promise.withResolvers<void>();    let states: Readonly<Record<string, ComposerAttachmentUploadState>> = {};    let signal: AbortSignal | undefined;    const upload = vi.fn(      async (_request: ComposerAttachmentUploadRequest, currentSignal: AbortSignal) => {        signal = currentSignal;        started.resolve();        return new Promise<boolean>((resolve) =>          currentSignal.addEventListener("abort", () => resolve(false), { once: true }),        );      },    );    const queue = createComposerAttachmentUploadQueue({      upload,      onChange: (next) => {        states = next;      },    });    const local = request("offline-draft");    queue.sync([local]);    await started.promise;    queue.sync([]);    await queue.settled();    expect(signal?.aborted).toBe(true);    expect(states).toEqual({});    upload.mockResolvedValueOnce(true);    queue.sync([local]);    await queue.settled();    expect(upload.mock.calls[1]?.[0]).toBe(local);    expect(states[composerAttachmentUploadKey(environmentId, local.attachment.id)]).toEqual({      status: "ready",    });    expect(local.attachment).toMatchObject({ fileUri: "file:///documents/offline-draft.pdf" });    queue.dispose();  });   it("ignores a late completion after removal or environment switch", async () => {    const gate = Promise.withResolvers<boolean>();    const started = Promise.withResolvers<void>();    let states: Readonly<Record<string, ComposerAttachmentUploadState>> = {};    const upload = vi.fn(async () => {      started.resolve();      return gate.promise;    });    const queue = createComposerAttachmentUploadQueue({      upload,      onChange: (next) => {        states = next;      },    });    queue.sync([request("photo")]);    await started.promise;    upload.mockResolvedValueOnce(true);    const other = EnvironmentId.make("environment-2");    queue.sync([request("photo", other)]);    gate.resolve(true);    await queue.settled();    expect(states).toEqual({ [composerAttachmentUploadKey(other, "photo")]: { status: "ready" } });    queue.sync([]);    expect(states).toEqual({});    queue.dispose();  });   it("restarts a re-added attachment after its aborted transfer finishes settling", async () => {    const firstStarted = Promise.withResolvers<void>();    const firstSettled = Promise.withResolvers<boolean>();    const secondStarted = Promise.withResolvers<void>();    const secondSettled = Promise.withResolvers<boolean>();    let states: Readonly<Record<string, ComposerAttachmentUploadState>> = {};    let firstSignal: AbortSignal | undefined;    const upload = vi.fn(async (_request: ComposerAttachmentUploadRequest, signal: AbortSignal) => {      if (!firstSignal) {        firstSignal = signal;        firstStarted.resolve();        return firstSettled.promise;      }      secondStarted.resolve();      return secondSettled.promise;    });    const queue = createComposerAttachmentUploadQueue({      upload,      onChange: (next) => {        states = next;      },    });    const local = request("re-added");    queue.sync([local]);    await firstStarted.promise;    queue.sync([]);    queue.sync([local]);    expect(firstSignal?.aborted).toBe(true);    expect(upload).toHaveBeenCalledOnce();    firstSettled.resolve(false);    await secondStarted.promise;    expect(upload).toHaveBeenCalledTimes(2);    secondSettled.resolve(true);    await queue.settled();    expect(states[composerAttachmentUploadKey(environmentId, local.attachment.id)]).toEqual({      status: "ready",    });    queue.dispose();  });   it("keeps failures stable until retry and reports bounded progress", async () => {    let states: Readonly<Record<string, ComposerAttachmentUploadState>> = {};    const progress: number[] = [];    const upload = vi.fn(      async (        _request: ComposerAttachmentUploadRequest,        _signal: AbortSignal,        report: (value: number) => void,      ): Promise<boolean> => {        report(0.12);        report(0.13);        report(1.1);        throw new Error("Server unavailable");      },    );    const queue = createComposerAttachmentUploadQueue({      upload,      onChange: (next) => {        states = next;        const state = next[composerAttachmentUploadKey(environmentId, "file")];        if (state?.status === "uploading") progress.push(state.progress);      },    });    queue.sync([request("file")]);    await queue.settled();    queue.sync([request("file")]);    expect(upload).toHaveBeenCalledOnce();    expect(states[composerAttachmentUploadKey(environmentId, "file")]).toEqual({      status: "failed",      reason: "Server unavailable",    });    expect(progress).toEqual([0, 0.1, 1]);    upload.mockImplementationOnce(async () => true);    queue.retry(environmentId, "file");    await queue.settled();    expect(states[composerAttachmentUploadKey(environmentId, "file")]).toEqual({ status: "ready" });    queue.dispose();  });   it("does not spin when an upload's draft was abandoned before persistence", async () => {    const upload = vi.fn(async () => false);    const queue = createComposerAttachmentUploadQueue({ upload, onChange: () => {} });    queue.sync([request("discarded")]);    await queue.settled();    expect(upload).toHaveBeenCalledOnce();    queue.dispose();  });}); describe("draft upload scope and offline submission", () => {  it("resolves thread, new-task, and queued-task drafts without crossing environments", () => {    expect(composerDraftEnvironmentId("environment-1:thread", [])).toBe(environmentId);    expect(composerDraftEnvironmentId("new-task:environment-1:project", [])).toBe(environmentId);    expect(      composerDraftEnvironmentId("pending-task:message", [{ messageId: "message", environmentId }]),    ).toBe(environmentId);    expect(composerDraftEnvironmentId("pending-task:missing", [])).toBeNull();    const colonEnvironment = EnvironmentId.make("a:vcs-status:b");    expect(composerDraftEnvironmentId(`${colonEnvironment}:thread`, [])).toBe(colonEnvironment);    expect(composerDraftEnvironmentId(`new-task:${colonEnvironment}:project`, [])).toBe(      colonEnvironment,    );  });   it("allows offline queuing while a connected composer waits for upload or retry", () => {    const key = composerAttachmentUploadKey(environmentId, "file");    const input = {      environmentId,      attachments: [request("file").attachment],      connected: true,      serverConfig: {        environment: {          capabilities: { attachmentUploads: true, fileAttachments: { maxUploadBytes: 1024 } },        },      },      states: {},    };    expect(composerAttachmentUploadBlockReason(input)).toBe("Attachment still uploading");    expect(composerAttachmentUploadBlockReason({ ...input, connected: false })).toBeNull();    expect(      composerAttachmentUploadBlockReason({        ...input,        states: { [key]: { status: "failed", reason: "Offline" } },      }),    ).toBe("Retry or remove the failed attachment");    expect(      composerAttachmentUploadBlockReason({ ...input, states: { [key]: { status: "ready" } } }),    ).toBeNull();  });});