@applicaster/zapp-react-native-utils 13.0.0-rc.2 → 13.0.0-rc.21

package/appUtils/HooksManager/__tests__/hook.test.js

@@ -29,7 +29,9 @@ const hooks = (options, otherHook = null) =>
 const manager = {
   presentScreenHook: jest.fn(),
   executeHook: jest.fn(),
-  invokeHandler: jest.fn(),
+  subscriber: {
+    invokeHandler: jest.fn(),
+  },
 };
 
 const getHook = (options, otherHook) =>
@@ -42,257 +44,267 @@ const getHook = (options, otherHook) =>
 function clearMocks() {
   manager.presentScreenHook.mockClear();
   manager.executeHook.mockClear();
-  manager.invokeHandler.mockClear();
+  manager.subscriber.invokeHandler.mockClear();
 }
 
-describe("Hook Properties", () => {
-  const hookPlugin = getHook({});
+describe("Hook", () => {
+  describe("Hook Properties", () => {
+    const hookPlugin = getHook({});
 
-  beforeEach(clearMocks);
+    beforeEach(clearMocks);
 
-  it("has all the hook properties", () => {
-    expect(hookPlugin).toMatchSnapshot();
+    it("has all the hook properties", () => {
+      expect(hookPlugin).toMatchSnapshot();
+    });
   });
-});
 
-describe("getModalContainer", () => {
-  it("returns ModalContainer", () => {
-    const ModalContainer = jest.fn();
+  describe("getModalContainer", () => {
+    it("returns ModalContainer", () => {
+      const ModalContainer = jest.fn();
 
-    const hookPlugin = getHook({
-      general: {},
-      module: { ModalContainer },
-    });
+      const hookPlugin = getHook({
+        general: {},
+        module: { ModalContainer },
+      });
 
-    expect(hookPlugin.getModalContainer()).toBe(ModalContainer);
+      expect(hookPlugin.getModalContainer()).toBe(ModalContainer);
+    });
   });
-});
 
-describe("isFlowBlocker", () => {
-  it("returns true if the hook is flow blocker", () => {
-    const hookPlugin = getHook({ general: { is_flow_blocker: true } });
+  describe("isFlowBlocker", () => {
+    it("returns true if the hook is flow blocker", () => {
+      const hookPlugin = getHook({ general: { is_flow_blocker: true } });
 
-    const hookWithoutScreen = getHook({
-      general: {},
-      module: { isFlowBlocker: () => true },
+      const hookWithoutScreen = getHook({
+        general: {},
+        module: { isFlowBlocker: () => true },
+      });
+
+      expect(hookPlugin.isFlowBlocker()).toBe(true);
+      expect(hookWithoutScreen.isFlowBlocker()).toBe(true);
     });
 
-    expect(hookPlugin.isFlowBlocker()).toBe(true);
-    expect(hookWithoutScreen.isFlowBlocker()).toBe(true);
-  });
+    it("returns false otherwise", () => {
+      const hookPlugin = getHook({ general: { is_flow_blocker: false } });
 
-  it("returns false otherwise", () => {
-    const hookPlugin = getHook({ general: { is_flow_blocker: false } });
+      const hookWithoutScreen = getHook({
+        general: {},
+        module: { isFlowBlocker: () => false },
+      });
 
-    const hookWithoutScreen = getHook({
-      general: {},
-      module: { isFlowBlocker: () => false },
+      expect(hookPlugin.isFlowBlocker()).toBeFalsy();
+      expect(hookWithoutScreen.isFlowBlocker()).toBeFalsy();
     });
-
-    expect(hookPlugin.isFlowBlocker()).toBeFalsy();
-    expect(hookWithoutScreen.isFlowBlocker()).toBeFalsy();
   });
-});
 
-describe("skipHook", () => {
-  it("returns true if the hooks module skipHook method returns true", () => {
-    const hookPlugin = getHook({ module: { skipHook: () => true } });
+  describe("skipHook", () => {
+    it("returns true if the hooks module skipHook method returns true", () => {
+      const hookPlugin = getHook({ module: { skipHook: () => true } });
 
-    expect(hookPlugin.skipHook()).toBe(true);
-  });
+      expect(hookPlugin.skipHook()).toBe(true);
+    });
 
-  it("returns false otherwise", () => {
-    const hookPlugin = getHook({ module: { skipHook: false } });
-    const hookPluginWithUndefinedSkipHook = getHook({ module: {} });
+    it("returns false otherwise", () => {
+      const hookPlugin = getHook({ module: { skipHook: false } });
+      const hookPluginWithUndefinedSkipHook = getHook({ module: {} });
 
-    expect(hookPlugin.skipHook()).toBeFalsy();
-    expect(hookPluginWithUndefinedSkipHook.skipHook()).toBeFalsy();
+      expect(hookPlugin.skipHook()).toBeFalsy();
+      expect(hookPluginWithUndefinedSkipHook.skipHook()).toBeFalsy();
+    });
   });
-});
 
-describe("lastHook", () => {
-  it("returns true if the current hook is the last one", () => {
-    const hookPlugin = getHook({});
-    expect(hookPlugin.lastHook).toBe(true);
-  });
+  describe("lastHook", () => {
+    it("returns true if the current hook is the last one", () => {
+      const hookPlugin = getHook({});
+      expect(hookPlugin.lastHook).toBe(true);
+    });
 
-  it("returns false otherwise", () => {
-    const hookPlugin = getHook(
-      {},
-      {
-        screen_id: "B4567",
-        type: "general",
-        identifier: "some_hook",
-        weight: 2,
-      }
-    );
-
-    expect(hookPlugin.lastHook).toBe(false);
+    it("returns false otherwise", () => {
+      const hookPlugin = getHook(
+        {},
+        {
+          screen_id: "B4567",
+          type: "general",
+          identifier: "some_hook",
+          weight: 2,
+        }
+      );
+
+      expect(hookPlugin.lastHook).toBe(false);
+    });
   });
-});
 
-describe("setStateAndNotify", () => {
-  let hookPlugin;
-  const args = ["foo", { bar: 42 }];
+  describe("setStateAndNotify", () => {
+    let hookPlugin;
+    const args = ["foo", { bar: 42 }];
 
-  beforeEach(() => {
-    clearMocks();
-    hookPlugin = getHook({});
-  });
+    beforeEach(() => {
+      clearMocks();
+      hookPlugin = getHook({});
+    });
 
-  it("changes the hook's state", () => {
-    hookPlugin.setStateAndNotify(HOOKS_EVENTS.START, ...args);
-    expect(hookPlugin.state).toEqual(1);
-  });
+    it("changes the hook's state", () => {
+      hookPlugin.setStateAndNotify(HOOKS_EVENTS.START, ...args);
+      expect(hookPlugin.state).toEqual(1);
+    });
 
-  it("calls invokes the handler on the hook manager", () => {
-    hookPlugin.setStateAndNotify(HOOKS_EVENTS.START, ...args);
+    it("calls invokes the handler on the hook manager", () => {
+      hookPlugin.setStateAndNotify(HOOKS_EVENTS.START, ...args);
 
-    expect(manager.invokeHandler).toHaveBeenCalledWith(
-      HOOKS_EVENTS.START,
-      ...args
-    );
+      expect(manager.subscriber.invokeHandler).toHaveBeenCalledWith(
+        HOOKS_EVENTS.START,
+        ...args
+      );
+    });
   });
-});
 
-describe("shouldPresentScreenHook", () => {
-  it("returns true if the hook has a screenId and allows screen presentation", () => {
-    const hookPlugin = getHook({});
+  describe("shouldPresentScreenHook", () => {
+    it("returns true if the hook has a screenId and allows screen presentation", () => {
+      const hookPlugin = getHook({});
 
-    const hookWithoutRiver = getHook({
-      screen_id: undefined,
-      module: { presentFullScreen: true },
+      const hookWithoutRiver = getHook({
+        screen_id: undefined,
+        module: { presentFullScreen: true },
+      });
+
+      expect(hookPlugin.shouldPresentScreenHook()).toBe(true);
+      expect(hookWithoutRiver.shouldPresentScreenHook()).toBe(true);
     });
 
-    expect(hookPlugin.shouldPresentScreenHook()).toBe(true);
-    expect(hookWithoutRiver.shouldPresentScreenHook()).toBe(true);
-  });
+    it("returns true if the hook is modal presentation", () => {
+      const hookPlugin = getHook({
+        general: { transition_type: HOOKS_TRANSITION_TYPE.MODAL },
+      });
 
-  it("returns true if the hook is modal presentation", () => {
-    const hookPlugin = getHook({
-      general: { transition_type: HOOKS_TRANSITION_TYPE.MODAL },
+      expect(hookPlugin.shouldPresentScreenHook()).toBe(true);
     });
 
-    expect(hookPlugin.shouldPresentScreenHook()).toBe(true);
-  });
+    it("returns false otherwise", () => {
+      const hookWithoutScreen = getHook({ screen_id: undefined });
 
-  it("returns false otherwise", () => {
-    const hookWithoutScreen = getHook({ screen_id: undefined });
+      const hookWithoutRiver = getHook({
+        screen_id: undefined,
+        module: { presentFullScreen: false },
+      });
 
-    const hookWithoutRiver = getHook({
-      screen_id: undefined,
-      module: { presentFullScreen: false },
-    });
+      const hookWithoutAllowScreen = getHook({
+        general: { allow_screen_plugin_presentation: false },
+      });
 
-    const hookWithoutAllowScreen = getHook({
-      general: { allow_screen_plugin_presentation: false },
-    });
+      const hookWithoutScreenAndAllow = getHook({
+        general: { allow_screen_plugin_presentation: false },
+        screen_id: null,
+      });
 
-    const hookWithoutScreenAndAllow = getHook({
-      general: { allow_screen_plugin_presentation: false },
-      screen_id: null,
+      expect(hookWithoutScreen.shouldPresentScreenHook()).toBeFalsy();
+      expect(hookWithoutAllowScreen.shouldPresentScreenHook()).toBeFalsy();
+      expect(hookWithoutScreenAndAllow.shouldPresentScreenHook()).toBeFalsy();
+      expect(hookWithoutRiver.shouldPresentScreenHook()).toBeFalsy();
     });
-
-    expect(hookWithoutScreen.shouldPresentScreenHook()).toBeFalsy();
-    expect(hookWithoutAllowScreen.shouldPresentScreenHook()).toBeFalsy();
-    expect(hookWithoutScreenAndAllow.shouldPresentScreenHook()).toBeFalsy();
-    expect(hookWithoutRiver.shouldPresentScreenHook()).toBeFalsy();
   });
-});
 
-describe("shouldStartNexHook", () => {
-  const hookPlugin = getHook({});
-  const hookWithoutScreen = getHook({ screen_id: undefined });
-
-  it("returns true if the nextHook has the same weight and is not a screen", () => {
-    expect(
-      hookWithoutScreen.shouldStartNextHook({
-        weight: hookWithoutScreen.weight,
-      })
-    ).toBe(true);
-  });
+  describe("shouldStartNexHook", () => {
+    const hookPlugin = getHook({});
+    const hookWithoutScreen = getHook({ screen_id: undefined });
 
-  it("returns false otherwise", () => {
-    // even if weight if the same, since hookPlugin should present a screen,
-    // it cannot run in parallel
-    expect(hookPlugin.shouldStartNextHook({ weight: hookPlugin })).toBeFalsy();
+    it("returns true if the nextHook has the same weight and is not a screen", () => {
+      expect(
+        hookWithoutScreen.shouldStartNextHook({
+          weight: hookWithoutScreen.weight,
+        })
+      ).toBe(true);
+    });
 
-    expect(
-      hookWithoutScreen.shouldStartNextHook({
-        weight: hookWithoutScreen.weight + 1,
-      })
-    ).toBeFalsy();
+    it("returns false otherwise", () => {
+      // even if weight if the same, since hookPlugin should present a screen,
+      // it cannot run in parallel
+      expect(
+        hookPlugin.shouldStartNextHook({ weight: hookPlugin })
+      ).toBeFalsy();
+
+      expect(
+        hookWithoutScreen.shouldStartNextHook({
+          weight: hookWithoutScreen.weight + 1,
+        })
+      ).toBeFalsy();
+    });
   });
-});
 
-describe("execute", () => {
-  const payload = { foo: "bar" };
-  const next = jest.fn();
+  describe("execute", () => {
+    const payload = { foo: "bar" };
+    const next = jest.fn();
 
-  beforeEach(clearMocks);
+    beforeEach(clearMocks);
 
-  describe("when the hook execution should be skipped", () => {
-    it("doesn't execute the hook, and goes to the next", () => {
-      const hookPlugin = getHook({ module: { skipHook: () => true } });
-      hookPlugin.execute(payload, next);
+    describe("when the hook execution should be skipped", () => {
+      it("doesn't execute the hook, and goes to the next", () => {
+        const hookPlugin = getHook({ module: { skipHook: () => true } });
+        hookPlugin.execute(payload, next);
 
-      expect(manager.presentScreenHook).not.toHaveBeenCalled();
-      expect(manager.executeHook).not.toHaveBeenCalled();
-      expect(next).toHaveBeenCalledWith({ payload, success: true });
+        expect(manager.presentScreenHook).not.toHaveBeenCalled();
+        expect(manager.executeHook).not.toHaveBeenCalled();
+        expect(next).toHaveBeenCalledWith({ payload, success: true });
+      });
     });
-  });
 
-  describe("when the hook is not in pending state", () => {
-    it("doesn't execute the hook, and goes to the next", () => {
-      const hookPlugin = getHook({});
-      hookPlugin.setStateAndNotify(HOOKS_EVENTS.START);
-      hookPlugin.execute(payload, next);
+    describe("when the hook is not in pending state", () => {
+      it("doesn't execute the hook, and goes to the next", () => {
+        const hookPlugin = getHook({});
+        hookPlugin.setStateAndNotify(HOOKS_EVENTS.START);
+        hookPlugin.execute(payload, next);
 
-      const hookStateSpy = jest.spyOn(hookPlugin, "setStateAndNotify");
+        const hookStateSpy = jest.spyOn(hookPlugin, "setStateAndNotify");
 
-      expect(hookStateSpy).not.toHaveBeenCalled();
-      expect(manager.presentScreenHook).not.toHaveBeenCalled();
-      expect(manager.executeHook).not.toHaveBeenCalled();
-      expect(next).toHaveBeenCalledWith({ payload });
+        expect(hookStateSpy).not.toHaveBeenCalled();
+        expect(manager.presentScreenHook).not.toHaveBeenCalled();
+        expect(manager.executeHook).not.toHaveBeenCalled();
+        expect(next).toHaveBeenCalledWith({ payload });
 
-      hookStateSpy.mockRestore();
+        hookStateSpy.mockRestore();
+      });
     });
-  });
 
-  describe("when the screen should be presented", () => {
-    it("executes the hook", () => {
-      const hookPlugin = getHook({});
-      const hookStateSpy = jest.spyOn(hookPlugin, "setStateAndNotify");
+    describe("when the screen should be presented", () => {
+      it("executes the hook", () => {
+        const hookPlugin = getHook({});
+        const hookStateSpy = jest.spyOn(hookPlugin, "setStateAndNotify");
 
-      hookPlugin.execute(payload, next);
+        hookPlugin.execute(payload, next);
 
-      expect(hookStateSpy).toHaveBeenCalledWith(HOOKS_EVENTS.START, hookPlugin);
+        expect(hookStateSpy).toHaveBeenCalledWith(
+          HOOKS_EVENTS.START,
+          hookPlugin
+        );
 
-      expect(manager.presentScreenHook).toHaveBeenCalledWith(
-        hookPlugin,
-        payload,
-        next
-      );
+        expect(manager.presentScreenHook).toHaveBeenCalledWith(
+          hookPlugin,
+          payload,
+          next
+        );
+      });
     });
-  });
 
-  describe("when the hook is headless", () => {
-    it("executes the hook", () => {
-      const hookPlugin = getHook({
-        general: { allow_screen_plugin_presentation: false },
-      });
+    describe("when the hook is headless", () => {
+      it("executes the hook", () => {
+        const hookPlugin = getHook({
+          general: { allow_screen_plugin_presentation: false },
+        });
 
-      const hookStateSpy = jest.spyOn(hookPlugin, "setStateAndNotify");
+        const hookStateSpy = jest.spyOn(hookPlugin, "setStateAndNotify");
 
-      hookPlugin.execute(payload, next);
+        hookPlugin.execute(payload, next);
 
-      expect(hookStateSpy).toHaveBeenCalledWith(HOOKS_EVENTS.START, hookPlugin);
+        expect(hookStateSpy).toHaveBeenCalledWith(
+          HOOKS_EVENTS.START,
+          hookPlugin
+        );
 
-      expect(manager.executeHook).toHaveBeenCalledWith(
-        hookPlugin,
-        payload,
-        next
-      );
+        expect(manager.executeHook).toHaveBeenCalledWith(
+          hookPlugin,
+          payload,
+          next
+        );
+      });
     });
   });
 });