Skip to content

armgit / kaneo

Public Imported from GitHub
0

⚡ Project management that doesn't become the project. Boards, Gantt charts, and GitHub integration. Self-host it or use Kaneo Cloud.

11.1 KB
Raw Blame
import { randomUUID } from "node:crypto";
import { eq } from "drizzle-orm";
import type { WSContext } from "hono/ws";
import {
  afterEach,
  beforeEach,
  describe,
  expect,
  it,
  vi,
} from "vite-plus/test";
import { auth } from "../../apps/api/src/auth";
import db, { schema } from "../../apps/api/src/database";
import { createApp } from "../../apps/api/src/index";
import {
  addUserConnection,
  broadcastToUser,
  removeUserConnection,
  SESSION_ENDED_CLOSE_CODE,
} from "../../apps/api/src/ws";
import { resetTestDatabase } from "./helpers/database";
import {
  enableBackchannelLogout,
  postLogoutToken,
  signLogoutToken,
} from "./helpers/logout-token";

async function seedUser(accountId?: string, providerId = "custom") {
  const [user] = await db
    .insert(schema.userTable)
    .values({
      id: `user-${randomUUID()}`,
      email: `${randomUUID()}@example.com`,
      emailVerified: true,
      name: "Provider User",
    })
    .returning();
  if (!user) throw new Error("Failed to seed user");
  if (accountId) {
    await db.insert(schema.accountTable).values({
      accountId,
      providerId,
      userId: user.id,
    });
  }
  return user;
}

async function seedSession(userId: string, oidcSid: string | null = null) {
  const id = randomUUID();
  await db.insert(schema.sessionTable).values({
    id,
    userId,
    token: randomUUID(),
    expiresAt: new Date(Date.now() + 60_000),
    oidcSid,
  });
  return id;
}

async function remainingSessionIds() {
  const sessions = await db
    .select({ id: schema.sessionTable.id })
    .from(schema.sessionTable);
  return sessions.map((session) => session.id).sort();
}

function fakeSocket() {
  return { send: vi.fn(), close: vi.fn() };
}

