Skip to content

armgit / kaneo

Public Imported from GitHub
0

⚡ Project management that doesn't become the project. Boards, Gantt charts, and GitHub integration. Self-host it or use Kaneo Cloud.

21.7 KB
Raw Blame
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import {
  act,
  cleanup,
  fireEvent,
  render,
  screen,
  waitFor,
} from "@testing-library/react";
import {
  afterEach,
  beforeEach,
  describe,
  expect,
  it,
  vi,
} from "vite-plus/test";
import type { SyncPreview } from "@/fetchers/integration-sync/types";
import { useUserPreferencesStore } from "@/store/user-preferences";
import { ResumeSyncDialog } from "./resume-sync-dialog";
import { SyncRulesSection } from "./sync-rules-section";

const mocks = vi.hoisted(() => ({
  get: vi.fn(),
  preview: vi.fn(),
  save: vi.fn(),
  review: vi.fn(),
  resume: vi.fn(),
  canManage: true,
}));
vi.mock("react-i18next", async (importOriginal) => ({
  ...(await importOriginal<typeof import("react-i18next")>()),
  useTranslation: () => ({ t: (key: string) => key }),
}));
vi.mock("@/hooks/use-workspace-permission", () => ({
  useWorkspacePermission: () => ({
    canManageSettings: () => mocks.canManage,
    canUpdateTasks: () => mocks.canManage,
  }),
}));
vi.mock("@/fetchers/integration-sync/get-sync-rules", () => ({
  default: mocks.get,
}));
vi.mock("@/fetchers/integration-sync/preview-sync-rules", () => ({
  default: mocks.preview,
}));
vi.mock("@/fetchers/integration-sync/save-sync-rules", () => ({
  default: mocks.save,
}));
vi.mock("@/fetchers/integration-sync/review-sync-resume", () => ({
  default: mocks.review,
}));
vi.mock("@/fetchers/integration-sync/resume-sync", () => ({
  default: mocks.resume,
}));
vi.mock("@/lib/toast", () => ({ toast: { success: vi.fn() } }));

const param = { projectId: "project-1", provider: "gitea" as const };
const saved: SyncPreview = {
  isActive: true,
  rules: {
    outgoing: { mode: "labels", match: "any", labels: ["label-1"] },
    incoming: { mode: "all" },
  },
  labels: [{ id: "label-1", name: "sync", color: "#123456" }],
  missingLabels: [],
  total: 2,
  matching: 1,
  willCreate: 0,
  willPause: 0,
  needsReview: 0,
  paused: 0,
  matchingTasks: [{ id: "task-1", title: "Matching task", number: 1 }],
  pausedTasks: [],
  pausedNextCursor: null,
  previewToken: "a".repeat(64),
};

beforeEach(() => {
  vi.clearAllMocks();
  mocks.canManage = true;
  useUserPreferencesStore.setState({ advancedSettings: false });
  mocks.get.mockResolvedValue(saved);
  mocks.preview.mockResolvedValue({ ...saved, previewToken: "b".repeat(64) });
  mocks.review.mockResolvedValue({
    task: { id: "task-1", number: 1, title: "Kaneo task" },
    local: { title: "Kaneo title", description: "Local body", state: "open" },
    remote: {
      title: "Repository title",
      description: "Remote body",
      state: "closed",
    },
    token: "c".repeat(64),
  });
});
afterEach(cleanup);
async function openEditor() {
  fireEvent.click(
    await screen.findByRole("button", { name: "settings:syncRules.edit" }),
  );
}
function mount(node = <SyncRulesSection {...param} />) {
  const client = new QueryClient({
    defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
  });
  return {
    client,
    ...render(
      <QueryClientProvider client={client}>{node}</QueryClientProvider>,
    ),
  };
}

