Kez/nodejs/packages/kez-channels/test/core.test.ts

import { describe, expect, it } from "vitest";
import {
  COMPACT_PROOF_PREFIX,
  Identity,
  NostrSecret,
  newClaimPayload,
  signClaim,
  toCompact,
  toMarkdown,
  toPrettyJson,
} from "@kez/core";
import {
  ChannelError,
  Registry,
  defaultRegistry,
  extractCompactToken,
  parseAndVerifyFor,
  parseProof,
} from "../src/index.js";

function sign(subjectStr: string) {
  const secret = NostrSecret.generate();
  const primary = secret.identity();
  const subject = Identity.parse(subjectStr);
  return signClaim(newClaimPayload(subject, primary, new Date()), secret);
}

describe("parseProof", () => {
  it("handles all four encodings", () => {
    const signed = sign("github:jason");
    expect(parseProof(toPrettyJson(signed))).toEqual(signed);
    expect(parseProof(toCompact(signed))).toEqual(signed);
    expect(parseProof(toMarkdown(signed))).toEqual(signed);
  });

  it("rejects unknown format", () => {
    expect(() => parseProof("just some text")).toThrow(/unknown/);
  });

  it("extracts compact token from surrounding prose", () => {
    const signed = sign("ap:@jason@mastodon.social");
    const compact = toCompact(signed);
    const bio = `hello world! my proof: ${compact} — verify it`;
    expect(parseProof(bio)).toEqual(signed);
  });
});

describe("extractCompactToken", () => {
  it("stops at non-base64url chars", () => {
    expect(extractCompactToken("before kez:z1:KLUv_QBYabc. after")).toBe(
      "kez:z1:KLUv_QBYabc",
    );
  });

  it("returns undefined when missing or empty body", () => {
    expect(extractCompactToken("nothing")).toBeUndefined();
    expect(extractCompactToken("kez:z1:")).toBeUndefined();
  });

  it("uses the canonical prefix constant", () => {
    expect(COMPACT_PROOF_PREFIX).toBe("kez:z1:");
  });
});

describe("parseAndVerifyFor", () => {
  it("passes on matching subject", () => {
    const signed = sign("github:jason");
    const hit = parseAndVerifyFor(toPrettyJson(signed), Identity.parse("github:jason"));
    expect(hit.proof).toEqual(signed);
  });

  it("flags subject mismatch", () => {
    const signed = sign("github:jason");
    expect(() =>
      parseAndVerifyFor(toPrettyJson(signed), Identity.parse("github:mallory")),
    ).toThrow(ChannelError);
  });
});

describe("Registry", () => {
  it("dispatches by scheme", async () => {
    const r = await defaultRegistry();
    expect(r.get("github")).toBeDefined();
    expect(r.get("dns")).toBeDefined();
    expect(r.get("nostr")).toBeDefined();
    expect(r.get("bluesky")).toBeDefined();
    expect(r.get("ap")).toBeDefined();
    expect(r.get("mastodon")).toBeDefined();
    expect(r.get("did")).toBeUndefined();
  });

  it("reports unknown system", async () => {
    const r = new Registry();
    await expect(r.verify(Identity.parse("github:jason"))).rejects.toBeInstanceOf(ChannelError);
  });
});