@lookiero/checkout 5.3.0 → 6.0.0-beta.0

package/src/infrastructure/tracking/useTrackItemPageView.ts

@@ -0,0 +1,72 @@
+import { useLayoutEffect } from "react";
+import { Segment } from "@lookiero/sty-psp-segment";
+import { useEmitUserEvent } from "@lookiero/sty-psp-tracking";
+import { CheckoutItemStatus } from "../../domain/checkoutItem/model/checkoutItem";
+import { Country } from "../../projection/shared/country";
+import { ItemPageViewTrackingEvent, TrackingEventName, TrackingEventCategory } from "./tracking";
+import { PROJECT, TrackingPage } from "./tracking";
+
+interface UseTrackItemPageViewFunctionArgs {
+  readonly page: TrackingPage;
+  readonly country: Country;
+  readonly segment: Segment;
+  readonly checkoutId?: string;
+  readonly checkoutItemId: string;
+  readonly productVariantId: string;
+  readonly replaceableFor: string[] | undefined;
+  readonly status: CheckoutItemStatus;
+  readonly unique: boolean;
+}
+
+interface UseTrackItemPageViewFunction {
+  (agrs: UseTrackItemPageViewFunctionArgs): void;
+}
+
+const useTrackItemPageView: UseTrackItemPageViewFunction = ({
+  page,
+  country,
+  segment,
+  checkoutId,
+  checkoutItemId,
+  productVariantId,
+  replaceableFor,
+  status,
+  unique,
+}) => {
+  const emitUserEvent = useEmitUserEvent<ItemPageViewTrackingEvent>();
+
+  useLayoutEffect(() => {
+    if (!(checkoutId && replaceableFor)) {
+      return;
+    }
+
+    const itemPageViewTrackingEvent: ItemPageViewTrackingEvent = {
+      event: TrackingEventName.PAGEVIEW,
+      eventCategory: TrackingEventCategory.NAVIGATION,
+      section: `${PROJECT}_${page}`,
+      store: country,
+      segment,
+      checkoutId,
+      checkoutItemId,
+      status,
+      productVariantId,
+      replaceableFor: replaceableFor.toString(),
+      unique,
+    };
+
+    emitUserEvent(itemPageViewTrackingEvent);
+  }, [
+    checkoutId,
+    checkoutItemId,
+    country,
+    emitUserEvent,
+    page,
+    productVariantId,
+    replaceableFor,
+    segment,
+    status,
+    unique,
+  ]);
+};
+
+export { useTrackItemPageView };

package/src/infrastructure/tracking/useTrackKeepItem.test.tsx

@@ -0,0 +1,43 @@
+import { renderHook } from "@testing-library/react-native";
+import { Segment } from "@lookiero/sty-psp-segment";
+import { useEmitUserEvent } from "@lookiero/sty-psp-tracking";
+import { Country } from "../../projection/shared/country";
+import { KeepItemTrackingEvent, TrackingEventName, TrackingEventCategory } from "./tracking";
+import { TrackingPage } from "./tracking";
+import { useTrackKeepItem as sut } from "./useTrackKeepItem";
+
+const mockEmitUserEvent = jest.fn();
+jest.mock("@lookiero/sty-psp-tracking");
+
+const country = Country.ES;
+const segment = Segment.WOMEN;
+
+const event: KeepItemTrackingEvent = {
+  event: TrackingEventName.KEEP_ITEM,
+  eventCategory: TrackingEventCategory.NAVIGATION,
+  section: "checkout_item",
+  store: country,
+  segment,
+  checkoutId: "c513ebc8-df68-4f47-b899-8ec0ced84ca8",
+  checkoutItemId: "a72120a3-6837-4fe9-adc3-a891b14160ff",
+};
+
+describe("useTrackKeepItem custom hook", () => {
+  test("renders correctly", () => {
+    (useEmitUserEvent as jest.Mock).mockImplementation(() => mockEmitUserEvent);
+
+    const { result } = renderHook(() =>
+      sut({
+        page: TrackingPage.ITEM,
+        country,
+        segment,
+        checkoutId: "c513ebc8-df68-4f47-b899-8ec0ced84ca8",
+        checkoutItemId: "a72120a3-6837-4fe9-adc3-a891b14160ff",
+      }),
+    );
+
+    result.current();
+
+    expect(mockEmitUserEvent).toHaveBeenCalledWith(event);
+  });
+});

