|
| 1 | +import { strict as assert } from "node:assert"; |
| 2 | +import test from "node:test"; |
| 3 | + |
| 4 | +import { canonicalNpub, truncateNpub } from "@/shared/lib/pubkey"; |
| 5 | +import { compareMembersByRole, formatMemberName } from "./memberUtils.ts"; |
| 6 | + |
| 7 | +// Sequential-value pubkeys, the same shape as the members-sidebar e2e |
| 8 | +// roster fixture: every full npub shares the `npub1qqq…` head, so the |
| 9 | +// compact label is decided by the checksum tail while the full npub |
| 10 | +// diverges mid-key. These two keys disagree between the two orders. |
| 11 | +const V5_HEX = |
| 12 | + "0000000000000000000000000000000000000000000000000000000000000005"; |
| 13 | +const V5_NPUB = |
| 14 | + "npub1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqzsfj2hcx"; |
| 15 | +const V24_HEX = |
| 16 | + "0000000000000000000000000000000000000000000000000000000000000018"; |
| 17 | +const V24_NPUB = |
| 18 | + "npub1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqvq532w5c"; |
| 19 | + |
| 20 | +function member(pubkey, overrides = {}) { |
| 21 | + return { |
| 22 | + pubkey, |
| 23 | + role: "member", |
| 24 | + isAgent: false, |
| 25 | + joinedAt: "2026-09-08T00:00:00Z", |
| 26 | + displayName: null, |
| 27 | + ...overrides, |
| 28 | + }; |
| 29 | +} |
| 30 | + |
| 31 | +function rosterOrder(members, currentPubkey) { |
| 32 | + return [...members] |
| 33 | + .sort((left, right) => compareMembersByRole(left, right, currentPubkey)) |
| 34 | + .map((item) => item.pubkey); |
| 35 | +} |
| 36 | + |
| 37 | +test("unnamed members order by full canonical npub, not the compact label", () => { |
| 38 | + assert.equal(canonicalNpub(V5_HEX), V5_NPUB); |
| 39 | + assert.equal(canonicalNpub(V24_HEX), V24_NPUB); |
| 40 | + // Compact labels order V5 first (`…2hcx` < `…2w5c`); the full npubs |
| 41 | + // disagree (`…vq53…` < `…zsfj…`). Ordering follows the full key. |
| 42 | + assert.ok(truncateNpub(V5_HEX).localeCompare(truncateNpub(V24_HEX)) < 0); |
| 43 | + assert.ok(V24_NPUB.localeCompare(V5_NPUB) < 0); |
| 44 | + |
| 45 | + const v5 = member(V5_HEX); |
| 46 | + const v24 = member(V24_HEX); |
| 47 | + |
| 48 | + assert.deepEqual(rosterOrder([v5, v24]), [V24_HEX, V5_HEX]); |
| 49 | + assert.deepEqual(rosterOrder([v24, v5]), [V24_HEX, V5_HEX]); |
| 50 | + |
| 51 | + // The compact 8+4 label stays the display form. |
| 52 | + assert.equal(formatMemberName(v5), "npub1qqq…2hcx"); |
| 53 | + assert.equal(formatMemberName(v24), "npub1qqq…2w5c"); |
| 54 | + |
| 55 | + // Authored names still order against npub surfaces as before. |
| 56 | + const bob = member("0".repeat(64), { displayName: "Bob" }); |
| 57 | + assert.deepEqual(rosterOrder([v5, bob, v24]), [ |
| 58 | + "0".repeat(64), |
| 59 | + V24_HEX, |
| 60 | + V5_HEX, |
| 61 | + ]); |
| 62 | +}); |
| 63 | + |
| 64 | +test("duplicate authored names tie-break by the full identity key", () => { |
| 65 | + const lowHexName = member(V5_HEX, { displayName: "Ada" }); |
| 66 | + const highHexName = member(V24_HEX, { displayName: "Ada" }); |
| 67 | + |
| 68 | + // Same name, distinct keys: the tie breaks by canonical npub (which |
| 69 | + // reverses the raw hex order of these two keys), in both input orders. |
| 70 | + assert.deepEqual(rosterOrder([lowHexName, highHexName]), [V24_HEX, V5_HEX]); |
| 71 | + assert.deepEqual(rosterOrder([highHexName, lowHexName]), [V24_HEX, V5_HEX]); |
| 72 | +}); |
| 73 | + |
| 74 | +test("role precedence still outranks the name stage", () => { |
| 75 | + const owner = member("1".repeat(64), { role: "owner", displayName: "Zed" }); |
| 76 | + const admin = member("2".repeat(64), { role: "admin", displayName: "Yan" }); |
| 77 | + const plain = member("3".repeat(64), { role: "member", displayName: "Xan" }); |
| 78 | + const guest = member("4".repeat(64), { role: "guest", displayName: "Wes" }); |
| 79 | + const bot = member("5".repeat(64), { role: "bot", displayName: "Ann" }); |
| 80 | + |
| 81 | + assert.deepEqual(rosterOrder([bot, guest, plain, admin, owner]), [ |
| 82 | + "1".repeat(64), |
| 83 | + "2".repeat(64), |
| 84 | + "3".repeat(64), |
| 85 | + "4".repeat(64), |
| 86 | + "5".repeat(64), |
| 87 | + ]); |
| 88 | +}); |
| 89 | + |
| 90 | +test("the current member still sorts first in compareMembersByRole", () => { |
| 91 | + const current = member(V24_HEX); |
| 92 | + const owner = member("1".repeat(64), { role: "owner", displayName: "Ada" }); |
| 93 | + |
| 94 | + assert.deepEqual(rosterOrder([owner, current], V24_HEX), [ |
| 95 | + V24_HEX, |
| 96 | + "1".repeat(64), |
| 97 | + ]); |
| 98 | + assert.ok(compareMembersByRole(current, owner, V24_HEX) < 0); |
| 99 | + assert.ok(compareMembersByRole(owner, current, V24_HEX) > 0); |
| 100 | + |
| 101 | + // Without a current pubkey, roles lead again. |
| 102 | + assert.ok(compareMembersByRole(current, owner) > 0); |
| 103 | +}); |
| 104 | + |
| 105 | +test("invalid keys keep the neutral surface and break ties deterministically", () => { |
| 106 | + const first = member("not-a-key"); |
| 107 | + const second = member("zzz-definitely-not-a-key"); |
| 108 | + |
| 109 | + // Both render the neutral label — never raw input — and the label |
| 110 | + // collision breaks by the normalized key, not incoming order. |
| 111 | + assert.equal(formatMemberName(first), "Unavailable"); |
| 112 | + assert.equal(formatMemberName(second), "Unavailable"); |
| 113 | + assert.deepEqual(rosterOrder([second, first]), [ |
| 114 | + "not-a-key", |
| 115 | + "zzz-definitely-not-a-key", |
| 116 | + ]); |
| 117 | + assert.deepEqual(rosterOrder([first, second]), [ |
| 118 | + "not-a-key", |
| 119 | + "zzz-definitely-not-a-key", |
| 120 | + ]); |
| 121 | +}); |
0 commit comments