Merge pull request #6 from Fhj0607/tests

Tests

__tests__/assignment/createAssignment.test.tsx

@@ -0,0 +1,82 @@
+import UpsertAssignment from "@/app/assignment/upsertAssignment";
+import { CheckSubjectCompletion } from "@/lib/progress";
+import { supabase } from "@/lib/supabase";
+import { fireEvent, render, waitFor } from "@testing-library/react-native";
+import { router } from "expo-router";
+
+const mockSingle = jest.fn();
+const mockSelect = jest.fn(() => ({ single: mockSingle, }));
+const mockInsert = jest.fn(() => ({ select: mockSelect, }));
+
+jest.mock("expo-router", () => ({
+  router: {
+    back: jest.fn(),
+    replace: jest.fn(),
+  },
+  Stack: {
+    Screen: () => null,
+  },
+  useLocalSearchParams: () => ({
+    sId: "subject-123",
+  }),
+}));
+
+jest.mock("@/lib/progress", () => ({
+  CheckSubjectCompletion: jest.fn(() => Promise.resolve()),
+}));
+
+jest.mock("@/lib/asyncStorage", () => ({
+  GetAssignmentNotificationId: jest.fn(() => Promise.resolve()),
+  SaveAssignmentNotificationId: jest.fn(() => Promise.resolve()),
+}));
+
+jest.mock("expo-notifications", () => ({
+  scheduleNotificationAsync: jest.fn(() => Promise.resolve("notification-123")),
+  SchedulableTriggerInputTypes: {
+    DATE: "date",
+  },
+}));
+
+jest.mock("@/lib/supabase", () => ({
+  supabase: {
+    auth: {
+      getUser: jest.fn(() =>
+        Promise.resolve({
+          data: { user: { id: "user-123" } },
+          error: null,
+        })
+      ),
+    },
+    from: jest.fn(() => ({
+      insert: mockInsert,
+    })),
+  },
+}));
+
+test("creates an assignment and navigates back", async () => {
+  mockSingle.mockResolvedValue({ 
+    data: { 
+        aId: "assignment-123", 
+        title: "create a simple test", 
+        deadline: "",
+    },
+    error: null,
+  });
+
+  const screen = render(<UpsertAssignment />);
+  fireEvent.changeText(screen.getByTestId("assignment-title-input"), "create a simple test");
+  fireEvent.press(screen.getByTestId("upsert-assignment-button"));
+
+  await waitFor(() => {
+    expect(supabase.from).toHaveBeenCalledWith("assignments");
+    expect(mockInsert).toHaveBeenCalledWith(
+      expect.objectContaining({
+        title: "create a simple test",
+        uId: "user-123",
+        sId: "subject-123",
+      })
+    );
+    expect(CheckSubjectCompletion).toHaveBeenCalledWith("subject-123");
+    expect(router.back).toHaveBeenCalled();
+  });
+});

__tests__/assignment/deleteAssignment.test.tsx

@@ -0,0 +1,141 @@
+import ViewDetailsAssignment from "@/app/assignment/viewDetailsAssignment";
+import { CheckSubjectCompletion } from "@/lib/progress";
+import { supabase } from "@/lib/supabase";
+import { fireEvent, render, waitFor } from "@testing-library/react-native";
+import { router } from "expo-router";
+import { Alert } from "react-native";
+
+const mockAssignmentSingle = jest.fn();
+const mockAssignmentSelectEq = jest.fn(() => ({ single: mockAssignmentSingle, }));
+const mockAssignmentSelect = jest.fn(() => ({ eq: mockAssignmentSelectEq, }));
+const mockAssignmentDeleteEq = jest.fn();
+const mockAssignmentDelete = jest.fn(() => ({ eq: mockAssignmentDeleteEq, }));
+
+const mockTasksSelectEq = jest.fn();
+const mockTasksSelect = jest.fn(() => ({ eq: mockTasksSelectEq }));
+
+const mockSubjectSingle = jest.fn();
+const mockSubjectSelectEq = jest.fn(() => ({ single: mockSubjectSingle }));
+const mockSubjectSelect = jest.fn(() => ({ eq: mockSubjectSelectEq }));
+
+jest.mock("expo-router", () => ({
+  router: {
+    back: jest.fn(),
+    replace: jest.fn(),
+  },
+  Stack: {
+    Screen: () => null,
+  },
+  useLocalSearchParams: () => ({
+    aId: "assignment-123",
+  }),
+  useFocusEffect: (callback: () => void) => {
+    const React = require("react");
+    React.useEffect(callback, [callback]);
+  },
+}));
+
+jest.mock("@/lib/progress", () => ({
+  CheckSubjectCompletion: jest.fn(() => Promise.resolve()),
+}));
+
+jest.mock("@/lib/supabase", () => ({
+  supabase: {
+    auth: {
+      getUser: jest.fn(() =>
+        Promise.resolve({
+          data: { user: { id: "user-123" } },
+          error: null,
+        })
+      ),
+      getSession: jest.fn(() =>
+        Promise.resolve({
+          data: {
+            session: {
+              user: { id: "user-123" },
+            },
+          },
+        })
+      ),
+      onAuthStateChange: jest.fn(() => ({
+        data: {
+          subscription: {
+            unsubscribe: jest.fn(),
+          },
+        },
+      })),
+    },
+    from: jest.fn((table: string) => {
+      if (table === "assignments") {
+        return {
+          select: mockAssignmentSelect,
+          delete: mockAssignmentDelete,
+        };
+      }
+
+      if (table === "tasks") {
+        return {
+          select: mockTasksSelect,
+        };
+      }
+
+      if (table === "subjects") {
+        return {
+          select: mockSubjectSelect,
+        };
+      }
+
+      return {};
+    }),
+  },
+}));
+
+const alertSpy = jest.spyOn(Alert, "alert");
+
+test("deletes a task and navigates back", async () => {
+  mockAssignmentSingle.mockResolvedValue({ 
+    data: { 
+      aId: "assignment-123",
+      title: "create a simple test",
+      uId: "user-123",
+      sId: "subject-123"
+    },
+    error: null,
+  });
+  mockTasksSelectEq.mockResolvedValue({ data: [], error: null, })
+  mockSubjectSingle.mockResolvedValue({
+    data: {
+      sId: "subject-123",
+      title: "ikt205g26v",
+      color: "blue",
+    },
+    error: null,
+  });
+  mockAssignmentDeleteEq.mockResolvedValue({ error: null, });
+
+  const screen = render(<ViewDetailsAssignment />);
+
+  await screen.findByText("create a simple test");
+  await screen.findByText("ikt205g26v");
+
+  fireEvent.press(await screen.findByTestId("delete-assignment-button"));
+
+  expect(alertSpy).toHaveBeenCalledWith(
+    "Delete Assignment",
+    "Are you sure you want to delete this assignment?",
+    expect.any(Array),
+  );
+
+  const alertButtons = alertSpy.mock.calls[0][2];
+  const confirmDeleteButton = alertButtons[1];
+
+  await confirmDeleteButton.onPress();    
+
+  await waitFor(() => {
+    expect(supabase.from).toHaveBeenCalledWith("assignments");
+    expect(mockAssignmentDelete).toHaveBeenCalled();
+    expect(mockAssignmentDeleteEq).toHaveBeenCalledWith("aId", "assignment-123");
+    expect(CheckSubjectCompletion).toHaveBeenCalledWith("subject-123");
+    expect(router.back).toHaveBeenCalled();
+  });
+});