describe("API integration: back-channel logout", () => {
  let issuer: string;

  beforeEach(async () => {
    await resetTestDatabase();
    ({ issuer } = enableBackchannelLogout());
  });

  afterEach(() => {
    vi.unstubAllEnvs();
    vi.unstubAllGlobals();
  });

  it("ends only the subject's sessions with the provider session ID", async () => {
    const user = await seedUser("kc-user-1");
    const other = await seedUser("kc-user-2");
    await seedSession(user.id, "kc-session-1");
    const otherProviderSession = await seedSession(user.id, "kc-session-2");
    const withoutSid = await seedSession(user.id);
    const otherUser = await seedSession(other.id, "kc-session-1");

    const response = await postLogoutToken(
      createApp().app,
      signLogoutToken(issuer, { sub: "kc-user-1", sid: "kc-session-1" }),
    );

    expect(response.status).toBe(200);
    expect(response.headers.get("cache-control")).toBe("no-store");
    expect(await response.text()).toBe("");
    expect(await remainingSessionIds()).toEqual(
      [otherProviderSession, withoutSid, otherUser].sort(),
    );
  });

  it("ends the sessions with the provider session ID when no subject is sent", async () => {
    const user = await seedUser("kc-user-1");
    const other = await seedUser("kc-user-2");
    await seedSession(user.id, "kc-session-1");
    await seedSession(other.id, "kc-session-1");
    const kept = await seedSession(user.id, "kc-session-2");

    const response = await postLogoutToken(
      createApp().app,
      signLogoutToken(issuer, { sid: "kc-session-1" }),
    );

    expect(response.status).toBe(200);
    expect(await remainingSessionIds()).toEqual([kept]);
  });

  it("ends every session of the subject, closes its realtime connections and keeps its API keys", async () => {
    const user = await seedUser("kc-user-1");
    const other = await seedUser("kc-user-2");
    const providerSession = await seedSession(user.id, "kc-session-1");
    const appSession = await seedSession(user.id);
    const kept = await seedSession(other.id, "kc-session-3");
    const { key } = await auth.api.createApiKey({
      body: { userId: user.id, name: "Logout test" },
    });
    const { app } = createApp();
    const providerSocket = fakeSocket();
    const appSocket = fakeSocket();
    const apiKeySocket = fakeSocket();
    const otherSocket = fakeSocket();
    const connections = [
      addUserConnection(
        user.id,
        providerSocket as unknown as WSContext,
        providerSession,
      ),
      addUserConnection(user.id, appSocket as unknown as WSContext, appSession),
      addUserConnection(user.id, apiKeySocket as unknown as WSContext),
    ];
    const otherConnection = addUserConnection(
      other.id,
      otherSocket as unknown as WSContext,
      kept,
    );
    try {
      const response = await postLogoutToken(
        app,
        signLogoutToken(issuer, { sub: "kc-user-1" }),
      );

      expect(response.status).toBe(200);
      expect(await remainingSessionIds()).toEqual([kept]);
      for (const socket of [providerSocket, appSocket])
        expect(socket.close).toHaveBeenCalledWith(
          SESSION_ENDED_CLOSE_CODE,
          "Session ended",
        );
      expect(apiKeySocket.close).not.toHaveBeenCalled();
      expect(otherSocket.close).not.toHaveBeenCalled();
      expect(
        (await app.request("/api/user/me", { headers: { "x-api-key": key } }))
          .status,
      ).toBe(200);
    } finally {
      for (const connection of connections)
        removeUserConnection(user.id, connection);
      removeUserConnection(other.id, otherConnection);
    }
  });

  it("leaves users of other providers with the same account ID signed in", async () => {
    const user = await seedUser("12345");
    const githubUser = await seedUser("12345", "github");
    await seedSession(user.id);
    const kept = await seedSession(githubUser.id);

    const response = await postLogoutToken(
      createApp().app,
      signLogoutToken(issuer, { sub: "12345" }),
    );

    expect(response.status).toBe(200);
    expect(await remainingSessionIds()).toEqual([kept]);
  });

  it("closes only the ended session's realtime connections while the user has another session", async () => {
    const user = await seedUser("kc-user-1");
    const ended = await seedSession(user.id, "kc-session-1");
    const kept = await seedSession(user.id, "kc-session-2");
    const endedSocket = fakeSocket();
    const keptSocket = fakeSocket();
    const connections = [
      addUserConnection(user.id, endedSocket as unknown as WSContext, ended),
      addUserConnection(user.id, keptSocket as unknown as WSContext, kept),
    ];
    try {
      const response = await postLogoutToken(
        createApp().app,
        signLogoutToken(issuer, { sub: "kc-user-1", sid: "kc-session-1" }),
      );

      expect(response.status).toBe(200);
      expect(await remainingSessionIds()).toEqual([kept]);
      expect(endedSocket.close).toHaveBeenCalledWith(
        SESSION_ENDED_CLOSE_CODE,
        "Session ended",
      );
      expect(keptSocket.close).not.toHaveBeenCalled();
      expect(keptSocket.send).not.toHaveBeenCalled();

      broadcastToUser(user.id, { type: "NOTIFICATION_CREATED" });

      await vi.waitFor(() =>
        expect(keptSocket.send).toHaveBeenCalledWith(
          JSON.stringify({ type: "NOTIFICATION_CREATED" }),
        ),
      );
      expect(endedSocket.send).not.toHaveBeenCalled();
    } finally {
      for (const connection of connections)
        removeUserConnection(user.id, connection);
    }
  });

  it("refuses a logout token the second time", async () => {
    const user = await seedUser("kc-user-1");
    await seedSession(user.id, "kc-session-1");
    const jti = randomUUID();
    const iat = Math.floor(Date.now() / 1000);
    const token = signLogoutToken(issuer, { sub: "kc-user-1", jti, iat });
    const { app } = createApp();
    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});

    expect((await postLogoutToken(app, token)).status).toBe(200);
    const replay = await postLogoutToken(app, token);

    expect(replay.status).toBe(400);
    expect(warn).toHaveBeenCalledWith(
      "Rejected a back-channel logout token: the logout token was used before",
    );
    expect(replay.headers.get("cache-control")).toBe("no-store");
    expect(await replay.json()).toEqual({ error: "invalid_request" });
    const [used, ...others] = await db
      .select()
      .from(schema.verificationTable)
      .where(
        eq(
          schema.verificationTable.identifier,
          `backchannel-logout:${issuer}:${jti}`,
        ),
      );
    expect(others).toHaveLength(0);
    expect(used?.expiresAt.getTime()).toBe((iat + 660) * 1000);
  });

  it("accepts only one of two identical logout tokens sent at once", async () => {
    const user = await seedUser("kc-user-1");
    await seedSession(user.id, "kc-session-1");
    const token = signLogoutToken(issuer, {
      sub: "kc-user-1",
      sid: "kc-session-1",
    });
    const { app } = createApp();
    vi.spyOn(console, "warn").mockImplementation(() => {});

    const responses = await Promise.all([
      postLogoutToken(app, token),
      postLogoutToken(app, token),
    ]);

    expect(responses.map((response) => response.status).sort()).toEqual([
      200, 400,
    ]);
    expect(await remainingSessionIds()).toEqual([]);
  });

  it("answers 200 for a subject without a Kaneo account", async () => {
    const user = await seedUser("kc-user-1");
    const kept = await seedSession(user.id, "kc-session-1");

    const response = await postLogoutToken(
      createApp().app,
      signLogoutToken(issuer, { sub: "kc-user-9", sid: "kc-session-1" }),
    );

    expect(response.status).toBe(200);
    expect(await remainingSessionIds()).toEqual([kept]);
  });

  it("answers 404 while back-channel logout is off", async () => {
    vi.stubEnv("CUSTOM_OAUTH_BACKCHANNEL_LOGOUT", "");

    const response = await postLogoutToken(
      createApp().app,
      signLogoutToken(issuer, { sub: "kc-user-1" }),
    );

    expect(response.status).toBe(404);
    expect(response.headers.get("cache-control")).toBe("no-store");
  });

  it("rejects a token for another client without recording it", async () => {
    const user = await seedUser("kc-user-1");
    const kept = await seedSession(user.id, "kc-session-1");
    vi.spyOn(console, "warn").mockImplementation(() => {});

    const response = await postLogoutToken(
      createApp().app,
      signLogoutToken(issuer, { sub: "kc-user-1", aud: "other-client" }),
    );

    expect(response.status).toBe(400);
    expect(await response.json()).toEqual({ error: "invalid_request" });
    expect(await remainingSessionIds()).toEqual([kept]);
    expect(await db.select().from(schema.verificationTable)).toHaveLength(0);
  });

  it("answers 503 while the discovery document cannot be loaded", async () => {
    const user = await seedUser("kc-user-1");
    const kept = await seedSession(user.id, "kc-session-1");
    vi.stubGlobal(
      "fetch",
      vi.fn(async () => new Response("down", { status: 500 })),
    );
    vi.spyOn(console, "warn").mockImplementation(() => {});

    const response = await postLogoutToken(
      createApp().app,
      signLogoutToken(issuer, { sub: "kc-user-1" }),
    );

    expect(response.status).toBe(503);
    expect(response.headers.get("cache-control")).toBe("no-store");
    expect(await response.json()).toEqual({ error: "temporarily_unavailable" });
    expect(await remainingSessionIds()).toEqual([kept]);
  });
});