Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

17.1 KB
Raw Blame
import { describe, it, expect, vi } from "vitest";
import * as memberQueries from "../../src/db/queries/community/member";
import {
  DEFAULT_MEMBERS_PAGE_SIZE,
  MAX_MEMBERS_PAGE_SIZE,
} from "../../src/constants/community";

function createSelectMock(rows: any[]) {
  const chain: any = {};
  chain.select = vi.fn(() => chain);
  chain.from = vi.fn(() => chain);
  chain.innerJoin = vi.fn(() => chain);
  chain.leftJoin = vi.fn(() => chain);
  chain.where = vi.fn(() => chain);
  chain.orderBy = vi.fn(() => chain);
  chain.limit = vi.fn(() => Promise.resolve(rows));
  // Terminal `where` when there's no orderBy/limit downstream.
  chain.whereTerminal = () => Promise.resolve(rows);
  return chain;
}

// Terminal-where mock: `.where()` itself resolves to rows (used for listMemberUserIds/countMembers).
function createTerminalWhereMock(rows: any[]) {
  const chain: any = {};
  chain.select = vi.fn(() => chain);
  chain.from = vi.fn(() => chain);
  chain.where = vi.fn(() => Promise.resolve(rows));
  return chain;
}


describe("removeMemberAndOwnerBots", () => {
  it("batches rail cleanup with target and bot deletes and returns the removed target", async () => {
    const handoffStatement: any = {};
    handoffStatement.set = vi.fn(() => handoffStatement);
    handoffStatement.where = vi.fn(() => handoffStatement);
    handoffStatement.returning = vi.fn(() => handoffStatement);
    const cleanupStatement: any = {};
    cleanupStatement.where = vi.fn(() => cleanupStatement);
    const emptyFolderStatement: any = {};
    emptyFolderStatement.where = vi.fn(() => emptyFolderStatement);
    const channelMembershipStatement: any = {};
    channelMembershipStatement.where = vi.fn(() => channelMembershipStatement);
    const targetStatement: any = {};
    targetStatement.where = vi.fn(() => targetStatement);
    targetStatement.returning = vi.fn(() => targetStatement);
    const botsStatement: any = {};
    botsStatement.where = vi.fn(() => botsStatement);
    const db: any = {
      update: vi.fn(() => handoffStatement),
      delete: vi
        .fn()
        .mockReturnValueOnce(cleanupStatement)
        .mockReturnValueOnce(emptyFolderStatement)
        .mockReturnValueOnce(targetStatement)
        .mockReturnValueOnce(channelMembershipStatement)
        .mockReturnValueOnce(botsStatement),
      batch: vi.fn().mockResolvedValue([
        [],
        { rowsAffected: 3 },
        { rowsAffected: 2 },
        { rowsAffected: 4 },
        [{ id: "mem_1" }],
        { rowsAffected: 2 },
      ]),
    };

    await expect(memberQueries.removeMemberAndOwnerBots(
      db,
      "mem_1",
      "srv_1",
      "user_1",
      ["bot_1", "bot_2"],
    )).resolves.toEqual({ id: "mem_1" });

    expect(db.batch).toHaveBeenCalledWith([
      handoffStatement,
      cleanupStatement,
      emptyFolderStatement,
      channelMembershipStatement,
      targetStatement,
      botsStatement,
    ]);
  });
});

describe("listMemberUserIds", () => {
  it("returns only userIds as strings", async () => {
    const db = createTerminalWhereMock([{ userId: "u_1" }, { userId: "u_2" }]);
    const result = await memberQueries.listMemberUserIds(db, "srv_1");
    expect(result).toEqual(["u_1", "u_2"]);
  });

  it("returns empty array on unknown serverId (no throw)", async () => {
    const db = createTerminalWhereMock([]);
    const result = await memberQueries.listMemberUserIds(db, "srv_missing");
    expect(result).toEqual([]);
  });
});

