AAA
cdd503a98d
Waiting feedback and tooltips now share consistent presentation lifecycles, while App shutdown and native-media operation failures stay within their owning session or output. This phase also consolidates the project standards and publishes searchable English/Chinese reader documentation alongside the homepage. Validation: repository hygiene and Markdown links; TypeScript, 971 Web tests and production build; website/documentation build; Go tests, vet and Windows/Linux builds with Windows capture checks; desktop/mobile UI and documentation review. Linux race, container and three-platform packaging checks run in the release pipeline. Physical macOS/Linux capture and broader network coverage remain outside this acceptance. The owner approved v1.4.0 publication. Existing empty-source, Windows URL-handler and public-invitation timeout reports remain tracked; this release makes no claim to resolve those device/network reports. The Windows capture-border request is next-phase work. ## Release notes ### 中文 这是一次以稳定性和交互一致性为重点的功能更新。等待与提示更有反馈，App 启动、原生分享和连接恢复的边界处理得到改善，使用与部署指南也有了统一的文档中心。 #### 新增与改进 - 欢迎语、等待短句和六类可轮换的标签页标题共用一致的显示规则。等待短句从一开始就出现，并在停留时轮换；明确的错误与操作提示保持固定。 - 房间准入等漫画采用更克制的小人物与循环动效。改进 tooltip 的定位与指向，减少对播放器的遮挡；状态、图标和文案保持相同含义。 - 新增中英文文档中心，提供搜索、手机目录、使用教程、问题排查与自部署指南。官网 FAQ 聚焦开始使用前的问题，详细排查统一进入文档中心。 #### 修复 - 使用 `--local` 启动不再清空已保存的 Piik 站点地址。 - 打开系统浏览器不再阻塞 App 的退出流程；改进临时公网邀请、终端和诊断导出在关闭时的清理及错误反馈。 - 单条原生媒体连接的操作失败不再被误判为整个会话的协议错误；重复停止分享保持幂等。 - 修复连接替换、转发停止和异常退出时的部分资源清理问题，避免迟到结果影响当前连接。 - Windows 原生采集中，单个输出的编码错误只结束对应输出；共享采集源本身的错误仍会结束分享。 #### 升级与已知边界 本次保持现有协议版本与配置格式。更新 App 或自托管 Server 后，重新打开页面即可使用对应的新界面。 个别设备的空窗口列表、Windows 浏览器启动异常，以及 Linux 编码输出的故障隔离仍在跟进。macOS/Linux 的物理采集和更广泛的公网网络场景仍需实机验证；本次不宣称这些问题已经解决，也不承诺所有网络都能直连。 ### English This feature update focuses on stability and consistent feedback. Waiting states are easier to follow, App startup and native sharing handle several failure cases more reliably, and the new documentation center brings usage and deployment guides together. #### New and improved - Welcome lines, waiting captions and six groups of rotating tab titles follow one presentation lifecycle. Waiting captions appear immediately and rotate while visible; actionable errors and instructions remain fixed. - Room-admission comics use restrained characters and looping motion. Tooltips point more accurately to their controls and interfere less with the player, with consistent meanings across illustrations, icons and copy. - A new English/Chinese documentation center includes search, mobile navigation, usage guides, troubleshooting and self-hosting. The homepage FAQ covers questions before getting started and links to the documentation for detailed help. #### Fixes - Starting with `--local` no longer clears a saved Piik site address. - Opening the system browser no longer blocks App shutdown. Temporary public invitations, the terminal and diagnostic exports handle cleanup and exit errors more consistently. - An operation failure on one native media connection no longer becomes a protocol failure for the entire session. Repeated stop-sharing requests are safe. - Fixed cleanup cases during connection replacement, relay shutdown and unexpected exits, preventing late results from affecting the current connection. - On Windows, an encoder failure for one native output stops that output only. A failure of the shared capture source still ends sharing. #### Updating and known limits Protocol versions and configuration formats are unchanged. After updating the App or your self-hosted Server, reopen the page to use its updated interface. Empty source lists on some devices, Windows browser-launch failures and Linux output-failure isolation remain under investigation. Physical macOS/Linux capture and broader public-network coverage still need device testing; this update does not claim to resolve those cases or guarantee a direct connection on every network.
1691 lines
46 KiB
TypeScript
1691 lines
46 KiB
TypeScript
import { describe, expect, it } from "vitest";
|
|
|
|
import {
|
|
DEFAULT_QUALITY_SETTINGS,
|
|
DEFAULT_ROUTE_POLICY,
|
|
DEFAULT_VIEWER_DISPLAY_NAME,
|
|
MAX_DISPLAY_NAME_CODE_POINTS,
|
|
MAX_MEDIA_ROUTE_REVISION,
|
|
MAX_VIEWER_QUALITY_EVIDENCE_BYTES,
|
|
MAX_VIEWER_PASSWORD_LENGTH,
|
|
MAX_VIEWERS_PER_ROOM_LIMIT,
|
|
SIGNALING_PROTOCOL,
|
|
clientMessageSchema,
|
|
createRoomRequestSchema,
|
|
decodeClientMessage,
|
|
normalizeDisplayName,
|
|
participantRouteAssignmentSchema,
|
|
preparedRouteCandidateSchema,
|
|
replaceRoomRequestSchema,
|
|
roomAccessUpdateRequestSchema,
|
|
roomAccessUpdateResponseSchema,
|
|
runtimeCapabilitiesSchema,
|
|
serverMessageSchema,
|
|
viewerPasswordSchema,
|
|
} from "../src/shared/protocol.js";
|
|
|
|
const token = "a".repeat(43);
|
|
const roomId = "1234";
|
|
const viewerGrant = `${"b".repeat(21)}g`;
|
|
const qualitySettings = {
|
|
resolution: "1080p",
|
|
maxFramerate: 60,
|
|
maxBitrate: 8_000_000,
|
|
degradationPreference: "maintain-resolution",
|
|
} as const;
|
|
|
|
describe("runtime capabilities", () => {
|
|
it("defaults missing capabilities off and ignores unknown descriptors", () => {
|
|
expect(runtimeCapabilitiesSchema.parse({})).toEqual({ sfu: false, natPrediction: false });
|
|
expect(runtimeCapabilitiesSchema.parse({ sfu: true, extra: { enabled: true } }))
|
|
.toEqual({ sfu: true, natPrediction: false });
|
|
expect(runtimeCapabilitiesSchema.parse({ natPrediction: true, SFU: true }))
|
|
.toEqual({ sfu: false, natPrediction: true });
|
|
expect(runtimeCapabilitiesSchema.parse({ sfu: true, natPrediction: true }))
|
|
.toEqual({ sfu: true, natPrediction: true });
|
|
});
|
|
|
|
it("rejects malformed known capabilities and non-object responses", () => {
|
|
for (const value of [null, [], true, { sfu: null }, { sfu: "true" },
|
|
{ natPrediction: null }, { natPrediction: 1 }]) {
|
|
expect(runtimeCapabilitiesSchema.safeParse(value).success).toBe(false);
|
|
}
|
|
});
|
|
});
|
|
|
|
const qualitySettingsWithAudio = {
|
|
...qualitySettings,
|
|
screenAudioQuality: "music",
|
|
} as const;
|
|
|
|
const legacyCodecQualitySettings = {
|
|
...qualitySettings,
|
|
videoCodec: "vp8",
|
|
} as const;
|
|
|
|
const qualityEvidence = {
|
|
type: "viewer-quality-evidence",
|
|
guard: {
|
|
connectionId: "connection_12345678",
|
|
routeRevision: 0,
|
|
presentationEpoch: 0,
|
|
},
|
|
sequence: 0,
|
|
windowMs: 2_000,
|
|
metrics: {
|
|
natTraversalPath: "ordinary",
|
|
width: 1_920,
|
|
height: 1_080,
|
|
framesPerSecond: 59.8,
|
|
bitrateKbps: 7_500,
|
|
packetsReceivedDelta: 1_500,
|
|
packetsLostDelta: 2,
|
|
rttMs: 18,
|
|
jitterMs: 3.5,
|
|
framesDecodedDelta: 120,
|
|
framesDroppedDelta: 1,
|
|
decodeMsPerFrame: 2.4,
|
|
freezeCountDelta: 0,
|
|
freezeDurationMsDelta: 0,
|
|
pauseCountDelta: 0,
|
|
pauseDurationMsDelta: 0,
|
|
codec: "video/H264",
|
|
codecProfile: "profile-level-id=42e01f",
|
|
codecParameters:
|
|
"packetization-mode=1; level-asymmetry-allowed=1",
|
|
audioBitrateKbps: 192,
|
|
audioPacketLossPercent: 0.2,
|
|
audioJitterMs: 2.5,
|
|
audioVideoPlayoutDeltaMs: -12.5,
|
|
videoJitterBufferDelayMs: 24,
|
|
audioJitterBufferDelayMs: 18,
|
|
audioConcealedSamplesPercent: 1,
|
|
audioConcealmentEventsDelta: 3,
|
|
audioCodec: "audio/opus",
|
|
},
|
|
} as const;
|
|
|
|
describe("client signaling protocol", () => {
|
|
it("uses the current strict signaling generation", () => {
|
|
expect(SIGNALING_PROTOCOL).toBe("piik-v23");
|
|
});
|
|
|
|
it("keeps signaling challenges strict and sequence-only", () => {
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "signaling-challenge",
|
|
sequence: Number.MAX_SAFE_INTEGER,
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
type: "signaling-challenge-response",
|
|
sequence: 0,
|
|
}).success,
|
|
).toBe(true);
|
|
for (const invalid of [
|
|
{ type: "signaling-challenge", sequence: -1 },
|
|
{ type: "signaling-challenge", sequence: 1.5 },
|
|
{
|
|
type: "signaling-challenge",
|
|
sequence: Number.MAX_SAFE_INTEGER + 1,
|
|
},
|
|
{ type: "signaling-challenge", sequence: 1, roomId },
|
|
{ type: "signaling-challenge-response", sequence: "1" },
|
|
{ type: "signaling-challenge-response", sequence: 1, sessionId: token },
|
|
]) {
|
|
expect(
|
|
(invalid.type === "signaling-challenge"
|
|
? clientMessageSchema
|
|
: serverMessageSchema
|
|
).safeParse(invalid).success,
|
|
).toBe(false);
|
|
}
|
|
});
|
|
|
|
it("accepts only an empty route diagnostic request", () => {
|
|
expect(
|
|
clientMessageSchema.safeParse({ type: "request-route-diagnostic" })
|
|
.success,
|
|
).toBe(true);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "request-route-diagnostic",
|
|
roomId,
|
|
}).success,
|
|
).toBe(false);
|
|
});
|
|
|
|
it("keeps Viewer route status as a strict crossed union", () => {
|
|
expect(
|
|
serverMessageSchema.parse({
|
|
type: "route-status",
|
|
revision: 3,
|
|
state: "waiting",
|
|
reason: "sfu-admission",
|
|
}),
|
|
).toEqual({
|
|
type: "route-status",
|
|
revision: 3,
|
|
state: "waiting",
|
|
reason: "sfu-admission",
|
|
});
|
|
expect(
|
|
serverMessageSchema.parse({
|
|
type: "route-status",
|
|
revision: 4,
|
|
state: "failed",
|
|
reason: "route-exhausted",
|
|
}),
|
|
).toEqual({
|
|
type: "route-status",
|
|
revision: 4,
|
|
state: "failed",
|
|
reason: "route-exhausted",
|
|
});
|
|
for (const invalid of [
|
|
{
|
|
type: "route-status",
|
|
revision: 3,
|
|
state: "waiting",
|
|
reason: "route-exhausted",
|
|
},
|
|
{
|
|
type: "route-status",
|
|
revision: 3,
|
|
state: "failed",
|
|
reason: "sfu-admission",
|
|
},
|
|
{
|
|
type: "route-status",
|
|
revision: 3,
|
|
state: "waiting",
|
|
reason: "sfu-admission",
|
|
retryAfterMs: 1_000,
|
|
},
|
|
{
|
|
type: "route-status",
|
|
revision: 3,
|
|
state: "waiting",
|
|
reason: "sfu-admission",
|
|
peerId: "private-peer-id",
|
|
},
|
|
]) {
|
|
expect(serverMessageSchema.safeParse(invalid).success).toBe(false);
|
|
}
|
|
});
|
|
|
|
it("accepts an atomic room creation profile", () => {
|
|
expect(
|
|
createRoomRequestSchema.parse({ codeEntryPolicy: "open" }),
|
|
).toEqual({ codeEntryPolicy: "open" });
|
|
expect(
|
|
createRoomRequestSchema.parse({
|
|
codeEntryPolicy: "private",
|
|
roomPassword: "room-password",
|
|
}),
|
|
).toEqual({
|
|
codeEntryPolicy: "private",
|
|
roomPassword: "room-password",
|
|
});
|
|
expect(
|
|
createRoomRequestSchema.parse({ codeEntryPolicy: "private" }),
|
|
).toEqual({ codeEntryPolicy: "private" });
|
|
expect(
|
|
createRoomRequestSchema.parse({
|
|
codeEntryPolicy: "open",
|
|
preferredRoomId: "4321",
|
|
}),
|
|
).toEqual({ codeEntryPolicy: "open", preferredRoomId: "4321" });
|
|
expect(
|
|
createRoomRequestSchema.safeParse({
|
|
codeEntryPolicy: "open",
|
|
preferredRoomId: "0432",
|
|
}).success,
|
|
).toBe(false);
|
|
for (const codeEntryPolicy of [
|
|
"password",
|
|
"private-link",
|
|
"public-watch",
|
|
1,
|
|
]) {
|
|
expect(
|
|
createRoomRequestSchema.safeParse({
|
|
codeEntryPolicy,
|
|
}).success,
|
|
).toBe(false);
|
|
}
|
|
});
|
|
|
|
it("accepts only a replacement creation profile", () => {
|
|
expect(
|
|
replaceRoomRequestSchema.parse({
|
|
codeEntryPolicy: "private",
|
|
roomPassword: "room-password",
|
|
}),
|
|
).toEqual({
|
|
codeEntryPolicy: "private",
|
|
roomPassword: "room-password",
|
|
});
|
|
expect(
|
|
replaceRoomRequestSchema.safeParse({
|
|
codeEntryPolicy: "open",
|
|
preferredRoomId: "4321",
|
|
}).success,
|
|
).toBe(false);
|
|
});
|
|
|
|
it("rejects the removed all-room ICE refresh request", () => {
|
|
expect(clientMessageSchema.safeParse({ type: "refresh-ice" }).success).toBe(
|
|
false,
|
|
);
|
|
});
|
|
|
|
it("accepts a bounded authentication message", () => {
|
|
expect(DEFAULT_ROUTE_POLICY).toEqual({
|
|
peerOnly: false,
|
|
topologyOptimization: true,
|
|
natPrediction: false,
|
|
});
|
|
expect(
|
|
decodeClientMessage(
|
|
JSON.stringify({
|
|
type: "authenticate",
|
|
protocol: SIGNALING_PROTOCOL,
|
|
roomId,
|
|
role: "viewer",
|
|
clientId: "client_12345678",
|
|
}),
|
|
),
|
|
).toMatchObject({ type: "authenticate", role: "viewer" });
|
|
expect(
|
|
decodeClientMessage(
|
|
JSON.stringify({
|
|
type: "authenticate",
|
|
protocol: SIGNALING_PROTOCOL,
|
|
roomId,
|
|
role: "viewer",
|
|
viewerGrant,
|
|
clientId: "client_12345678",
|
|
}),
|
|
),
|
|
).toMatchObject({ viewerGrant });
|
|
expect(
|
|
decodeClientMessage(
|
|
JSON.stringify({
|
|
type: "authenticate",
|
|
protocol: SIGNALING_PROTOCOL,
|
|
roomId,
|
|
role: "host",
|
|
token,
|
|
clientId: "host_client_12345678",
|
|
shareGeneration: "share_generation_12345678",
|
|
qualitySettings: qualitySettingsWithAudio,
|
|
}),
|
|
),
|
|
).toMatchObject({
|
|
role: "host",
|
|
shareGeneration: "share_generation_12345678",
|
|
qualitySettings: qualitySettingsWithAudio,
|
|
routePolicy: {
|
|
peerOnly: false,
|
|
topologyOptimization: true,
|
|
natPrediction: false,
|
|
},
|
|
});
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "authenticate",
|
|
protocol: SIGNALING_PROTOCOL,
|
|
roomId,
|
|
role: "viewer",
|
|
clientId: "client_12345678",
|
|
capabilities: { peerIceTurn: true },
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "authenticate",
|
|
roomId,
|
|
role: "viewer",
|
|
clientId: "client_12345678",
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "authenticate",
|
|
protocol: "invalid-protocol",
|
|
roomId,
|
|
role: "viewer",
|
|
clientId: "client_12345678",
|
|
}).success,
|
|
).toBe(false);
|
|
});
|
|
|
|
it("normalizes display names and rejects misleading Unicode boundaries", () => {
|
|
expect(normalizeDisplayName(" Cafe\u0301\u00a0朋友 ")).toBe("Café 朋友");
|
|
expect(normalizeDisplayName("玩家 👩💻")).toBe("玩家 👩💻");
|
|
expect(normalizeDisplayName("名".repeat(MAX_DISPLAY_NAME_CODE_POINTS))).toBe(
|
|
"名".repeat(MAX_DISPLAY_NAME_CODE_POINTS),
|
|
);
|
|
expect(
|
|
normalizeDisplayName("名".repeat(MAX_DISPLAY_NAME_CODE_POINTS + 1)),
|
|
).toBeNull();
|
|
for (const invalid of ["a\nb", "a\u202eb", "a\ufeffb", "a\ud800b"]) {
|
|
expect(normalizeDisplayName(invalid)).toBeNull();
|
|
}
|
|
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "authenticate",
|
|
protocol: SIGNALING_PROTOCOL,
|
|
roomId,
|
|
role: "viewer",
|
|
clientId: "client_12345678",
|
|
displayName: "小明",
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "authenticate",
|
|
protocol: SIGNALING_PROTOCOL,
|
|
roomId,
|
|
role: "host",
|
|
token,
|
|
clientId: "client_12345678",
|
|
viewerPresence: true,
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "set-display-name",
|
|
displayName: " Cafe\u0301 ",
|
|
}).success,
|
|
).toBe(false);
|
|
expect(DEFAULT_VIEWER_DISPLAY_NAME).toBe("观众");
|
|
});
|
|
|
|
it("accepts only canonical bounded Viewer grants and access actions", () => {
|
|
for (const malformedGrant of [
|
|
"b".repeat(21),
|
|
"b".repeat(23),
|
|
`${"b".repeat(21)}=`,
|
|
`${"b".repeat(21)}b`,
|
|
`g1.${roomId}.1787076000.${"b".repeat(43)}`,
|
|
]) {
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "authenticate",
|
|
protocol: SIGNALING_PROTOCOL,
|
|
roomId,
|
|
role: "viewer",
|
|
viewerGrant: malformedGrant,
|
|
clientId: "client_12345678",
|
|
}).success,
|
|
).toBe(false);
|
|
}
|
|
for (const policy of ["open", "private"] as const) {
|
|
expect(
|
|
roomAccessUpdateRequestSchema.safeParse({
|
|
action: "set-code-entry-policy",
|
|
policy,
|
|
}).success,
|
|
).toBe(true);
|
|
}
|
|
expect(
|
|
roomAccessUpdateRequestSchema.safeParse({
|
|
action: "rotate-viewer-grant",
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
roomAccessUpdateRequestSchema.safeParse({
|
|
action: "revoke-viewer-grant",
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
roomAccessUpdateRequestSchema.safeParse({
|
|
action: "set-code-entry-policy",
|
|
policy: "disabled",
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
roomAccessUpdateRequestSchema.safeParse({
|
|
action: "set-code-entry-policy",
|
|
policy: "password",
|
|
}).success,
|
|
).toBe(false);
|
|
for (const removedMessage of [
|
|
{ type: "set-code-entry-policy", policy: "open" },
|
|
{ type: "rotate-viewer-grant" },
|
|
{ type: "revoke-viewer-grant" },
|
|
{ type: "set-viewer-password", password: "room-password" },
|
|
]) {
|
|
expect(clientMessageSchema.safeParse(removedMessage).success).toBe(false);
|
|
}
|
|
});
|
|
|
|
it("accepts simple bounded Viewer passwords and access responses", () => {
|
|
expect(viewerPasswordSchema.safeParse("x").success).toBe(true);
|
|
expect(viewerPasswordSchema.safeParse("simple-password").success).toBe(true);
|
|
for (const invalid of [
|
|
"",
|
|
"contains space",
|
|
"line\nbreak",
|
|
"x".repeat(MAX_VIEWER_PASSWORD_LENGTH + 1),
|
|
]) {
|
|
expect(viewerPasswordSchema.safeParse(invalid).success).toBe(false);
|
|
}
|
|
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "authenticate",
|
|
protocol: SIGNALING_PROTOCOL,
|
|
roomId,
|
|
role: "viewer",
|
|
clientId: "client_12345678",
|
|
viewerPassword: "easy-password",
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
roomAccessUpdateRequestSchema.safeParse({
|
|
action: "set-viewer-password",
|
|
password: null,
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
roomAccessUpdateResponseSchema.safeParse({
|
|
type: "viewer-password-updated",
|
|
enabled: true,
|
|
}).success,
|
|
).toBe(true);
|
|
});
|
|
|
|
it("rejects unknown fields and malformed tokens", () => {
|
|
const result = clientMessageSchema.safeParse({
|
|
type: "authenticate",
|
|
protocol: SIGNALING_PROTOCOL,
|
|
roomId,
|
|
role: "host",
|
|
token: "short",
|
|
clientId: "client_12345678",
|
|
admin: true,
|
|
});
|
|
|
|
expect(result.success).toBe(false);
|
|
});
|
|
|
|
it("requires a host token and rejects viewer tokens or malformed room codes", () => {
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "authenticate",
|
|
protocol: SIGNALING_PROTOCOL,
|
|
roomId,
|
|
role: "host",
|
|
token,
|
|
clientId: "client_12345678",
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "authenticate",
|
|
protocol: SIGNALING_PROTOCOL,
|
|
roomId,
|
|
role: "viewer",
|
|
token,
|
|
clientId: "client_12345678",
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "authenticate",
|
|
protocol: SIGNALING_PROTOCOL,
|
|
roomId: "1234",
|
|
role: "viewer",
|
|
clientId: "client_12345678",
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "authenticate",
|
|
protocol: SIGNALING_PROTOCOL,
|
|
roomId: "0123",
|
|
role: "viewer",
|
|
clientId: "client_12345678",
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "authenticate",
|
|
protocol: SIGNALING_PROTOCOL,
|
|
roomId: "1".repeat(5),
|
|
role: "viewer",
|
|
clientId: "client_12345678",
|
|
}).success,
|
|
).toBe(false);
|
|
});
|
|
|
|
it("bounds SDP before routing it", () => {
|
|
const result = clientMessageSchema.safeParse({
|
|
type: "signal",
|
|
targetPeerId: "viewer_12345678",
|
|
payload: {
|
|
kind: "description",
|
|
connectionId: "connection_12345678",
|
|
description: {
|
|
type: "offer",
|
|
sdp: "v".repeat(48 * 1024 + 1),
|
|
},
|
|
},
|
|
});
|
|
|
|
expect(result.success).toBe(false);
|
|
});
|
|
|
|
it("requires viewers to choose ICE restart or peer rebuild explicitly", () => {
|
|
const restartRequest = {
|
|
type: "restart-request",
|
|
connectionId: "connection_12345678",
|
|
rebuild: true,
|
|
};
|
|
|
|
expect(clientMessageSchema.safeParse(restartRequest).success).toBe(true);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
...restartRequest,
|
|
targetPeerId: "parent_12345678",
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: restartRequest.type,
|
|
connectionId: restartRequest.connectionId,
|
|
}).success,
|
|
).toBe(false);
|
|
});
|
|
|
|
it("accepts explicit sharing-stop and abandonment messages", () => {
|
|
expect(clientMessageSchema.safeParse({ type: "stop-sharing" }).success).toBe(
|
|
true,
|
|
);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "stop-sharing",
|
|
shareGeneration: "share_generation_12345678",
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "authenticate",
|
|
protocol: SIGNALING_PROTOCOL,
|
|
roomId,
|
|
role: "host",
|
|
token,
|
|
clientId: "client_12345678",
|
|
shareGeneration: "share_generation_12345678",
|
|
}).success,
|
|
).toBe(true);
|
|
expect(clientMessageSchema.safeParse({ type: "abandon-room" }).success).toBe(
|
|
true,
|
|
);
|
|
});
|
|
|
|
it("keeps intentional pause updates strict and generation-bound", () => {
|
|
const pause = {
|
|
type: "set-sharing-paused",
|
|
shareGeneration: "share_generation_12345678",
|
|
paused: true,
|
|
};
|
|
expect(clientMessageSchema.safeParse(pause).success).toBe(true);
|
|
expect(
|
|
clientMessageSchema.safeParse({ ...pause, paused: false }).success,
|
|
).toBe(true);
|
|
expect(
|
|
clientMessageSchema.safeParse({ ...pause, shareGeneration: undefined })
|
|
.success,
|
|
).toBe(false);
|
|
expect(
|
|
clientMessageSchema.safeParse({ ...pause, paused: "true" }).success,
|
|
).toBe(false);
|
|
expect(
|
|
clientMessageSchema.safeParse({ ...pause, unexpected: 1 }).success,
|
|
).toBe(false);
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
type: "host-status",
|
|
online: true,
|
|
paused: true,
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
serverMessageSchema.safeParse({ type: "host-status", online: true })
|
|
.success,
|
|
).toBe(false);
|
|
const authoritativePause = {
|
|
type: "pause-sharing-source",
|
|
shareGeneration: "share_generation_12345678",
|
|
};
|
|
expect(serverMessageSchema.safeParse(authoritativePause).success).toBe(true);
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
...authoritativePause,
|
|
unexpected: null,
|
|
}).success,
|
|
).toBe(false);
|
|
});
|
|
|
|
it("accepts only strict, bounded quality settings", () => {
|
|
expect(DEFAULT_QUALITY_SETTINGS).not.toHaveProperty("videoCodec");
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "set-quality-settings",
|
|
qualitySettings,
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "set-quality-settings",
|
|
qualitySettings: qualitySettingsWithAudio,
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "set-quality-settings",
|
|
qualitySettings: { ...qualitySettings, resolution: "480p" },
|
|
}).success,
|
|
).toBe(true);
|
|
for (const screenAudioQuality of [
|
|
"saver",
|
|
"music",
|
|
"very-high",
|
|
] as const) {
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "set-quality-settings",
|
|
qualitySettings: { ...qualitySettings, screenAudioQuality },
|
|
}).success,
|
|
).toBe(true);
|
|
}
|
|
for (const invalid of [
|
|
{ ...qualitySettings, resolution: "2160p" },
|
|
{ ...qualitySettings, maxFramerate: 14 },
|
|
{ ...qualitySettings, maxFramerate: 61 },
|
|
{ ...qualitySettings, maxFramerate: 30.5 },
|
|
{ ...qualitySettings, maxBitrate: 1_999_999 },
|
|
{ ...qualitySettings, maxBitrate: 12_000_001 },
|
|
{ ...qualitySettings, maxBitrate: 5_000_000.5 },
|
|
{ ...qualitySettings, degradationPreference: "automatic" },
|
|
legacyCodecQualitySettings,
|
|
{ ...qualitySettings, screenAudioQuality: "lossless" },
|
|
{ ...qualitySettings, screenAudioQuality: 960_000 },
|
|
{ ...qualitySettings, codec: "video/VP9" },
|
|
]) {
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "set-quality-settings",
|
|
qualitySettings: invalid,
|
|
}).success,
|
|
).toBe(false);
|
|
}
|
|
const { maxFramerate: _missing, ...missingField } = qualitySettings;
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "set-quality-settings",
|
|
qualitySettings: missingField,
|
|
}).success,
|
|
).toBe(false);
|
|
});
|
|
|
|
it("accepts only a bounded browser relay capacity", () => {
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "relay-capacity",
|
|
downstreamEdges: 0,
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "relay-capacity",
|
|
downstreamEdges: 1,
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "relay-capacity",
|
|
downstreamEdges: 2,
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "relay-capacity",
|
|
downstreamEdges: 3,
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "relay-capacity",
|
|
downstreamEdges: 4,
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "relay-capacity",
|
|
downstreamEdges: 1,
|
|
score: 100,
|
|
}).success,
|
|
).toBe(false);
|
|
});
|
|
|
|
it("accepts only strict, bounded viewer quality evidence", () => {
|
|
expect(clientMessageSchema.safeParse(qualityEvidence).success).toBe(true);
|
|
const { natTraversalPath: _path, ...legacyMetrics } =
|
|
qualityEvidence.metrics;
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
...qualityEvidence,
|
|
metrics: legacyMetrics,
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
...qualityEvidence,
|
|
metrics: {
|
|
...qualityEvidence.metrics,
|
|
freezeDurationMsDelta: 12_000,
|
|
pauseDurationMsDelta: 6_000,
|
|
},
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
...qualityEvidence,
|
|
metrics: {
|
|
...qualityEvidence.metrics,
|
|
freezeCountDelta: null,
|
|
freezeDurationMsDelta: null,
|
|
pauseCountDelta: null,
|
|
pauseDurationMsDelta: null,
|
|
},
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
Buffer.byteLength(JSON.stringify(qualityEvidence), "utf8"),
|
|
).toBeLessThanOrEqual(MAX_VIEWER_QUALITY_EVIDENCE_BYTES);
|
|
|
|
for (const invalid of [
|
|
{ ...qualityEvidence, roomId },
|
|
{
|
|
...qualityEvidence,
|
|
guard: { ...qualityEvidence.guard, peerId: "viewer_12345678" },
|
|
},
|
|
{ ...qualityEvidence, windowMs: 999 },
|
|
{ ...qualityEvidence, sequence: -1 },
|
|
{
|
|
...qualityEvidence,
|
|
metrics: { ...qualityEvidence.metrics, width: null },
|
|
},
|
|
{
|
|
...qualityEvidence,
|
|
metrics: { ...qualityEvidence.metrics, bitrateKbps: Number.POSITIVE_INFINITY },
|
|
},
|
|
{
|
|
...qualityEvidence,
|
|
metrics: { ...qualityEvidence.metrics, freezeCountDelta: -1 },
|
|
},
|
|
{
|
|
...qualityEvidence,
|
|
metrics: {
|
|
...qualityEvidence.metrics,
|
|
freezeCountDelta: Number.MAX_SAFE_INTEGER + 1,
|
|
},
|
|
},
|
|
{
|
|
...qualityEvidence,
|
|
metrics: {
|
|
...qualityEvidence.metrics,
|
|
freezeDurationMsDelta: Number.MAX_SAFE_INTEGER + 1,
|
|
},
|
|
},
|
|
{
|
|
...qualityEvidence,
|
|
metrics: { ...qualityEvidence.metrics, pauseCountDelta: -1 },
|
|
},
|
|
{
|
|
...qualityEvidence,
|
|
metrics: {
|
|
...qualityEvidence.metrics,
|
|
pauseDurationMsDelta: Number.MAX_SAFE_INTEGER + 1,
|
|
},
|
|
},
|
|
{
|
|
...qualityEvidence,
|
|
metrics: {
|
|
...qualityEvidence.metrics,
|
|
codecParameters: "sprop-parameter-sets=deadbeef",
|
|
},
|
|
},
|
|
{
|
|
...qualityEvidence,
|
|
metrics: {
|
|
...qualityEvidence.metrics,
|
|
codecProfile: "device-id=deadbeef",
|
|
},
|
|
},
|
|
{
|
|
...qualityEvidence,
|
|
metrics: {
|
|
...qualityEvidence.metrics,
|
|
scalabilityMode: "DEVICE_ABC123",
|
|
},
|
|
},
|
|
{
|
|
...qualityEvidence,
|
|
metrics: {
|
|
...qualityEvidence.metrics,
|
|
decoderImplementation: "device-specific-decoder",
|
|
},
|
|
},
|
|
]) {
|
|
expect(clientMessageSchema.safeParse(invalid).success).toBe(false);
|
|
}
|
|
});
|
|
|
|
it("accepts only native sender quality state with exact known identity", () => {
|
|
const sender = {
|
|
type: "sender-quality-evidence",
|
|
childPeerId: "viewer_12345678",
|
|
connectionId: "connection_12345678",
|
|
rtpStatsId: "rtp-stats-1",
|
|
trackIdentifier: "track-1",
|
|
sampleTimestampMs: 2_000,
|
|
routeRevision: 3,
|
|
state: "degraded",
|
|
diagnostics: {
|
|
natTraversalPath: "ordinary",
|
|
reason: "bandwidth",
|
|
framesPerSecond: 24,
|
|
bitrateKbps: 1_500,
|
|
},
|
|
} as const;
|
|
expect(clientMessageSchema.safeParse(sender).success).toBe(true);
|
|
const { natTraversalPath: _senderPath, ...legacyDiagnostics } =
|
|
sender.diagnostics;
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
...sender,
|
|
diagnostics: legacyDiagnostics,
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
...sender,
|
|
state: "healthy",
|
|
rtpStatsId: null,
|
|
diagnostics: { ...sender.diagnostics, reason: "none" },
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
...sender,
|
|
sampleTimestampMs: null,
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "sfu-publisher-quality-evidence",
|
|
publicationGeneration: "publication_generation_12345678",
|
|
routeRevision: 4,
|
|
state: "healthy",
|
|
sampleTimestampMs: 2_000,
|
|
diagnostics: {
|
|
natTraversalPath: "ordinary",
|
|
reason: "none",
|
|
framesPerSecond: 30,
|
|
bitrateKbps: 2_000,
|
|
},
|
|
}).success,
|
|
).toBe(true);
|
|
});
|
|
|
|
it.each([
|
|
["video/VP8", null, "max-fr=60; max-fs=8160"],
|
|
["video/VP9", "profile-id=2", "max-fs=8160"],
|
|
["video/AV1", "profile=1", "level-idx=31; tier=0"],
|
|
["video/unknown", null, null],
|
|
])(
|
|
"accepts canonical viewer codec evidence for %s",
|
|
(codec, codecProfile, codecParameters) => {
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
...qualityEvidence,
|
|
metrics: {
|
|
...qualityEvidence.metrics,
|
|
codec,
|
|
codecProfile,
|
|
codecParameters,
|
|
},
|
|
}).success,
|
|
).toBe(true);
|
|
},
|
|
);
|
|
|
|
it("accepts bounded route acknowledgements and failures", () => {
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "route-ready",
|
|
revision: 7,
|
|
phase: "prepare",
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "route-ready",
|
|
revision: 7,
|
|
phase: "prepare",
|
|
qualityApproved: true,
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "route-ready",
|
|
revision: 7,
|
|
phase: "prepare",
|
|
qualityApproved: false,
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "route-transport-connected",
|
|
revision: 7,
|
|
connectionId: "connection_12345678",
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "route-media-unavailable",
|
|
revision: 7,
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "route-failed",
|
|
revision: 7,
|
|
phase: "active",
|
|
connectionId: null,
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "refresh-sfu",
|
|
revision: MAX_MEDIA_ROUTE_REVISION,
|
|
}).success,
|
|
).toBe(true);
|
|
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "route-ready",
|
|
revision: -1,
|
|
phase: "prepare",
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "route-transport-connected",
|
|
revision: 7,
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "route-media-unavailable",
|
|
revision: -1,
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "route-failed",
|
|
revision: 7,
|
|
phase: "active",
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
clientMessageSchema.safeParse({
|
|
type: "refresh-sfu",
|
|
revision: 1.5,
|
|
}).success,
|
|
).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe("server signaling protocol", () => {
|
|
it("keeps route status pairings revision-fenced and strict", () => {
|
|
for (const message of [
|
|
{
|
|
type: "route-status",
|
|
revision: 3,
|
|
state: "waiting",
|
|
reason: "sfu-admission",
|
|
},
|
|
{
|
|
type: "route-status",
|
|
revision: 4,
|
|
state: "failed",
|
|
reason: "route-exhausted",
|
|
},
|
|
]) {
|
|
expect(serverMessageSchema.safeParse(message).success).toBe(true);
|
|
}
|
|
for (const message of [
|
|
{
|
|
type: "route-status",
|
|
revision: 3,
|
|
state: "waiting",
|
|
reason: "route-exhausted",
|
|
},
|
|
{
|
|
type: "route-status",
|
|
revision: 3,
|
|
state: "failed",
|
|
reason: "sfu-admission",
|
|
},
|
|
{
|
|
type: "route-status",
|
|
revision: 3,
|
|
state: "failed",
|
|
reason: "route-exhausted",
|
|
retry: true,
|
|
},
|
|
]) {
|
|
expect(serverMessageSchema.safeParse(message).success).toBe(false);
|
|
}
|
|
});
|
|
|
|
it("accepts only the privacy-safe route snapshot payload", () => {
|
|
const message = {
|
|
type: "route-diagnostic-snapshot",
|
|
snapshot: {
|
|
children: [
|
|
{
|
|
ordinal: 1,
|
|
parent: { kind: "host" },
|
|
effectiveCapacity: 2,
|
|
childCount: 1,
|
|
demandAgeMs: 100,
|
|
queueWaitMs: 10,
|
|
candidateStartMs: 20,
|
|
firstDecodedFrameMs: 80,
|
|
finalMs: 80,
|
|
finalRoute: "direct",
|
|
rejectionBucket: "none",
|
|
quality: {
|
|
eligibleWindows: 3,
|
|
eligibleDurationMs: 6_000,
|
|
freezeWindows: 1,
|
|
freezeCount: 1,
|
|
freezeDurationMs: 250,
|
|
pauseCount: 0,
|
|
pauseDurationMs: 0,
|
|
},
|
|
},
|
|
{
|
|
ordinal: 2,
|
|
parent: { kind: "viewer", ordinal: 1 },
|
|
effectiveCapacity: 0,
|
|
childCount: 0,
|
|
demandAgeMs: 90,
|
|
queueWaitMs: null,
|
|
candidateStartMs: null,
|
|
firstDecodedFrameMs: null,
|
|
finalMs: null,
|
|
finalRoute: "waiting",
|
|
rejectionBucket: "sfu-admission",
|
|
quality: null,
|
|
},
|
|
],
|
|
operation: {
|
|
childOrdinal: 2,
|
|
reason: "join",
|
|
stage: "admission",
|
|
cursor: 1,
|
|
candidateCount: 2,
|
|
},
|
|
},
|
|
} as const;
|
|
expect(serverMessageSchema.safeParse(message).success).toBe(true);
|
|
for (const invalid of [
|
|
{
|
|
...message,
|
|
snapshot: { ...message.snapshot, peerId: "viewer_private_12345678" },
|
|
},
|
|
{
|
|
...message,
|
|
snapshot: {
|
|
...message.snapshot,
|
|
children: [
|
|
{
|
|
...message.snapshot.children[0],
|
|
connectionId: "connection_private_12345678",
|
|
},
|
|
],
|
|
},
|
|
},
|
|
{
|
|
...message,
|
|
snapshot: {
|
|
...message.snapshot,
|
|
children: [
|
|
{
|
|
...message.snapshot.children[0],
|
|
quality: {
|
|
...message.snapshot.children[0].quality,
|
|
presentationEpoch: 1,
|
|
},
|
|
},
|
|
],
|
|
},
|
|
},
|
|
{
|
|
...message,
|
|
snapshot: {
|
|
...message.snapshot,
|
|
children: [
|
|
{
|
|
...message.snapshot.children[0],
|
|
quality: {
|
|
...message.snapshot.children[0].quality,
|
|
freezeCount: -1,
|
|
},
|
|
},
|
|
],
|
|
},
|
|
},
|
|
{
|
|
...message,
|
|
snapshot: {
|
|
...message.snapshot,
|
|
children: [
|
|
message.snapshot.children[0],
|
|
{
|
|
...message.snapshot.children[1],
|
|
parent: { kind: "viewer", ordinal: 2 },
|
|
},
|
|
],
|
|
},
|
|
},
|
|
{
|
|
...message,
|
|
snapshot: {
|
|
...message.snapshot,
|
|
operation: {
|
|
...message.snapshot.operation,
|
|
rejectionBucket: "raw-error",
|
|
},
|
|
},
|
|
},
|
|
]) {
|
|
expect(serverMessageSchema.safeParse(invalid).success).toBe(false);
|
|
}
|
|
});
|
|
it("accepts only STUN URLs in the authenticated peer ICE config", () => {
|
|
for (const url of ["stun:stun.test:80/", "stun:stun.test:3478/"]) {
|
|
expect(serverMessageSchema.safeParse({
|
|
...authenticatedMessage(20),
|
|
iceConfig: { iceServers: [{ urls: url }], natPredictionStunUrls: [] },
|
|
}).success).toBe(false);
|
|
}
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
type: "ice-config",
|
|
iceConfig: { iceServers: [] },
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
...authenticatedMessage(8),
|
|
iceConfig: {
|
|
iceServers: [
|
|
{
|
|
urls: "turn:relay.example.test:3478?transport=udp",
|
|
username: `1787076000:${"a".repeat(32)}`,
|
|
credential: "credential",
|
|
},
|
|
],
|
|
},
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
...authenticatedMessage(8),
|
|
iceConfig: {
|
|
iceServers: [{ urls: "turn:relay.example.test:3478?transport=udp" }],
|
|
},
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
...authenticatedMessage(8),
|
|
iceConfig: {
|
|
iceServers: [{ urls: "stuns:stun.example.test:5349" }],
|
|
},
|
|
}).success,
|
|
).toBe(false);
|
|
});
|
|
|
|
function authenticatedMessage(maxViewers: number) {
|
|
return {
|
|
type: "authenticated",
|
|
protocol: SIGNALING_PROTOCOL,
|
|
role: "host",
|
|
peerId: "host_12345678",
|
|
maxViewers,
|
|
endpointMediaCopyCapacity: 2,
|
|
hostOnline: true,
|
|
connectionId: null,
|
|
mediaMode: "peer-assisted",
|
|
shareGeneration: "share_generation_12345678",
|
|
routeRevision: 0,
|
|
routeAssignment: {
|
|
upstream: { kind: "none" },
|
|
childPeerIds: [],
|
|
sfuPublicationGeneration: null,
|
|
},
|
|
qualitySettings,
|
|
routePolicy: DEFAULT_ROUTE_POLICY,
|
|
codeEntryPolicy: "open",
|
|
viewerPasswordEnabled: false,
|
|
viewerAuthorizationGeneration: "viewer_generation_12345678",
|
|
iceConfig: {
|
|
iceServers: [],
|
|
natPredictionStunUrls: [],
|
|
},
|
|
};
|
|
}
|
|
|
|
it("scopes password configuration state to authenticated Hosts", () => {
|
|
const host = authenticatedMessage(8) as Record<string, unknown>;
|
|
expect(serverMessageSchema.safeParse(host).success).toBe(true);
|
|
delete host.viewerPasswordEnabled;
|
|
expect(serverMessageSchema.safeParse(host).success).toBe(false);
|
|
|
|
const viewer = {
|
|
...authenticatedMessage(8),
|
|
role: "viewer",
|
|
peerId: "viewer_12345678",
|
|
} as Record<string, unknown>;
|
|
delete viewer.viewerPasswordEnabled;
|
|
expect(serverMessageSchema.safeParse(viewer).success).toBe(true);
|
|
viewer.viewerPasswordEnabled = true;
|
|
expect(serverMessageSchema.safeParse(viewer).success).toBe(false);
|
|
});
|
|
|
|
it("requires the v20 NAT observation configuration", () => {
|
|
const message = authenticatedMessage(8);
|
|
const { natPredictionStunUrls: _urls, ...legacyIceConfig } =
|
|
message.iceConfig;
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
...message,
|
|
iceConfig: legacyIceConfig,
|
|
}).success,
|
|
).toBe(false);
|
|
});
|
|
|
|
it("accepts dynamic viewer limits within the protocol boundary", () => {
|
|
expect(MAX_VIEWERS_PER_ROOM_LIMIT).toBe(20);
|
|
expect(serverMessageSchema.safeParse(authenticatedMessage(1)).success).toBe(
|
|
true,
|
|
);
|
|
expect(serverMessageSchema.safeParse(authenticatedMessage(8)).success).toBe(
|
|
true,
|
|
);
|
|
expect(
|
|
serverMessageSchema.safeParse(
|
|
authenticatedMessage(MAX_VIEWERS_PER_ROOM_LIMIT),
|
|
).success,
|
|
).toBe(true);
|
|
});
|
|
|
|
it("requires the authenticated endpoint capacity to be 1, 2, or 3", () => {
|
|
for (const endpointMediaCopyCapacity of [1, 2, 3]) {
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
...authenticatedMessage(8),
|
|
endpointMediaCopyCapacity,
|
|
}).success,
|
|
).toBe(true);
|
|
}
|
|
for (const endpointMediaCopyCapacity of [undefined, 0, 4, 1.5]) {
|
|
const message = authenticatedMessage(8) as Record<string, unknown>;
|
|
if (endpointMediaCopyCapacity === undefined) {
|
|
delete message.endpointMediaCopyCapacity;
|
|
} else {
|
|
message.endpointMediaCopyCapacity = endpointMediaCopyCapacity;
|
|
}
|
|
expect(serverMessageSchema.safeParse(message).success).toBe(false);
|
|
}
|
|
});
|
|
|
|
it("accepts a strict, unique and bounded Viewer presence snapshot", () => {
|
|
const viewer = {
|
|
role: "viewer",
|
|
peerId: "viewer_12345678",
|
|
displayName: "小明",
|
|
upstream: { kind: "peer", peerId: "viewer_parent_12345678" },
|
|
} as const;
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
type: "viewer-presence",
|
|
viewers: [
|
|
{
|
|
...viewer,
|
|
upstream: { kind: "sfu" },
|
|
mediaReady: true,
|
|
},
|
|
],
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
type: "viewer-presence",
|
|
viewers: [{ ...viewer, mediaReady: false }],
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
type: "viewer-presence",
|
|
viewers: [viewer, viewer],
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
type: "viewer-presence",
|
|
viewers: [{ ...viewer, mediaTopology: "peer-relay" }],
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
type: "viewer-presence",
|
|
viewers: [{ ...viewer, ip: "203.0.113.1" }],
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
type: "viewer-presence",
|
|
viewers: [
|
|
viewer,
|
|
{
|
|
role: "host",
|
|
peerId: "host_12345678",
|
|
displayName: "分享者",
|
|
upstream: { kind: "none" },
|
|
},
|
|
],
|
|
}).success,
|
|
).toBe(true);
|
|
});
|
|
|
|
it("requires a complete bounded peer-assisted assignment", () => {
|
|
const peerAssisted = {
|
|
...authenticatedMessage(8),
|
|
mediaMode: "peer-assisted",
|
|
shareGeneration: "share_generation_12345678",
|
|
routeRevision: 0,
|
|
routeAssignment: {
|
|
upstream: { kind: "none" },
|
|
childPeerIds: ["viewer_12345678", "viewer_87654321"],
|
|
sfuPublicationGeneration: null,
|
|
},
|
|
qualitySettings,
|
|
routePolicy: DEFAULT_ROUTE_POLICY,
|
|
};
|
|
|
|
expect(serverMessageSchema.safeParse(peerAssisted).success).toBe(true);
|
|
const incomplete = {
|
|
...authenticatedMessage(8),
|
|
} as Record<string, unknown>;
|
|
delete incomplete.routeAssignment;
|
|
expect(serverMessageSchema.safeParse(incomplete).success).toBe(false);
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
...peerAssisted,
|
|
routeAssignment: {
|
|
...peerAssisted.routeAssignment,
|
|
childPeerIds: [
|
|
"viewer_12345678",
|
|
"viewer_87654321",
|
|
"viewer_third_1234",
|
|
"viewer_overflow_1",
|
|
],
|
|
},
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
...peerAssisted,
|
|
qualitySettings: { ...qualitySettings, maxBitrate: 20_000_000 },
|
|
}).success,
|
|
).toBe(false);
|
|
const missingMode = {
|
|
...authenticatedMessage(8),
|
|
} as Record<string, unknown>;
|
|
delete missingMode.mediaMode;
|
|
expect(serverMessageSchema.safeParse(missingMode).success).toBe(false);
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
type: "quality-settings",
|
|
qualitySettings: {
|
|
resolution: "720p",
|
|
maxFramerate: 30,
|
|
maxBitrate: 3_000_000,
|
|
degradationPreference: "balanced",
|
|
},
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
type: "quality-settings",
|
|
qualitySettings: { ...qualitySettings, maxFramerate: 0 },
|
|
}).success,
|
|
).toBe(false);
|
|
});
|
|
|
|
it("accepts only bounded connection-attempt progress on a prepared route", () => {
|
|
const candidate = {
|
|
childPeerId: "child_12345678", connectionId: "connection_12345678",
|
|
transport: "direct", qualityProbe: false,
|
|
};
|
|
for (const current of [1, 2, 3]) {
|
|
expect(preparedRouteCandidateSchema.safeParse({
|
|
...candidate, connectionAttempt: { current, total: 3 },
|
|
}).success).toBe(true);
|
|
}
|
|
for (const connectionAttempt of [
|
|
{ current: 0, total: 3 }, { current: 4, total: 3 },
|
|
{ current: 1, total: 4 }, { current: 1.5, total: 3 },
|
|
]) {
|
|
expect(preparedRouteCandidateSchema.safeParse({
|
|
...candidate, connectionAttempt,
|
|
}).success).toBe(false);
|
|
}
|
|
});
|
|
|
|
it("keeps route messages strict alongside the single authenticated mode", () => {
|
|
const assignment = {
|
|
upstream: { kind: "peer", peerId: "parent_12345678" },
|
|
childPeerIds: ["child_12345678", "child_87654321"],
|
|
sfuPublicationGeneration: null,
|
|
};
|
|
|
|
expect(participantRouteAssignmentSchema.safeParse(assignment).success).toBe(
|
|
true,
|
|
);
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
type: "route-update",
|
|
revision: 9,
|
|
phase: "prepare",
|
|
assignment,
|
|
candidate: {
|
|
childPeerId: "child_12345678",
|
|
connectionId: "connection_12345678",
|
|
transport: "direct",
|
|
qualityProbe: false,
|
|
},
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
type: "route-update",
|
|
revision: 10,
|
|
phase: "prepare",
|
|
assignment,
|
|
candidate: {
|
|
childPeerId: "child_12345678",
|
|
connectionId: "connection_12345678",
|
|
transport: "sfu",
|
|
qualityProbe: true,
|
|
},
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
type: "route-update",
|
|
revision: 10,
|
|
phase: "prepare",
|
|
assignment,
|
|
candidate: {
|
|
childPeerId: "child_12345678",
|
|
connectionId: "connection_12345678",
|
|
transport: "direct",
|
|
qualityProbe: false,
|
|
unexpected: null,
|
|
},
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
type: "sfu-config",
|
|
revision: 9,
|
|
publicationGeneration: "publication_12345678",
|
|
connectionId: "connection_12345678",
|
|
}).success,
|
|
).toBe(true);
|
|
|
|
expect(
|
|
participantRouteAssignmentSchema.safeParse({
|
|
...assignment,
|
|
childPeerIds: [
|
|
"child_12345678",
|
|
"child_87654321",
|
|
"child_third_1234",
|
|
"child_overflow_1",
|
|
],
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
participantRouteAssignmentSchema.safeParse({
|
|
...assignment,
|
|
childPeerIds: ["child_12345678", "child_12345678"],
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
type: "route-update",
|
|
revision: 9,
|
|
phase: "prepare",
|
|
assignment,
|
|
roomAssignments: [],
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
type: "sfu-config",
|
|
revision: 9,
|
|
publicationGeneration: "publication_12345678",
|
|
connectionId: "",
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
...authenticatedMessage(8),
|
|
routeRevision: MAX_MEDIA_ROUTE_REVISION + 1,
|
|
}).success,
|
|
).toBe(false);
|
|
});
|
|
|
|
it("accepts every bounded hybrid upstream shape", () => {
|
|
for (const upstream of [
|
|
{ kind: "none" },
|
|
{ kind: "peer", peerId: "parent_12345678" },
|
|
{ kind: "sfu" },
|
|
]) {
|
|
expect(
|
|
participantRouteAssignmentSchema.safeParse({
|
|
upstream,
|
|
childPeerIds: [],
|
|
sfuPublicationGeneration:
|
|
upstream.kind === "peer" ? null : "generation_12345678",
|
|
}).success,
|
|
).toBe(true);
|
|
}
|
|
expect(
|
|
participantRouteAssignmentSchema.safeParse({
|
|
upstream: { kind: "sfu" },
|
|
childPeerIds: [],
|
|
sfuPublicationGeneration: null,
|
|
}).success,
|
|
).toBe(false);
|
|
});
|
|
|
|
it("accepts only canonical server-derived viewer evidence envelopes", () => {
|
|
const forwarded = {
|
|
...qualityEvidence,
|
|
viewerPeerId: "viewer_12345678",
|
|
upstream: { kind: "peer", peerId: "host_12345678" },
|
|
};
|
|
expect(serverMessageSchema.safeParse(forwarded).success).toBe(true);
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
...forwarded,
|
|
metrics: {
|
|
...forwarded.metrics,
|
|
freezeDurationMsDelta: 12_000,
|
|
pauseDurationMsDelta: 6_000,
|
|
},
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
...forwarded,
|
|
upstream: { kind: "sfu" },
|
|
}).success,
|
|
).toBe(true);
|
|
expect(
|
|
Buffer.byteLength(JSON.stringify(forwarded), "utf8"),
|
|
).toBeLessThanOrEqual(MAX_VIEWER_QUALITY_EVIDENCE_BYTES);
|
|
expect(
|
|
serverMessageSchema.safeParse({ ...forwarded, roomId }).success,
|
|
).toBe(false);
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
...qualityEvidence,
|
|
viewerPeerId: "viewer_12345678",
|
|
}).success,
|
|
).toBe(false);
|
|
expect(
|
|
serverMessageSchema.safeParse({
|
|
...forwarded,
|
|
upstream: { kind: "none" },
|
|
}).success,
|
|
).toBe(false);
|
|
});
|
|
|
|
it.each([0, 1.5, MAX_VIEWERS_PER_ROOM_LIMIT + 1])(
|
|
"rejects viewer limit %s outside the protocol boundary",
|
|
(maxViewers) => {
|
|
expect(
|
|
serverMessageSchema.safeParse(authenticatedMessage(maxViewers)).success,
|
|
).toBe(false);
|
|
},
|
|
);
|
|
|
|
});
|