package/src/infrastructure/tracking/useTrackKeepItem.ts

@@ -0,0 +1,47 @@
+import { useCallback } from "react";
+import { Segment } from "@lookiero/sty-psp-segment";
+import { useEmitUserEvent } from "@lookiero/sty-psp-tracking";
+import { Country } from "../../projection/shared/country";
+import { KeepItemTrackingEvent, TrackingEventName, TrackingEventCategory } from "./tracking";
+import { PROJECT, TrackingPage } from "./tracking";
+
+interface KeepItemFunction {
+  (): void;
+}
+
+interface UseTrackKeepItemFunctionArgs {
+  readonly page: TrackingPage;
+  readonly country: Country;
+  readonly segment: Segment;
+  readonly checkoutId: string | undefined;
+  readonly checkoutItemId: string;
+}
+interface UseTrackKeepItemFunction {
+  (agrs: UseTrackKeepItemFunctionArgs): KeepItemFunction;
+}
+
+const useTrackKeepItem: UseTrackKeepItemFunction = ({ page, country, segment, checkoutId, checkoutItemId }) => {
+  const emitUserEvent = useEmitUserEvent<KeepItemTrackingEvent>();
+
+  const keepItem: KeepItemFunction = useCallback(() => {
+    if (!checkoutId) {
+      return;
+    }
+
+    const keepItemTrackingEvent: KeepItemTrackingEvent = {
+      event: TrackingEventName.KEEP_ITEM,
+      eventCategory: TrackingEventCategory.NAVIGATION,
+      section: `${PROJECT}_${page}`,
+      store: country,
+      segment,
+      checkoutId,
+      checkoutItemId,
+    };
+
+    emitUserEvent(keepItemTrackingEvent);
+  }, [checkoutId, checkoutItemId, country, emitUserEvent, page, segment]);
+
+  return keepItem;
+};
+
+export { useTrackKeepItem };

package/src/infrastructure/tracking/useTrackPageView.test.tsx

@@ -0,0 +1,40 @@
+import { renderHook } from "@testing-library/react-native";
+import { Segment } from "@lookiero/sty-psp-segment";
+import { useEmitUserEvent } from "@lookiero/sty-psp-tracking";
+import { Country } from "../../projection/shared/country";
+import { TrackingEventName, TrackingEventCategory, PageViewTrackingEvent } from "./tracking";
+import { TrackingPage } from "./tracking";
+import { useTrackPageView as sut } from "./useTrackPageView";
+
+const mockEmitUserEvent = jest.fn();
+jest.mock("@lookiero/sty-psp-tracking");
+
+const checkoutId = "c513ebc8-df68-4f47-b899-8ec0ced84ca8";
+const country = Country.ES;
+const segment = Segment.WOMEN;
+
+const event: PageViewTrackingEvent = {
+  event: TrackingEventName.PAGEVIEW,
+  eventCategory: TrackingEventCategory.NAVIGATION,
+  section: "checkout_item",
+  store: country,
+  segment,
+  checkoutId,
+};
+
+describe("useTrackPageView custom hook", () => {
+  test("renders correctly", () => {
+    (useEmitUserEvent as jest.Mock).mockImplementation(() => mockEmitUserEvent);
+
+    renderHook(() =>
+      sut({
+        page: TrackingPage.ITEM,
+        country,
+        segment,
+        checkoutId,
+      }),
+    );
+
+    expect(mockEmitUserEvent).toHaveBeenCalledWith(event);
+  });
+});

package/src/infrastructure/tracking/useTrackPageView.ts