describe("countMembers", () => {
  it("returns count on populated server", async () => {
    const db = createTerminalWhereMock([{ cnt: 7 }]);
    expect(await memberQueries.countMembers(db, "srv_1")).toBe(7);
  });

  it("returns 0 on empty server", async () => {
    const db = createTerminalWhereMock([{ cnt: 0 }]);
    expect(await memberQueries.countMembers(db, "srv_1")).toBe(0);
  });

  it("returns 0 on unknown serverId via ?? 0 fallback", async () => {
    const db = createTerminalWhereMock([]);
    expect(await memberQueries.countMembers(db, "srv_missing")).toBe(0);
  });
});

function buildMember(i: number) {
  return {
    id: `mem_${i}`,
    serverId: "srv_1",
    userId: `u_${i}`,
    role: "member",
    nickname: null,
    joinedAt: `2025-01-${String(i).padStart(2, "0")}T00:00:00.000Z`,
    userName: `User ${i}`,
    userEmail: `u${i}@x.com`,
    userImage: null,
    discriminator: String(i).padStart(4, "0"),
  };
}

describe("listMembersPaginated", () => {
  it("first page: limit+1 rows โ†’ hasMore=true + typed cursor from last kept row", async () => {
    const limit = 3;
    const rows = [buildMember(1), buildMember(2), buildMember(3), buildMember(4)];
    const db = createSelectMock(rows);
    const result = await memberQueries.listMembersPaginated(db, "srv_1", { limit });
    expect(result.members).toHaveLength(limit);
    expect(result.hasMore).toBe(true);
    expect(result.cursor).toEqual({
      joinedAt: rows[2].joinedAt,
      id: rows[2].id,
    });
  });

  it("last page: fewer than limit rows โ†’ hasMore=false, cursor=undefined", async () => {
    const db = createSelectMock([buildMember(1), buildMember(2)]);
    const result = await memberQueries.listMembersPaginated(db, "srv_1", { limit: 3 });
    expect(result.hasMore).toBe(false);
    expect(result.cursor).toBeUndefined();
    expect(result.members).toHaveLength(2);
  });

  it("cursor round-trip: two pages concatenate to the full sequence without dupes/skips", async () => {
    const limit = 2;
    const all = [buildMember(1), buildMember(2), buildMember(3), buildMember(4)];
    // page 1 โ†’ returns first 3 (limit+1)
    const page1Db = createSelectMock(all.slice(0, 3));
    const page1 = await memberQueries.listMembersPaginated(page1Db, "srv_1", { limit });
    expect(page1.hasMore).toBe(true);
    expect(page1.cursor).toBeDefined();

    // page 2 โ†’ returns remaining 2 (< limit+1) using the cursor from page 1
    const page2Db = createSelectMock(all.slice(2, 4));
    const page2 = await memberQueries.listMembersPaginated(page2Db, "srv_1", {
      limit,
      cursor: page1.cursor,
    });
    expect(page2.hasMore).toBe(false);
    expect(page2.cursor).toBeUndefined();

    const combinedIds = [...page1.members, ...page2.members].map((m) => m.id);
    expect(combinedIds).toEqual(all.map((m) => m.id));
  });

  it("orderBy is called with asc(joinedAt), asc(id); cursor uses gt (not lt/eq)", async () => {
    const db = createSelectMock([buildMember(1)]);
    await memberQueries.listMembersPaginated(db, "srv_1", {
      limit: 5,
      cursor: { joinedAt: "2024-12-01T00:00:00.000Z", id: "mem_x" },
    });
    expect(db.orderBy).toHaveBeenCalledTimes(1);
    // Cursor branch: `where` gets `and(eq(serverId, ...), or(gt, and(eq, gt)))`
    expect(db.where).toHaveBeenCalledTimes(1);
    // Sanity: limit passed as limit + 1
    expect(db.limit).toHaveBeenCalledWith(6);
  });

  it("clamps limit above MAX_MEMBERS_PAGE_SIZE down to the cap", async () => {
    const db = createSelectMock([]);
    await memberQueries.listMembersPaginated(db, "srv_1", {
      limit: MAX_MEMBERS_PAGE_SIZE + 500,
    });
    expect(db.limit).toHaveBeenCalledWith(MAX_MEMBERS_PAGE_SIZE + 1);
  });

  it("clamps limit <= 0 up to 1", async () => {
    const db = createSelectMock([]);
    await memberQueries.listMembersPaginated(db, "srv_1", { limit: 0 });
    expect(db.limit).toHaveBeenCalledWith(2);

    const db2 = createSelectMock([]);
    await memberQueries.listMembersPaginated(db2, "srv_1", { limit: -5 });
    expect(db2.limit).toHaveBeenCalledWith(2);
  });

  it("default limit equals DEFAULT_MEMBERS_PAGE_SIZE when opts.limit omitted", async () => {
    const db = createSelectMock([]);
    await memberQueries.listMembersPaginated(db, "srv_1", {});
    expect(db.limit).toHaveBeenCalledWith(DEFAULT_MEMBERS_PAGE_SIZE + 1);
  });

  it("rows carry the user's discriminator", async () => {
    const db = createSelectMock([buildMember(1), buildMember(2)]);
    const result = await memberQueries.listMembersPaginated(db, "srv_1", { limit: 5 });
    expect(result.members.map((r) => r.discriminator)).toEqual(["0001", "0002"]);
  });

  it("leftJoins communityUserProfile and passes through statusEmoji/statusText, including a user with no profile row", async () => {
    const db = createSelectMock([
      { ...buildMember(1), statusEmoji: "๐ŸŽง", statusText: "Vibing" },
      { ...buildMember(2), statusEmoji: null, statusText: null },
    ]);
    const result = await memberQueries.listMembersPaginated(db, "srv_1", { limit: 5 });
    expect(db.leftJoin).toHaveBeenCalledTimes(1);
    expect(result.members[0]).toMatchObject({ statusEmoji: "๐ŸŽง", statusText: "Vibing" });
    expect(result.members[1]).toMatchObject({ statusEmoji: null, statusText: null });
  });
});

