siftlode/frontend/src/lib/downloads.test.ts

// @vitest-environment jsdom
//
// One-click share: quickShareLink turns the row's Share button into a single action —
// ensure a public link (mint on demand, downloadable), copy it, and toast with an "open in new
// tab" action. These pin the branch matrix: reuse-vs-mint, copy-ok-vs-fail, and the create-failure path.
import { describe, it, expect, beforeEach, vi } from "vitest";
import { QueryClient } from "@tanstack/react-query";

// vi.mock is hoisted above these consts, so the mock fns must live in a hoisted block too.
const { downloadLinks, createDownloadLink, folderLinks, createFolderLink, copyText, notify } =
  vi.hoisted(() => ({
    downloadLinks: vi.fn(),
    createDownloadLink: vi.fn(),
    folderLinks: vi.fn(),
    createFolderLink: vi.fn(),
    copyText: vi.fn(),
    notify: vi.fn(),
  }));

vi.mock("./api", () => ({
  api: { downloadLinks, createDownloadLink, folderLinks, createFolderLink },
}));
vi.mock("./clipboard", () => ({ copyText }));
vi.mock("./notifications", () => ({ notify }));

import { quickShareLink } from "./downloads";
import { qk } from "./queryKeys";

const t = (k: string) => k;
const origin = window.location.origin;

type ToastArg = {
  level: string;
  message: string;
  action?: { label: string; onClick: () => void };
};
const firstToast = () => notify.mock.calls[0]![0] as ToastArg;

function qc() {
  return new QueryClient({ defaultOptions: { queries: { retry: false } } });
}

beforeEach(() => {
  downloadLinks.mockReset();
  createDownloadLink.mockReset();
  folderLinks.mockReset();
  createFolderLink.mockReset();
  copyText.mockReset().mockResolvedValue(true);
  notify.mockReset();
});

describe("quickShareLink", () => {
  it("mints a downloadable link on demand, copies it, and toasts with an open-in-new-tab action", async () => {
    downloadLinks.mockResolvedValue([]); // none yet
    createDownloadLink.mockResolvedValue({ id: 7, url: "/watch/tok7" });
    const openSpy = vi.spyOn(window, "open").mockReturnValue(null);

    const url = await quickShareLink(qc(), { kind: "file", id: 42 }, t);

    expect(url).toBe(`${origin}/watch/tok7`);
    // Minted with an EMPTY body so the backend default (allow_download=true) applies.
    expect(createDownloadLink).toHaveBeenCalledWith(42, {});
    expect(copyText).toHaveBeenCalledWith(`${origin}/watch/tok7`);
    const arg = firstToast();
    expect(arg.level).toBe("success");
    expect(arg.message).toBe("downloads.share.linkCopied");
    expect(arg.action!.label).toBe("downloads.share.openNewTab");
    arg.action!.onClick();
    expect(openSpy).toHaveBeenCalledWith(`${origin}/watch/tok7`, "_blank", "noopener,noreferrer");
  });

  it("reuses an existing link instead of minting a duplicate", async () => {
    downloadLinks.mockResolvedValue([{ id: 3, url: "/watch/old" }]);

    const url = await quickShareLink(qc(), { kind: "file", id: 1 }, t);

    expect(url).toBe(`${origin}/watch/old`);
    expect(createDownloadLink).not.toHaveBeenCalled();
    expect(firstToast().level).toBe("success");
  });

  it("passes over a link whose address the server can no longer show", async () => {
    downloadLinks.mockResolvedValue([
      { id: 4, url: null },
      { id: 3, url: "/watch/older" },
    ]);

    const url = await quickShareLink(qc(), { kind: "file", id: 1 }, t);

    expect(url).toBe(`${origin}/watch/older`);
    expect(createDownloadLink).not.toHaveBeenCalled();
  });

  it("mints a new link when none it has can be shown, keeping the old ones listed", async () => {
    const hidden = { id: 4, url: null };
    downloadLinks.mockResolvedValue([hidden]);
    createDownloadLink.mockResolvedValue({ id: 8, url: "/watch/new" });
    const client = qc();

    const url = await quickShareLink(client, { kind: "file", id: 6 }, t);

    expect(url).toBe(`${origin}/watch/new`);
    expect(copyText).toHaveBeenCalledWith(`${origin}/watch/new`);
    expect(client.getQueryData(qk.downloadLinks(6))).toEqual([
      { id: 8, url: "/watch/new" },
      hidden,
    ]);
  });

  it("a folder's link is the folder's own: listed, made and cached under the folder", async () => {
    folderLinks.mockResolvedValue([]);
    createFolderLink.mockResolvedValue({ id: 9, url: "/watch/fold" });
    const client = qc();
    client.setQueryData(qk.fileFolders(), []);

    const url = await quickShareLink(client, { kind: "folder", id: 5 }, t);

    expect(url).toBe(`${origin}/watch/fold`);
    expect(folderLinks).toHaveBeenCalledWith(5);
    expect(createFolderLink).toHaveBeenCalledWith(5, {});
    expect(downloadLinks).not.toHaveBeenCalled();
    expect(createDownloadLink).not.toHaveBeenCalled();
    expect(client.getQueryData(qk.folderLinks(5))).toEqual([{ id: 9, url: "/watch/fold" }]);
    // The rail's mark of a shared folder is asked for again.
    expect(client.getQueryState(qk.fileFolders())!.isInvalidated).toBe(true);
  });

  it("still toasts (warning) with the open action when the clipboard copy fails", async () => {
    downloadLinks.mockResolvedValue([{ id: 5, url: "/watch/x" }]);
    copyText.mockResolvedValue(false);

    const url = await quickShareLink(qc(), { kind: "file", id: 2 }, t);

    expect(url).toBe(`${origin}/watch/x`); // the link is never a dead end
    const arg = firstToast();
    expect(arg.level).toBe("warning");
    expect(arg.message).toBe("downloads.share.copyFailed");
    expect(arg.action!.label).toBe("downloads.share.openNewTab");
  });

  it("reports an error and returns null when link creation fails", async () => {
    downloadLinks.mockResolvedValue([]);
    createDownloadLink.mockRejectedValue(new Error("boom"));

    const url = await quickShareLink(qc(), { kind: "file", id: 9 }, t);

    expect(url).toBeNull();
    expect(copyText).not.toHaveBeenCalled();
    // Titled with what failed, and carrying why (notifyActionError), not a bare message.
    expect(notify).toHaveBeenCalledWith(
      expect.objectContaining({ level: "error", title: "downloads.share.linkFailed" }),
    );
  });
});