@@ -0,0 +1,39 @@
+import { useLayoutEffect } from "react";
+import { Segment } from "@lookiero/sty-psp-segment";
+import { useEmitUserEvent } from "@lookiero/sty-psp-tracking";
+import { Country } from "../../projection/shared/country";
+import { PROJECT, TrackingPage, PageViewTrackingEvent, TrackingEventName, TrackingEventCategory } from "./tracking";
+
+interface UseTrackPageViewFunctionArgs {
+  readonly page: TrackingPage;
+  readonly country: Country;
+  readonly segment: Segment;
+  readonly checkoutId: string | undefined;
+}
+
+interface UseTrackPageViewFunction {
+  (agrs: UseTrackPageViewFunctionArgs): void;
+}
+
+const useTrackPageView: UseTrackPageViewFunction = ({ page, country, segment, checkoutId }) => {
+  const emitUserEvent = useEmitUserEvent<PageViewTrackingEvent>();
+
+  useLayoutEffect(() => {
+    if (!checkoutId) {
+      return;
+    }
+
+    const pageViewTrackingEvent: PageViewTrackingEvent = {
+      event: TrackingEventName.PAGEVIEW,
+      eventCategory: TrackingEventCategory.NAVIGATION,
+      section: `${PROJECT}_${page}`,
+      store: country,
+      segment,
+      checkoutId,
+    };
+
+    emitUserEvent(pageViewTrackingEvent);
+  }, [checkoutId, country, emitUserEvent, page, segment]);
+};
+
+export { useTrackPageView };

package/src/infrastructure/tracking/useTrackPressBack.test.tsx

@@ -0,0 +1,41 @@
+import { renderHook } from "@testing-library/react-native";
+import { Segment } from "@lookiero/sty-psp-segment";
+import { useEmitUserEvent } from "@lookiero/sty-psp-tracking";
+import { Country } from "../../projection/shared/country";
+import { PressBackTrackingEvent, TrackingEventName, TrackingEventCategory } from "./tracking";
+import { TrackingPage } from "./tracking";
+import { useTrackPressBack as sut } from "./useTrackPressBack";
+
+const mockEmitUserEvent = jest.fn();
+jest.mock("@lookiero/sty-psp-tracking");
+
+const country = Country.ES;
+const segment = Segment.WOMEN;
+
+const event: PressBackTrackingEvent = {
+  event: TrackingEventName.PRESS_BACK,
+  eventCategory: TrackingEventCategory.NAVIGATION,
+  section: "checkout_item",
+  store: country,
+  segment,
+  checkoutId: "c513ebc8-df68-4f47-b899-8ec0ced84ca8",
+};
+
+describe("useTrackPressBack custom hook", () => {
+  test("renders correctly", () => {
+    (useEmitUserEvent as jest.Mock).mockImplementation(() => mockEmitUserEvent);
+
+    const { result } = renderHook(() =>
+      sut({
+        page: TrackingPage.ITEM,
+        country,
+        segment,
+        checkoutId: "c513ebc8-df68-4f47-b899-8ec0ced84ca8",
+      }),
+    );
+
+    result.current();
+
+    expect(mockEmitUserEvent).toHaveBeenCalledWith(event);
+  });
+});

package/src/infrastructure/tracking/useTrackPressBack.ts

@@ -0,0 +1,45 @@
+import { useCallback } from "react";
+import { Segment } from "@lookiero/sty-psp-segment";
+import { useEmitUserEvent } from "@lookiero/sty-psp-tracking";
+import { Country } from "../../projection/shared/country";
+import { PROJECT, TrackingPage, PressBackTrackingEvent, TrackingEventName, TrackingEventCategory } from "./tracking";
+
+interface PressBackFunction {
+  (): void;
+}
+
+interface UseTrackPressBackFunctionArgs {
+  readonly page: TrackingPage;
+  readonly country: Country;
+  readonly segment: Segment;
+  readonly checkoutId: string | undefined;
+}
+
+interface UseTrackPressBackFunction {
+  (args: UseTrackPressBackFunctionArgs): PressBackFunction;
+}
+
+const useTrackPressBack: UseTrackPressBackFunction = ({ page, country, segment, checkoutId }) => {
+  const emitUserEvent = useEmitUserEvent<PressBackTrackingEvent>();
+
+  const pressBack: PressBackFunction = useCallback(() => {
+    if (!checkoutId) {
+      return;
+    }
+
+    const pressBackTrackingEvent: PressBackTrackingEvent = {
+      event: TrackingEventName.PRESS_BACK,
+      eventCategory: TrackingEventCategory.NAVIGATION,
+      section: `${PROJECT}_${page}`,
+      store: country,
+      segment,
+      checkoutId,
+    };
+
+    emitUserEvent(pressBackTrackingEvent);
+  }, [checkoutId, country, emitUserEvent, page, segment]);
+
+  return pressBack;
+};
+
+export { useTrackPressBack };

package/src/infrastructure/tracking/useTrackPressContinue.test.tsx

