Skip to content

Job application tracker and AI-powered job search assistant. Helps job seekers manage their search journey with AI resume review, job matching, task logging, and application analytics, all while keeping your data private.

18.3 KB
Raw Blame
import { TaskForm } from "@/components/tasks/TaskForm";
import { screen, render, waitFor } from "@testing-library/react";
import { getCurrentUser } from "@/utils/user.utils";
import userEvent from "@testing-library/user-event";
import { createTask, updateTask } from "@/actions/task.actions";
import { Task } from "@/models/task.model";

vi.mock("@/utils/user.utils", () => ({
  getCurrentUser: vi.fn(),
}));

vi.mock("@/actions/task.actions", () => ({
  createTask: vi.fn().mockResolvedValue({ success: true, data: { id: "new-task-id" } }),
  updateTask: vi.fn().mockResolvedValue({ success: true, data: { id: "task-id" } }),
}));

global.ResizeObserver = class ResizeObserver {
  observe() {}
  unobserve() {}
  disconnect() {}
};

document.createRange = () => {
  const range = new Range();

  range.getBoundingClientRect = vi.fn().mockReturnValue({
    bottom: 0,
    height: 0,
    left: 0,
    right: 0,
    top: 0,
    width: 0,
  });

  range.getClientRects = () => {
    return {
      item: () => null,
      length: 0,
      [Symbol.iterator]: vi.fn(),
    };
  };

  return range;
};

