@hyper-fetch/firebase-admin 7.5.2 → 8.0.0

package/__tests__/features/firestore/shared/methods/set-doc.test.suite.ts

@@ -0,0 +1,70 @@
+import { Client } from "@hyper-fetch/core";
+
+import type { Tea } from "../../../../utils";
+import type { FirebaseAdminAdapter } from "adapter";
+import { testLifecycleEvents } from "../../../../shared/request-events.shared";
+
+export const setDocTestSuite = (adapterFunction: () => ReturnType<typeof FirebaseAdminAdapter>) => {
+  describe("setDoc", () => {
+    it("should set data", async () => {
+      const newData = { origin: "Poland", type: "Green", year: 2023, name: "Pou Ran Do Cha", amount: 10 } as Tea;
+      const client = new Client({ url: "teas/" }).setAdapter(adapterFunction());
+      const getReq = client
+        .createRequest<{ response: Tea }>()({
+          endpoint: ":teaId",
+          method: "getDoc",
+        })
+        .setParams({ teaId: 1 });
+      const setReq = client
+        .createRequest<{ response: Tea; payload: Tea }>()({
+          endpoint: ":teaId",
+          method: "setDoc",
+        })
+        .setParams({ teaId: 1 })
+        .setPayload(newData);
+
+      await setReq.send();
+      const { data } = await getReq.send();
+
+      expect(data).toStrictEqual({ ...newData, __key: "1" });
+    });
+    it("should merge data if merge options is passed", async () => {
+      const client = new Client({ url: "teas/" }).setAdapter(adapterFunction());
+      const getReq = client
+        .createRequest<{ response: Tea }>()({
+          endpoint: ":teaId",
+          method: "getDoc",
+        })
+        .setParams({ teaId: 1 });
+      const { data: existingData } = await getReq.send();
+      const setReq = client
+        .createRequest<{ response: Tea; payload: Tea }>()({
+          endpoint: ":teaId",
+          method: "setDoc",
+          options: { merge: true },
+        })
+        .setParams({ teaId: 1 })
+        .setPayload({ name: "Pou Ran Do Cha" } as Tea);
+
+      await setReq.send();
+      const { data } = await getReq.send();
+
+      expect(data).toStrictEqual({ ...existingData, name: "Pou Ran Do Cha" });
+      // expect(extra.snapshot.exists()).toBe(true);
+    });
+    it("should emit lifecycle events", async () => {
+      const client = new Client({ url: "teas/" }).setAdapter(adapterFunction());
+
+      const request = client
+        .createRequest<{ response: Tea; payload: Tea }>()({
+          endpoint: ":teaId",
+          method: "setDoc",
+          options: { merge: true },
+        })
+        .setParams({ teaId: 1 })
+        .setPayload({ name: "Pou Ran Do Cha" } as Tea);
+
+      await testLifecycleEvents(request);
+    });
+  });
+};

package/__tests__/features/firestore/shared/methods/update-doc.test.suite.ts

@@ -0,0 +1,40 @@
+import { Client } from "@hyper-fetch/core";
+
+import type { FirebaseAdminAdapter } from "adapter";
+import type { Tea } from "../../../../utils";
+import { testLifecycleEvents } from "../../../../shared/request-events.shared";
+
+export const updateDocTestSuite = (adapterFunction: () => ReturnType<typeof FirebaseAdminAdapter>) => {
+  describe("updateDoc", () => {
+    it("should allow for updating data", async () => {
+      const newData = { name: "Pou Ran Do Cha", amount: 100, year: 966 } as Tea;
+      const client = new Client({ url: "teas/" }).setAdapter(adapterFunction());
+      const updateReq = client
+        .createRequest<{ response: Tea; payload: Tea }>()({
+          endpoint: ":teaId",
+          method: "updateDoc",
+        })
+        .setPayload(newData);
+      const getReq = client.createRequest<{ response: Tea }>()({
+        endpoint: ":teaId",
+        method: "getDoc",
+      });
+      await updateReq.send({ params: { teaId: 1 } });
+      const { data } = await getReq.send({ params: { teaId: 1 } });
+      expect(data).toStrictEqual({ ...newData, origin: "China", type: "Green", __key: "1" });
+    });
+    it("should emit lifecycle events", async () => {
+      const client = new Client({ url: "teas/" }).setAdapter(adapterFunction());
+      const newData = { name: "Pou Ran Do Cha", amount: 100, year: 966 } as Tea;
+
+      const request = client
+        .createRequest<{ response: Tea; payload: Tea }>()({
+          endpoint: ":teaId",
+          method: "updateDoc",
+        })
+        .setPayload(newData);
+
+      await testLifecycleEvents(request);
+    });
+  });
+};