__tests__/assignment/editAssignment.test.tsx

@@ -0,0 +1,100 @@
+import UpsertAssignment from "@/app/assignment/upsertAssignment";
+import { CheckSubjectCompletion } from "@/lib/progress";
+import { supabase } from "@/lib/supabase";
+import { fireEvent, render, waitFor } from "@testing-library/react-native";
+import { router } from "expo-router";
+
+const mockUpdateSingle = jest.fn();
+const mockUpdateSelect = jest.fn(() => ({ single: mockUpdateSingle, }));
+const mockUpdateEq = jest.fn(() => ({ select: mockUpdateSelect, }));
+const mockUpdate = jest.fn(() => ({ eq: mockUpdateEq, }));
+const mockSingle = jest.fn();
+const mockSelectEq = jest.fn(() => ({ single: mockSingle, }));
+const mockSelect = jest.fn(() => ({ eq: mockSelectEq, }));
+
+jest.mock("expo-router", () => ({
+  router: {
+    back: jest.fn(),
+    replace: jest.fn(),
+  },
+  Stack: {
+    Screen: () => null,
+  },
+  useLocalSearchParams: () => ({
+    aId: "assignment-123",
+  }),
+  useFocusEffect: (callback: () => void) => callback(),
+}));
+
+jest.mock("@/lib/progress", () => ({
+  CheckSubjectCompletion: jest.fn(() => Promise.resolve()),
+}));
+
+jest.mock("@/lib/asyncStorage", () => ({
+  GetAssignmentNotificationId: jest.fn(() => Promise.resolve(null)),
+}));
+
+jest.mock("expo-notifications", () => ({
+  scheduleNotificationAsync: jest.fn(() => Promise.resolve("notification-123")),
+  SchedulableTriggerInputTypes: {
+    DATE: "date",
+  },
+}));
+
+jest.mock("@/lib/supabase", () => ({
+  supabase: {
+    auth: {
+      getUser: jest.fn(() =>
+        Promise.resolve({
+          data: { user: { id: "user-123" } },
+          error: null,
+        })
+      ),
+    },
+    from: jest.fn(() => ({
+      select: mockSelect,
+      update: mockUpdate,
+    })),
+  },
+}));
+
+test("updates an assignment and navigates back", async () => {
+  mockSingle.mockResolvedValue({ 
+    data: {
+        aId: "assignment-123", 
+        title: "create a simple test",
+        deadline: "2026-04-25",
+        uId: "user-123",
+        sId: "subject-123",
+    },
+    error: null,
+  });
+  mockUpdateSingle.mockResolvedValue({
+    data: {
+        aId: "assignment-123", 
+        title: "create a harder test",
+        deadline: "2026-04-25",
+        uId: "user-123",
+    },
+    error: null,
+  });
+
+  const screen = render(<UpsertAssignment />);
+  fireEvent.changeText(await screen.findByTestId("assignment-title-input"), "create a harder test");
+  fireEvent.press(screen.getByTestId("upsert-assignment-button"));
+
+  await waitFor(() => {
+    expect(supabase.from).toHaveBeenCalledWith("assignments");
+    expect(mockSelect).toHaveBeenCalled();
+    expect(mockUpdate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        title: "create a harder test",
+        uId: "user-123",
+        deadline: "2026-04-25",
+      })
+    );
+    expect(mockUpdateSingle).toHaveBeenCalled();
+    expect(CheckSubjectCompletion).toHaveBeenCalledWith("subject-123");
+    expect(router.back).toHaveBeenCalled();
+  });
+});

__tests__/authGuard.test.tsx

