@evervault/react-native 2.4.0 → 2.5.1

package/src/ThreeDSecure/useThreeDSecure.test.tsx

@@ -2,6 +2,7 @@ import { PropsWithChildren } from "react";
 import { EvervaultProvider } from "../EvervaultProvider";
 import { act, renderHook } from "@testing-library/react-native";
 import { useThreeDSecure } from "./useThreeDSecure";
+import { ThreeDSecureEvent } from "./event";
 
 function wrapper({ children }: PropsWithChildren) {
   return (
@@ -17,6 +18,10 @@ const callbacks = {
   onFailure: vi.fn(),
 };
 
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
 it("returns the correct state", () => {
   const { result } = renderHook(() => useThreeDSecure(), {
     wrapper,
@@ -31,7 +36,7 @@ it("returns the correct state", () => {
 });
 
 it("starts a session when action is required", async () => {
-  const { result, rerender } = renderHook(() => useThreeDSecure(), {
+  const { result } = renderHook(() => useThreeDSecure(), {
     wrapper,
   });
 
@@ -49,6 +54,112 @@ it("starts a session when action is required", async () => {
   expect(result.current.isVisible).toBe(true);
 });
 
+it("fails the session when failOnChallenge is true and a challenge is required", async () => {
+  const { result } = renderHook(() => useThreeDSecure(), {
+    wrapper,
+  });
+
+  vi.spyOn(global, "fetch").mockResolvedValue({
+    json: () => Promise.resolve({ status: "action-required" }),
+  } as any);
+
+  const onRequestChallenge = vi.fn();
+
+  await act(() =>
+    result.current.start("session_123", {
+      ...callbacks,
+      onRequestChallenge,
+      failOnChallenge: true,
+    })
+  );
+
+  expect(callbacks.onFailure).toHaveBeenCalled();
+  expect(onRequestChallenge).not.toHaveBeenCalled();
+});
+
+it("fails the session when failOnChallenge is a function that returns true and a challenge is required", async () => {
+  const { result } = renderHook(() => useThreeDSecure(), {
+    wrapper,
+  });
+
+  vi.spyOn(global, "fetch").mockResolvedValue({
+    json: () => Promise.resolve({ status: "action-required" }),
+  } as any);
+
+  const onRequestChallenge = vi.fn();
+
+  await act(() =>
+    result.current.start("session_123", {
+      ...callbacks,
+      onRequestChallenge,
+      failOnChallenge: () => Promise.resolve(true),
+    })
+  );
+
+  expect(callbacks.onFailure).toHaveBeenCalled();
+  expect(onRequestChallenge).not.toHaveBeenCalled();
+});
+
+it("fails the session when failOnChallenge resolves true at hook level and a challenge is required", async () => {
+  const { result } = renderHook(
+    () =>
+      useThreeDSecure({
+        failOnChallenge: () => Promise.resolve(true),
+      }),
+    {
+      wrapper,
+    }
+  );
+
+  vi.spyOn(global, "fetch").mockResolvedValue({
+    json: () => Promise.resolve({ status: "action-required" }),
+  } as any);
+
+  const onRequestChallenge = vi.fn();
+  await act(() =>
+    result.current.start("session_123", {
+      ...callbacks,
+      onRequestChallenge,
+    })
+  );
+
+  expect(onRequestChallenge).not.toHaveBeenCalled();
+  expect(callbacks.onFailure).toHaveBeenCalled();
+});
+
+it("fails the session when onRequestChallenge is called and defaultPrevented is true", async () => {
+  const { result } = renderHook(() => useThreeDSecure(), {
+    wrapper,
+  });
+
+  vi.spyOn(global, "fetch").mockResolvedValue({
+    json: () => Promise.resolve({ status: "action-required" }),
+  } as any);
+
+  let onRequestChallenge = vi.fn((event: ThreeDSecureEvent) =>
+    event.preventDefault()
+  );
+  await act(() =>
+    result.current.start("session_123", {
+      ...callbacks,
+      onRequestChallenge,
+    })
+  );
+  expect(onRequestChallenge).toHaveBeenCalled();
+  expect(callbacks.onFailure).toHaveBeenCalled();
+
+  let onFailure = vi.fn();
+  onRequestChallenge = vi.fn();
+  await act(() =>
+    result.current.start("session_123", {
+      onFailure,
+      onRequestChallenge,
+    })
+  );
+  expect(onRequestChallenge).toHaveBeenCalled();
+  expect(onFailure).not.toHaveBeenCalled();
+});
+
 it("calls the success callback when the session is successful", async () => {
   const { result } = renderHook(() => useThreeDSecure(), {
     wrapper,

package/src/ThreeDSecure/useThreeDSecure.ts

@@ -1,30 +1,47 @@
 import { useCallback, useMemo, useState } from "react";
 import { useRef } from "react";
 import { startSession, threeDSecureSession } from "./session";
-import { ThreeDSecureSession, ThreeDSecureState } from "./types";
+import {
+  ThreeDSecureOptions,
+  ThreeDSecureSession,
+  ThreeDSecureState,
+} from "./types";
 import { useEvervault } from "../useEvervault";
 
-export function useThreeDSecure(): ThreeDSecureState {
+export interface UseThreeDSecureOptions {
+  failOnChallenge?: boolean | (() => Promise<boolean>);
+}
+
+export function useThreeDSecure(
+  options?: UseThreeDSecureOptions
+): ThreeDSecureState {
   const { appId } = useEvervault();
   const intervalRef = useRef<NodeJS.Timeout | null>(null);
   const [session, setSession] = useState<ThreeDSecureSession | null>(null);
   const [isVisible, setIsVisible] = useState(false);
 
+  const failOnChallenge = options?.failOnChallenge ?? false;
+
   const start = useCallback<ThreeDSecureState["start"]>(
-    (sessionId, callbacks) => {
+    (sessionId, options) => {
+      const startOptions: ThreeDSecureOptions = {
+        ...options,
+        failOnChallenge: options?.failOnChallenge ?? failOnChallenge,
+      };
+
       const session = threeDSecureSession({
         sessionId,
         appId,
-        callbacks,
+        options: startOptions,
         intervalRef,
         setIsVisible,
       });
 
       setSession(session);
 
-      startSession(session, callbacks, intervalRef, setIsVisible);
+      startSession(session, startOptions, intervalRef, setIsVisible);
     },
-    [appId]
+    [appId, failOnChallenge]
   );
 
   const cancel = useCallback<ThreeDSecureState["cancel"]>(async () => {