package/__tests__/features/firestore/shared/methods.shared.tests.ts

@@ -0,0 +1,24 @@
+import type { FirebaseAdminAdapter, FirebaseAdminAdapterTypes, FirebaseAdminSocketAdapterTypes } from "adapter";
+import { addDocTestSuite } from "./methods/add-doc.test.suite";
+import { deleteDocTestSuite } from "./methods/delete-doc.test.suite";
+import { getDocTestSuite } from "./methods/get-doc.test.suite";
+import { getDocsTestSuite } from "./methods/get-docs.test.suite";
+import { setDocTestSuite } from "./methods/set-doc.test.suite";
+import { updateDocTestSuite } from "./methods/update-doc.test.suite";
+import { onSnapshotTestSuite } from "./methods/on-snapshot.test.suite";
+
+export const methodsSharedTestCases = (adapterFunction: () => ReturnType<typeof FirebaseAdminAdapter>) => {
+  addDocTestSuite(adapterFunction);
+  deleteDocTestSuite(adapterFunction);
+  getDocTestSuite(adapterFunction);
+  getDocsTestSuite(adapterFunction);
+  setDocTestSuite(adapterFunction);
+  updateDocTestSuite(adapterFunction);
+};
+
+export const socketsMethodsSharedTestCases = (
+  adapter: FirebaseAdminSocketAdapterTypes<any>,
+  coreAdapter: FirebaseAdminAdapterTypes<any>,
+) => {
+  onSnapshotTestSuite(adapter, coreAdapter);
+};

package/__tests__/features/realtime/admin/constraints.admin.spec.ts

@@ -0,0 +1,15 @@
+import { FirebaseAdminAdapter } from "adapter";
+import { seedRealtimeDatabaseAdmin } from "../../../utils/seed.admin";
+import { realtimeDbAdmin } from "../../../utils";
+import { constraintsSharedTestCases } from "../shared/constraints.shared.tests";
+
+describe("Realtime Database Admin [Constraints]", () => {
+  let db: any;
+  beforeEach(async () => {
+    db = await realtimeDbAdmin;
+    await db.ref("teas").set(null);
+    await seedRealtimeDatabaseAdmin(db);
+  });
+
+  constraintsSharedTestCases(() => FirebaseAdminAdapter(db));
+});

package/__tests__/features/realtime/admin/methods.admin.spec.ts

@@ -0,0 +1,24 @@
+/**
+ * @vitest-environment node
+ */
+import { realtimeDbAdmin, seedRealtimeDatabaseAdmin } from "../../../utils";
+import { FirebaseAdminAdapter } from "adapter";
+import { methodsSharedTestCases } from "../shared/methods.shared.tests";
+
+describe("Realtime Database Admin [ Methods ]", () => {
+  let db: any;
+
+  beforeAll(async () => {
+    db = await realtimeDbAdmin;
+  });
+  beforeEach(async () => {
+    await db.ref("teas").set(null);
+    await seedRealtimeDatabaseAdmin(db);
+  });
+
+  afterEach(async () => {
+    await db.ref("teas").set(null);
+  });
+
+  methodsSharedTestCases(() => FirebaseAdminAdapter(db));
+});

package/__tests__/features/realtime/admin/sockets.base.spec.ts

@@ -0,0 +1,15 @@
+/**
+ * @vitest-environment node
+ */
+import { realtimeDbAdmin, seedRealtimeDatabaseAdmin } from "../../../utils";
+import { socketsMethodsSharedTestCases } from "../shared/methods.shared.tests";
+import { FirebaseSocketsAdminAdapter, FirebaseAdminAdapter } from "adapter";
+
+describe("Realtime Database Admin [Sockets]", () => {
+  socketsMethodsSharedTestCases(
+    realtimeDbAdmin,
+    seedRealtimeDatabaseAdmin,
+    FirebaseSocketsAdminAdapter,
+    FirebaseAdminAdapter,
+  );
+});

package/__tests__/features/realtime/shared/constraints.shared.tests.ts

