⚡ Project management that doesn't become the project. Boards, Gantt charts, and GitHub integration. Self-host it or use Kaneo Cloud.
TypeScript honoissue-managementissue-trackerjira-alternativekanbanlinear-alternativemcpproject-managementreactself-hostedtypescript
import enUS from "@i18n/en-US.json";
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import {
act,
cleanup,
fireEvent,
render,
screen,
} from "@testing-library/react";
import type { ReactNode } from "react";
import {
afterEach,
beforeEach,
describe,
expect,
it,
vi,
} from "vite-plus/test";
import CreateTaskModal from "./create-task-modal";
function createTestQueryClient() {
return new QueryClient({
defaultOptions: {
queries: {
retry: false,
},
},
});
}
function createWrapper() {
const queryClient = createTestQueryClient();
return function Wrapper({ children }: { children: ReactNode }) {
return (
<QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
);
};
}
const useLocation = vi.fn();
const deleteTask = vi.fn(async () => {});
const updateTask = vi.fn(async (input: Record<string, unknown>) => input);
const setProject = vi.fn();
let workspaceId = "workspace-1";
let projects: { id: string; name: string; slug: string }[] | undefined;
let columnsError = false;
let columnsFetching = false;
const refetchColumns = vi.fn();
let projectColumns:
| { id: string; slug: string; name: string; isFinal: boolean }[]
| undefined;
let storedProject: { id: string; columns: unknown[] } | null = null;
let uploadAsset: ((file: File) => Promise<unknown>) | undefined;
const stageUpload = vi.fn();
let customFieldDefs: unknown[] | undefined;
vi.mock("@/lib/upload-draft-asset", () => ({
uploadDraftAsset: (...args: unknown[]) => stageUpload(...args),
}));
beforeEach(() => {
workspaceId = "workspace-1";
projects = [
{ id: "project-1", name: "Alpha", slug: "alp" },
{ id: "project-2", name: "Beta", slug: "bet" },
];
storedProject = null;
customFieldDefs = undefined;
columnsError = false;
columnsFetching = false;
refetchColumns.mockImplementation(async () => ({
data: projectColumns,
isError: columnsError,
}));
projectColumns = [
{ id: "todo", slug: "to-do", name: "To Do", isFinal: false },
];
useLocation.mockReturnValue({ pathname: "/dashboard/workspace/workspace-1" });
});
const createTask = vi.fn(async (input: Record<string, unknown>) => ({
id: "task-1",
title: input.title,
status: input.status,
projectId: input.projectId,
createdAt: "2026-08-05T00:00:00.000Z",
}));
afterEach(() => {
cleanup();
document.body.innerHTML = "";
vi.clearAllMocks();
});
vi.mock("@tanstack/react-router", () => ({
useLocation: () => useLocation(),
useParams: ({
select,
}: {
select: (params: { workspaceId?: string }) => unknown;
}) =>
select({
workspaceId: useLocation().pathname.match(/\/workspace\/([^/]+)/)?.[1],
}),
}));
vi.mock("@/components/task/task-description-editor", () => ({
default: (props: {
taskId?: string;
uploadAsset: (file: File) => Promise<unknown>;
onChange: (value: string) => void;
}) => {
uploadAsset = props.uploadAsset;
return (
<textarea
data-testid="description-editor"
data-task-id={props.taskId}
onChange={(event) => props.onChange(event.target.value)}
/>
);
},
}));
vi.mock("@/hooks/mutations/label/use-create-label", () => ({
default: () => ({ mutateAsync: vi.fn() }),
}));
vi.mock("@/hooks/mutations/task/use-create-task", () => ({
default: () => ({ mutateAsync: createTask }),
}));
vi.mock("@/hooks/mutations/task/use-delete-task", () => ({
useDeleteTask: () => ({ mutateAsync: deleteTask }),
}));
vi.mock("@/hooks/mutations/task/use-update-task", () => ({
useUpdateTask: () => ({ mutateAsync: updateTask }),
}));
vi.mock("@/hooks/queries/label/use-get-labels-by-workspace", () => ({
default: () => ({ data: [] }),
}));
vi.mock("@/hooks/queries/workspace/use-active-workspace", () => ({
default: () => ({ data: { id: workspaceId, name: "WS" } }),
}));
vi.mock(
"@/hooks/queries/workspace-users/use-get-active-workspace-users",
() => ({
useGetActiveWorkspaceUsers: () => ({ data: { members: [] } }),
}),
);
vi.mock("@/hooks/queries/workspace-users/use-get-project-members", () => ({
default: () => ({ data: undefined }),
}));
vi.mock("@/hooks/use-workspace-permission", () => ({
useWorkspacePermission: () => ({
canCreateTasks: () => true,
canCreateLabels: () => true,
}),
}));
vi.mock("@/hooks/queries/column/use-get-columns", () => ({
useGetColumns: () => ({
data: projectColumns,
isError: columnsError,
isFetching: columnsFetching,
refetch: refetchColumns,
}),
}));
vi.mock(
"@/hooks/queries/custom-field/use-get-custom-fields-by-project",
() => ({
default: () => ({ data: customFieldDefs }),
}),
);
vi.mock("@/hooks/queries/project/use-get-projects", () => ({
default: () => ({ data: projects }),
}));
vi.mock("@/store/project", () => ({
default: () => ({ project: storedProject, setProject }),
}));
vi.mock("@/lib/toast", () => ({
toast: { error: vi.fn(), success: vi.fn() },
}));
vi.mock("react-i18next", () => ({
useTranslation: () => ({
t: (key: string) => {
if (key === "tasks:popover.dueDate.clear")
return enUS.tasks.popover.dueDate.clear;
// Keep the real source bundle involved so a deleted clear label fails.
if (key === "common:modals.createTask.clearDueDate") {
const source: Record<string, unknown> = enUS.common.modals.createTask;
return typeof source.clearDueDate === "string"
? source.clearDueDate
: key;
}
return key;
},
i18n: { language: "en-US" },
}),
initReactI18next: { type: "3rdParty", init: vi.fn() },
}));
describe("CreateTaskModal", () => {
it("stops offering recurrence when the target changes to a final column", async () => {
projectColumns = [
{ id: "todo", slug: "to-do", name: "To Do", isFinal: false },
{ id: "done", slug: "done", name: "Done", isFinal: true },
];
const onClose = vi.fn();
const { rerender } = render(<CreateTaskModal open onClose={onClose} />, {
wrapper: createWrapper(),
});
await chooseBeta();
enterTitle();
fireEvent.click(screen.getByText("common:modals.createTask.dueDate"));
fireEvent.click(await screen.findByText("tasks:popover.recurrence.toggle"));
rerender(<CreateTaskModal open status="done" onClose={onClose} />);
expect(
screen.queryByText("tasks:popover.recurrence.toggle"),
).not.toBeInTheDocument();
submit();
await vi.waitFor(() =>
expect(createTask).toHaveBeenCalledWith(
expect.objectContaining({ status: "done", recurrence: undefined }),
),
);
});
it("shows a translated clear-date action and clears the selected due date", async () => {
render(<CreateTaskModal open onClose={vi.fn()} />, {
wrapper: createWrapper(),
});
await chooseBeta();
const trigger = screen
.getByText("common:modals.createTask.dueDate")
.closest("button")!;
fireEvent.click(trigger);
fireEvent.click(await screen.findByText("tasks:due.today"));
fireEvent.click(trigger);
fireEvent.click(await screen.findByText("Clear date"));
expect(trigger).toHaveTextContent("common:modals.createTask.dueDate");
enterTitle();
submit();
await vi.waitFor(() =>
expect(createTask).toHaveBeenCalledWith(
expect.objectContaining({ dueDate: undefined }),
),
);
});
it("keeps unsaved input while discard confirmation is open", async () => {
useLocation.mockReturnValue({
pathname: "/dashboard/workspace/workspace-1/project/project-1/board",
});
const onClose = vi.fn();
render(<CreateTaskModal open onClose={onClose} />, {
wrapper: createWrapper(),
});
const titleInput = screen.getByPlaceholderText(
"common:modals.createTask.taskTitlePlaceholder",
);
fireEvent.change(titleInput, { target: { value: "Unsaved task" } });
const backdrop = document.querySelector('[data-slot="dialog-backdrop"]');
expect(backdrop).not.toBeNull();
fireEvent.pointerDown(backdrop as Element);
fireEvent.pointerUp(backdrop as Element);
fireEvent.click(backdrop as Element);
expect(onClose).not.toHaveBeenCalled();
expect(
await screen.findByText("common:modals.createTask.discardTitle"),
).toBeTruthy();
expect(titleInput).toHaveValue("Unsaved task");
fireEvent.keyDown(document, { key: "Enter", ctrlKey: true });
expect(createTask).not.toHaveBeenCalled();
expect(onClose).not.toHaveBeenCalled();
});
it("closes after the user confirms discarding unsaved input", async () => {
useLocation.mockReturnValue({
pathname: "/dashboard/workspace/workspace-1/project/project-1/board",
});
const onClose = vi.fn();
render(<CreateTaskModal open onClose={onClose} />, {
wrapper: createWrapper(),
});
fireEvent.change(
screen.getByPlaceholderText(
"common:modals.createTask.taskTitlePlaceholder",
),
{
target: { value: "Unsaved task" },
},
);
const backdrop = document.querySelector('[data-slot="dialog-backdrop"]');
fireEvent.pointerDown(backdrop as Element);
fireEvent.pointerUp(backdrop as Element);
fireEvent.click(backdrop as Element);
await screen.findByText("common:modals.createTask.discardTitle");
fireEvent.click(screen.getByText("common:modals.createTask.discardButton"));
expect(onClose).toHaveBeenCalledTimes(1);
});
it("treats a selected project as unsaved input", async () => {
useLocation.mockReturnValue({
pathname: "/dashboard/workspace/workspace-1",
});
render(<CreateTaskModal open onClose={vi.fn()} />, {
wrapper: createWrapper(),
});
fireEvent.click(screen.getByText("common:modals.createTask.selectProject"));
fireEvent.click(await screen.findByText("Beta"));
const backdrop = document.querySelector('[data-slot="dialog-backdrop"]');
fireEvent.pointerDown(backdrop as Element);
fireEvent.pointerUp(backdrop as Element);
fireEvent.click(backdrop as Element);
expect(
await screen.findByText("common:modals.createTask.discardTitle"),
).toBeTruthy();
});
it("shows a project picker and creates the task in the chosen project", async () => {
useLocation.mockReturnValue({
pathname: "/dashboard/workspace/workspace-1",
});
render(<CreateTaskModal open onClose={vi.fn()} />, {
wrapper: createWrapper(),
});
const pickerTrigger = screen.getByText(
"common:modals.createTask.selectProject",
);
fireEvent.click(pickerTrigger);
fireEvent.click(await screen.findByText("Beta"));
fireEvent.change(
screen.getByPlaceholderText(
"common:modals.createTask.taskTitlePlaceholder",
),
{
target: { value: "Picked project task" },
},
);
fireEvent.submit(document.querySelector("form") as HTMLFormElement);
await vi.waitFor(() => {
expect(createTask).toHaveBeenCalledWith(
expect.objectContaining({
title: "Picked project task",
projectId: "project-2",
}),
);
});
});
it("creates Home tasks in the first open custom column and shows its name", async () => {
projectColumns = [
{ id: "done", slug: "done", name: "Finished", isFinal: true },
{
id: "ready",
slug: "ready-for-work",
name: "Ready for work",
isFinal: false,
},
];
render(<CreateTaskModal open onClose={vi.fn()} />, {
wrapper: createWrapper(),
});
await chooseBeta();
expect(screen.getByText("Ready for work")).toBeInTheDocument();
enterTitle();
submit();
await vi.waitFor(() =>
expect(createTask).toHaveBeenCalledWith(
expect.objectContaining({ status: "ready-for-work" }),
),
);
});
it("creates a repeating task from the due date picker", async () => {
render(<CreateTaskModal open onClose={vi.fn()} />, {
wrapper: createWrapper(),
});
await chooseBeta();
enterTitle();
fireEvent.click(screen.getByText("common:modals.createTask.dueDate"));
fireEvent.click(await screen.findByText("tasks:popover.recurrence.toggle"));
submit();
await vi.waitFor(() =>
expect(createTask).toHaveBeenCalledWith(
expect.objectContaining({
recurrence: expect.objectContaining({
frequency: "weekly",
interval: 1,
}),
}),
),
);
// The rule follows the due date's weekday until the user picks days.
expect(createTask.mock.calls.at(-1)?.[0].recurrence).not.toHaveProperty(
"weekdays",
);
});
it("waits for the chosen project's columns before submitting", async () => {
projectColumns = undefined;
render(<CreateTaskModal open onClose={vi.fn()} />, {
wrapper: createWrapper(),
});
await chooseBeta();
enterTitle();
expect(
screen.getByText("common:modals.createTask.createButton"),
).toBeDisabled();
submit();
expect(createTask).not.toHaveBeenCalled();
});
it("uses fresh workflow columns when a cached open column became final", async () => {
refetchColumns.mockResolvedValue({
data: [
{ id: "todo", slug: "to-do", name: "Completed", isFinal: true },
{ id: "ready", slug: "ready", name: "Ready", isFinal: false },
],
isError: false,
});
render(<CreateTaskModal open onClose={vi.fn()} />, {
wrapper: createWrapper(),
});
await chooseBeta();
enterTitle();
submit();
await vi.waitFor(() =>
expect(createTask).toHaveBeenCalledWith(
expect.objectContaining({ status: "ready" }),
),
);
});
it("does not create from cached columns when the submission refresh fails", async () => {
refetchColumns.mockResolvedValue({ data: projectColumns, isError: true });
render(<CreateTaskModal open onClose={vi.fn()} />, {
wrapper: createWrapper(),
});
await chooseBeta();
enterTitle();
submit();
await vi.waitFor(() => expect(refetchColumns).toHaveBeenCalledOnce());
expect(createTask).not.toHaveBeenCalled();
});
it("waits for refreshing cached workflow columns", async () => {
columnsFetching = true;
render(<CreateTaskModal open onClose={vi.fn()} />, {
wrapper: createWrapper(),
});
await chooseBeta();
enterTitle();
expect(
screen.getByText("common:modals.createTask.createButton"),
).toBeDisabled();
submit();
expect(createTask).not.toHaveBeenCalled();
});
it("does not publish after closing during workflow verification", async () => {
let finish!: (value: unknown) => void;
refetchColumns.mockImplementation(
() =>
new Promise((resolve) => {
finish = resolve;
}),
);
const view = render(<CreateTaskModal open onClose={vi.fn()} />, {
wrapper: createWrapper(),
});
await chooseBeta();
enterTitle();
submit();
view.rerender(<CreateTaskModal open={false} onClose={vi.fn()} />);
await act(async () => {
finish({ data: projectColumns, isError: false });
});
expect(createTask).not.toHaveBeenCalled();
});
it("offers a retry when project statuses could not be loaded", async () => {
projectColumns = undefined;
columnsError = true;
render(<CreateTaskModal open onClose={vi.fn()} />, {
wrapper: createWrapper(),
});
await chooseBeta();
expect(screen.getByRole("alert")).toHaveTextContent(
"common:modals.createTask.statusLoadError",
);
fireEvent.click(screen.getByText("common:error.tryAgain"));
expect(refetchColumns).toHaveBeenCalledOnce();
submit();
expect(createTask).not.toHaveBeenCalled();
});
it("uses planned instead of an ambiguous open/final status slug", async () => {
projectColumns = [
{ id: "done", slug: "shared", name: "Finished", isFinal: true },
{ id: "open", slug: "shared", name: "Open", isFinal: false },
];
render(<CreateTaskModal open onClose={vi.fn()} />, {
wrapper: createWrapper(),
});
await chooseBeta();
enterTitle();
submit();
await vi.waitFor(() =>
expect(createTask).toHaveBeenCalledWith(
expect.objectContaining({ status: "planned" }),
),
);
});
it("uses planned when every column is final", async () => {
projectColumns = [
{ id: "done", slug: "done", name: "Finished", isFinal: true },
];
render(<CreateTaskModal open onClose={vi.fn()} />, {
wrapper: createWrapper(),
});
await chooseBeta();
enterTitle();
submit();
await vi.waitFor(() =>
expect(createTask).toHaveBeenCalledWith(
expect.objectContaining({ status: "planned" }),
),
);
});
it("keeps an explicit planned status even when the project has custom columns", async () => {
projectColumns = [
{ id: "ready", slug: "ready", name: "Ready", isFinal: false },
];
render(<CreateTaskModal open status="planned" onClose={vi.fn()} />, {
wrapper: createWrapper(),
});
await chooseBeta();
enterTitle();
submit();
await vi.waitFor(() =>
expect(createTask).toHaveBeenCalledWith(
expect.objectContaining({ status: "planned" }),
),
);
});
it("hides the picker when a project is in scope from the route", () => {
useLocation.mockReturnValue({
pathname: "/dashboard/workspace/workspace-1/project/project-1/board",
});
render(<CreateTaskModal open onClose={vi.fn()} />, {
wrapper: createWrapper(),
});
expect(
screen.queryByText("common:modals.createTask.selectProject"),
).toBeNull();
});
});
function enterTitle(title = "Private task") {
fireEvent.change(
screen.getByPlaceholderText(
"common:modals.createTask.taskTitlePlaceholder",
),
{
target: { value: title },
},
);
}
async function chooseBeta() {
fireEvent.click(screen.getByText("common:modals.createTask.selectProject"));
fireEvent.click(await screen.findByText("Beta"));
}
function submit() {
fireEvent.submit(document.querySelector("form") as HTMLFormElement);
}
describe("CreateTaskModal context isolation", () => {
it("never falls back to the last globally visited project", () => {
storedProject = { id: "foreign-project", columns: [] };
render(<CreateTaskModal open onClose={vi.fn()} />, {
wrapper: createWrapper(),
});
enterTitle();
expect(
screen.getByText("common:modals.createTask.createButton"),
).toBeDisabled();
submit();
expect(createTask).not.toHaveBeenCalled();
});
it("clears selected project and private fields after close and reopen", async () => {
const props = { open: true, onClose: vi.fn() };
const view = render(<CreateTaskModal {...props} />, {
wrapper: createWrapper(),
});
await chooseBeta();
enterTitle();
view.rerender(<CreateTaskModal {...props} open={false} />);
view.rerender(<CreateTaskModal {...props} />);
expect(
screen.getByPlaceholderText(
"common:modals.createTask.taskTitlePlaceholder",
),
).toHaveValue("");
enterTitle("New task");
submit();
expect(createTask).not.toHaveBeenCalled();
});
it("clears workspace A's selection when workspace B becomes active", async () => {
const view = render(<CreateTaskModal open onClose={vi.fn()} />, {
wrapper: createWrapper(),
});
await chooseBeta();
enterTitle();
workspaceId = "workspace-2";
projects = [{ id: "project-3", name: "Gamma", slug: "gam" }];
useLocation.mockReturnValue({
pathname: "/dashboard/workspace/workspace-2",
});
view.rerender(<CreateTaskModal open onClose={vi.fn()} />);
enterTitle("Workspace B secret");
submit();
expect(createTask).not.toHaveBeenCalled();
expect(
screen.getByText("common:modals.createTask.selectProject"),
).toBeInTheDocument();
});
it("does not expose the previous workspace while the route's workspace is loading", async () => {
const view = render(<CreateTaskModal open onClose={vi.fn()} />, {
wrapper: createWrapper(),
});
await chooseBeta();
enterTitle();
useLocation.mockReturnValue({
pathname: "/dashboard/workspace/workspace-2",
});
view.rerender(<CreateTaskModal open onClose={vi.fn()} />);
expect(screen.queryByTestId("description-editor")).toBeNull();
expect(createTask).not.toHaveBeenCalled();
});
it.each([undefined, []])(
"rejects explicit project IDs until current workspace query proves membership (%s)",
async (data) => {
projects = data;
render(<CreateTaskModal open projectId="project-2" onClose={vi.fn()} />, {
wrapper: createWrapper(),
});
enterTitle();
submit();
await expect(uploadAsset?.(new File(["x"], "x.png"))).rejects.toThrow();
expect(createTask).not.toHaveBeenCalled();
},
);
it("stages attachments without creating a task and claims them only on submit", async () => {
stageUpload.mockResolvedValue({
id: "staged-1",
url: "/asset/staged-1",
kind: "image",
});
render(<CreateTaskModal open onClose={vi.fn()} />, {
wrapper: createWrapper(),
});
await chooseBeta();
enterTitle();
await act(async () => {
await uploadAsset?.(new File(["x"], "x.png"));
});
expect(createTask).not.toHaveBeenCalled();
expect(updateTask).not.toHaveBeenCalled();
fireEvent.change(screen.getByTestId("description-editor"), {
target: { value: "" },
});
submit();
await vi.waitFor(() => expect(createTask).toHaveBeenCalledOnce());
expect(createTask).toHaveBeenCalledWith(
expect.objectContaining({
draftAssetIds: ["staged-1"],
projectId: "project-2",
}),
);
});
it("does not submit while attachments are uploading", async () => {
let finish!: (value: unknown) => void;
stageUpload.mockImplementationOnce(
() =>
new Promise((resolve) => {
finish = resolve;
}),
);
render(<CreateTaskModal open onClose={vi.fn()} />, {
wrapper: createWrapper(),
});
await chooseBeta();
enterTitle();
let pending!: Promise<unknown>;
act(() => {
pending = uploadAsset!(new File(["x"], "x.png"));
});
expect(
screen.getByText("activity:comment.editor.uploadingFile"),
).toBeDisabled();
submit();
expect(createTask).not.toHaveBeenCalled();
await act(async () => {
finish({ id: "staged-2" });
await pending;
});
submit();
await vi.waitFor(() => expect(createTask).toHaveBeenCalledOnce());
});
it("closing after an upload creates no published task or deletion side effect", async () => {
stageUpload.mockResolvedValue({ id: "staged-1" });
const view = render(<CreateTaskModal open onClose={vi.fn()} />, {
wrapper: createWrapper(),
});
await chooseBeta();
await act(async () => {
await uploadAsset?.(new File(["x"], "x.png"));
});
view.rerender(<CreateTaskModal open={false} onClose={vi.fn()} />);
expect(createTask).not.toHaveBeenCalled();
expect(deleteTask).not.toHaveBeenCalled();
expect(setProject).not.toHaveBeenCalled();
});
});
const customField = (
id: string,
type: string,
required: boolean,
defaultValue: string | null = null,
) => ({
id,
projectId: "project-2",
name: id,
type,
required,
defaultValue,
options: null,
position: 0,
createdAt: "",
updatedAt: "",
});
describe("CreateTaskModal custom fields", () => {
it("flags empty required fields instead of creating, then sends the filled values", async () => {
customFieldDefs = [
customField("customer", "text", true),
customField("billable", "boolean", true, "false"),
customField("points", "number", false),
];
render(<CreateTaskModal open onClose={vi.fn()} projectId="project-2" />, {
wrapper: createWrapper(),
});
enterTitle();
submit();
expect(
await screen.findByText("tasks:customFields.missingRequired"),
).toBeInTheDocument();
expect(createTask).not.toHaveBeenCalled();
const customerChip = document.querySelector(
'[data-custom-field="customer"]',
) as HTMLElement;
expect(document.activeElement).toBe(customerChip);
fireEvent.click(customerChip);
const input = await screen.findByLabelText("customer");
fireEvent.change(input, { target: { value: "Acme Corp" } });
fireEvent.keyDown(input, { key: "Enter" });
await vi.waitFor(() =>
expect(
screen.queryByText("tasks:customFields.missingRequired"),
).not.toBeInTheDocument(),
);
submit();
await vi.waitFor(() =>
expect(createTask).toHaveBeenCalledWith(
expect.objectContaining({
customFields: [
{ fieldId: "customer", value: "Acme Corp" },
{ fieldId: "billable", value: "false" },
],
}),
),
);
});
});