describe("searchMembers", () => {
  function createSearchMock(rows: any[]) {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.innerJoin = vi.fn(() => chain);
    chain.leftJoin = vi.fn(() => chain);
    chain.where = vi.fn(() => chain);
    chain.orderBy = vi.fn(() => chain);
    chain.limit = vi.fn(() => Promise.resolve(rows));
    return chain;
  }


  it("prefix-only: 'Ali' returns Alice + Alicia; 'Bob' returns Bob; 'li' returns nothing", async () => {
    // The Drizzle mock returns whatever `.limit()` resolves to โ€” assert that the
    // caller pattern is `${escapeLikePattern(q)}%` (prefix) and confirm we hand
    // that through to `like(...)` unchanged by inspecting the `where` chain.
    const rowsForAli = [{ id: "m1", userName: "Alice" }, { id: "m2", userName: "Alicia" }];
    const dbAli = createSearchMock(rowsForAli);
    const resAli = await memberQueries.searchMembers(dbAli, "srv_1", "Ali");
    expect(resAli.members.map((r) => r.userName)).toEqual(["Alice", "Alicia"]);

    const rowsForBob = [{ id: "m3", userName: "Bob" }];
    const dbBob = createSearchMock(rowsForBob);
    const resBob = await memberQueries.searchMembers(dbBob, "srv_1", "Bob");
    expect(resBob.members.map((r) => r.userName)).toEqual(["Bob"]);

    // Fixture with no prefix match โ€” DB returns an empty page. This
    // pins prefix semantics: "li" should NOT match "Alice"/"Alicia".
    const dbNone = createSearchMock([]);
    const resNone = await memberQueries.searchMembers(dbNone, "srv_1", "li");
    expect(resNone).toEqual({ members: [], hasMore: false, cursor: undefined });
  });

  it("orders by user.name ASC then id ASC", async () => {
    const db = createSearchMock([]);
    await memberQueries.searchMembers(db, "srv_1", "A");
    expect(db.orderBy).toHaveBeenCalledTimes(1);
    // The order-by arg list is opaque to Drizzle's mock, but a single call
    // confirms only one ordering ran.
  });

  it("clamps limit above MAX_MEMBERS_PAGE_SIZE down to the cap", async () => {
    const db = createSearchMock([]);
    await memberQueries.searchMembers(db, "srv_1", "A", { limit: MAX_MEMBERS_PAGE_SIZE + 5000 });
    expect(db.limit).toHaveBeenCalledWith(MAX_MEMBERS_PAGE_SIZE + 1);
  });

  it("defaults to MAX_MEMBERS_PAGE_SIZE when limit omitted", async () => {
    const db = createSearchMock([]);
    await memberQueries.searchMembers(db, "srv_1", "A");
    expect(db.limit).toHaveBeenCalledWith(MAX_MEMBERS_PAGE_SIZE + 1);
  });

  it("leftJoins communityUserProfile and passes through statusEmoji/statusText", async () => {
    const db = createSearchMock([
      { id: "m1", userName: "Alice", statusEmoji: "๐ŸŽฎ", statusText: "Gaming" },
    ]);
    const res = await memberQueries.searchMembers(db, "srv_1", "Ali");
    expect(db.leftJoin).toHaveBeenCalledTimes(1);
    expect(res.members[0]).toMatchObject({ statusEmoji: "๐ŸŽฎ", statusText: "Gaming" });
  });

  it("escapes % and _ wildcards in the query string (LIKE escape)", async () => {
    // We can't observe the driver-level parameter binding here, but the
    // helper `escapeLikePattern` is trusted and tested elsewhere. Sanity
    // check: the call succeeds and passes through to `.where(...)` once.
    const db = createSearchMock([]);
    await memberQueries.searchMembers(db, "srv_1", "50%_off");
    expect(db.where).toHaveBeenCalledTimes(1);
  });

  it("does NOT filter blocked users โ€” an isBlocked pre-check is never applied inside the query", async () => {
    // Query semantics: `searchMembers` scopes by serverId + LIKE only. There
    // is no join against `blocked_relationship` / `communityFriendship`. This
    // test pins that decision by asserting the row set is unfiltered when the
    // caller passes anyone in โ€” the query doesn't know about the caller.
    const db = createSearchMock([
      { id: "m1", userId: "u_blocker", userName: "Alice" },
      { id: "m2", userId: "u_blocked_by_caller", userName: "Alicia" },
    ]);
    const res = await memberQueries.searchMembers(db, "srv_1", "Ali");
    expect(res.members.map((r) => r.id)).toEqual(["m1", "m2"]);
  });

  it("rows carry the user's discriminator", async () => {
    const db = createSearchMock([
      { id: "m1", userName: "Alex", discriminator: "0001" },
      { id: "m2", userName: "Alex", discriminator: "0002" },
    ]);
    const res = await memberQueries.searchMembers(db, "srv_1", "Alex");
    expect(res.members.map((r) => r.discriminator)).toEqual(["0001", "0002"]);
  });

  it("returns a stable name/id cursor and slices off the probe row", async () => {
    const db = createSearchMock([
      { id: "m1", userName: "Alex" },
      { id: "m2", userName: "Alex" },
      { id: "m3", userName: "Alicia" },
    ]);
    const res = await memberQueries.searchMembers(db, "srv_1", "Al", { limit: 2 });
    expect(db.limit).toHaveBeenCalledWith(3);
    expect(res.members.map((row) => row.id)).toEqual(["m1", "m2"]);
    expect(res).toMatchObject({
      hasMore: true,
      cursor: { name: "Alex", id: "m2" },
    });
  });

  it("adds the same-name cursor boundary to the scoped search", async () => {
    const db = createSearchMock([]);
    await memberQueries.searchMembers(db, "srv_1", "Alex", {
      cursor: { name: "Alex", id: "m200" },
    });
    expect(db.where).toHaveBeenCalledTimes(1);
    expect(db.orderBy).toHaveBeenCalledTimes(1);
  });
});