@@ -0,0 +1,57 @@
+import { Client } from "@hyper-fetch/core";
+
+import type { FirebaseAdminAdapter } from "../../../../src";
+import { $endAt, $limitToFirst, $orderByChild, $startAt } from "../../../../src";
+import type { Tea } from "../../../utils";
+
+export const constraintsSharedTestCases = (adapterFunction: () => ReturnType<typeof FirebaseAdminAdapter>) => {
+  describe("Ordering", () => {
+    it("Should allow ordering by child", async () => {
+      const client = new Client({ url: "teas/" }).setAdapter(adapterFunction());
+      const req = client.createRequest<{ response: Tea[] }>()({
+        endpoint: "",
+        method: "getDocs",
+      });
+      const { data } = await req.send({
+        queryParams: { constraints: [$orderByChild("origin")] },
+      });
+      expect(data?.map((el) => el.origin)).toStrictEqual([
+        "China",
+        "China",
+        "China",
+        "China",
+        "China",
+        "China",
+        "China",
+        "Japan",
+        "Taiwan",
+        "Taiwan",
+      ]);
+    });
+  });
+  describe("Filtering and ordering", () => {
+    it("Should allow to limit the result and order it", async () => {
+      const client = new Client({ url: "teas/" }).setAdapter(adapterFunction());
+      const req = client.createRequest<{ response: Tea[] }>()({
+        endpoint: "",
+        method: "getDocs",
+      });
+      const { data } = await req.send({
+        queryParams: { constraints: [$orderByChild("origin"), $limitToFirst(5)] },
+      });
+      expect(data?.map((tea) => tea.origin)).toStrictEqual(["China", "China", "China", "China", "China"]);
+    });
+    it("Should allow to combine multiple filters", async () => {
+      const client = new Client({ url: "teas/" }).setAdapter(adapterFunction());
+      const req = client.createRequest<{ response: Tea[] }>()({
+        endpoint: "",
+        method: "getDocs",
+      });
+      const { data } = await req.send({
+        queryParams: { constraints: [$orderByChild("year"), $startAt(2021), $endAt(2022)] },
+      });
+      expect(data).toHaveLength(5);
+      expect(data?.map((tea) => tea.year)).toStrictEqual([2021, 2021, 2021, 2022, 2022]);
+    });
+  });
+};

package/__tests__/features/realtime/shared/methods/get.test.suite.ts

@@ -0,0 +1,64 @@
+import { Client } from "@hyper-fetch/core";
+
+import type { FirebaseAdminAdapter } from "adapter";
+import { testLifecycleEvents } from "../../../../shared/request-events.shared";
+import type { Tea } from "../../../../utils";
+
+export const getTestSuite = (adapterFunction: () => ReturnType<typeof FirebaseAdminAdapter>) => {
+  describe("get", () => {
+    let client = new Client({ url: "teas/" }).setAdapter(adapterFunction());
+    let clientBees = new Client({ url: "bees/" }).setAdapter(adapterFunction());
+    beforeEach(() => {
+      clientBees = new Client({ url: "bees/" }).setAdapter(adapterFunction());
+      client = new Client({ url: "teas/" }).setAdapter(adapterFunction());
+    });
+
+    it("should return data available for endpoint", async () => {
+      const req = client.createRequest<{ response: Tea[] }>()({
+        endpoint: "",
+        method: "get",
+      });
+      const { data, extra, status, success, error } = await req.send();
+      expect(data).toHaveLength(10);
+      expect(data![0]).toHaveProperty("__key");
+      expect(extra).toHaveProperty("snapshot");
+      expect(extra).toHaveProperty("ref");
+      expect(status).toBe("success");
+      expect(success).toBe(true);
+      expect(error).toBe(null);
+    });
+    it("should return data for dynamic endpoint", async () => {
+      const req = client
+        .createRequest<{ response: Tea }>()({
+          endpoint: ":teaId",
+          method: "get",
+        })
+        .setParams({ teaId: 1 });
+
+      const { data } = await req.send();
+      expect(data).toStrictEqual({ amount: 150, name: "Taiping Hou Kui", origin: "China", type: "Green", year: 2023 });
+    });
+    it("should return emptyResource status for non existing resource", async () => {
+      const req = clientBees
+        .createRequest<{ response: Tea }>()({
+          endpoint: ":teaId",
+          method: "get",
+        })
+        .setParams({ teaId: 1 });
+
+      const { data, status } = await req.send();
+      expect(data).toStrictEqual(null);
+      expect(status).toStrictEqual("emptyResource");
+    });
+    it("should emit lifecycle events", async () => {
+      const req = clientBees
+        .createRequest<{ response: Tea }>()({
+          endpoint: ":teaId",
+          method: "get",
+        })
+        .setParams({ teaId: 1 });
+
+      await testLifecycleEvents(req);
+    });
+  });
+};