@@ -0,0 +1,40 @@
+import { renderHook } from "@testing-library/react-native";
+import { Segment } from "@lookiero/sty-psp-segment";
+import { useEmitUserEvent } from "@lookiero/sty-psp-tracking";
+import { Country } from "../../projection/shared/country";
+import { PressContinueTrackingEvent, TrackingPage, TrackingEventName, TrackingEventCategory } from "./tracking";
+import { useTrackPressContinue as sut } from "./useTrackPressContinue";
+
+const mockEmitUserEvent = jest.fn();
+jest.mock("@lookiero/sty-psp-tracking");
+
+const country = Country.ES;
+const segment = Segment.WOMEN;
+
+const event: PressContinueTrackingEvent = {
+  event: TrackingEventName.PRESS_CONTINUE,
+  eventCategory: TrackingEventCategory.NAVIGATION,
+  section: "checkout_item",
+  store: country,
+  segment,
+  checkoutId: "c513ebc8-df68-4f47-b899-8ec0ced84ca8",
+};
+
+describe("useTrackPressContinue custom hook", () => {
+  test("renders correctly", () => {
+    (useEmitUserEvent as jest.Mock).mockImplementation(() => mockEmitUserEvent);
+
+    const { result } = renderHook(() =>
+      sut({
+        page: TrackingPage.ITEM,
+        country,
+        segment,
+        checkoutId: "c513ebc8-df68-4f47-b899-8ec0ced84ca8",
+      }),
+    );
+
+    result.current();
+
+    expect(mockEmitUserEvent).toHaveBeenCalledWith(event);
+  });
+});

package/src/infrastructure/tracking/useTrackPressContinue.ts

@@ -0,0 +1,50 @@
+import { useCallback } from "react";
+import { Segment } from "@lookiero/sty-psp-segment";
+import { useEmitUserEvent } from "@lookiero/sty-psp-tracking";
+import { Country } from "../../projection/shared/country";
+import {
+  PROJECT,
+  TrackingPage,
+  PressContinueTrackingEvent,
+  TrackingEventName,
+  TrackingEventCategory,
+} from "./tracking";
+
+interface PressContinueFunction {
+  (): void;
+}
+
+interface UseTrackPressContinueFunctionArgs {
+  readonly page: TrackingPage;
+  readonly country: Country;
+  readonly segment: Segment;
+  readonly checkoutId: string | undefined;
+}
+interface UseTrackPressContinueFunction {
+  (agrs: UseTrackPressContinueFunctionArgs): PressContinueFunction;
+}
+
+const useTrackPressContinue: UseTrackPressContinueFunction = ({ page, country, segment, checkoutId }) => {
+  const emitUserEvent = useEmitUserEvent<PressContinueTrackingEvent>();
+
+  const pressContinue: PressContinueFunction = useCallback(() => {
+    if (!checkoutId) {
+      return;
+    }
+
+    const pressContinueTrackingEvent: PressContinueTrackingEvent = {
+      event: TrackingEventName.PRESS_CONTINUE,
+      eventCategory: TrackingEventCategory.NAVIGATION,
+      section: `${PROJECT}_${page}`,
+      store: country,
+      segment,
+      checkoutId,
+    };
+
+    emitUserEvent(pressContinueTrackingEvent);
+  }, [checkoutId, country, emitUserEvent, page, segment]);
+
+  return pressContinue;
+};
+
+export { useTrackPressContinue };

package/src/infrastructure/tracking/useTrackPressItem.test.tsx

@@ -0,0 +1,41 @@
+import { renderHook } from "@testing-library/react-native";
+import { Segment } from "@lookiero/sty-psp-segment";
+import { useEmitUserEvent } from "@lookiero/sty-psp-tracking";
+import { Country } from "../../projection/shared/country";
+import { TrackingPage, PressItemTrackingEvent, TrackingEventName, TrackingEventCategory } from "./tracking";
+import { useTrackPressItem as sut } from "./useTrackPressItem";
+
+const mockEmitUserEvent = jest.fn();
+jest.mock("@lookiero/sty-psp-tracking");
+
+const country = Country.ES;
+const segment = Segment.WOMEN;
+
+const event: PressItemTrackingEvent = {
+  event: TrackingEventName.PRESS_ITEM,
+  eventCategory: TrackingEventCategory.NAVIGATION,
+  section: "checkout_item",
+  store: country,
+  segment,
+  checkoutId: "c513ebc8-df68-4f47-b899-8ec0ced84ca8",
+  checkoutItemId: "a72120a3-6837-4fe9-adc3-a891b14160ff",
+};
+
+describe("useTrackPressItem custom hook", () => {
+  test("renders correctly", () => {
+    (useEmitUserEvent as jest.Mock).mockImplementation(() => mockEmitUserEvent);
+
+    const { result } = renderHook(() =>
+      sut({
+        page: TrackingPage.ITEM,
+        country,
+        segment,
+        checkoutId: "c513ebc8-df68-4f47-b899-8ec0ced84ca8",
+      }),
+    );
+
+    result.current({ checkoutItemId: "a72120a3-6837-4fe9-adc3-a891b14160ff" });
+
+    expect(mockEmitUserEvent).toHaveBeenCalledWith(event);
+  });
+});