describe("getMembersByUserIds", () => {
  // `.leftJoin().where()` is terminal here (no orderBy/limit).
  function createMock(rows: any[]) {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.innerJoin = vi.fn(() => chain);
    chain.leftJoin = vi.fn(() => chain);
    chain.where = vi.fn(() => Promise.resolve(rows));
    return chain;
  }


  it("returns [] without querying when the id list is empty", async () => {
    const db = createMock([{ id: "should_not_be_used" }]);
    const res = await memberQueries.getMembersByUserIds(db, "srv_1", []);
    expect(res).toEqual([]);
    expect(db.select).not.toHaveBeenCalled();
  });

  it("returns hydrated rows (incl. status columns) for the given ids", async () => {
    const rows = [
      { id: "m1", userId: "u_1", userName: "Ann", statusEmoji: "๐ŸŽง", statusText: "Vibing", userIsBot: false, userOwnerUserId: null },
      { id: "m2", userId: "u_2", userName: "Bob", statusEmoji: null, statusText: null, userIsBot: false, userOwnerUserId: null },
    ];
    const db = createMock(rows);
    const res = await memberQueries.getMembersByUserIds(db, "srv_1", ["u_1", "u_2"]);
    expect(res.map((r) => r.userId)).toEqual(["u_1", "u_2"]);
    expect(res[0]).toMatchObject({ statusEmoji: "๐ŸŽง", statusText: "Vibing" });
  });
});