package/__tests__/features/realtime/shared/methods/on-value.test.suite.ts

@@ -0,0 +1,190 @@
+/* eslint-disable max-params */
+import { Socket } from "@hyper-fetch/sockets";
+import { Client } from "@hyper-fetch/core";
+import waitForExpect from "wait-for-expect";
+
+import type { FirebaseAdminAdapterTypes, FirebaseAdminSocketAdapterTypes } from "adapter";
+import type { Tea } from "../../../../utils";
+
+export const onValueTestSuite = (
+  db: Promise<any>,
+  seedDb: (initializedDb: any) => Promise<void>,
+  socketsAdapter: (database: any) => FirebaseAdminSocketAdapterTypes<any>,
+  coreAdapter: (database: any) => FirebaseAdminAdapterTypes<any>,
+) => {
+  describe("when using onValue method", () => {
+    let initializedSocketsAdapter: any;
+    let initializedCoreAdapter: any;
+    let initializedDb: any;
+    let spy = vi.fn();
+    const newData = { origin: "Poland", type: "Green", year: 2043, name: "Pou Ran Do Cha", amount: 100 } as Tea;
+
+    beforeAll(async () => {
+      initializedDb = await db;
+      initializedSocketsAdapter = socketsAdapter(initializedDb);
+      initializedCoreAdapter = coreAdapter(initializedDb);
+    });
+
+    beforeEach(async () => {
+      await seedDb(initializedDb);
+    });
+
+    const initialize = async () => {
+      const client = new Client({ url: "teas/" }).setAdapter(initializedCoreAdapter);
+      const socket = new Socket({ url: "teas/", adapter: initializedSocketsAdapter });
+      const pushReq = client
+        .createRequest<{ response: Tea; payload: Tea }>()({
+          endpoint: "",
+          method: "push",
+        })
+        .setPayload(newData);
+      const socketBees = new Socket({ url: "bees/", adapter: initializedSocketsAdapter });
+
+      return { client, socket, pushReq, socketBees };
+    };
+
+    beforeEach(() => {
+      vi.resetAllMocks();
+      vi.clearAllMocks();
+      spy = vi.fn();
+    });
+
+    it("should return unmount function", async () => {
+      const { socket } = await initialize();
+      const onValueReq = socket.createListener<Tea[]>()({
+        topic: "",
+      });
+      const unmount = onValueReq.listen(spy);
+      expect(typeof unmount).toBe("function");
+    });
+
+    it("should unmount listeners", async () => {
+      const { socket, pushReq } = await initialize();
+      const onValueReq = socket.createListener<Tea[]>()({
+        topic: "",
+      });
+      const unmount = onValueReq.listen(spy);
+
+      await waitForExpect(async () => {
+        expect(spy).toHaveBeenCalledTimes(1);
+      });
+
+      unmount();
+
+      await pushReq.send();
+      await pushReq.send();
+
+      await waitForExpect(async () => {
+        expect(spy).toHaveBeenCalledTimes(1);
+      }, 1000);
+
+      expect(socket.adapter.listeners.get(onValueReq.topic)?.size).toBe(0);
+    });
+
+    it("should return emptyResource status", async () => {
+      const { socketBees } = await initialize();
+      const onValueReq = socketBees.createListener<Tea[]>()({
+        topic: "",
+        options: { onlyOnce: false },
+      });
+
+      let receivedData: any;
+      let receivedExtra: any;
+
+      const unmount = onValueReq.listen(({ data, extra }) => {
+        spy();
+        receivedData = data;
+        receivedExtra = extra;
+      });
+
+      await waitForExpect(async () => {
+        expect(spy).toHaveBeenCalled();
+        expect(receivedData).toBeNull();
+        expect(receivedExtra.status).toBe("emptyResource");
+      });
+
+      unmount();
+    });
+
+    it("should be called once with onlyOnce option", async () => {
+      const { socket, pushReq } = await initialize();
+      const onValueReq = socket.createListener<Tea[]>()({
+        topic: "",
+        options: { onlyOnce: true },
+      });
+
+      const unmount = onValueReq.listen(spy);
+
+      await pushReq.send();
+
+      await waitForExpect(async () => {
+        expect(spy).toHaveBeenCalledTimes(1);
+      });
+
+      unmount();
+    });
+
+    it("should receive updates", async () => {
+      const { socket, pushReq } = await initialize();
+
+      const onValueReq = socket.createListener<Tea[]>()({
+        topic: "",
+        options: { onlyOnce: false },
+      });
+
+      let receivedData: Tea[] | null;
+      let receivedExtra: any;
+
+      const unmount = onValueReq.listen(({ data, extra }) => {
+        spy();
+        receivedData = data;
+        receivedExtra = extra;
+      });
+
+      const { data } = await pushReq.send();
+
+      await waitForExpect(async () => {
+        expect(receivedData).toEqual(expect.arrayContaining([{ ...newData, __key: data?.__key }]));
+        expect(receivedExtra).toHaveProperty("snapshot");
+        expect(receivedExtra).toHaveProperty("status");
+        expect(receivedExtra).toHaveProperty("ref");
+        expect(receivedExtra.status).toBe("success");
+      });
+
+      unmount();
+    });
+
+    it("should return data available for doc", async () => {
+      const { socket } = await initialize();
+      const onValueReq = socket
+        .createListener<Tea[]>()({
+          topic: ":teaId",
+        })
+        .setParams({ teaId: 1 });
+
+      let receivedData: any;
+      let receivedExtra: any;
+      const unmount = onValueReq.listen(({ data, extra }) => {
+        spy();
+        receivedData = data;
+        receivedExtra = extra;
+      });
+
+      await waitForExpect(async () => {
+        expect(receivedData).toStrictEqual({
+          __key: "1",
+          amount: 150,
+          name: "Taiping Hou Kui",
+          origin: "China",
+          type: "Green",
+          year: 2023,
+        });
+        expect(receivedExtra).toHaveProperty("snapshot");
+        expect(receivedExtra).toHaveProperty("ref");
+        expect(receivedExtra.status).toBe("success");
+      });
+
+      unmount();
+    });
+  });
+};