@@ -0,0 +1,79 @@
+import TabLayout from "@/app/(tabs)/_layout";
+import { supabase } from "@/lib/supabase";
+import { render, waitFor } from "@testing-library/react-native";
+
+jest.mock("expo-router", () => {
+  const React = require("react");
+  const { Text, View } = require("react-native");
+
+  const MockTabs = ({ children }: { children?: React.ReactNode }) => (
+    <View>
+      <Text>tabs</Text>
+      {children}
+    </View>
+  );
+
+  MockTabs.Screen = () => null;
+
+  return {
+    Redirect: ({ href }: { href: string }) => <Text>redirect:{href}</Text>,
+    Tabs: MockTabs,
+    router: {
+      push: jest.fn(),
+    },
+  };
+});
+
+jest.mock("expo-notifications", () => ({
+  getLastNotificationResponse: jest.fn(() => null),
+  addNotificationResponseReceivedListener: jest.fn(() => ({
+    remove: jest.fn(),
+  })),
+}));
+
+jest.mock("@/lib/supabase", () => ({
+  supabase: {
+    auth: {
+      getSession: jest.fn(),
+      onAuthStateChange: jest.fn(() => ({
+        data: {
+          subscription: {
+            unsubscribe: jest.fn(),
+          },
+        },
+      })),
+    },
+  },
+}));
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+test("redirects to login if there is no session", async () => {
+  (supabase.auth.getSession as jest.Mock).mockResolvedValue({
+    data: { session: null },
+  });
+
+  const screen = render(<TabLayout />);
+
+  await waitFor(() => {
+    expect(screen.getByText("redirect:/login")).toBeTruthy();
+  });
+});
+
+test("renders tabs when session exists", async () => {
+  (supabase.auth.getSession as jest.Mock).mockResolvedValue({
+    data: {
+      session: {
+        user: { id: "user-123" },
+      },
+    },
+  });
+
+  const screen = render(<TabLayout />);
+
+  await waitFor(() => {
+    expect(screen.getByText("tabs")).toBeTruthy();
+  });
+});

__tests__/subject/createSubject.test.tsx

@@ -0,0 +1,52 @@
+import UpsertSubject from "@/app/subject/upsertSubject";
+import { supabase } from "@/lib/supabase";
+import { fireEvent, render, waitFor } from "@testing-library/react-native";
+import { router } from "expo-router";
+
+const mockInsert = jest.fn();
+
+jest.mock("expo-router", () => ({
+  router: {
+    back: jest.fn(),
+    replace: jest.fn(),
+  },
+  Stack: {
+    Screen: () => null,
+  },
+  useLocalSearchParams: () => ({}),
+}));
+
+jest.mock("@/lib/supabase", () => ({
+  supabase: {
+    auth: {
+      getUser: jest.fn(() =>
+        Promise.resolve({
+          data: { user: { id: "user-123" } },
+          error: null,
+        })
+      ),
+    },
+    from: jest.fn(() => ({
+      insert: mockInsert,
+    })),
+  },
+}));
+
+test("creates a subject and navigates back", async () => {
+  mockInsert.mockResolvedValue({ error: null });
+
+  const screen = render(<UpsertSubject />);
+  fireEvent.changeText(screen.getByTestId("subject-title-input"), "ikt205g26v");
+  fireEvent.press(screen.getByTestId("upsert-subject-button"));
+
+  await waitFor(() => {
+    expect(supabase.from).toHaveBeenCalledWith("subjects");
+    expect(mockInsert).toHaveBeenCalledWith(
+      expect.objectContaining({
+        title: "ikt205g26v",
+        uId: "user-123",
+      })
+    );
+    expect(router.back).toHaveBeenCalled();
+  });
+});

__tests__/subject/deleteSubject.test.tsx

@@ -0,0 +1,116 @@
+import ViewDetailsSubject from "@/app/subject/viewDetailsSubject";
+import { supabase } from "@/lib/supabase";
+import { fireEvent, render, waitFor } from "@testing-library/react-native";
+import { router } from "expo-router";
+import { Alert } from "react-native";
+
+const mockSubjectSingle = jest.fn();
+const mockSubjectSelectEq = jest.fn(() => ({ single: mockSubjectSingle }));
+const mockSubjectSelect = jest.fn(() => ({ eq: mockSubjectSelectEq }));
+const mockSubjectDeleteEq = jest.fn();
+const mockSubjectDelete = jest.fn(() => ({ eq: mockSubjectDeleteEq }));
+
+const mockAssignmentsOrder = jest.fn();
+const mockAssignmentsEq = jest.fn(() => ({ order: mockAssignmentsOrder }));
+const mockAssignmentsSelect = jest.fn(() => ({ eq: mockAssignmentsEq }));
+
+jest.mock("expo-router", () => ({
+  router: {
+    back: jest.fn(),
+    replace: jest.fn(),
+  },
+  Stack: {
+    Screen: () => null,
+  },
+  useLocalSearchParams: () => ({
+    sId: "subject-123",
+  }),
+  useFocusEffect: (callback: () => void) => {
+    const React = require("react");
+    React.useEffect(callback, [callback]);
+  },
+}));
+
+jest.mock("@/lib/supabase", () => ({
+  supabase: {
+    auth: {
+      getUser: jest.fn(() =>
+        Promise.resolve({
+          data: { user: { id: "user-123" } },
+          error: null,
+        })
+      ),
+      getSession: jest.fn(() =>
+        Promise.resolve({
+          data: {
+            session: {
+              user: { id: "user-123" },
+            },
+          },
+        })
+      ),
+      onAuthStateChange: jest.fn(() => ({
+        data: {
+          subscription: {
+            unsubscribe: jest.fn(),
+          },
+        },
+      })),
+    },
+    from: jest.fn((table) => {
+      if (table === "subjects") {
+        return {
+          select: mockSubjectSelect,
+          delete: mockSubjectDelete,
+        };
+      }
+
+      if (table === "assignments") {
+        return {
+          select: mockAssignmentsSelect,
+        };
+      }
+
+      return {};
+    }),
+  },
+}));
+
+const alertSpy = jest.spyOn(Alert, "alert");
+
+test("deletes a subject and navigates back", async () => {
+  mockSubjectSingle.mockResolvedValue({ 
+    data: { 
+      sId: "subject-123",
+      title: "ikt205g26v",
+      uId: "user-123",
+    },
+    error: null,
+  });
+  mockAssignmentsOrder.mockResolvedValue({ data: [], error: null, })
+  mockSubjectDeleteEq.mockResolvedValue({ error: null, });
+
+  const screen = render(<ViewDetailsSubject />);
+
+  await screen.findByText("ikt205g26v");
+
+  fireEvent.press(await screen.findByTestId("delete-subject-button"));
+
+  expect(alertSpy).toHaveBeenCalledWith(
+    "Delete Subject",
+    "Are you sure you want to delete this subject?",
+    expect.any(Array),
+  );
+
+  const alertButtons = alertSpy.mock.calls[0][2];
+  const confirmDeleteButton = alertButtons[1];
+
+  await confirmDeleteButton.onPress();    
+
+  await waitFor(() => {
+    expect(supabase.from).toHaveBeenCalledWith("subjects");
+    expect(mockSubjectDelete).toHaveBeenCalled();
+    expect(mockSubjectDeleteEq).toHaveBeenCalledWith("sId", "subject-123");
+    expect(router.back).toHaveBeenCalled();
+  });
+});