package/src/infrastructure/tracking/useTrackPressItem.ts

@@ -0,0 +1,51 @@
+import { useCallback } from "react";
+import { Segment } from "@lookiero/sty-psp-segment";
+import { useEmitUserEvent } from "@lookiero/sty-psp-tracking";
+import { Country } from "../../projection/shared/country";
+import { PROJECT, TrackingPage, PressItemTrackingEvent, TrackingEventName, TrackingEventCategory } from "./tracking";
+
+interface PressItemFunctionArgs {
+  readonly checkoutItemId: string;
+}
+interface PressItemFunction {
+  (args: PressItemFunctionArgs): void;
+}
+
+interface UseTrackPressItemFunctionArgs {
+  readonly page: TrackingPage;
+  readonly country: Country;
+  readonly segment: Segment;
+  readonly checkoutId: string | undefined;
+}
+interface UseTrackPressItemFunction {
+  (agrs: UseTrackPressItemFunctionArgs): PressItemFunction;
+}
+
+const useTrackPressItem: UseTrackPressItemFunction = ({ page, country, segment, checkoutId }) => {
+  const emitUserEvent = useEmitUserEvent<PressItemTrackingEvent>();
+
+  const pressItem: PressItemFunction = useCallback(
+    ({ checkoutItemId }) => {
+      if (!checkoutId) {
+        return;
+      }
+
+      const pressItemTrackingEvent: PressItemTrackingEvent = {
+        event: TrackingEventName.PRESS_ITEM,
+        eventCategory: TrackingEventCategory.NAVIGATION,
+        section: `${PROJECT}_${page}`,
+        store: country,
+        segment,
+        checkoutId,
+        checkoutItemId,
+      };
+
+      emitUserEvent(pressItemTrackingEvent);
+    },
+    [checkoutId, country, emitUserEvent, page, segment],
+  );
+
+  return pressItem;
+};
+
+export { useTrackPressItem };

package/src/infrastructure/tracking/useTrackPressNext.test.tsx

@@ -0,0 +1,45 @@
+import { renderHook } from "@testing-library/react-native";
+import { Segment } from "@lookiero/sty-psp-segment";
+import { useEmitUserEvent } from "@lookiero/sty-psp-tracking";
+import { Country } from "../../projection/shared/country";
+import { TrackingPage, PressNextTrackingEvent, TrackingEventName, TrackingEventCategory } from "./tracking";
+import { useTrackPressNext as sut } from "./useTrackPressNext";
+
+const mockEmitUserEvent = jest.fn();
+jest.mock("@lookiero/sty-psp-tracking");
+
+const country = Country.ES;
+const segment = Segment.WOMEN;
+
+const event: PressNextTrackingEvent = {
+  event: TrackingEventName.PRESS_NEXT,
+  eventCategory: TrackingEventCategory.NAVIGATION,
+  section: "checkout_item",
+  store: country,
+  segment,
+  checkoutId: "c513ebc8-df68-4f47-b899-8ec0ced84ca8",
+  from: "faaf6ce4-8b7b-4cbd-a50b-32dd23388112",
+  to: "b5555baf-fec7-4ab2-bb6f-1d482acee8b2",
+};
+
+describe("useTrackPressNext custom hook", () => {
+  test("renders correctly", () => {
+    (useEmitUserEvent as jest.Mock).mockImplementation(() => mockEmitUserEvent);
+
+    const { result } = renderHook(() =>
+      sut({
+        page: TrackingPage.ITEM,
+        country,
+        segment,
+        checkoutId: "c513ebc8-df68-4f47-b899-8ec0ced84ca8",
+      }),
+    );
+
+    result.current({
+      from: "faaf6ce4-8b7b-4cbd-a50b-32dd23388112",
+      to: "b5555baf-fec7-4ab2-bb6f-1d482acee8b2",
+    });
+
+    expect(mockEmitUserEvent).toHaveBeenCalledWith(event);
+  });
+});

