rabbbit

tests/server/ClanTagOwnership.test.ts

@@ -0,0 +1,222 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { UserMeResponse } from "../../src/core/ApiSchemas";
+import {
+  clanExistsByTag,
+  resolveClanTag,
+} from "../../src/server/ClanTagOwnership";
+
+const okResponse = (status: number, body = ""): Response =>
+  ({
+    status,
+    text: async () => body,
+  }) as unknown as Response;
+
+const userWithClans = (tags: string[]): UserMeResponse =>
+  ({
+    user: {},
+    player: {
+      publicId: "p1",
+      adfree: false,
+      flares: [],
+      achievements: { singleplayerMap: [] },
+      friends: [],
+      subscription: null,
+      clans: tags.map((tag) => ({
+        tag,
+        name: tag,
+        role: "member" as const,
+        joinedAt: new Date().toISOString(),
+        memberCount: 1,
+      })),
+    },
+  }) as UserMeResponse;
+
+describe("clanExistsByTag", () => {
+  let cache: Map<string, { expiresAt: number }>;
+  let now: number;
+
+  beforeEach(() => {
+    cache = new Map();
+    now = 1_000_000;
+  });
+
+  it("returns true on HTTP 200", async () => {
+    const fetcher = vi.fn(async () => okResponse(200));
+    const result = await clanExistsByTag("ABC", {
+      baseUrl: "https://auth.example",
+      fetcher: fetcher as unknown as typeof fetch,
+      cache,
+      now: () => now,
+    });
+    expect(result).toBe(true);
+  });
+
+  it("returns false on HTTP 404 without caching it", async () => {
+    const fetcher = vi.fn(async () => okResponse(404));
+    const result = await clanExistsByTag("XYZ", {
+      baseUrl: "https://auth.example",
+      fetcher: fetcher as unknown as typeof fetch,
+      cache,
+      now: () => now,
+    });
+    expect(result).toBe(false);
+    // Negative results must not poison the cache — a clan can be created
+    // moments after a 404 and a stale "false" would briefly let non-members
+    // wear the tag.
+    expect(cache.size).toBe(0);
+  });
+
+  it("returns null on unexpected status (fail-closed) and does not cache", async () => {
+    const fetcher = vi.fn(async () => okResponse(503));
+    const result = await clanExistsByTag("ABC", {
+      baseUrl: "https://auth.example",
+      fetcher: fetcher as unknown as typeof fetch,
+      cache,
+      now: () => now,
+    });
+    expect(result).toBeNull();
+    expect(cache.size).toBe(0);
+  });
+
+  it("returns null on transport error (fail-closed)", async () => {
+    const fetcher = vi.fn(async () => {
+      throw new Error("offline");
+    });
+    const result = await clanExistsByTag("ABC", {
+      baseUrl: "https://auth.example",
+      fetcher: fetcher as unknown as typeof fetch,
+      cache,
+      now: () => now,
+    });
+    expect(result).toBeNull();
+  });
+
+  it("uppercases the tag in the request URL", async () => {
+    const fetcher = vi.fn(async () => okResponse(200));
+    await clanExistsByTag("abc", {
+      baseUrl: "https://auth.example",
+      fetcher: fetcher as unknown as typeof fetch,
+      cache,
+      now: () => now,
+    });
+    const calledUrl = (fetcher.mock.calls[0] as unknown[])[0] as string;
+    expect(calledUrl).toContain("/public/clan/ABC/exists");
+  });
+
+  it("serves positive results from cache without re-fetching", async () => {
+    const fetcher = vi.fn(async () => okResponse(200));
+    await clanExistsByTag("ABC", {
+      baseUrl: "https://auth.example",
+      fetcher: fetcher as unknown as typeof fetch,
+      cache,
+      now: () => now,
+    });
+    await clanExistsByTag("ABC", {
+      baseUrl: "https://auth.example",
+      fetcher: fetcher as unknown as typeof fetch,
+      cache,
+      now: () => now,
+    });
+    expect(fetcher).toHaveBeenCalledTimes(1);
+  });
+
+  it("re-fetches positive entries after TTL expiry", async () => {
+    const fetcher = vi.fn(async () => okResponse(200));
+    await clanExistsByTag("ABC", {
+      baseUrl: "https://auth.example",
+      fetcher: fetcher as unknown as typeof fetch,
+      cache,
+      now: () => now,
+      ttlMs: 1000,
+    });
+    now += 2000;
+    await clanExistsByTag("ABC", {
+      baseUrl: "https://auth.example",
+      fetcher: fetcher as unknown as typeof fetch,
+      cache,
+      now: () => now,
+      ttlMs: 1000,
+    });
+    expect(fetcher).toHaveBeenCalledTimes(2);
+  });
+
+  it("evicts the oldest entry when maxEntries is exceeded", async () => {
+    const fetcher = vi.fn(async () => okResponse(200));
+    const deps = {
+      baseUrl: "https://auth.example",
+      fetcher: fetcher as unknown as typeof fetch,
+      cache,
+      now: () => now,
+      maxEntries: 2,
+    };
+    await clanExistsByTag("A", deps);
+    await clanExistsByTag("B", deps);
+    await clanExistsByTag("C", deps);
+    expect(cache.size).toBe(2);
+    expect(cache.has("A")).toBe(false);
+    expect(cache.has("B")).toBe(true);
+    expect(cache.has("C")).toBe(true);
+  });
+
+  it("treats body {exists:false} as false on 200 without caching", async () => {
+    const fetcher = vi.fn(async () =>
+      okResponse(200, JSON.stringify({ exists: false })),
+    );
+    const result = await clanExistsByTag("ABC", {
+      baseUrl: "https://auth.example",
+      fetcher: fetcher as unknown as typeof fetch,
+      cache,
+      now: () => now,
+    });
+    expect(result).toBe(false);
+    expect(cache.size).toBe(0);
+  });
+});
+
+describe("resolveClanTag", () => {
+  it("passes a null tag through unchanged", async () => {
+    const probe = vi.fn();
+    const result = await resolveClanTag(null, null, probe);
+    expect(result).toEqual({ tag: null, dropped: false });
+    expect(probe).not.toHaveBeenCalled();
+  });
+
+  it("accepts a tag when the user is a member (case-insensitive)", async () => {
+    const probe = vi.fn();
+    const me = userWithClans(["abc"]);
+    const result = await resolveClanTag("ABC", me, probe);
+    expect(result).toEqual({ tag: "ABC", dropped: false });
+    expect(probe).not.toHaveBeenCalled();
+  });
+
+  it("drops a tag belonging to a real clan the user does not belong to", async () => {
+    const probe = vi.fn(async () => true);
+    const me = userWithClans(["other"]);
+    const result = await resolveClanTag("ABC", me, probe);
+    expect(result).toEqual({ tag: null, dropped: true, reason: "exists" });
+  });
+
+  it("keeps a tag that does not match any real clan (fictional)", async () => {
+    const probe = vi.fn(async () => false);
+    const result = await resolveClanTag("ABC", null, probe);
+    expect(result).toEqual({ tag: "ABC", dropped: false });
+  });
+
+  it("drops the tag on inconclusive existence check (fail-closed)", async () => {
+    const probe = vi.fn(async () => null);
+    const result = await resolveClanTag("ABC", null, probe);
+    expect(result).toEqual({
+      tag: null,
+      dropped: true,
+      reason: "inconclusive",
+    });
+  });
+
+  it("treats anonymous users as members of no clans", async () => {
+    const probe = vi.fn(async () => true);
+    const result = await resolveClanTag("ABC", null, probe);
+    expect(result.tag).toBeNull();
+    expect(result.dropped).toBe(true);
+    expect(probe).toHaveBeenCalledWith("ABC");
+  });
+});