elizaos--eliza/plugins/plugin-telegram/__tests__/core-test-mock.ts

/**
 * Shared `vi.mock("@elizaos/core")` factory for the plugin's unit tests: stubs
 * the enums, logger, `Service` base, and id helpers the connector touches while
 * delegating to the real interaction protocol so callback encoding/layout is
 * exercised for real rather than re-stubbed.
 */
import { vi } from "vitest";

vi.mock("@elizaos/core", async () => {
  const { createHash } = await import("node:crypto");

  // The interaction protocol (parse/serialize/layout/callback/normalize) is
  // pure — types-only imports, no runtime deps — so the mock uses the real
  // implementation rather than re-stubbing it.
  const interactions = await import(
    "../../../packages/core/src/messaging/interactions/index"
  );

  // The message-triage adapter base + service are equally pure (only `logger`
  // and type imports), so the mock delegates to the real submodules rather than
  // re-stubbing — `triage-adapter.ts` subclasses BaseMessageAdapter at module
  // eval, so the real class must be present or `./index` fails to load.
  const { BaseMessageAdapter } = await import(
    "../../../packages/core/src/features/messaging/triage/adapters/base"
  );
  const { getDefaultTriageService } = await import(
    "../../../packages/core/src/features/messaging/triage/triage-service"
  );

  const logger = {
    debug: vi.fn(),
    error: vi.fn(),
    info: vi.fn(),
    success: vi.fn(),
    warn: vi.fn(),
  };

  const ChannelType = {
    API: "API",
    DM: "DM",
    FEED: "FEED",
    GROUP: "GROUP",
    SELF: "SELF",
    THREAD: "THREAD",
    VOICE_DM: "VOICE_DM",
    VOICE_GROUP: "VOICE_GROUP",
    WORLD: "WORLD",
  } as const;

  const EventType = {
    MESSAGE_RECEIVED: "MESSAGE_RECEIVED",
    MESSAGE_SENT: "MESSAGE_SENT",
    REACTION_RECEIVED: "REACTION_RECEIVED",
    WORLD_JOINED: "WORLD_JOINED",
  } as const;

  const ModelType = {
    IMAGE_DESCRIPTION: "IMAGE_DESCRIPTION",
  } as const;

  const Role = {
    ADMIN: "ADMIN",
    GUEST: "GUEST",
    MEMBER: "MEMBER",
    NONE: "NONE",
    OWNER: "OWNER",
  } as const;

  const ServiceType = {
    PDF: "pdf",
  } as const;

  function stringToUuid(target: string | number): string {
    const value = typeof target === "number" ? String(target) : target;
    if (typeof value !== "string") {
      throw new TypeError("Value must be string");
    }
    if (
      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
        value,
      )
    ) {
      return value;
    }

    const bytes = createHash("sha1")
      .update(encodeURIComponent(value))
      .digest()
      .subarray(0, 16);
    bytes[8] = (bytes[8] & 0x3f) | 0x80;
    bytes[6] = bytes[6] & 0x0f;

    const hex = bytes.toString("hex");
    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(
      12,
      16,
    )}-${hex.slice(16, 20)}-${hex.slice(20)}`;
  }

  class Service {
    protected runtime: unknown;

    constructor(runtime?: unknown) {
      this.runtime = runtime;
    }
  }

  class CommandRegistryService extends Service {
    static readonly serviceType = "commands";

    register(): void {}

    list(): unknown[] {
      return [];
    }
  }

  return {
    ...interactions,
    BaseMessageAdapter,
    ChannelType,
    CommandRegistryService,
    EventType,
    getDefaultTriageService,
    ModelType,
    Role,
    Service,
    ServiceType,
    createUniqueUuid: (runtime: { agentId: string }, baseUserId: string) =>
      baseUserId === runtime.agentId
        ? runtime.agentId
        : stringToUuid(`${baseUserId}:${runtime.agentId}`),
    lifeOpsPassiveConnectorsEnabled: () => true,
    logger,
    stringToUuid,
  };
});