@gakr-gakr/feishu 0.1.0

package/src/monitor.broadcast.reply-once.lifecycle.test-support.ts

@@ -0,0 +1,264 @@
+import "./lifecycle.test-support.js";
+import { createNonExitingRuntimeEnv } from "autobot/plugin-sdk/plugin-test-runtime";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { ClawdbotConfig, RuntimeEnv } from "../runtime-api.js";
+import { FeishuConfigSchema } from "./config-schema.js";
+import {
+  getFeishuLifecycleTestMocks,
+  resetFeishuLifecycleTestMocks,
+} from "./lifecycle.test-support.js";
+import {
+  createFeishuTextMessageEvent,
+  createFeishuLifecycleReplyDispatcher,
+  installFeishuLifecycleReplyRuntime,
+  mockFeishuReplyOnceDispatch,
+  restoreFeishuLifecycleStateDir,
+  runFeishuLifecycleSequence,
+  setFeishuLifecycleStateDir,
+  setupFeishuLifecycleHandler,
+} from "./test-support/lifecycle-test-support.js";
+import type { FeishuConfig, ResolvedFeishuAccount } from "./types.js";
+
+const {
+  createEventDispatcherMock,
+  createFeishuReplyDispatcherMock,
+  dispatchReplyFromConfigMock,
+  finalizeInboundContextMock,
+  resolveAgentRouteMock,
+  resolveBoundConversationMock,
+  withReplyDispatcherMock,
+} = getFeishuLifecycleTestMocks();
+
+let handlersByAccount = new Map<string, Record<string, (data: unknown) => Promise<void>>>();
+let runtimesByAccount = new Map<string, RuntimeEnv>();
+const originalStateDir = process.env.AUTOBOT_STATE_DIR;
+
+function createLifecycleConfig(): ClawdbotConfig {
+  return {
+    broadcast: {
+      oc_broadcast_group: ["susan", "main"],
+    },
+    agents: {
+      list: [{ id: "main" }, { id: "susan" }],
+    },
+    channels: {
+      feishu: {
+        enabled: true,
+        groupPolicy: "open",
+        requireMention: false,
+        resolveSenderNames: false,
+        accounts: {
+          "account-A": {
+            enabled: true,
+            appId: "cli_a",
+            appSecret: "secret_a", // pragma: allowlist secret
+            connectionMode: "websocket",
+            groupPolicy: "open",
+            requireMention: false,
+            resolveSenderNames: false,
+            groups: {
+              oc_broadcast_group: {
+                requireMention: false,
+              },
+            },
+          },
+          "account-B": {
+            enabled: true,
+            appId: "cli_b",
+            appSecret: "secret_b", // pragma: allowlist secret
+            connectionMode: "websocket",
+            groupPolicy: "open",
+            requireMention: false,
+            resolveSenderNames: false,
+            groups: {
+              oc_broadcast_group: {
+                requireMention: false,
+              },
+            },
+          },
+        },
+      },
+    },
+    messages: {
+      inbound: {
+        debounceMs: 0,
+        byChannel: {
+          feishu: 0,
+        },
+      },
+    },
+  } as ClawdbotConfig;
+}
+
+function createLifecycleAccount(accountId: "account-A" | "account-B"): ResolvedFeishuAccount {
+  const config: FeishuConfig = FeishuConfigSchema.parse({
+    enabled: true,
+    connectionMode: "websocket",
+    groupPolicy: "open",
+    requireMention: false,
+    resolveSenderNames: false,
+    groups: {
+      oc_broadcast_group: {
+        requireMention: false,
+      },
+    },
+  });
+  return {
+    accountId,
+    selectionSource: "explicit",
+    enabled: true,
+    configured: true,
+    appId: accountId === "account-A" ? "cli_a" : "cli_b",
+    appSecret: accountId === "account-A" ? "secret_a" : "secret_b", // pragma: allowlist secret
+    domain: "feishu",
+    config,
+  };
+}
+
+async function setupLifecycleMonitor(accountId: "account-A" | "account-B") {
+  const runtime = createNonExitingRuntimeEnv();
+  runtimesByAccount.set(accountId, runtime);
+  return setupFeishuLifecycleHandler({
+    createEventDispatcherMock,
+    onRegister: (registered) => {
+      handlersByAccount.set(accountId, registered);
+    },
+    runtime,
+    cfg: createLifecycleConfig(),
+    account: createLifecycleAccount(accountId),
+    handlerKey: "im.message.receive_v1",
+    missingHandlerMessage: `missing im.message.receive_v1 handler for ${accountId}`,
+    once: true,
+  });
+}
+
+describe("Feishu broadcast reply-once lifecycle", () => {
+  beforeEach(() => {
+    vi.useRealTimers();
+    resetFeishuLifecycleTestMocks();
+    handlersByAccount = new Map();
+    runtimesByAccount = new Map();
+    setFeishuLifecycleStateDir("autobot-feishu-broadcast");
+
+    createFeishuReplyDispatcherMock.mockReturnValue(createFeishuLifecycleReplyDispatcher());
+
+    resolveBoundConversationMock.mockReturnValue(null);
+    resolveAgentRouteMock.mockReturnValue({
+      agentId: "main",
+      channel: "feishu",
+      accountId: "account-A",
+      sessionKey: "agent:main:feishu:group:oc_broadcast_group",
+      mainSessionKey: "agent:main:main",
+      matchedBy: "default",
+    });
+
+    mockFeishuReplyOnceDispatch({
+      dispatchReplyFromConfigMock,
+      replyText: "broadcast reply once",
+      shouldSendFinalReply: (ctx) =>
+        typeof (ctx as { SessionKey?: string } | undefined)?.SessionKey === "string" &&
+        (ctx as { SessionKey: string }).SessionKey.includes("agent:main:"),
+    });
+
+    withReplyDispatcherMock.mockImplementation(async ({ run }) => await run());
+
+    installFeishuLifecycleReplyRuntime({
+      resolveAgentRouteMock,
+      finalizeInboundContextMock,
+      dispatchReplyFromConfigMock,
+      withReplyDispatcherMock,
+      storePath: "/tmp/feishu-broadcast-sessions.json",
+    });
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    restoreFeishuLifecycleStateDir(originalStateDir);
+  });
+
+  it("uses one active reply path when the same broadcast event reaches two accounts", async () => {
+    const onMessageA = await setupLifecycleMonitor("account-A");
+    const onMessageB = await setupLifecycleMonitor("account-B");
+    const event = createFeishuTextMessageEvent({
+      messageId: "om_broadcast_once",
+      chatId: "oc_broadcast_group",
+      text: "hello broadcast",
+    });
+
+    await runFeishuLifecycleSequence(
+      [() => onMessageA(event), () => onMessageB(event)],
+      [
+        () => {
+          expect(dispatchReplyFromConfigMock.mock.calls.length).toBeGreaterThan(0);
+        },
+        () => {
+          expect(dispatchReplyFromConfigMock).toHaveBeenCalledTimes(2);
+          expect(createFeishuReplyDispatcherMock).toHaveBeenCalledTimes(1);
+        },
+      ],
+    );
+
+    expect(runtimesByAccount.get("account-A")?.error).not.toHaveBeenCalled();
+    expect(runtimesByAccount.get("account-B")?.error).not.toHaveBeenCalled();
+
+    expect(dispatchReplyFromConfigMock).toHaveBeenCalledTimes(2);
+    expect(createFeishuReplyDispatcherMock).toHaveBeenCalledTimes(1);
+    expect(createFeishuReplyDispatcherMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        accountId: "account-a",
+        chatId: "oc_broadcast_group",
+        replyToMessageId: "om_broadcast_once",
+      }),
+    );
+
+    const sessionKeys = finalizeInboundContextMock.mock.calls.map(
+      (call) => (call[0] as { SessionKey?: string }).SessionKey,
+    );
+    expect(sessionKeys).toContain("agent:main:feishu:group:oc_broadcast_group");
+    expect(sessionKeys).toContain("agent:susan:feishu:group:oc_broadcast_group");
+
+    const activeDispatcher = createFeishuReplyDispatcherMock.mock.results[0]?.value.dispatcher as {
+      sendFinalReply: ReturnType<typeof vi.fn>;
+    };
+    expect(activeDispatcher.sendFinalReply).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not duplicate delivery after a post-send failure on the first account", async () => {
+    const onMessageA = await setupLifecycleMonitor("account-A");
+    const onMessageB = await setupLifecycleMonitor("account-B");
+    const event = createFeishuTextMessageEvent({
+      messageId: "om_broadcast_retry",
+      chatId: "oc_broadcast_group",
+      text: "hello broadcast",
+    });
+
+    dispatchReplyFromConfigMock.mockImplementationOnce(async ({ ctx, dispatcher }) => {
+      if (typeof ctx?.SessionKey === "string" && ctx.SessionKey.includes("agent:susan:")) {
+        return { queuedFinal: false, counts: { final: 0 } };
+      }
+      await dispatcher.sendFinalReply({ text: "broadcast reply once" });
+      throw new Error("post-send failure");
+    });
+
+    await runFeishuLifecycleSequence(
+      [() => onMessageA(event), () => onMessageB(event)],
+      [
+        () => {
+          expect(dispatchReplyFromConfigMock.mock.calls.length).toBeGreaterThan(0);
+        },
+        () => {
+          expect(dispatchReplyFromConfigMock).toHaveBeenCalledTimes(2);
+        },
+      ],
+    );
+
+    expect(runtimesByAccount.get("account-A")?.error).not.toHaveBeenCalled();
+    expect(runtimesByAccount.get("account-B")?.error).not.toHaveBeenCalled();
+    expect(dispatchReplyFromConfigMock).toHaveBeenCalledTimes(2);
+
+    const activeDispatcher = createFeishuReplyDispatcherMock.mock.results[0]?.value.dispatcher as {
+      sendFinalReply: ReturnType<typeof vi.fn>;
+    };
+    expect(activeDispatcher.sendFinalReply).toHaveBeenCalledTimes(1);
+  });
+});