describe("TaskForm Component", () => {
  const mockUser = { id: "user-id" };
  const mockActivityTypes = [
    {
      id: "type-1",
      label: "Development",
      value: "development",
      createdAt: new Date(),
      updatedAt: new Date(),
    },
    {
      id: "type-2",
      label: "Testing",
      value: "testing",
      createdAt: new Date(),
      updatedAt: new Date(),
    },
  ];
  const mockResetEditTask = vi.fn();
  const mockOnTaskSaved = vi.fn();
  const mockSetDialogOpen = vi.fn();
  const mockOnSaveAndStart = vi.fn();
  const user = userEvent.setup({ skipHover: true });

  window.HTMLElement.prototype.scrollIntoView = vi.fn();
  window.HTMLElement.prototype.hasPointerCapture = vi.fn();

  beforeEach(() => {
    (getCurrentUser as any).mockResolvedValue(mockUser);
    vi.clearAllMocks();
  });

  describe("Add Task Mode", () => {
    beforeEach(() => {
      render(
        <TaskForm
          activityTypes={mockActivityTypes}
          editTask={null}
          resetEditTask={mockResetEditTask}
          onTaskSaved={mockOnTaskSaved}
          dialogOpen={true}
          setDialogOpen={mockSetDialogOpen}
        />
      );
    });

    it("should render the dialog with title 'Add Task'", () => {
      const dialogTitle = screen.getByTestId("task-form-dialog-title");
      expect(dialogTitle).toBeInTheDocument();
      expect(dialogTitle).toHaveTextContent("Add Task");
    });

    it("should show all form fields", () => {
      expect(screen.getByLabelText(/Title/i)).toBeInTheDocument();
      expect(screen.getByLabelText(/Activity Type/i)).toBeInTheDocument();
      expect(screen.getByLabelText(/Status/i)).toBeInTheDocument();
      expect(screen.getByText(/Priority:/i)).toBeInTheDocument();
      expect(screen.getByText(/% Complete:/i)).toBeInTheDocument();
      expect(screen.getByLabelText(/Due Date/i)).toBeInTheDocument();
      expect(screen.getByText(/Description/i)).toBeInTheDocument();
    });

    it("should have default values", () => {
      const titleInput = screen.getByLabelText(/Title/i);
      expect(titleInput).toHaveValue("");

      const statusSelect = screen.getByLabelText(/Status/i);
      expect(statusSelect).toHaveTextContent("In Progress");

      expect(screen.getByText(/Priority: 5/i)).toBeInTheDocument();
      expect(screen.getByText(/% Complete: 0%/i)).toBeInTheDocument();
    });

    it("should show validation errors when submitting empty form", async () => {
      const saveBtn = screen.getByTestId("save-task-btn");
      await user.click(saveBtn);

      await waitFor(() => {
        expect(
          screen.getByText("Title must be at least 2 characters.")
        ).toBeInTheDocument();
      });
    });

    it("should successfully submit a new task", async () => {
      const titleInput = screen.getByLabelText(/Title/i);
      await user.type(titleInput, "New Test Task");

      const activityTypeCombobox = screen.getByLabelText(/Activity Type/i);
      await user.click(activityTypeCombobox);
      const developmentOption = screen.getByRole("option", {
        name: "Development",
      });
      await user.click(developmentOption);

      const saveBtn = screen.getByTestId("save-task-btn");
      await user.click(saveBtn);

      await waitFor(() => {
        expect(createTask).toHaveBeenCalledTimes(1);
        expect(createTask).toHaveBeenCalledWith(
          expect.objectContaining({
            title: "New Test Task",
            activityTypeId: "type-1",
            status: "in-progress",
            priority: 5,
            percentComplete: 0,
          })
        );
        expect(mockOnTaskSaved).toHaveBeenCalledTimes(1);
        expect(mockSetDialogOpen).toHaveBeenCalledWith(false);
        expect(mockResetEditTask).toHaveBeenCalledTimes(1);
      });
    });

    it("should close the dialog when cancel button is clicked", async () => {
      const cancelBtn = screen.getByRole("button", { name: /cancel/i });
      await user.click(cancelBtn);

      expect(mockResetEditTask).toHaveBeenCalledTimes(1);
      expect(mockSetDialogOpen).toHaveBeenCalledWith(false);
    });

    it("should display activity types in combobox", async () => {
      const activityTypeCombobox = screen.getByLabelText(/Activity Type/i);
      await user.click(activityTypeCombobox);

      const options = screen.getAllByRole("option");
      expect(options.length).toBeGreaterThan(0);
      expect(
        screen.getByRole("option", { name: "Development" })
      ).toBeInTheDocument();
      expect(
        screen.getByRole("option", { name: "Testing" })
      ).toBeInTheDocument();
    });

    it("should display all status options", async () => {
      const statusSelect = screen.getByLabelText(/Status/i);
      await user.click(statusSelect);

      expect(
        screen.getByRole("option", { name: "In Progress" })
      ).toBeInTheDocument();
      expect(
        screen.getByRole("option", { name: "Complete" })
      ).toBeInTheDocument();
      expect(
        screen.getByRole("option", { name: "Needs Attention" })
      ).toBeInTheDocument();
      expect(
        screen.getByRole("option", { name: "Cancelled" })
      ).toBeInTheDocument();
    });

    it("should handle title input correctly", async () => {
      const titleInput = screen.getByLabelText(/Title/i);
      await user.type(titleInput, "Test Task Title");

      expect(titleInput).toHaveValue("Test Task Title");
    });

    it("should validate title minimum length", async () => {
      const titleInput = screen.getByLabelText(/Title/i);
      await user.type(titleInput, "A");

      const saveBtn = screen.getByTestId("save-task-btn");
      await user.click(saveBtn);

      await waitFor(() => {
        expect(
          screen.getByText("Title must be at least 2 characters.")
        ).toBeInTheDocument();
      });
    });

    it("should validate due date is not in the past", async () => {
      const titleInput = screen.getByLabelText(/Title/i);
      await user.type(titleInput, "Valid Title");

      // Note: Due date validation happens at schema level
      // Testing the form's handling of the validation error
      const saveBtn = screen.getByTestId("save-task-btn");
      await user.click(saveBtn);

      await waitFor(() => {
        expect(createTask).toHaveBeenCalled();
      });
    });
  });

  describe("Edit Task Mode", () => {
    const mockEditTask: Task = {
      id: "task-id",
      userId: "user-id",
      title: "Existing Task",
      description: "Existing description",
      status: "needs-attention",
      priority: 7,
      percentComplete: 60,
      dueDate: new Date("2026-12-31"),
      activityTypeId: "type-1",
      activityType: {
        id: "type-1",
        label: "Development",
        value: "development",
        createdAt: new Date(),
        updatedAt: new Date(),
      },
      activities: [],
      createdAt: new Date(),
      updatedAt: new Date(),
    };

    beforeEach(() => {
      render(
        <TaskForm
          activityTypes={mockActivityTypes}
          editTask={mockEditTask}
          resetEditTask={mockResetEditTask}
          onTaskSaved={mockOnTaskSaved}
          dialogOpen={true}
          setDialogOpen={mockSetDialogOpen}
        />
      );
    });

    it("should render the dialog with title 'Edit Task'", () => {
      const dialogTitle = screen.getByTestId("task-form-dialog-title");
      expect(dialogTitle).toBeInTheDocument();
      expect(dialogTitle).toHaveTextContent("Edit Task");
    });

    it("should populate form with existing task data", () => {
      const titleInput = screen.getByLabelText(/Title/i);
      expect(titleInput).toHaveValue("Existing Task");

      const statusSelect = screen.getByLabelText(/Status/i);
      expect(statusSelect).toHaveTextContent("Needs Attention");

      expect(screen.getByText(/Priority: 7/i)).toBeInTheDocument();
      expect(screen.getByText(/% Complete: 60%/i)).toBeInTheDocument();
    });

    it("should successfully submit updated task", async () => {
      const titleInput = screen.getByLabelText(/Title/i);
      await user.clear(titleInput);
      await user.type(titleInput, "Updated Task Title");

      const saveBtn = screen.getByTestId("save-task-btn");
      await user.click(saveBtn);

      await waitFor(() => {
        expect(updateTask).toHaveBeenCalledTimes(1);
        expect(updateTask).toHaveBeenCalledWith(
          expect.objectContaining({
            id: "task-id",
            title: "Updated Task Title",
            status: "needs-attention",
            priority: 7,
            percentComplete: 60,
          })
        );
        expect(mockOnTaskSaved).toHaveBeenCalledTimes(1);
        expect(mockSetDialogOpen).toHaveBeenCalledWith(false);
        expect(mockResetEditTask).toHaveBeenCalledTimes(1);
      });
    });

    it("should update status correctly", async () => {
      const statusSelect = screen.getByLabelText(/Status/i);
      await user.click(statusSelect);

      const completeOption = screen.getByRole("option", { name: "Complete" });
      await user.click(completeOption);

      await waitFor(() => {
        expect(statusSelect).toHaveTextContent("Complete");
      });
    });

    it("should handle form reset when cancel is clicked", async () => {
      const titleInput = screen.getByLabelText(/Title/i);
      await user.clear(titleInput);
      await user.type(titleInput, "Changed Title");

      const cancelBtn = screen.getByRole("button", { name: /cancel/i });
      await user.click(cancelBtn);

      expect(mockResetEditTask).toHaveBeenCalledTimes(1);
      expect(mockSetDialogOpen).toHaveBeenCalledWith(false);
    });
  });

  describe("Error Handling", () => {
    beforeEach(() => {
      render(
        <TaskForm
          activityTypes={mockActivityTypes}
          editTask={null}
          resetEditTask={mockResetEditTask}
          onTaskSaved={mockOnTaskSaved}
          dialogOpen={true}
          setDialogOpen={mockSetDialogOpen}
        />
      );
    });

    it("should handle create task failure", async () => {
      (createTask as any).mockResolvedValue({
        success: false,
        message: "Failed to create task",
      });

      const titleInput = screen.getByLabelText(/Title/i);
      await user.type(titleInput, "Test Task");

      const saveBtn = screen.getByTestId("save-task-btn");
      await user.click(saveBtn);

      await waitFor(() => {
        expect(createTask).toHaveBeenCalled();
        expect(mockOnTaskSaved).not.toHaveBeenCalled();
        expect(mockSetDialogOpen).not.toHaveBeenCalledWith(false);
      });
    });

    it("should handle update task failure", async () => {
      const mockEditTask: Task = {
        id: "task-id",
        userId: "user-id",
        title: "Existing Task",
        description: "",
        status: "in-progress",
        priority: 5,
        percentComplete: 0,
        dueDate: null,
        activityTypeId: null,
        activityType: null,
        activities: [],
        createdAt: new Date(),
        updatedAt: new Date(),
      };

      (updateTask as any).mockResolvedValue({
        success: false,
        message: "Failed to update task",
      });

      render(
        <TaskForm
          activityTypes={mockActivityTypes}
          editTask={mockEditTask}
          resetEditTask={mockResetEditTask}
          onTaskSaved={mockOnTaskSaved}
          dialogOpen={true}
          setDialogOpen={mockSetDialogOpen}
        />
      );

      // Just verify that when update fails, onTaskSaved is not called
      // We verify this through the mock setup, not through interaction
      expect(mockOnTaskSaved).not.toHaveBeenCalled();
    });
  });

  describe("Save and Start", () => {
    beforeEach(() => {
      (createTask as any).mockResolvedValue({
        success: true,
        data: { id: "new-task-id" },
      });
      (updateTask as any).mockResolvedValue({
        success: true,
        data: { id: "task-id" },
      });
    });

    it("should not show the Save & Start button when onSaveAndStart is not provided", () => {
      render(
        <TaskForm
          activityTypes={mockActivityTypes}
          editTask={null}
          resetEditTask={mockResetEditTask}
          onTaskSaved={mockOnTaskSaved}
          dialogOpen={true}
          setDialogOpen={mockSetDialogOpen}
        />
      );

      expect(
        screen.queryByTestId("save-and-start-task-btn")
      ).not.toBeInTheDocument();
    });

    it("should create the task and invoke onSaveAndStart with the new task id", async () => {
      render(
        <TaskForm
          activityTypes={mockActivityTypes}
          editTask={null}
          resetEditTask={mockResetEditTask}
          onTaskSaved={mockOnTaskSaved}
          dialogOpen={true}
          setDialogOpen={mockSetDialogOpen}
          onSaveAndStart={mockOnSaveAndStart}
        />
      );

      const titleInput = screen.getByLabelText(/Title/i);
      await user.type(titleInput, "New Test Task");

      const activityTypeCombobox = screen.getByLabelText(/Activity Type/i);
      await user.click(activityTypeCombobox);
      const developmentOption = screen.getByRole("option", {
        name: "Development",
      });
      await user.click(developmentOption);

      const saveAndStartBtn = screen.getByTestId("save-and-start-task-btn");
      await user.click(saveAndStartBtn);

      await waitFor(() => {
        expect(createTask).toHaveBeenCalledTimes(1);
        expect(mockOnTaskSaved).toHaveBeenCalledTimes(1);
        expect(mockSetDialogOpen).toHaveBeenCalledWith(false);
        expect(mockOnSaveAndStart).toHaveBeenCalledWith("new-task-id");
      });
    });

    it("should update the task and invoke onSaveAndStart with the existing task id", async () => {
      const mockEditTask: Task = {
        id: "task-id",
        userId: "user-id",
        title: "Existing Task",
        description: "Existing description",
        status: "in-progress",
        priority: 5,
        percentComplete: 0,
        dueDate: null,
        activityTypeId: "type-1",
        activityType: {
          id: "type-1",
          label: "Development",
          value: "development",
          createdAt: new Date(),
          updatedAt: new Date(),
        },
        activities: [],
        createdAt: new Date(),
        updatedAt: new Date(),
      };

      render(
        <TaskForm
          activityTypes={mockActivityTypes}
          editTask={mockEditTask}
          resetEditTask={mockResetEditTask}
          onTaskSaved={mockOnTaskSaved}
          dialogOpen={true}
          setDialogOpen={mockSetDialogOpen}
          onSaveAndStart={mockOnSaveAndStart}
        />
      );

      const saveAndStartBtn = screen.getByTestId("save-and-start-task-btn");
      await user.click(saveAndStartBtn);

      await waitFor(() => {
        expect(updateTask).toHaveBeenCalledTimes(1);
        expect(mockOnSaveAndStart).toHaveBeenCalledWith("task-id");
      });
    });

    it("should not invoke onSaveAndStart when create fails", async () => {
      (createTask as any).mockResolvedValueOnce({
        success: false,
        message: "Failed to create task",
      });

      render(
        <TaskForm
          activityTypes={mockActivityTypes}
          editTask={null}
          resetEditTask={mockResetEditTask}
          onTaskSaved={mockOnTaskSaved}
          dialogOpen={true}
          setDialogOpen={mockSetDialogOpen}
          onSaveAndStart={mockOnSaveAndStart}
        />
      );

      const titleInput = screen.getByLabelText(/Title/i);
      await user.type(titleInput, "New Test Task");

      const saveAndStartBtn = screen.getByTestId("save-and-start-task-btn");
      await user.click(saveAndStartBtn);

      await waitFor(() => {
        expect(createTask).toHaveBeenCalledTimes(1);
      });
      expect(mockOnSaveAndStart).not.toHaveBeenCalled();
    });

    it("should not invoke onSaveAndStart when the regular Save button is used", async () => {
      render(
        <TaskForm
          activityTypes={mockActivityTypes}
          editTask={null}
          resetEditTask={mockResetEditTask}
          onTaskSaved={mockOnTaskSaved}
          dialogOpen={true}
          setDialogOpen={mockSetDialogOpen}
          onSaveAndStart={mockOnSaveAndStart}
        />
      );

      const titleInput = screen.getByLabelText(/Title/i);
      await user.type(titleInput, "New Test Task");

      const saveBtn = screen.getByTestId("save-task-btn");
      await user.click(saveBtn);

      await waitFor(() => {
        expect(createTask).toHaveBeenCalledTimes(1);
      });
      expect(mockOnSaveAndStart).not.toHaveBeenCalled();
    });
  });

  describe("Dialog State Management", () => {
    it("should not render when dialogOpen is false", () => {
      render(
        <TaskForm
          activityTypes={mockActivityTypes}
          editTask={null}
          resetEditTask={mockResetEditTask}
          onTaskSaved={mockOnTaskSaved}
          dialogOpen={false}
          setDialogOpen={mockSetDialogOpen}
        />
      );

      const dialogTitle = screen.queryByTestId("task-form-dialog-title");
      expect(dialogTitle).not.toBeInTheDocument();
    });

    it("should render when dialogOpen is true", () => {
      render(
        <TaskForm
          activityTypes={mockActivityTypes}
          editTask={null}
          resetEditTask={mockResetEditTask}
          onTaskSaved={mockOnTaskSaved}
          dialogOpen={true}
          setDialogOpen={mockSetDialogOpen}
        />
      );

      const dialogTitle = screen.getByTestId("task-form-dialog-title");
      expect(dialogTitle).toBeInTheDocument();
    });
  });
});