package/__tests__/features/realtime/shared/methods/push.test.suite.ts

@@ -0,0 +1,48 @@
+import { Client } from "@hyper-fetch/core";
+
+import type { FirebaseAdminAdapter } from "adapter";
+import { testLifecycleEvents } from "../../../../shared/request-events.shared";
+import type { Tea } from "../../../../utils";
+
+export const pushTestSuite = (adapterFunction: () => ReturnType<typeof FirebaseAdminAdapter>) => {
+  describe("push", () => {
+    let client = new Client({ url: "teas/" }).setAdapter(adapterFunction());
+    beforeEach(() => {
+      client = new Client({ url: "teas/" }).setAdapter(adapterFunction());
+    });
+
+    it("should allow for adding data to a list", async () => {
+      const newData = { origin: "Poland", type: "Green", year: 2023, name: "Pou Ran Do Cha", amount: 100 } as Tea;
+      const getReq = client.createRequest<{ response: Tea[] }>()({
+        endpoint: "",
+        method: "getDoc",
+      });
+      const pushReq = client
+        .createRequest<{ response: Tea; payload: Tea }>()({
+          endpoint: "",
+          method: "setDoc",
+          options: {},
+        })
+        .setPayload(newData);
+      const { data: pushedData, extra } = await pushReq.send();
+      const { data } = await getReq.send();
+
+      expect(data).toHaveLength(11);
+      expect(data).toContainEqual({ ...newData, __key: pushedData?.__key });
+      expect(extra).toHaveProperty("key");
+    });
+    it("should emit lifecycle events", async () => {
+      const newData = { origin: "Poland", type: "Green", year: 2043, name: "Pou Ran Do Cha", amount: 100 } as Tea;
+
+      const pushReq = client
+        .createRequest<{ response: Tea; payload: Tea }>()({
+          endpoint: "teas/",
+          method: "setDoc",
+          options: {},
+        })
+        .setPayload(newData);
+
+      await testLifecycleEvents(pushReq);
+    });
+  });
+};