describe("advanced sync settings", () => {
  it("keeps a dirty rule draft while loading another paused-task page", async () => {
    useUserPreferencesStore.setState({ advancedSettings: true });
    const initial = {
      ...saved,
      labels: [
        ...saved.labels,
        { id: "label-2", name: "later", color: "#654321" },
      ],
      paused: 30,
      pausedNextCursor: "next-page",
    };
    let release!: () => void;
    const gate = new Promise<void>((resolve) => {
      release = resolve;
    });
    mocks.get.mockImplementation(async (_params, after?: string) => {
      if (after) {
        await gate;
        return { ...initial, pausedNextCursor: null };
      }
      return initial;
    });
    mocks.save.mockResolvedValue(initial);
    mount();
    await openEditor();
    fireEvent.click(await screen.findByRole("checkbox", { name: "later" }));
    await waitFor(() =>
      expect(
        screen.getByRole("button", { name: "settings:syncRules.apply" }),
      ).toBeEnabled(),
    );
    fireEvent.click(
      screen.getByRole("button", { name: "settings:syncRules.reviewPaused" }),
    );
    fireEvent.click(
      screen.getByRole("button", { name: "settings:syncRules.next" }),
    );
    try {
      await waitFor(() =>
        expect(mocks.get).toHaveBeenCalledWith(param, "next-page"),
      );
      expect(screen.getByRole("checkbox", { name: "later" })).toBeChecked();
      expect(
        screen.getByRole("button", { name: "settings:syncRules.next" }),
      ).toBeDisabled();
    } finally {
      await act(async () => {
        release();
      });
    }
    await waitFor(() =>
      expect(
        screen.getByRole("button", { name: "settings:syncRules.next" }),
      ).toBeDisabled(),
    );
    expect(screen.getByRole("checkbox", { name: "later" })).toBeChecked();
    fireEvent.click(
      screen.getByRole("button", { name: "settings:syncRules.apply" }),
    );
    await waitFor(() =>
      expect(mocks.save).toHaveBeenCalledWith(
        param,
        {
          ...saved.rules,
          outgoing: {
            mode: "labels",
            match: "any",
            labels: ["label-1", "label-2"],
          },
        },
        "b".repeat(64),
      ),
    );
  });

  it.each([
    { projectId: "another-project", provider: "gitea" as const },
    { projectId: param.projectId, provider: "github" as const },
  ])(
    "does not show a previous integration's data while changing scope to %j",
    async (nextParam) => {
      useUserPreferencesStore.setState({ advancedSettings: true });
      let release!: () => void;
      const gate = new Promise<void>((resolve) => {
        release = resolve;
      });
      mocks.get.mockImplementation(async (scope) => {
        if (
          scope.projectId === nextParam.projectId &&
          scope.provider === nextParam.provider
        )
          await gate;
        return saved;
      });
      const { client, rerender } = mount();
      await openEditor();
      await screen.findByRole("checkbox", { name: "sync" });
      rerender(
        <QueryClientProvider client={client}>
          <SyncRulesSection {...nextParam} />
        </QueryClientProvider>,
      );
      try {
        await waitFor(() =>
          expect(mocks.get).toHaveBeenCalledWith(nextParam, undefined),
        );
        expect(screen.queryByRole("checkbox", { name: "sync" })).toBeNull();
        expect(screen.getByRole("status")).toHaveTextContent(
          "settings:syncRules.loading",
        );
      } finally {
        await act(async () => {
          release();
        });
      }
    },
  );

  it.each(["apply", "reload"])(
    "keeps a dirty draft after shared rules change until %s",
    async (choice) => {
      useUserPreferencesStore.setState({ advancedSettings: true });
      const initial = {
        ...saved,
        labels: [
          ...saved.labels,
          { id: "label-2", name: "later", color: "#654321" },
        ],
      };
      mocks.get.mockResolvedValue(initial);
      const { client } = mount();
      await openEditor();
      fireEvent.click(await screen.findByRole("checkbox", { name: "later" }));
      const draft = {
        ...saved.rules,
        outgoing: {
          mode: "labels",
          match: "any",
          labels: ["label-1", "label-2"],
        },
      };
      act(() =>
        client.setQueryData(
          ["integration-sync", param.projectId, param.provider, ""],
          {
            ...initial,
            rules: { outgoing: { mode: "all" }, incoming: { mode: "all" } },
          },
        ),
      );
      await screen.findByText("settings:syncRules.rulesChanged");
      expect(screen.getByRole("checkbox", { name: "sync" })).toBeChecked();
      expect(screen.getByRole("checkbox", { name: "later" })).toBeChecked();
      expect(mocks.save).not.toHaveBeenCalled();
      if (choice === "reload") {
        fireEvent.click(
          screen.getByRole("button", {
            name: "settings:syncRules.loadSavedRules",
          }),
        );
        expect(screen.queryByRole("checkbox")).toBeNull();
        expect(
          screen.queryByText("settings:syncRules.rulesChanged"),
        ).toBeNull();
        expect(mocks.save).not.toHaveBeenCalled();
      } else {
        const apply = screen.getByRole("button", {
          name: "settings:syncRules.apply",
        });
        await waitFor(() => expect(apply).toBeEnabled());
        fireEvent.click(apply);
        await waitFor(() =>
          expect(mocks.save).toHaveBeenCalledWith(param, draft, "b".repeat(64)),
        );
      }
    },
  );

  it("adopts refreshed shared rules when the editor has no draft changes", async () => {
    useUserPreferencesStore.setState({ advancedSettings: true });
    const { client } = mount();
    await openEditor();
    await screen.findByRole("checkbox", { name: "sync" });
    act(() =>
      client.setQueryData(
        ["integration-sync", param.projectId, param.provider, ""],
        {
          ...saved,
          rules: { outgoing: { mode: "all" }, incoming: { mode: "all" } },
        },
      ),
    );
    await waitFor(() => expect(screen.queryByRole("checkbox")).toBeNull());
    expect(screen.queryByText("settings:syncRules.rulesChanged")).toBeNull();
    expect(
      screen.getByRole("button", { name: "settings:syncRules.apply" }),
    ).toBeDisabled();
  });

  it("invalidates a cached rule preview after resuming a link", async () => {
    const { client } = mount(
      <ResumeSyncDialog
        param={param}
        linkId="link-1"
        taskId="task-1"
        onClose={vi.fn()}
      />,
    );
    const key = [
      "integration-sync-preview",
      param.projectId,
      param.provider,
      saved.rules,
    ];
    client.setQueryData(key, { ...saved, paused: 1, needsReview: 1 });
    await screen.findByText("Kaneo title");
    fireEvent.click(
      screen.getByRole("button", { name: "settings:syncRules.useKaneo" }),
    );
    await waitFor(() =>
      expect(client.getQueryState(key)?.isInvalidated).toBe(true),
    );
  });
  it("removes unavailable labels without resetting valid selections or match mode", async () => {
    useUserPreferencesStore.setState({ advancedSettings: true });
    mocks.get.mockResolvedValue({
      ...saved,
      missingLabels: ["deleted-label"],
      rules: {
        ...saved.rules,
        outgoing: {
          mode: "labels",
          match: "all",
          labels: ["label-1", "deleted-label"],
        },
      },
    });
    mount();
    await openEditor();
    fireEvent.click(
      await screen.findByRole("button", {
        name: "settings:syncRules.removeMissingLabels",
      }),
    );
    expect(screen.getByRole("checkbox", { name: "sync" })).toBeChecked();
    const apply = screen.getByRole("button", {
      name: "settings:syncRules.apply",
    });
    await waitFor(() => expect(apply).toBeEnabled());
    fireEvent.click(apply);
    await waitFor(() =>
      expect(mocks.save).toHaveBeenCalledWith(
        param,
        {
          ...saved.rules,
          outgoing: { mode: "labels", match: "all", labels: ["label-1"] },
        },
        "b".repeat(64),
      ),
    );
  });

  it("refreshes an open comparison and submits its new token after invalidation", async () => {
    const { client } = mount(
      <ResumeSyncDialog
        param={param}
        linkId="link-1"
        taskId="task-1"
        onClose={vi.fn()}
      />,
    );
    await screen.findByText("Kaneo title");
    mocks.review.mockResolvedValueOnce({
      task: { id: "task-1", number: 1, title: "Kaneo task" },
      local: {
        title: "Live Kaneo title",
        description: "Local body",
        state: "open",
      },
      remote: {
        title: "Repository title",
        description: "Remote body",
        state: "closed",
      },
      token: "d".repeat(64),
    });
    await act(async () => {
      await client.invalidateQueries({
        queryKey: ["integration-sync-review", param.projectId],
      });
    });
    expect(await screen.findByText("Live Kaneo title")).toBeVisible();
    expect(screen.queryByText("Kaneo title")).toBeNull();
    fireEvent.click(
      screen.getByRole("button", { name: "settings:syncRules.useKaneo" }),
    );
    await waitFor(() =>
      expect(mocks.resume).toHaveBeenCalledWith(
        param,
        "link-1",
        "d".repeat(64),
        "kaneo",
      ),
    );
  });

  it("refreshes cached issue metadata after saving rules", async () => {
    useUserPreferencesStore.setState({ advancedSettings: true });
    mocks.get.mockResolvedValue({ ...saved, willCreate: 1 });
    const { client } = mount();
    client.setQueryData(["external-links", "task-1"], [{ metadata: "{}" }]);
    await openEditor();
    const apply = await screen.findByRole("button", {
      name: "settings:syncRules.exportPending",
    });
    await waitFor(() => expect(apply).toBeEnabled());
    fireEvent.click(apply);
    await waitFor(() =>
      expect(
        client.getQueryState(["external-links", "task-1"])?.isInvalidated,
      ).toBe(true),
    );
  });

  it("shows a retry after a failed refresh even when rules were cached", async () => {
    const { client } = mount();
    await screen.findByText("settings:syncRules.tasksLabelled");
    mocks.get.mockRejectedValueOnce(new Error("Unavailable"));
    await act(async () => {
      await client.invalidateQueries({ queryKey: ["integration-sync"] });
    });
    expect(
      await screen.findByText("settings:syncRules.loadError"),
    ).toBeVisible();
    expect(screen.queryByText("settings:syncRules.tasksLabelled")).toBeNull();
    fireEvent.click(
      screen.getByRole("button", { name: "settings:codeHosting.retry" }),
    );
    expect(
      await screen.findByText("settings:syncRules.tasksLabelled"),
    ).toBeVisible();
  });

  it("stops at 50 labels while allowing a selected label to be removed", async () => {
    useUserPreferencesStore.setState({ advancedSettings: true });
    const labels = Array.from({ length: 51 }, (_, i) => ({
      id: `label-${i + 1}`,
      name: `Label ${i + 1}`,
      color: "#123456",
    }));
    mocks.get.mockResolvedValue({
      ...saved,
      labels,
      rules: {
        ...saved.rules,
        outgoing: {
          mode: "labels",
          match: "any",
          labels: labels.slice(0, 50).map((label) => label.id),
        },
      },
    });
    mount();
    await openEditor();
    const extra = await screen.findByRole("checkbox", { name: "Label 51" });
    expect(extra).toHaveAttribute("aria-disabled", "true");
    fireEvent.click(extra);
    expect(extra).not.toBeChecked();
    const selected = screen.getByRole("checkbox", { name: "Label 1" });
    expect(selected).not.toHaveAttribute("aria-disabled", "true");
    fireEvent.click(selected);
    expect(extra).not.toHaveAttribute("aria-disabled", "true");
    fireEvent.click(extra);
    expect(selected).toHaveAttribute("aria-disabled", "true");
    expect(extra).toBeChecked();
  });

  it("offers an explicit retry for eligible tasks without an issue link", async () => {
    useUserPreferencesStore.setState({ advancedSettings: true });
    mocks.get.mockResolvedValue({ ...saved, willCreate: 1 });
    mount();
    await openEditor();
    const retry = await screen.findByRole("button", {
      name: "settings:syncRules.exportPending",
    });
    await waitFor(() => expect(retry).toBeEnabled());
    fireEvent.click(retry);
    await waitFor(() =>
      expect(mocks.save).toHaveBeenCalledWith(
        param,
        saved.rules,
        "b".repeat(64),
      ),
    );
  });
  it("shows the active rule while advanced mode is off and preserves it when toggled", async () => {
    mount();
    await screen.findByText("settings:syncRules.advancedHint");
    expect(screen.getByText("settings:syncRules.tasksLabelled")).toBeVisible();
    expect(screen.getByText("sync")).toBeVisible();
    expect(
      screen.queryByRole("button", { name: "settings:syncRules.edit" }),
    ).toBeNull();
    expect(
      screen.queryByRole("button", { name: "settings:syncRules.apply" }),
    ).toBeNull();
    act(() => useUserPreferencesStore.getState().setAdvancedSettings(true));
    await openEditor();
    expect(await screen.findByRole("checkbox", { name: "sync" })).toBeChecked();
    act(() => useUserPreferencesStore.getState().setAdvancedSettings(false));
    expect(screen.queryByRole("checkbox", { name: "sync" })).toBeNull();
    expect(mocks.save).not.toHaveBeenCalled();
  });

  it("requires a selected label and a current impact preview before saving", async () => {
    useUserPreferencesStore.setState({ advancedSettings: true });
    mount();
    await openEditor();
    const checkbox = await screen.findByRole("checkbox", { name: "sync" });
    const apply = screen.getByRole("button", {
      name: "settings:syncRules.apply",
    });
    fireEvent.click(checkbox);
    expect(apply).toBeDisabled();
    expect(mocks.preview).not.toHaveBeenCalled();
    fireEvent.click(checkbox);
    fireEvent.click(
      screen.getByRole("combobox", { name: "settings:syncRules.incoming" }),
      { detail: 1 },
    );
    const option = await screen.findByRole("option", {
      name: "settings:syncRules.filtered",
    });
    fireEvent.pointerDown(option);
    fireEvent.mouseDown(option);
    fireEvent.pointerUp(option);
    fireEvent.mouseUp(option);
    fireEvent.click(option, { detail: 1 });
    fireEvent.change(
      await screen.findByRole("textbox", {
        name: "settings:syncRules.repositoryLabel",
      }),
      { target: { value: "ready" } },
    );
    fireEvent.click(
      screen.getByRole("button", { name: "settings:syncRules.addLabel" }),
    );
    await waitFor(() => expect(apply).toBeEnabled());
    fireEvent.click(apply);
    await waitFor(() =>
      expect(mocks.save).toHaveBeenCalledWith(
        param,
        expect.objectContaining({
          incoming: { mode: "labels", match: "any", labels: ["ready"] },
        }),
        "b".repeat(64),
      ),
    );
  });

  it("shows shared rules to members without an editor or resume controls", async () => {
    mocks.canManage = false;
    useUserPreferencesStore.setState({ advancedSettings: true });
    mocks.get.mockResolvedValue({
      ...saved,
      paused: 1,
      pausedTasks: [
        {
          id: "task-1",
          number: 1,
          title: "Paused task",
          linkId: "link-1",
          url: "https://git.example/1",
          eligible: true,
        },
      ],
    });
    mount();
    fireEvent.click(
      await screen.findByRole("button", {
        name: "settings:syncRules.reviewPaused",
      }),
    );
    await screen.findByText("Paused task");
    expect(
      screen.queryByRole("button", { name: "settings:syncRules.review" }),
    ).toBeNull();
    expect(
      screen.queryByRole("button", { name: "settings:syncRules.edit" }),
    ).toBeNull();
    expect(screen.queryByRole("checkbox")).toBeNull();
  });

  it("keeps the comparison open and requires refresh after a failed resume", async () => {
    const onClose = vi.fn();
    mocks.resume.mockRejectedValue(new Error("Comparison changed"));
    mount(
      <ResumeSyncDialog
        param={param}
        linkId="link-1"
        taskId="task-1"
        onClose={onClose}
      />,
    );
    await screen.findByText("Repository title");
    const keepLocal = screen.getByRole("button", {
      name: "settings:syncRules.useKaneo",
    });
    fireEvent.click(keepLocal);
    await screen.findByText("settings:syncRules.resumeError");
    expect(onClose).not.toHaveBeenCalled();
    expect(keepLocal).toBeDisabled();
    fireEvent.click(
      screen.getByRole("button", {
        name: "settings:syncRules.refreshComparison",
      }),
    );
    await waitFor(() => expect(keepLocal).toBeEnabled());
    expect(mocks.review).toHaveBeenCalledTimes(2);
  });

  it("summarizes both directions with label pills", async () => {
    mocks.get.mockResolvedValue({
      ...saved,
      rules: {
        outgoing: { mode: "labels", match: "all", labels: ["label-1"] },
        incoming: { mode: "labels", match: "any", labels: ["bug", "design"] },
      },
    });
    mount();
    expect(
      await screen.findByText("settings:syncRules.kaneoToProvider"),
    ).toBeVisible();
    expect(
      screen.getByText("settings:syncRules.providerToKaneo"),
    ).toBeVisible();
    expect(screen.getByText("sync")).toBeVisible();
    expect(screen.getByText("bug")).toBeVisible();
    expect(screen.getByText("design")).toBeVisible();
    expect(screen.getByText("settings:syncRules.joinOr")).toBeVisible();
  });

  it("collapses paused links into one callout until reviewed", async () => {
    mocks.get.mockResolvedValue({
      ...saved,
      paused: 2,
      pausedTasks: [
        {
          id: "task-1",
          number: 1,
          title: "Paused task",
          linkId: "link-1",
          url: "https://git.example/1",
          eligible: true,
        },
      ],
    });
    mount();
    const review = await screen.findByRole("button", {
      name: "settings:syncRules.reviewPaused",
    });
    expect(screen.getByText("settings:syncRules.pausedSummary")).toBeVisible();
    expect(screen.queryByText("Paused task")).toBeNull();
    fireEvent.click(review);
    expect(screen.getByText("Paused task")).toBeVisible();
    fireEvent.click(
      screen.getByRole("button", { name: "settings:syncRules.review" }),
    );
    expect(await screen.findByRole("dialog")).toBeVisible();
  });

  it("closes the editor on cancel without saving", async () => {
    useUserPreferencesStore.setState({ advancedSettings: true });
    mount();
    await openEditor();
    fireEvent.click(await screen.findByRole("checkbox", { name: "sync" }));
    fireEvent.click(
      screen.getByRole("button", { name: "common:actions.cancel" }),
    );
    expect(screen.queryByRole("checkbox")).toBeNull();
    expect(
      screen.getByRole("button", { name: "settings:syncRules.edit" }),
    ).toBeVisible();
    expect(mocks.save).not.toHaveBeenCalled();
  });
});