__tests__/subject/editSubject.test.tsx

@@ -0,0 +1,70 @@
+import UpsertSubject from "@/app/subject/upsertSubject";
+import { supabase } from "@/lib/supabase";
+import { fireEvent, render, waitFor } from "@testing-library/react-native";
+import { router } from "expo-router";
+
+const mockUpdateEq = jest.fn();
+const mockUpdate = jest.fn(() => ({ eq: mockUpdateEq, }));
+const mockSingle = jest.fn();
+const mockSelectEq = jest.fn(() => ({ single: mockSingle, }));
+const mockSelect = jest.fn(() => ({ eq: mockSelectEq, }));
+
+jest.mock("expo-router", () => ({
+  router: {
+    back: jest.fn(),
+    replace: jest.fn(),
+  },
+  Stack: {
+    Screen: () => null,
+  },
+  useLocalSearchParams: () => ({
+    sId: "subject-123",
+  }),
+  useFocusEffect: (callback: () => void) => callback(),
+}));
+
+jest.mock("@/lib/supabase", () => ({
+  supabase: {
+    auth: {
+      getUser: jest.fn(() =>
+        Promise.resolve({
+          data: { user: { id: "user-123" } },
+          error: null,
+        })
+      ),
+    },
+    from: jest.fn(() => ({
+      select: mockSelect,
+      update: mockUpdate,
+    })),
+  },
+}));
+
+test("updates a subject and navigates back", async () => {
+  mockSingle.mockResolvedValue({ 
+    data: { 
+        sId: "subject-123",
+        title: "ikt205g26v",
+        uId: "user-123",
+    },
+    error: null,
+  });
+  mockUpdateEq.mockResolvedValue({ error: null, });
+
+  const screen = render(<UpsertSubject />);
+  fireEvent.changeText(await screen.findByTestId("subject-title-input"), "ikt206g26v");
+  fireEvent.press(screen.getByTestId("upsert-subject-button"));
+
+  await waitFor(() => {
+    expect(supabase.from).toHaveBeenCalledWith("subjects");
+    expect(mockSelect).toHaveBeenCalled();
+    expect(mockUpdate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        title: "ikt206g26v",
+        uId: "user-123",
+      })
+    );
+    expect(mockUpdateEq).toHaveBeenCalledWith("sId", "subject-123");
+    expect(router.back).toHaveBeenCalled();
+  });
+});

__tests__/task/createTask.test.tsx

@@ -0,0 +1,61 @@
+import UpsertTask from "@/app/task/upsertTask";
+import { CheckAssignmentCompletion } from "@/lib/progress";
+import { supabase } from "@/lib/supabase";
+import { fireEvent, render, waitFor } from "@testing-library/react-native";
+import { router } from "expo-router";
+
+const mockInsert = jest.fn();
+
+jest.mock("expo-router", () => ({
+  router: {
+    back: jest.fn(),
+    replace: jest.fn(),
+  },
+  Stack: {
+    Screen: () => null,
+  },
+  useLocalSearchParams: () => ({
+    aId: "assignment-123",
+  }),
+}));
+
+jest.mock("@/lib/progress", () => ({
+  CheckAssignmentCompletion: jest.fn(() => Promise.resolve()),
+}));
+
+jest.mock("@/lib/supabase", () => ({
+  supabase: {
+    auth: {
+      getUser: jest.fn(() =>
+        Promise.resolve({
+          data: { user: { id: "user-123" } },
+          error: null,
+        })
+      ),
+    },
+    from: jest.fn(() => ({
+      insert: mockInsert,
+    })),
+  },
+}));
+
+test("creates a task and navigates back", async () => {
+  mockInsert.mockResolvedValue({ error: null });
+
+  const screen = render(<UpsertTask />);
+  fireEvent.changeText(screen.getByTestId("task-title-input"), "Read chapter 4");
+  fireEvent.press(screen.getByTestId("upsert-task-button"));
+
+  await waitFor(() => {
+    expect(supabase.from).toHaveBeenCalledWith("tasks");
+    expect(mockInsert).toHaveBeenCalledWith(
+      expect.objectContaining({
+        title: "Read chapter 4",
+        uId: "user-123",
+        aId: "assignment-123",
+      })
+    );
+    expect(CheckAssignmentCompletion).toHaveBeenCalledWith("assignment-123");
+    expect(router.back).toHaveBeenCalled();
+  });
+});

__tests__/task/deleteTask.test.tsx