package/__tests__/features/realtime/shared/methods/remove.test.suite.ts

@@ -0,0 +1,46 @@
+import { Client } from "@hyper-fetch/core";
+
+import type { FirebaseAdminAdapter } from "adapter";
+import { testLifecycleEvents } from "../../../../shared/request-events.shared";
+import type { Tea } from "../../../../utils";
+
+export const removeTestSuite = (adapterFunction: () => ReturnType<typeof FirebaseAdminAdapter>) => {
+  let client = new Client({ url: "teas/" }).setAdapter(adapterFunction());
+  beforeEach(() => {
+    client = new Client({ url: "teas/" }).setAdapter(adapterFunction());
+  });
+  describe("remove", () => {
+    it("should allow for removing data", async () => {
+      const getReq = client
+        .createRequest<{ response: Tea }>()({
+          endpoint: ":teaId",
+          method: "getDoc",
+        })
+        .setParams({ teaId: 1 });
+
+      const removeReq = client
+        .createRequest<{ response: Tea }>()({
+          endpoint: ":teaId",
+          method: "deleteDoc",
+        })
+        .setParams({ teaId: 1 });
+
+      await removeReq.send();
+      const { data, extra } = await getReq.send();
+      expect(data).toBe(null);
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      expect(extra?.snapshot?.exists()).toBe(false);
+    });
+    it("should emit lifecycle events", async () => {
+      const removeReq = client
+        .createRequest<{ response: Tea }>()({
+          endpoint: ":teaId",
+          method: "deleteDoc",
+        })
+        .setParams({ teaId: 1 });
+
+      await testLifecycleEvents(removeReq);
+    });
+  });
+};

package/__tests__/features/realtime/shared/methods/set.test.suite.ts

@@ -0,0 +1,70 @@
+import { Client } from "@hyper-fetch/core";
+
+import type { FirebaseAdminAdapter, RealtimeDbGetMethodExtra } from "adapter";
+import { testLifecycleEvents } from "../../../../shared/request-events.shared";
+import type { Tea } from "../../../../utils";
+
+export const setTestSuite = (adapterFunction: () => ReturnType<typeof FirebaseAdminAdapter>) => {
+  describe("set", () => {
+    let client = new Client({ url: "teas/" }).setAdapter(adapterFunction());
+    beforeEach(() => {
+      client = new Client({ url: "teas/" }).setAdapter(adapterFunction());
+    });
+    it("should set data", async () => {
+      const newData = { origin: "Poland", type: "Green", year: 2023, name: "Pou Ran Do Cha", amount: 10 } as Tea;
+
+      const getReq = client
+        .createRequest<{ response: Tea }>()({
+          endpoint: ":teaId",
+          method: "get",
+        })
+        .setParams({ teaId: 1 });
+      const setReq = client
+        .createRequest<{ response: Tea; payload: Tea }>()({
+          endpoint: ":teaId",
+          method: "set",
+        })
+        .setParams({ teaId: 1 })
+        .setPayload(newData);
+
+      await setReq.send();
+      const { data, extra } = await getReq.send();
+      expect(data).toStrictEqual(newData);
+      expect(extra).not.toBeNull();
+      expect((extra as RealtimeDbGetMethodExtra).snapshot.exists()).toBe(true);
+    });
+    it("should allow for removing data via set", async () => {
+      const getReq = client
+        .createRequest<{ response: Tea | null }>()({
+          endpoint: ":teaId",
+          method: "get",
+        })
+        .setParams({ teaId: 1 });
+
+      const setReq = client
+        .createRequest<{ response: Tea | null; payload: { data: null } }>()({
+          endpoint: ":teaId",
+          method: "set",
+        })
+        .setParams({ teaId: 1 })
+        .setPayload({ data: null });
+
+      await setReq.send();
+      const { data, extra } = await getReq.send();
+      expect(data).toBe(null);
+      expect(extra).not.toBeNull();
+      expect((extra as RealtimeDbGetMethodExtra).snapshot.exists()).toBe(false);
+    });
+    it("should emit lifecycle events", async () => {
+      const setReq = client
+        .createRequest<{ response: Tea | null; payload: { data: null } }>()({
+          endpoint: ":teaId",
+          method: "set",
+        })
+        .setParams({ teaId: 1 })
+        .setPayload({ data: null });
+
+      await testLifecycleEvents(setReq);
+    });
+  });
+};