describe("getMemberById", () => {
  function createMock(rows: any[]) {
    const chain: any = {};
    chain.select = vi.fn(() => chain);
    chain.from = vi.fn(() => chain);
    chain.innerJoin = vi.fn(() => chain);
    chain.where = vi.fn(() => Promise.resolve(rows));
    return chain;
  }

  it("returns the row when memberId is scoped to the given serverId", async () => {
    const row = buildMember(1);
    const db = createMock([row]);
    const result = await memberQueries.getMemberById(db, "mem_1", { serverId: "srv_1" });
    expect(result).toEqual(row);
    // Scope-first: `.where(and(eq(id, ...), eq(serverId, ...)))` โ€” a single
    // clause with both bounds. No listMembers-style fetch-and-filter.
    expect(db.where).toHaveBeenCalledTimes(1);
    expect(db.innerJoin).toHaveBeenCalledTimes(1);
  });

  it("returns null when memberId belongs to a different server (scope wins)", async () => {
    // Simulated DB behaviour: `WHERE id = mem_1 AND server_id = srv_2` finds
    // nothing because mem_1 lives on srv_1. Proves scoping happens in SQL,
    // not in JS post-filtering.
    const db = createMock([]);
    const result = await memberQueries.getMemberById(db, "mem_1", { serverId: "srv_2" });
    expect(result).toBeNull();
  });

  it("returns null when memberId does not exist at all", async () => {
    const db = createMock([]);
    const result = await memberQueries.getMemberById(db, "mem_missing", { serverId: "srv_1" });
    expect(result).toBeNull();
  });

  it("returned row includes role, userName, userId โ€” the fields both PATCH/DELETE call sites read", async () => {
    const row = buildMember(2);
    const db = createMock([row]);
    const result = await memberQueries.getMemberById(db, "mem_2", { serverId: "srv_1" });
    expect(result).not.toBeNull();
    expect(result!.role).toBe("member");
    expect(result!.userName).toBe("User 2");
    expect(result!.userId).toBe("u_2");
  });
});