@@ -0,0 +1,150 @@
+import ViewDetailsTask from "@/app/task/viewDetailsTask";
+import { CheckAssignmentCompletion } from "@/lib/progress";
+import { supabase } from "@/lib/supabase";
+import { fireEvent, render, waitFor } from "@testing-library/react-native";
+import { router } from "expo-router";
+import { Alert } from "react-native";
+
+const mockTaskSingle = jest.fn();
+const mockTaskSelectEq = jest.fn(() => ({ single: mockTaskSingle }));
+const mockTaskSelect = jest.fn(() => ({ eq: mockTaskSelectEq }));
+const mockTaskDeleteEq = jest.fn();
+const mockTaskDelete = jest.fn(() => ({ eq: mockTaskDeleteEq }));
+
+const mockAssignmentSingle = jest.fn();
+const mockAssignmentSelectEq = jest.fn(() => ({ single: mockAssignmentSingle }));
+const mockAssignmentSelect = jest.fn(() => ({ eq: mockAssignmentSelectEq }));
+
+const mockSubjectSingle = jest.fn();
+const mockSubjectSelectEq = jest.fn(() => ({ single: mockSubjectSingle }));
+const mockSubjectSelect = jest.fn(() => ({ eq: mockSubjectSelectEq }));
+
+jest.mock("expo-router", () => ({
+  router: {
+    back: jest.fn(),
+    replace: jest.fn(),
+  },
+  Stack: {
+    Screen: () => null,
+  },
+  useLocalSearchParams: () => ({
+    tId: "task-123",
+  }),
+  useFocusEffect: (callback: () => void) => {
+    const React = require("react");
+    React.useEffect(callback, [callback]);
+  },
+}));
+
+jest.mock("@/lib/progress", () => ({
+  CheckAssignmentCompletion: jest.fn(() => Promise.resolve()),
+}));
+
+jest.mock("@/lib/supabase", () => ({
+  supabase: {
+    auth: {
+      getUser: jest.fn(() =>
+        Promise.resolve({
+          data: { user: { id: "user-123" } },
+          error: null,
+        })
+      ),
+      getSession: jest.fn(() =>
+        Promise.resolve({
+          data: {
+            session: {
+              user: { id: "user-123" },
+            },
+          },
+        })
+      ),
+      onAuthStateChange: jest.fn(() => ({
+        data: {
+          subscription: {
+            unsubscribe: jest.fn(),
+          },
+        },
+      })),
+    },
+    from: jest.fn((table: string) => {
+      if (table === "tasks") {
+        return {
+          select: mockTaskSelect,
+          delete: mockTaskDelete,
+        };
+      }
+
+      if (table === "assignments") {
+        return {
+          select: mockAssignmentSelect,
+        };
+      }
+
+      if (table === "subjects") {
+        return {
+          select: mockSubjectSelect,
+        };
+      }
+
+      return {};
+    }),
+  },
+}));
+
+const alertSpy = jest.spyOn(Alert, "alert");
+
+test("deletes a task and navigates back", async () => {
+  mockTaskSingle.mockResolvedValue({ 
+    data: { 
+      tId: "task-123",
+      title: "Read chapter 4",
+      uId: "user-123",
+      aId: "assignment-123",
+    },
+    error: null,
+  });
+  mockAssignmentSingle.mockResolvedValue({
+    data: { 
+      aId: "assignment-123",
+      title: "create a simple test",
+      uId: "user-123",
+      sId: "subject-123",
+    },
+    error: null,
+  });
+  mockSubjectSingle.mockResolvedValue({
+    data: {
+      sId: "subject-123",
+      title: "ikt205g26v",
+      color: "blue",
+    },
+    error: null,
+  });
+  mockTaskDeleteEq.mockResolvedValue({ error: null, });
+
+  const screen = render(<ViewDetailsTask />);
+
+  await screen.findByText("Read chapter 4");
+  await screen.findByText("ikt205g26v");
+
+  fireEvent.press(await screen.findByTestId("delete-task-button"));
+
+  expect(alertSpy).toHaveBeenCalledWith(
+    "Delete Task",
+    "Are you sure you want to delete this task?",
+    expect.any(Array),
+  );
+
+  const alertButtons = alertSpy.mock.calls[0][2];
+  const confirmDeleteButton = alertButtons[1];
+
+  await confirmDeleteButton.onPress();    
+
+  await waitFor(() => {
+    expect(supabase.from).toHaveBeenCalledWith("tasks");
+    expect(mockTaskDelete).toHaveBeenCalled();
+    expect(mockTaskDeleteEq).toHaveBeenCalledWith("tId", "task-123");
+    expect(CheckAssignmentCompletion).toHaveBeenCalledWith("assignment-123");
+    expect(router.back).toHaveBeenCalled();
+  });
+});

__tests__/task/editTask.test.tsx

@@ -0,0 +1,78 @@
+import UpsertTask from "@/app/task/upsertTask";
+import { CheckAssignmentCompletion } from "@/lib/progress";
+import { supabase } from "@/lib/supabase";
+import { fireEvent, render, waitFor } from "@testing-library/react-native";
+import { router } from "expo-router";
+
+const mockUpdateEq = jest.fn();
+const mockUpdate = jest.fn(() => ({ eq: mockUpdateEq, }));
+const mockSingle = jest.fn();
+const mockSelectEq = jest.fn(() => ({ single: mockSingle, }));
+const mockSelect = jest.fn(() => ({ eq: mockSelectEq, }));
+
+jest.mock("expo-router", () => ({
+  router: {
+    back: jest.fn(),
+    replace: jest.fn(),
+  },
+  Stack: {
+    Screen: () => null,
+  },
+  useLocalSearchParams: () => ({
+    tId: "task-123",
+  }),
+  useFocusEffect: (callback: () => void) => callback(),
+}));
+
+jest.mock("@/lib/progress", () => ({
+  CheckAssignmentCompletion: jest.fn(() => Promise.resolve()),
+}));
+
+jest.mock("@/lib/supabase", () => ({
+  supabase: {
+    auth: {
+      getUser: jest.fn(() =>
+        Promise.resolve({
+          data: { user: { id: "user-123" } },
+          error: null,
+        })
+      ),
+    },
+    from: jest.fn(() => ({
+      select: mockSelect,
+      update: mockUpdate,
+    })),
+  },
+}));
+
+test("updates a task and navigates back", async () => {
+  mockSingle.mockResolvedValue({ 
+    data: {
+      tId: "task-123", 
+      title: "Read chapter 4",
+      uId: "user-123",
+      aId: "assignment-123",
+    },
+    error: null,
+  });
+  mockUpdateEq.mockResolvedValue({ error: null, });
+
+  const screen = render(<UpsertTask />);
+  fireEvent.changeText(await screen.findByTestId("task-title-input"), "Read chapter 5");
+  fireEvent.press(screen.getByTestId("upsert-task-button"));
+
+  await waitFor(() => {
+    expect(supabase.from).toHaveBeenCalledWith("tasks");
+    expect(mockSelect).toHaveBeenCalled();
+    expect(mockUpdate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        title: "Read chapter 5",
+        uId: "user-123",
+        aId: "assignment-123",
+      })
+    );
+    expect(mockUpdateEq).toHaveBeenCalledWith("tId", "task-123");
+    expect(CheckAssignmentCompletion).toHaveBeenCalledWith("assignment-123");    
+    expect(router.back).toHaveBeenCalled();
+  });
+});