package/src/infrastructure/tracking/useTrackPressNext.ts

@@ -0,0 +1,54 @@
+import { useCallback } from "react";
+import { Segment } from "@lookiero/sty-psp-segment";
+import { useEmitUserEvent } from "@lookiero/sty-psp-tracking";
+import { Country } from "../../projection/shared/country";
+import { PROJECT, TrackingPage, PressNextTrackingEvent, TrackingEventName, TrackingEventCategory } from "./tracking";
+
+interface PressNextFunctionArgs {
+  readonly from: string;
+  readonly to: string;
+}
+interface PressNextFunction {
+  (args: PressNextFunctionArgs): void;
+}
+
+interface UseTrackPressNextFunctionArgs {
+  readonly page: TrackingPage;
+  readonly country: Country;
+  readonly segment: Segment;
+  readonly checkoutId: string | undefined;
+}
+
+interface UseTrackPressNextFunction {
+  (args: UseTrackPressNextFunctionArgs): PressNextFunction;
+}
+
+const useTrackPressNext: UseTrackPressNextFunction = ({ page, country, segment, checkoutId }) => {
+  const emitUserEvent = useEmitUserEvent<PressNextTrackingEvent>();
+
+  const pressNext: PressNextFunction = useCallback(
+    ({ from, to }) => {
+      if (!checkoutId) {
+        return;
+      }
+
+      const pressNextTrackingEvent: PressNextTrackingEvent = {
+        event: TrackingEventName.PRESS_NEXT,
+        eventCategory: TrackingEventCategory.NAVIGATION,
+        section: `${PROJECT}_${page}`,
+        store: country,
+        segment,
+        checkoutId,
+        from,
+        to,
+      };
+
+      emitUserEvent(pressNextTrackingEvent);
+    },
+    [checkoutId, country, emitUserEvent, page, segment],
+  );
+
+  return pressNext;
+};
+
+export { useTrackPressNext };

package/src/infrastructure/tracking/useTrackPressPrevious.test.tsx

@@ -0,0 +1,45 @@
+import { renderHook } from "@testing-library/react-native";
+import { Segment } from "@lookiero/sty-psp-segment";
+import { useEmitUserEvent } from "@lookiero/sty-psp-tracking";
+import { Country } from "../../projection/shared/country";
+import { TrackingPage, PressPreviousTrackingEvent, TrackingEventName, TrackingEventCategory } from "./tracking";
+import { useTrackPressPrevious as sut } from "./useTrackPressPrevious";
+
+const mockEmitUserEvent = jest.fn();
+jest.mock("@lookiero/sty-psp-tracking");
+
+const country = Country.ES;
+const segment = Segment.WOMEN;
+
+const event: PressPreviousTrackingEvent = {
+  event: TrackingEventName.PRESS_PREVIOUS,
+  eventCategory: TrackingEventCategory.NAVIGATION,
+  section: "checkout_item",
+  store: country,
+  segment,
+  checkoutId: "c513ebc8-df68-4f47-b899-8ec0ced84ca8",
+  from: "faaf6ce4-8b7b-4cbd-a50b-32dd23388112",
+  to: "b5555baf-fec7-4ab2-bb6f-1d482acee8b2",
+};
+
+describe("useTrackPressPrevious custom hook", () => {
+  test("renders correctly", () => {
+    (useEmitUserEvent as jest.Mock).mockImplementation(() => mockEmitUserEvent);
+
+    const { result } = renderHook(() =>
+      sut({
+        page: TrackingPage.ITEM,
+        country,
+        segment,
+        checkoutId: "c513ebc8-df68-4f47-b899-8ec0ced84ca8",
+      }),
+    );
+
+    result.current({
+      from: "faaf6ce4-8b7b-4cbd-a50b-32dd23388112",
+      to: "b5555baf-fec7-4ab2-bb6f-1d482acee8b2",
+    });
+
+    expect(mockEmitUserEvent).toHaveBeenCalledWith(event);
+  });
+});