amirealtime-api.test.ts

import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";

import {
  buildAmIRealtimeResultOk,
  ChainIndexingConfigTypeIds,
  ChainIndexingStatusIds,
  type ChainIndexingStatusSnapshotFollowing,
  type CrossChainIndexingStatusSnapshot,
  createRealtimeIndexingStatusProjection,
  OmnichainIndexingStatusIds,
  type UnixTimestamp,
} from "@ensnode/ensnode-sdk";

import { factory } from "@/lib/hono-factory";
import * as middleware from "@/middleware/indexing-status.middleware";

import amIRealtimeApi, { AMIREALTIME_DEFAULT_MAX_WORST_CASE_DISTANCE } from "./amirealtime-api"; // adjust import path as needed

vi.mock("@/middleware/indexing-status.middleware", () => ({
  indexingStatusMiddleware: vi.fn(),
}));

const indexingStatusMiddlewareMock = vi.mocked(middleware.indexingStatusMiddleware);

describe("amirealtime-api", () => {
  const now: UnixTimestamp = 1766123729;

  const arrangeMockedIndexingStatusMiddleware = ({
    now,
    slowestChainIndexingCursor,
  }: {
    now: UnixTimestamp;
    slowestChainIndexingCursor: UnixTimestamp;
  }) => {
    indexingStatusMiddlewareMock.mockImplementation(async (c, next) => {
      const indexingStatus = {
        omnichainSnapshot: {
          omnichainStatus: OmnichainIndexingStatusIds.Following,
          omnichainIndexingCursor: slowestChainIndexingCursor,
          chains: new Map([
            [
              1,
              {
                chainStatus: ChainIndexingStatusIds.Following,
                latestIndexedBlock: {
                  timestamp: now - 10,
                  number: 150,
                },
                latestKnownBlock: {
                  timestamp: now,
                  number: 151,
                },
                config: {
                  configType: ChainIndexingConfigTypeIds.Indefinite,
                  startBlock: {
                    number: 100,
                    timestamp: now - 1000,
                  },
                },
              } satisfies ChainIndexingStatusSnapshotFollowing,
            ],
          ]),
        } as CrossChainIndexingStatusSnapshot["omnichainSnapshot"],
        snapshotTime: now,
        slowestChainIndexingCursor,
      } satisfies Pick<
        CrossChainIndexingStatusSnapshot,
        "omnichainSnapshot" | "slowestChainIndexingCursor" | "snapshotTime"
      > as CrossChainIndexingStatusSnapshot;

      const realtimeProjection = createRealtimeIndexingStatusProjection(indexingStatus, now);

      c.set("indexingStatus", realtimeProjection);

      return await next();
    });
  };

  let app: ReturnType<typeof factory.createApp>;

  beforeEach(() => {
    // Create a fresh app instance for each test with middleware registered
    app = factory.createApp();
    app.use(middleware.indexingStatusMiddleware);
    app.route("/amirealtime", amIRealtimeApi);
  });

  afterEach(() => {
    indexingStatusMiddlewareMock.mockReset();
  });

  describe("GET /amirealtime", () => {
    describe("request", () => {
      it("should accept valid maxWorstCaseDistance query param", async () => {
        // Arrange: set `indexingStatus` context var
        arrangeMockedIndexingStatusMiddleware({ now, slowestChainIndexingCursor: now - 10 });

        // Act
        const response = await app.request("http://localhost/amirealtime?maxWorstCaseDistance=300");
        const responseJson = await response.json();

        // Assert
        expect(response.status).toBe(200);
        expect(responseJson).toStrictEqual(
          buildAmIRealtimeResultOk({
            maxWorstCaseDistance: 300,
            worstCaseDistance: 10,
            slowestChainIndexingCursor: now - 10,
          }),
        );
      });

      it("should accept valid maxWorstCaseDistance query param (set to `0`)", async () => {
        // Arrange: set `indexingStatus` context var
        arrangeMockedIndexingStatusMiddleware({ now, slowestChainIndexingCursor: now });

        // Act
        const response = await app.request("http://localhost/amirealtime?maxWorstCaseDistance=0");
        const responseJson = await response.json();

        // Assert
        expect(response.status).toBe(200);
        expect(responseJson).toStrictEqual(
          buildAmIRealtimeResultOk({
            maxWorstCaseDistance: 0,
            worstCaseDistance: 0,
            slowestChainIndexingCursor: now,
          }),
        );
      });

      it("should use default maxWorstCaseDistance when unset", async () => {
        // Arrange: set `indexingStatus` context var
        arrangeMockedIndexingStatusMiddleware({ now, slowestChainIndexingCursor: now - 10 });

        // Act
        const response = await app.request("http://localhost/amirealtime?maxWorstCaseDistance");
        const responseJson = await response.json();

        // Assert
        expect(response.status).toBe(200);
        expect(responseJson).toStrictEqual(
          buildAmIRealtimeResultOk({
            maxWorstCaseDistance: AMIREALTIME_DEFAULT_MAX_WORST_CASE_DISTANCE,
            worstCaseDistance: 10,
            slowestChainIndexingCursor: now - 10,
          }),
        );
      });

      it("should use default maxWorstCaseDistance when not provided", async () => {
        // Arrange: set `indexingStatus` context var
        arrangeMockedIndexingStatusMiddleware({ now, slowestChainIndexingCursor: now - 10 });

        // Act
        const response = await app.request("http://localhost/amirealtime");
        const responseJson = await response.json();

        // Assert
        expect(response.status).toBe(200);
        expect(responseJson).toStrictEqual(
          buildAmIRealtimeResultOk({
            maxWorstCaseDistance: AMIREALTIME_DEFAULT_MAX_WORST_CASE_DISTANCE,
            worstCaseDistance: 10,
            slowestChainIndexingCursor: now - 10,
          }),
        );
      });

      it("should reject invalid maxWorstCaseDistance (negative number)", async () => {
        // Arrange: set `indexingStatus` context var
        arrangeMockedIndexingStatusMiddleware({ now, slowestChainIndexingCursor: now - 10 });

        // Act
        const response = await app.request("http://localhost/amirealtime?maxWorstCaseDistance=-1");

        // Assert
        expect(response.status).toBe(400);
        await expect(response.text()).resolves.toMatch(
          /maxWorstCaseDistance query param must be a non-negative integer/,
        );
      });

      it("should reject invalid maxWorstCaseDistance (not a number)", async () => {
        // Arrange: set `indexingStatus` context var
        arrangeMockedIndexingStatusMiddleware({ now, slowestChainIndexingCursor: now - 10 });

        // Act
        const response = await app.request(
          "http://localhost/amirealtime?maxWorstCaseDistance=invalid",
        );

        // Assert
        expect(response.status).toBe(400);
        await expect(response.text()).resolves.toMatch(
          /maxWorstCaseDistance query param must be a number/,
        );
      });
    });

    describe("response", () => {
      it("should return 200 when worstCaseDistance is below maxWorstCaseDistance", async () => {
        // Arrange: set `indexingStatus` context var
        arrangeMockedIndexingStatusMiddleware({ now, slowestChainIndexingCursor: now - 9 });

        // Act
        const response = await app.request("http://localhost/amirealtime?maxWorstCaseDistance=10");
        const responseJson = await response.json();

        // Assert
        expect(response.status).toBe(200);
        expect(responseJson).toStrictEqual(
          buildAmIRealtimeResultOk({
            maxWorstCaseDistance: 10,
            slowestChainIndexingCursor: now - 9,
            worstCaseDistance: 9,
          }),
        );
      });

      it("should return 200 when worstCaseDistance equals maxWorstCaseDistance", async () => {
        // Arrange: set `indexingStatus` context var
        arrangeMockedIndexingStatusMiddleware({ now, slowestChainIndexingCursor: now - 10 });

        // Act
        const response = await app.request("http://localhost/amirealtime?maxWorstCaseDistance=10");
        const responseJson = await response.json();

        // Assert
        expect(response.status).toBe(200);
        expect(responseJson).toStrictEqual(
          buildAmIRealtimeResultOk({
            maxWorstCaseDistance: 10,
            slowestChainIndexingCursor: 1766123719,
            worstCaseDistance: 10,
          }),
        );
      });

      it("should return 503 when worstCaseDistance exceeds maxWorstCaseDistance", async () => {
        // Arrange: set `indexingStatus` context var
        arrangeMockedIndexingStatusMiddleware({ now, slowestChainIndexingCursor: now - 11 });

        // Act
        const response = await app.request("http://localhost/amirealtime?maxWorstCaseDistance=10");
        const responseJson = await response.json();

        // Assert
        expect(response.status).toBe(503);
        expect(responseJson).toHaveProperty("errorMessage");
        expect(responseJson.errorMessage).toMatch(
          /Indexing Status 'worstCaseDistance' must be below or equal to the requested 'maxWorstCaseDistance'; worstCaseDistance = 11; maxWorstCaseDistance = 10/,
        );
      });

      it("should return 503 when indexing status has not been resolved", async () => {
        // Arrange: set `indexingStatus` context var
        indexingStatusMiddlewareMock.mockImplementation(async (c, next) => {
          c.set("indexingStatus", new Error("Network error"));

          return await next();
        });

        // Act
        const response = await app.request("http://localhost/amirealtime?maxWorstCaseDistance=10");
        const responseJson = await response.json();

        // Assert
        expect(response.status).toBe(503);
        expect(responseJson).toHaveProperty("errorMessage");
        expect(responseJson.errorMessage).toMatch(
          /Indexing Status must be resolved successfully before 'maxWorstCaseDistance' can be applied./,
        );
      });
    });
  });
});