app/(tabs)/subjects.tsx

@@ -4,13 +4,14 @@ import { Subject } from '@/lib/types';
 import { Session } from '@supabase/supabase-js';
 import { router, Stack, useFocusEffect } from 'expo-router';
 import { useCallback, useEffect, useState } from 'react';
-import { Alert, Pressable, ScrollView, Text, View } from 'react-native';
+import { ActivityIndicator, Alert, Pressable, ScrollView, Text, View } from 'react-native';
 
 import type { SubjectColor } from '@/lib/subjectColors';
 
 export default function Subjects() {
   const [subjects, SetSubjects] = useState<Subject[]>([]);
   const [session, SetSession] = useState<Session | null>(null);
+  const [isLoading, SetIsLoading] = useState(false);
 
   useEffect(() => {
     supabase.auth.getSession().then(({ data }) => {
@@ -29,12 +30,16 @@ export default function Subjects() {
   const GetSubjects = async () => {
     if (!session?.user.id) return;
 
+    SetIsLoading(true);
+
     const { data, error } = await supabase
       .from('subjects')
       .select('*')
       .eq('uId', session.user.id)
       .order('lastChanged', { ascending: false });
 
+    SetIsLoading(false);  
+
     if (error) {
       Alert.alert('Subjects could not be fetched, please try again');
       return;
@@ -51,6 +56,14 @@ export default function Subjects() {
     }, [session])
   );
 
+  if (isLoading) {
+    return (
+      <View className="flex-1 items-center justify-center bg-app-bg">
+        <ActivityIndicator size="large" />
+      </View>
+    );
+  }
+
   return (
     <View className="flex-1 bg-app-bg">
       <Stack.Screen

app/assignment/upsertAssignment.tsx

@@ -256,6 +256,7 @@ export default function UpsertAssignment() {
               <View className="mb-5">
                 <Text className={labelClassName}>Title</Text>
                 <TextInput
+                  testID = "assignment-title-input"
                   className={inputClassName}
                   placeholder="Enter assignment title"
                   placeholderTextColor="#9CA3AF"
@@ -325,6 +326,7 @@ export default function UpsertAssignment() {
               </Pressable>
 
               <Pressable
+                testID = "upsert-assignment-button"
                 className={`h-14 items-center justify-center rounded-2xl ${
                   isSaving ? 'bg-accent-disabled' : 'bg-accent'
                 }`}

app/assignment/viewDetailsAssignment.tsx

@@ -6,7 +6,7 @@ import type { Assignment, Task } from '@/lib/types';
 import { Session } from '@supabase/supabase-js';
 import { router, Stack, useFocusEffect, useLocalSearchParams } from 'expo-router';
 import { useCallback, useEffect, useState } from 'react';
-import { Alert, Pressable, SectionList, Text, View } from "react-native";
+import { ActivityIndicator, Alert, Pressable, SectionList, Text, View } from "react-native";
 
 
 export default function ViewDetailsAssignment() {
@@ -14,6 +14,7 @@ export default function ViewDetailsAssignment() {
   const [assignment, SetAssignment] = useState<Assignment | null>(null);
   const [tasks, SetTasks] = useState<Task[]>([]);
   const [session, SetSession] = useState<Session | null>(null);
+  const [isLoading, SetIsLoading] = useState(false);
   const [subjectMeta, setSubjectMeta] = useState({
     title: 'No Subject',
     color: 'slate' as SubjectColor,
@@ -34,12 +35,16 @@ export default function ViewDetailsAssignment() {
   [])
 
   const GetAssignment = async (assignmentId: string) => {
+    SetIsLoading(true);
+
     const { data, error } = await supabase
       .from('assignments')
       .select('*')
       .eq('aId', assignmentId)
       .single();
 
+    SetIsLoading(false);  
+
     if (error || !data) {
       Alert.alert('Assignment could not be fetched, please try again');
       return;
@@ -48,12 +53,16 @@ export default function ViewDetailsAssignment() {
     SetAssignment(data);
 
     if (data.sId) {
+      SetIsLoading(true);
+
       const { data: subjectData, error: subjectError } = await supabase
         .from('subjects')
         .select('title, color')
         .eq('sId', data.sId)
         .single();
 
+      SetIsLoading(false);
+
       if (subjectError || !subjectData) {
         setSubjectMeta({
           title: 'Unknown Subject',
@@ -70,8 +79,12 @@ export default function ViewDetailsAssignment() {
   };
 
   const GetTasks = async (aId: string) => { 
+    SetIsLoading(true);
+
     const { data, error } = await supabase.from("tasks").select("*").eq("aId", aId);
 
+    SetIsLoading(false);
+
     if (error) {
       Alert.alert("Tasks could not be fetched, please try again");
       return;
@@ -176,6 +189,14 @@ export default function ViewDetailsAssignment() {
       ? 0
       : Math.round((completedTasks / totalTasks) * 100);
 
+  if (isLoading) {
+    return (
+      <View className="flex-1 items-center justify-center bg-app-bg">
+        <ActivityIndicator size="large" />
+      </View>
+    );
+  }
+
   if (!assignment) {
     return (
       <View className="flex-1 bg-app-bg px-5 pt-6">
@@ -330,7 +351,7 @@ export default function ViewDetailsAssignment() {
                   className="mr-3 flex-1 items-center justify-center rounded-2xl border border-app-border bg-app-subtle py-3"
                   onPress={() =>
                     router.push({
-                      pathname: '/assignment/upsertAssignment',
+                      pathname: '../assignment/upsertAssignment',
                       params: { aId: assignment.aId },
                     })
                   }
@@ -339,6 +360,7 @@ export default function ViewDetailsAssignment() {
                 </Pressable>
 
                 <Pressable
+                  testID="delete-assignment-button"
                   className="flex-1 items-center justify-center rounded-2xl border border-app-border bg-app-surface py-3"
                   onPress={() => DeleteAssignment(assignment.aId)}
                 >
@@ -353,7 +375,7 @@ export default function ViewDetailsAssignment() {
               className="mb-6 mt-5 h-14 items-center justify-center rounded-2xl bg-accent"
               onPress={() =>
                 router.push({
-                  pathname: '/task/upsertTask',
+                  pathname: '../task/upsertTask',
                   params: { aId: assignment.aId },
                 })
               }
@@ -434,7 +456,7 @@ export default function ViewDetailsAssignment() {
                     className="mr-3 flex-1 items-center justify-center rounded-2xl border border-app-border bg-app-subtle py-3"
                     onPress={() =>
                       router.push({
-                        pathname: '/task/upsertTask',
+                        pathname: '../task/upsertTask',
                         params: { tId: item.tId },
                       })
                     }

app/subject/upsertSubject.tsx

@@ -161,6 +161,7 @@ export default function UpsertSubject() {
                             <View className="mb-5">
                                 <Text className={labelClassName}>Title</Text>
                                 <TextInput className={inputClassName}
+                                    testID = "subject-title-input"
                                     placeholder="Enter subject title"
                                     placeholderTextColor="#9CA3AF"
                                     value={title}
@@ -311,6 +312,7 @@ export default function UpsertSubject() {
                             </Pressable>
 
                             <Pressable
+                                testID = "upsert-subject-button"
                                 className={`h-14 items-center justify-center rounded-2xl ${
                                     isSaving 
                                         ? 'bg-accent-disabled' 

app/subject/viewDetailsSubject.tsx

@@ -6,7 +6,7 @@ import type { Assignment } from '@/lib/types';
 import { Session } from '@supabase/supabase-js';
 import { router, Stack, useFocusEffect, useLocalSearchParams } from 'expo-router';
 import { useCallback, useEffect, useState } from 'react';
-import { Alert, Pressable, SectionList, Text, View } from 'react-native';
+import { ActivityIndicator, Alert, Pressable, SectionList, Text, View } from 'react-native';
 
 export type Subject = {
   sId: string;
@@ -23,6 +23,7 @@ export default function ViewDetailsSubject() {
   const [subject, SetSubject] = useState<Subject | null>(null);  
   const [assignments, SetAssignments] = useState<Assignment[]>([]);
   const [session, SetSession] = useState<Session | null>(null);
+  const [isLoading, SetIsLoading] = useState(false);
 
   const assignmentSections = [
     {
@@ -48,12 +49,16 @@ export default function ViewDetailsSubject() {
   }, []);
 
   const GetSubject = async (subjectId: string) => {
+    SetIsLoading(true);
+
     const { data, error } = await supabase
       .from('subjects')
       .select('*')
       .eq('sId', subjectId)
       .single();
 
+    SetIsLoading(false);  
+
     if (error) {
       Alert.alert('Subject could not be fetched, please try again');
       return;
@@ -63,12 +68,16 @@ export default function ViewDetailsSubject() {
   };
 
   const GetAssignments = async (subjectId: string) => {
+    SetIsLoading(true);
+
     const { data, error } = await supabase
       .from('assignments')
       .select('*')
       .eq('sId', subjectId)
       .order('deadline', { ascending: true });
 
+    SetIsLoading(false);  
+
     if (error) {
       Alert.alert('Assignments could not be fetched, please try again');
       return;
@@ -167,6 +176,14 @@ export default function ViewDetailsSubject() {
       ? 0
       : Math.round((completedAssignments / totalAssignments) * 100);
 
+  if (isLoading) {
+    return (
+      <View className="flex-1 items-center justify-center bg-app-bg">
+        <ActivityIndicator size="large" />
+      </View>
+    );
+  }
+
   if (!subject) {
     return (
       <View className="flex-1 bg-app-bg px-5 pt-6">
@@ -323,7 +340,7 @@ export default function ViewDetailsSubject() {
                   className="mr-3 flex-1 items-center justify-center rounded-2xl border border-app-border bg-app-subtle py-3"
                   onPress={() =>
                     router.push({
-                      pathname: '/subject/upsertSubject',
+                      pathname: '../subject/upsertSubject',
                       params: { sId: subject.sId },
                     })
                   }
@@ -334,6 +351,7 @@ export default function ViewDetailsSubject() {
                 </Pressable>
 
                 <Pressable
+                  testID="delete-subject-button"
                   className="flex-1 items-center justify-center rounded-2xl border border-app-border bg-app-surface py-3"
                   onPress={() => DeleteSubject(subject.sId)}
                 >
@@ -348,7 +366,7 @@ export default function ViewDetailsSubject() {
               className="mb-6 mt-5 h-14 items-center justify-center rounded-2xl bg-accent"
               onPress={() =>
                 router.push({
-                  pathname: '/assignment/upsertAssignment',
+                  pathname: '../assignment/upsertAssignment',
                   params: { sId: subject.sId },
                 })
               }
@@ -420,7 +438,7 @@ export default function ViewDetailsSubject() {
                     className="mr-3 flex-1 items-center justify-center rounded-2xl border border-app-border bg-app-subtle py-3"
                     onPress={() =>
                       router.push({
-                        pathname: '/assignment/upsertAssignment',
+                        pathname: '../assignment/upsertAssignment',
                         params: { aId: item.aId },
                       })
                     }

app/task/upsertTask.tsx

@@ -181,6 +181,7 @@ export default function UpsertTask() {
               <View className="mb-5">
                 <Text className={labelClassName}>Title</Text>
                 <TextInput
+                  testID="task-title-input"
                   className={inputClassName}
                   placeholder="Enter task title"
                   placeholderTextColor="#9CA3AF"
@@ -237,6 +238,7 @@ export default function UpsertTask() {
               </Pressable>
 
               <Pressable
+                testID="upsert-task-button"
                 className={`h-14 items-center justify-center rounded-2xl ${
                   isSaving ? 'bg-accent-disabled' : 'bg-accent'
                 }`}

app/task/viewDetailsTask.tsx

@@ -6,13 +6,14 @@ import type { Task } from '@/lib/types';
 import { Session } from '@supabase/supabase-js';
 import { router, Stack, useFocusEffect, useLocalSearchParams } from 'expo-router';
 import { useCallback, useEffect, useState } from 'react';
-import { Alert, Pressable, Text, View } from 'react-native';
+import { ActivityIndicator, Alert, Pressable, Text, View } from 'react-native';
 
 export default function ViewDetailsTask() {
   const { tId } = useLocalSearchParams<{ tId: string }>();
 
   const [task, SetTask] = useState<Task | null>(null);
   const [session, SetSession] = useState<Session | null>(null);
+  const [isLoading, SetIsLoading] = useState(false);
   const [contextMeta, setContextMeta] = useState({
     subjectTitle: 'No Subject',
     assignmentTitle: 'No Assignment',
@@ -30,12 +31,16 @@ export default function ViewDetailsTask() {
   }, []);
 
   const GetTask = async (taskId: string) => {
+    SetIsLoading(true);
+
     const { data, error } = await supabase
       .from('tasks')
       .select('*')
       .eq('tId', taskId)
       .single();
     
+    SetIsLoading(false);    
+
     if (error || !data) {
       Alert.alert('Task could not be fetched, please try again');
       return;
@@ -44,12 +49,16 @@ export default function ViewDetailsTask() {
     SetTask(data);
 
     if (data.aId) {
+      SetIsLoading(true);
+
       const { data: assignmentData, error: assignmentError } = await supabase
         .from('assignments')
         .select('title, sId')
         .eq('aId', data.aId)
         .single();
 
+      SetIsLoading(false);    
+
       if (assignmentError || !assignmentData) {
         setContextMeta({
           subjectTitle: 'Unknown Subject',
@@ -60,12 +69,16 @@ export default function ViewDetailsTask() {
       }
 
       if (assignmentData.sId) {
+        SetIsLoading(true);
+
         const { data: subjectData, error: subjectError } = await supabase
           .from('subjects')
           .select('title, color')
           .eq('sId', assignmentData.sId)
           .single();
 
+        SetIsLoading(false);  
+
         if (subjectError || !subjectData) {
           setContextMeta({
             subjectTitle: 'Unknown Subject',
@@ -135,6 +148,14 @@ export default function ViewDetailsTask() {
 
   const colorSet = getSubjectColorSet(contextMeta.subjectColor);
 
+  if (isLoading) {
+    return (
+      <View className="flex-1 items-center justify-center bg-app-bg">
+        <ActivityIndicator size="large" />
+      </View>
+    );
+  }
+
   if (!task) {
     return (
       <View className="flex-1 bg-app-bg px-5 pt-6">
@@ -272,7 +293,7 @@ export default function ViewDetailsTask() {
               className="mr-3 flex-1 items-center justify-center rounded-2xl border border-app-border bg-app-subtle py-3"
               onPress={() =>
                 router.push({
-                  pathname: '/task/upsertTask',
+                  pathname: '../task/upsertTask',
                   params: { tId: task.tId },
                 })
               }
@@ -283,6 +304,7 @@ export default function ViewDetailsTask() {
             </Pressable>
 
             <Pressable
+              testID="delete-task-button"
               className="flex-1 items-center justify-center rounded-2xl border border-app-border bg-app-surface py-3"
               onPress={() => DeleteTask(task.tId)}
             >

notes/work-report-2026-04-24-to-25.md

@@ -0,0 +1,71 @@
+# CRUD Testing Summary (React Native + Jest + Supabase)
+
+## What these tests are about
+Tests verify **app behavior**, not Supabase itself.
+
+They check:
+- User interaction works
+- Correct database functions are called
+- Navigation happens after actions
+
+---
+
+## CRUD Breakdown
+
+### CREATE
+- User inputs data
+- `insert()` is called
+- App navigates back
+
+Flow:
+User → type → press create → insert() → router.back()
+
+---
+
+### READ
+- Data is fetched (`select().eq().single()`)
+- State updates
+- UI renders correct content
+
+---
+
+### UPDATE
+- Existing data is loaded
+- User edits input
+- `update().eq()` is called with correct values
+- Navigation happens
+
+---
+
+### DELETE
+- User presses delete
+- `Alert.alert()` is triggered
+- Confirm button (`onPress`) is manually called in test
+- `delete().eq()` runs
+- Navigation happens
+
+---
+
+## Why mocking is used
+- No real database calls
+- Faster tests
+- Full control over success/error cases
+- No side effects (no real data created/deleted)
+
+---
+
+## Mock rule
+The mock must match the real call chain:
+
+Real:
+from → update → eq → select → single
+
+Mock:
+from() → update() → eq() → select() → single()
+
+If not → errors like:
+".select is not a function"
+
+---
+
+https://oss.callstack.com/react-native-testing-library/

package.json

@@ -9,7 +9,8 @@
     "android": "expo run:android",
     "ios": "expo run:ios",
     "web": "expo start --web",
-    "lint": "expo lint"
+    "lint": "expo lint",
+    "test": "jest"
   },
   "dependencies": {
     "@expo/vector-icons": "^15.0.3",
@@ -48,10 +49,20 @@
     "tailwindcss": "^3.4.19"
   },
   "devDependencies": {
+    "@testing-library/react-native": "^13.3.3",
+    "@types/jest": "^30.0.0",
     "@types/react": "~19.1.0",
     "eslint": "^9.25.0",
     "eslint-config-expo": "~10.0.0",
+    "jest": "^29.7.0",
+    "jest-expo": "^55.0.16",
+    "patch-package": "^8.0.1",
+    "react-test-renderer": "19.1.0",
+    "tailwindcss": "^3.4.19",
     "typescript": "~5.9.2"
   },
-  "private": true
+  "private": true,
+  "jest": {
+    "preset": "jest-expo"
+  }
 }