tanstack-query-firebase/packages/react/src/firestore/useDeleteDocumentMutation.test.tsx at 1ae45f6de3c7e9d6cace1581624a0151eaec8fbc · invertase/tanstack-query-firebase · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
import { renderHook, waitFor, act } from "@testing-library/react";
import {
  doc,
  type DocumentReference,
  getDoc,
  setDoc,
} from "firebase/firestore";
import { beforeEach, describe, expect, test } from "vitest";
import { useDeleteDocumentMutation } from "./useDeleteDocumentMutation";

import {
  expectFirestoreError,
  firestore,
  wipeFirestore,
} from "~/testing-utils";
import { queryClient, wrapper } from "../../utils";

describe("useDeleteDocumentMutation", () => {
  beforeEach(async () => {
    await wipeFirestore();
    queryClient.clear();
  });

  test("successfully deletes an existing document", async () => {
    const docRef = doc(firestore, "tests", "deleteTest");

    await setDoc(docRef, { foo: "bar" });

    const initialSnapshot = await getDoc(docRef);
    expect(initialSnapshot.exists()).toBe(true);

    const { result } = renderHook(() => useDeleteDocumentMutation(), {
      wrapper,
    });

    expect(result.current.isPending).toBe(false);
    expect(result.current.isIdle).toBe(true);

    await act(() => result.current.mutate(docRef));

    await waitFor(() => {
      expect(result.current.isSuccess).toBe(true);
    });

    const finalSnapshot = await getDoc(docRef);
    expect(finalSnapshot.exists()).toBe(false);
  });

  test("handles type-safe document references", async () => {
    interface TestDoc {
      foo: string;
      num: number;
    }

    const docRef = doc(
      firestore,
      "tests",
      "typedDoc"
    ) as DocumentReference<TestDoc>;
    await setDoc(docRef, { foo: "test", num: 123 });

    const { result } = renderHook(() => useDeleteDocumentMutation(), {
      wrapper,
    });

    await act(() => result.current.mutate(docRef));

    await waitFor(() => {
      expect(result.current.isSuccess).toBe(true);
    });

    const snapshot = await getDoc(docRef);
    expect(snapshot.exists()).toBe(false);
  });

  test("handles errors when deleting from restricted collection", async () => {
    const restrictedDocRef = doc(firestore, "restrictedCollection", "someDoc");

    const { result } = renderHook(() => useDeleteDocumentMutation(), {
      wrapper,
    });

    await act(() => result.current.mutate(restrictedDocRef));

    await waitFor(() => {
      expect(result.current.isError).toBe(true);
    });

    expectFirestoreError(result.current.error, "permission-denied");
  });

  test("calls onSuccess callback after deletion", async () => {
    const docRef = doc(firestore, "tests", "callbackTest");
    await setDoc(docRef, { foo: "callback" });

    let callbackCalled = false;

    const { result } = renderHook(
      () =>
        useDeleteDocumentMutation({
          onSuccess: () => {
            callbackCalled = true;
          },
        }),
      { wrapper }
    );

    await act(() => result.current.mutate(docRef));

    await waitFor(() => {
      expect(result.current.isSuccess).toBe(true);
    });

    expect(callbackCalled).toBe(true);
    const snapshot = await getDoc(docRef);
    expect(snapshot.exists()).toBe(false);
  });

  test("handles deletion of non-existent document", async () => {
    const nonExistentDocRef = doc(firestore, "tests", "doesNotExist");

    const { result } = renderHook(() => useDeleteDocumentMutation(), {
      wrapper,
    });

    await act(() => result.current.mutate(nonExistentDocRef));

    await waitFor(() => {
      expect(result.current.isSuccess).toBe(true);
    });

    const snapshot = await getDoc(nonExistentDocRef);
    expect(snapshot.exists()).toBe(false);
  });
});