package/src/monitor.card-action.lifecycle.test-support.ts

@@ -0,0 +1,421 @@
+import { createRuntimeEnv } from "autobot/plugin-sdk/plugin-test-runtime";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import "./lifecycle.test-support.js";
+import { resetProcessedFeishuCardActionTokensForTests } from "./card-action.js";
+import { createFeishuCardInteractionEnvelope } from "./card-interaction.js";
+import {
+  getFeishuLifecycleTestMocks,
+  resetFeishuLifecycleTestMocks,
+} from "./lifecycle.test-support.js";
+import {
+  createFeishuLifecycleConfig,
+  createFeishuLifecycleReplyDispatcher,
+  createResolvedFeishuLifecycleAccount,
+  expectFeishuReplyDispatcherSentFinalReplyOnce,
+  expectFeishuReplyPipelineDedupedAcrossReplay,
+  expectFeishuReplyPipelineDedupedAfterPostSendFailure,
+  installFeishuLifecycleReplyRuntime,
+  mockFeishuReplyOnceDispatch,
+  restoreFeishuLifecycleStateDir,
+  setFeishuLifecycleStateDir,
+  setupFeishuLifecycleHandler,
+} from "./test-support/lifecycle-test-support.js";
+
+const {
+  createEventDispatcherMock,
+  createFeishuReplyDispatcherMock,
+  dispatchReplyFromConfigMock,
+  finalizeInboundContextMock,
+  resolveAgentRouteMock,
+  resolveBoundConversationMock,
+  sendCardFeishuMock,
+  sendMessageFeishuMock,
+  touchBindingMock,
+  withReplyDispatcherMock,
+} = getFeishuLifecycleTestMocks();
+
+let handlers: Record<string, (data: unknown) => Promise<void>> = {};
+let lastRuntime = createRuntimeEnv();
+const originalStateDir = process.env.AUTOBOT_STATE_DIR;
+const lifecycleConfig = createFeishuLifecycleConfig({
+  accountId: "acct-card",
+  appId: "cli_test",
+  appSecret: "secret_test",
+  channelConfig: {
+    dmPolicy: "open",
+    allowFrom: ["ou_user1"],
+  },
+  accountConfig: {
+    dmPolicy: "open",
+    allowFrom: ["ou_user1"],
+  },
+});
+
+const lifecycleAccount = createResolvedFeishuLifecycleAccount({
+  accountId: "acct-card",
+  appId: "cli_test",
+  appSecret: "secret_test",
+  config: {
+    dmPolicy: "open",
+    allowFrom: ["ou_user1"],
+  },
+});
+
+function createCardActionEvent(params: {
+  token: string;
+  action: string;
+  command: string;
+  chatId?: string;
+  chatType?: "group" | "p2p";
+}) {
+  const openId = "ou_user1";
+  const chatId = params.chatId ?? "p2p:ou_user1";
+  const chatType = params.chatType ?? "p2p";
+  return {
+    operator: {
+      open_id: openId,
+      user_id: "user_1",
+      union_id: "union_1",
+    },
+    token: params.token,
+    action: {
+      tag: "button",
+      value: createFeishuCardInteractionEnvelope({
+        k: "quick",
+        a: params.action,
+        q: params.command,
+        c: {
+          u: openId,
+          h: chatId,
+          t: chatType,
+          e: Date.now() + 60_000,
+        },
+      }),
+    },
+    context: {
+      open_id: openId,
+      user_id: "user_1",
+      chat_id: chatId,
+    },
+  };
+}
+
+async function setupLifecycleMonitor() {
+  lastRuntime = createRuntimeEnv();
+  return setupFeishuLifecycleHandler({
+    createEventDispatcherMock,
+    onRegister: (registered) => {
+      handlers = registered;
+    },
+    runtime: lastRuntime,
+    cfg: lifecycleConfig,
+    account: lifecycleAccount,
+    handlerKey: "card.action.trigger",
+    missingHandlerMessage: "missing card.action.trigger handler",
+  });
+}
+
+function latestReplyDispatcherParams() {
+  const call = createFeishuReplyDispatcherMock.mock.calls.at(-1);
+  if (!call) {
+    throw new Error("expected Feishu reply dispatcher call");
+  }
+  return call[0] as {
+    accountId?: string;
+    chatId?: string;
+    replyToMessageId?: string;
+  };
+}
+
+function latestFinalizedContext() {
+  const call = finalizeInboundContextMock.mock.calls.at(-1);
+  if (!call) {
+    throw new Error("expected finalized inbound context call");
+  }
+  return call[0] as {
+    AccountId?: string;
+    SessionKey?: string;
+    MessageSid?: string;
+  };
+}
+
+describe("Feishu card-action lifecycle", () => {
+  beforeEach(() => {
+    vi.useRealTimers();
+    resetFeishuLifecycleTestMocks();
+    handlers = {};
+    lastRuntime = createRuntimeEnv();
+    resetProcessedFeishuCardActionTokensForTests();
+    setFeishuLifecycleStateDir("autobot-feishu-card-action");
+
+    createFeishuReplyDispatcherMock.mockReturnValue(createFeishuLifecycleReplyDispatcher());
+
+    resolveBoundConversationMock.mockImplementation(() => ({
+      bindingId: "binding-card",
+      targetSessionKey: "agent:bound-agent:feishu:direct:ou_user1",
+    }));
+
+    resolveAgentRouteMock.mockReturnValue({
+      agentId: "main",
+      channel: "feishu",
+      accountId: "acct-card",
+      sessionKey: "agent:main:feishu:direct:ou_user1",
+      mainSessionKey: "agent:main:main",
+      matchedBy: "default",
+    });
+
+    mockFeishuReplyOnceDispatch({
+      dispatchReplyFromConfigMock,
+      replyText: "card action reply once",
+    });
+
+    withReplyDispatcherMock.mockImplementation(async ({ run }) => await run());
+
+    installFeishuLifecycleReplyRuntime({
+      resolveAgentRouteMock,
+      finalizeInboundContextMock,
+      dispatchReplyFromConfigMock,
+      withReplyDispatcherMock,
+      storePath: "/tmp/feishu-card-action-sessions.json",
+    });
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    resetProcessedFeishuCardActionTokensForTests();
+    restoreFeishuLifecycleStateDir(originalStateDir);
+  });
+
+  it("routes one reply across duplicate callback delivery", async () => {
+    const onCardAction = await setupLifecycleMonitor();
+    const event = createCardActionEvent({
+      token: "tok-card-once",
+      action: "feishu.quick_actions.help",
+      command: "/help",
+    });
+
+    await expectFeishuReplyPipelineDedupedAcrossReplay({
+      handler: onCardAction,
+      event,
+      dispatchReplyFromConfigMock,
+      createFeishuReplyDispatcherMock,
+    });
+
+    expect(lastRuntime?.error).not.toHaveBeenCalled();
+    expect(dispatchReplyFromConfigMock).toHaveBeenCalledTimes(1);
+    expect(createFeishuReplyDispatcherMock).toHaveBeenCalledTimes(1);
+    const dispatcherParams = latestReplyDispatcherParams();
+    expect(dispatcherParams.accountId).toBe("acct-card");
+    expect(dispatcherParams.chatId).toBe("p2p:ou_user1");
+    expect(dispatcherParams.replyToMessageId).toBeUndefined();
+    const finalized = latestFinalizedContext();
+    expect(finalized.AccountId).toBe("acct-card");
+    expect(finalized.SessionKey).toBe("agent:bound-agent:feishu:direct:ou_user1");
+    expect(finalized.MessageSid).toBe("card-action-tok-card-once");
+    expect(touchBindingMock).toHaveBeenCalledWith("binding-card");
+
+    expectFeishuReplyDispatcherSentFinalReplyOnce({ createFeishuReplyDispatcherMock });
+    expect(sendMessageFeishuMock).not.toHaveBeenCalled();
+    expect(sendCardFeishuMock).not.toHaveBeenCalled();
+  });
+
+  it("routes v2 callbacks that report open_chat_id instead of chat_id", async () => {
+    const onCardAction = await setupLifecycleMonitor();
+    const chatId = "oc_group_v2";
+
+    await onCardAction({
+      operator: {
+        open_id: "ou_user1",
+      },
+      token: "tok-card-v2-context",
+      action: {
+        tag: "button",
+        value: createFeishuCardInteractionEnvelope({
+          k: "quick",
+          a: "feishu.quick_actions.help",
+          q: "/help",
+          c: {
+            u: "ou_user1",
+            h: chatId,
+            t: "group",
+            e: Date.now() + 60_000,
+          },
+        }),
+      },
+      context: {
+        open_message_id: "om_card_v2",
+        open_chat_id: chatId,
+      },
+    });
+
+    expect(lastRuntime?.error).not.toHaveBeenCalled();
+    expect(dispatchReplyFromConfigMock).toHaveBeenCalledTimes(1);
+    const dispatcherParams = latestReplyDispatcherParams();
+    expect(dispatcherParams.accountId).toBe("acct-card");
+    expect(dispatcherParams.chatId).toBe(chatId);
+    expect(dispatcherParams.replyToMessageId).toBe("om_card_v2");
+    expect(latestFinalizedContext().MessageSid).toBe("card-action-tok-card-v2-context");
+  });
+
+  it("routes v2 callbacks with nested operator identity", async () => {
+    const onCardAction = await setupLifecycleMonitor();
+    const chatId = "p2p:ou_user1";
+
+    await onCardAction({
+      operator: {
+        user_id: {
+          open_id: "ou_user1",
+          user_id: "user_1",
+          union_id: "union_1",
+        },
+      },
+      token: "tok-card-v2-nested-operator",
+      action: {
+        tag: "button",
+        value: createFeishuCardInteractionEnvelope({
+          k: "quick",
+          a: "feishu.quick_actions.help",
+          q: "/help",
+          c: {
+            u: "ou_user1",
+            h: chatId,
+            t: "p2p",
+            e: Date.now() + 60_000,
+          },
+        }),
+      },
+      context: {
+        open_message_id: "om_card_v2_nested",
+        open_chat_id: chatId,
+      },
+    });
+
+    expect(lastRuntime?.error).not.toHaveBeenCalled();
+    expect(dispatchReplyFromConfigMock).toHaveBeenCalledTimes(1);
+    expect(createFeishuReplyDispatcherMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        accountId: "acct-card",
+        chatId,
+        replyToMessageId: "om_card_v2_nested",
+      }),
+    );
+    expect(finalizeInboundContextMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        AccountId: "acct-card",
+        SessionKey: "agent:bound-agent:feishu:direct:ou_user1",
+        MessageSid: "card-action-tok-card-v2-nested-operator",
+      }),
+    );
+  });
+
+  it("routes SDK-style card callbacks without context as direct callbacks", async () => {
+    const onCardAction = await setupLifecycleMonitor();
+
+    await onCardAction({
+      open_id: "ou_user1",
+      user_id: "user_1",
+      tenant_key: "tenant_1",
+      open_message_id: "om_sdk_card",
+      token: "tok-card-sdk-flat",
+      action: {
+        tag: "button",
+        value: {
+          command: "/help",
+        },
+      },
+    });
+
+    expect(lastRuntime?.error).not.toHaveBeenCalled();
+    expect(dispatchReplyFromConfigMock).toHaveBeenCalledTimes(1);
+    const dispatcherParams = latestReplyDispatcherParams();
+    expect(dispatcherParams.accountId).toBe("acct-card");
+    expect(dispatcherParams.chatId).toBe("ou_user1");
+    expect(dispatcherParams.replyToMessageId).toBe("om_sdk_card");
+    expect(latestFinalizedContext().MessageSid).toBe("card-action-tok-card-sdk-flat");
+  });
+
+  it("plain-sends card action replies when Feishu provides no real message id", async () => {
+    const onCardAction = await setupLifecycleMonitor();
+
+    await onCardAction({
+      open_id: "ou_user1",
+      token: "tok-card-no-reply-target",
+      action: {
+        tag: "button",
+        value: {
+          command: "/help",
+        },
+      },
+    });
+
+    expect(lastRuntime?.error).not.toHaveBeenCalled();
+    expect(dispatchReplyFromConfigMock).toHaveBeenCalledTimes(1);
+    const dispatcherParams = latestReplyDispatcherParams();
+    expect(dispatcherParams.accountId).toBe("acct-card");
+    expect(dispatcherParams.chatId).toBe("ou_user1");
+    expect(dispatcherParams.replyToMessageId).toBeUndefined();
+    expect(latestFinalizedContext().MessageSid).toBe("card-action-tok-card-no-reply-target");
+  });
+
+  it("does not duplicate delivery when retrying after a post-send failure", async () => {
+    const onCardAction = await setupLifecycleMonitor();
+    const event = createCardActionEvent({
+      token: "tok-card-retry",
+      action: "feishu.quick_actions.help",
+      command: "/help",
+    });
+
+    dispatchReplyFromConfigMock.mockImplementationOnce(async ({ dispatcher }) => {
+      await dispatcher.sendFinalReply({ text: "card action reply once" });
+      throw new Error("post-send failure");
+    });
+
+    await expectFeishuReplyPipelineDedupedAfterPostSendFailure({
+      handler: onCardAction,
+      event,
+      dispatchReplyFromConfigMock,
+      runtimeErrorMock: lastRuntime?.error as ReturnType<typeof vi.fn>,
+    });
+
+    expect(lastRuntime?.error).toHaveBeenCalledTimes(1);
+    expect(dispatchReplyFromConfigMock).toHaveBeenCalledTimes(1);
+    expectFeishuReplyDispatcherSentFinalReplyOnce({ createFeishuReplyDispatcherMock });
+  });
+
+  it("drops malformed card-action events with empty tokens before handler dispatch", async () => {
+    const onCardAction = await setupLifecycleMonitor();
+
+    await onCardAction({
+      operator: {
+        open_id: "ou_user1",
+        user_id: "user_1",
+        union_id: "union_1",
+      },
+      token: "",
+      action: {
+        tag: "button",
+        value: createFeishuCardInteractionEnvelope({
+          k: "quick",
+          a: "feishu.quick_actions.help",
+          q: "/help",
+          c: {
+            u: "ou_user1",
+            h: "p2p:ou_user1",
+            t: "p2p",
+            e: Date.now() + 60_000,
+          },
+        }),
+      },
+      context: {
+        open_id: "ou_user1",
+        user_id: "user_1",
+        chat_id: "p2p:ou_user1",
+      },
+    });
+
+    expect(lastRuntime?.error).toHaveBeenCalledWith(
+      "feishu[acct-card]: ignoring malformed card action payload",
+    );
+    expect(dispatchReplyFromConfigMock).not.toHaveBeenCalled();
+  });
+});