okooooooo/Piik
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
Piik/internal/server/protocol/contract_test.go
T
AAA 1b9f5bd2a2 feat: add room interactions and media sharing improvements 
## Problem and outcome / 问题与结果

This phase adds lightweight room interaction without making media depend on chat,
and adds Windows source-audio exclusion and optional SFU-only hosting at their
existing owners. It also corrects confirmed encoder/capture ownership and native
color-conversion defects. Host microphone commentary remains on the shared media
path; room voice and 4K are outside this phase.

## Release notes

### 中文

这是一次功能更新：Piik 加入了文字聊天与表情互动，并完善了 Windows 声音采集、画面颜色和自部署选项。

#### 新功能

- **边看边聊。** 在可移动、可缩放的聊天窗口中发送消息，或开启弹幕。停止分享后，房间中的朋友仍可继续聊天。
- **表情互动。** 点击沙发上的人物，给自己发表情，或把番茄等表情送给朋友；各端按同一事件显示动画。
- **排除应用声音。** Windows App 分享整个屏幕时，可排除一个应用及其子进程的声音，适合同时使用语音软件。所选应用退出后，来源声音停止，避免恢复为未过滤的系统声音。
- **可选的纯 SFU 模式。** 自部署管理员可让共享画面和声音统一通过媒体服务器转发。默认仍为优先 P2P；App 公网邀请保持纯 P2P。
- **Windows HDR 转 SDR。** 原生采集与缩略图自动将 HDR 来源转换为 SDR，沿用现有观看链路。

#### 修复与改进

- 修复原生颜色转换的范围与矩阵处理，避免已复现的暗部丢失、高光裁切和颜色偏差。
- 修复共享编码器切换时使用过期需求或过期帧信息的问题，保护正在观看的画面；修复换源后旧采集事件可能影响新来源的问题。
- 统一新控件、浮窗与来源选择文案，补充中英文使用说明。

#### 使用与升级

聊天与表情需要新版站点页面和 Server；声音排除需要新版页面与支持此能力的 Windows App。聊天只保留本页最近收到的消息，刷新后清空，不补发历史，且不提供端到端加密。

HDR 转换输出为 SDR，不代表端到端 HDR 或多声道支持。既有房主麦克风与立体声能力保留。

### English

This feature update brings text chat and reactions to Piik, alongside improvements to Windows audio capture, picture colors and self-hosting options.

#### New features

- **Chat while watching.** Send messages in a movable, resizable window, or enable on-screen chat. Friends can keep chatting after the host stops sharing.
- **Reactions.** Select a person on the sofa to react above yourself or send a tomato and other reactions to a friend. Participants animate the same shared event.
- **Exclude application audio.** When sharing a whole screen with Windows App, exclude one application and its child processes, useful when using a separate voice app. Source audio stops if the selected app exits, preventing a return to unfiltered system sound.
- **Optional SFU-only hosting.** Site operators can require shared video and audio to pass through the media server. P2P-first remains the default; App Public invite remains P2P-only.
- **Windows HDR-to-SDR conversion.** Native capture and source thumbnails automatically convert HDR sources to SDR for the existing viewing path.

#### Fixes and improvements

- Correct native color-conversion ranges and matrices, addressing reproduced crushed shadows, clipped highlights and color shifts.
- Correct stale demand and frame evidence during shared-encoder handoffs to protect the current picture. Prevent events from a replaced capture from affecting its successor.
- Align new controls, floating panels and source-picker copy, with updated Chinese and English guides.

#### Using this update

Chat and reactions require updated site pages and Server. Audio exclusion requires updated pages and a Windows App that supports the capability. Chat retains only recent messages received by the current page, clears on refresh and does not replay history. It is not end-to-end encrypted.

HDR conversion produces SDR; it does not add end-to-end HDR or surround sound. Existing host microphone commentary and stereo support remain available.

## Verification / 验证

- Web type checks, 78 test files / 1275 tests and production build: PASS.
- Go core tests, formatting/vet and target builds: PASS; Darwin cgo remains platform-limited on this Windows runner.
- Native build/check/color probes and synthetic HDR-to-SDR H.264/VP8 browser reception: PASS.
- Access/privacy gate, Native H.264 SFU-only media gate and local Auto/H.264 Host gate: PASS.
- Three real production pages: chat/reactions, stop/resume, idle-room join, host departure/return, offline draft recovery and invitation revocation: PASS.
- Synthetic parent/child process-audio exclusion and target lifetime: PASS; no raw audio retained.
- Windows candidate archive extraction and packaged Local startup/shutdown: PASS.
- Documentation and website build: PASS.
- [Candidate CI](https://github.com/TNTcraftHIM/Piik/actions/runs/36873766646) at
  `f26cd208d03bc0dcbe353f8cac217f993216b0a3`: Go core and race checks, Web tests,
  Server/container checks and Windows/macOS/Linux App packaging all PASS.
  Publication was skipped as intended.

The owner accepted the UI/model and bounded local walkthrough for phase closure.
Physical HDR/mixed displays, mobile keyboard,
real voice applications across output devices and macOS/Linux capture remain
unverified. Existing field reports without matched evidence are not claimed
resolved. The owner authorized v1.7.0 publication on 2026-10-02. The final
documentation-only commit records that authorization; product code matches
the verified candidate above.

## Impact / 影响

Authorized version: **v1.7.0**, matching the local release planner. Current wire
contracts remain Browser/server 23, Native control 9 and capture 7. Optional
capabilities gate new functionality; existing room/media authority remains owned
by the existing services. No new ports, message persistence, room voice or
automatic room creation on page visit. Updated README, guides, standards,
research evidence and TODO stay with the candidate phase.
2026-10-02 01:36:45 +08:00

752 lines
31 KiB
Go
Raw Permalink Blame History

package protocol
import (
"bytes"
"encoding/json"
"fmt"
"strings"
"testing"
)
func TestRuntimeCapabilities(t *testing.T) {
for _, test := range []struct {
data string
want RuntimeCapabilities
}{
{`{}`, RuntimeCapabilities{}},
{`{"connectionAttemptProgress4":true}`, RuntimeCapabilities{ConnectionAttemptProgress4: true}},
{`{"sfu":true,"extra":{"enabled":true}}`, RuntimeCapabilities{Sfu: true}},
{`{"sfu":true,"sfuOnly":true}`, RuntimeCapabilities{Sfu: true, SfuOnly: true}},
{`{"natPrediction":true,"SFU":true}`, RuntimeCapabilities{NatPrediction: true}},
{`{"sfu":true,"natPrediction":true}`, RuntimeCapabilities{Sfu: true, NatPrediction: true}},
{`{"sfu":"ignored duplicate","sfu":true}`, RuntimeCapabilities{Sfu: true}},
} {
got := RuntimeCapabilities{Sfu: true, NatPrediction: true}
if err := json.Unmarshal([]byte(test.data), &got); err != nil || got != test.want {
t.Errorf("decode %s = %+v, %v; want %+v", test.data, got, err, test.want)
}
}
for _, data := range []string{
`null`, `[]`, `true`, `{"sfu":null}`, `{"sfu":"true"}`, `{"sfuOnly":null}`, `{"sfuOnly":"true"}`,
`{"natPrediction":null}`, `{"natPrediction":1}`,
`{"connectionAttemptProgress4":null}`, `{"connectionAttemptProgress4":4}`,
} {
var got RuntimeCapabilities
if err := json.Unmarshal([]byte(data), &got); err == nil {
t.Errorf("expected %s to be rejected", data)
}
}
}
func TestStrictMemberNamesCannotPopulateForbiddenOrOptionalFields(t *testing.T) {
for _, sample := range []struct {
name string
data string
target any
}{
{"none upstream with folded empty peer", `{"kind":"none","peerid":""}`, &MediaRouteUpstream{}},
{"host diagnostic with folded zero ordinal", `{"kind":"host","Ordinal":0}`, &RouteDiagnosticParent{}},
{"host presence with folded false ready", `{"role":"host","peerId":"host_12345678","displayName":"Host","upstream":{"kind":"none"},"mediaready":false}`, &ParticipantPresenceEntry{}},
{"viewer presence with folded false ready", `{"role":"viewer","peerId":"viewer_12345678","displayName":"Viewer","upstream":{"kind":"none"},"mediaready":false}`, &ParticipantPresenceEntry{}},
} {
t.Run(sample.name, func(t *testing.T) {
if err := json.Unmarshal([]byte(sample.data), sample.target); err == nil {
t.Fatal("a noncanonical member must not populate a schema field")
}
})
}
assertServerMessage(t, "folded route policy cannot be ignored by its default",
object(with(drop(authenticatedHost(), "routePolicy"), member{"routepolicy", testRoutePolicy})), false)
}
// member is one JSON object key with its raw encoded value, so the tests can
// reproduce the exact wire shapes from tests/protocol.test.ts (including key
// presence, which a Go map cannot express).
type member struct {
key string
raw string
}
func object(members []member) []byte {
var builder strings.Builder
builder.WriteByte('{')
for index, entry := range members {
if index > 0 {
builder.WriteByte(',')
}
fmt.Fprintf(&builder, "%q:%s", entry.key, entry.raw)
}
builder.WriteByte('}')
return []byte(builder.String())
}
func with(base []member, changes ...member) []member {
out := append([]member(nil), base...)
for _, change := range changes {
replaced := false
for index := range out {
if out[index].key == change.key {
out[index] = change
replaced = true
break
}
}
if !replaced {
out = append(out, change)
}
}
return out
}
func drop(base []member, keys ...string) []member {
out := make([]member, 0, len(base))
for _, entry := range base {
remove := false
for _, key := range keys {
if entry.key == key {
remove = true
}
}
if !remove {
out = append(out, entry)
}
}
return out
}
const (
testAssignmentNone = `{"upstream":{"kind":"none"},"childPeerIds":[],` +
`"sfuPublicationGeneration":null}`
testQualitySettings = `{"resolution":"1080p","maxFramerate":60,"maxBitrate":8000000,` +
`"degradationPreference":"maintain-resolution"}`
testRoutePolicy = `{"peerOnly":false,"topologyOptimization":true,"natPrediction":false}`
testIceConfig = `{"iceServers":[],"natPredictionStunUrls":[]}`
)
func authenticatedHost() []member {
return []member{
{"type", `"authenticated"`},
{"protocol", `"piik-v23"`},
{"peerId", `"host_12345678"`},
{"maxViewers", `8`},
{"endpointMediaCopyCapacity", `2`},
{"hostOnline", `true`},
{"connectionId", `null`},
{"iceConfig", testIceConfig},
{"routePolicy", testRoutePolicy},
{"codeEntryPolicy", `"open"`},
{"viewerAuthorizationGeneration", `"viewer_generation_12345678"`},
{"mediaMode", `"peer-assisted"`},
{"shareGeneration", `"share_generation_12345678"`},
{"routeRevision", `0`},
{"routeAssignment", testAssignmentNone},
{"qualitySettings", testQualitySettings},
{"role", `"host"`},
{"viewerPasswordEnabled", `false`},
}
}
func assertServerMessage(t *testing.T, name string, data []byte, want bool) {
t.Helper()
t.Run(name, func(t *testing.T) {
_, err := DecodeServerMessage(data)
if want && err != nil {
t.Fatalf("expected %s to decode, got %v", data, err)
}
if !want && err == nil {
t.Fatalf("expected %s to be rejected", data)
}
})
}
func assertClientMessage(t *testing.T, name string, data []byte, want bool) {
t.Helper()
t.Run(name, func(t *testing.T) {
_, err := DecodeClientMessage(data)
if want && err != nil {
t.Fatalf("expected %s to decode, got %v", data, err)
}
if !want && err == nil {
t.Fatalf("expected %s to be rejected", data)
}
})
}
// "accepts dynamic viewer limits within the protocol boundary" and
// "rejects viewer limit %s outside the protocol boundary".
func TestAuthenticatedViewerLimits(t *testing.T) {
for _, sample := range []struct {
raw string
want bool
}{{`1`, true}, {`8`, true}, {`20`, true}, {`0`, false}, {`1.5`, false}, {`21`, false}} {
assertServerMessage(t, "maxViewers "+sample.raw,
object(with(authenticatedHost(), member{"maxViewers", sample.raw})), sample.want)
}
}
// "requires the authenticated endpoint capacity to be 1, 2, or 3".
func TestAuthenticatedEndpointCapacity(t *testing.T) {
for _, sample := range []struct {
raw string
want bool
}{{`1`, true}, {`2`, true}, {`3`, true}, {`0`, false}, {`4`, false}, {`1.5`, false}} {
assertServerMessage(t, "capacity "+sample.raw,
object(with(authenticatedHost(),
member{"endpointMediaCopyCapacity", sample.raw})), sample.want)
}
assertServerMessage(t, "capacity absent",
object(drop(authenticatedHost(), "endpointMediaCopyCapacity")), false)
}
// "scopes password configuration state to authenticated Hosts".
func TestAuthenticatedPasswordStateIsHostScoped(t *testing.T) {
assertServerMessage(t, "host carries the flag", object(authenticatedHost()), true)
assertServerMessage(t, "host without the flag",
object(drop(authenticatedHost(), "viewerPasswordEnabled")), false)
viewer := drop(with(authenticatedHost(),
member{"role", `"viewer"`}, member{"peerId", `"viewer_12345678"`}),
"viewerPasswordEnabled")
assertServerMessage(t, "viewer without the flag", object(viewer), true)
assertServerMessage(t, "viewer with the flag",
object(with(viewer, member{"viewerPasswordEnabled", `true`})), false)
assertServerMessage(t, "viewer with hostPaused",
object(with(viewer, member{"hostPaused", `true`})), true)
}
func TestAuthenticatedRoomRevision(t *testing.T) {
assertServerMessage(t, "revision at the ceiling",
object(with(authenticatedHost(), member{"routeRevision", `9007199254740991`})), true)
assertServerMessage(t, "revision past the ceiling",
object(with(authenticatedHost(), member{"routeRevision", `9007199254740992`})), false)
assertServerMessage(t, "absent route assignment",
object(drop(authenticatedHost(), "routeAssignment")), false)
assertServerMessage(t, "absent media mode",
object(drop(authenticatedHost(), "mediaMode")), false)
assertServerMessage(t, "quality settings past the bitrate ceiling",
object(with(authenticatedHost(), member{"qualitySettings",
`{"resolution":"1080p","maxFramerate":60,"maxBitrate":20000000,` +
`"degradationPreference":"maintain-resolution"}`})), false)
}
// "accepts only STUN URLs in the authenticated peer ICE config" and
// "requires the v20 NAT observation configuration".
func TestAuthenticatedIceConfig(t *testing.T) {
for _, sample := range []struct {
name string
raw string
want bool
}{
{"empty", `{"iceServers":[],"natPredictionStunUrls":[]}`, true},
{"one stun url", `{"iceServers":[{"urls":"stun:stun.example.test:3478"}],` +
`"natPredictionStunUrls":[]}`, true},
{"a list of stun urls", `{"iceServers":[{"urls":["stun:a.example.test:3478",` +
`"stun:b.example.test:3478"]}],"natPredictionStunUrls":[]}`, true},
{"missing nat prediction urls", `{"iceServers":[]}`, false},
{"turn url", `{"iceServers":[{"urls":"turn:relay.example.test:3478?transport=udp"}],` +
`"natPredictionStunUrls":[]}`, false},
{"turn credentials", `{"iceServers":[{"urls":"turn:relay.example.test:3478",` +
`"username":"1787076000","credential":"credential"}],` +
`"natPredictionStunUrls":[]}`, false},
{"stuns url", `{"iceServers":[{"urls":"stuns:stun.example.test:5349"}],` +
`"natPredictionStunUrls":[]}`, false},
{"too many nat prediction urls", `{"iceServers":[],"natPredictionStunUrls":` +
`["stun:a.example.test:3478","stun:b.example.test:3478",` +
`"stun:c.example.test:3478"]}`, false},
} {
assertServerMessage(t, "iceConfig "+sample.name,
object(with(authenticatedHost(), member{"iceConfig", sample.raw})), sample.want)
}
}
// "keeps Viewer route status as a strict crossed union".
func TestRouteStatusCrossedUnion(t *testing.T) {
for _, sample := range []struct {
name string
raw string
want bool
}{
{"waiting on admission",
`{"type":"route-status","revision":3,"state":"waiting","reason":"sfu-admission"}`, true},
{"failed on exhaustion",
`{"type":"route-status","revision":4,"state":"failed","reason":"route-exhausted"}`, true},
{"waiting on exhaustion",
`{"type":"route-status","revision":3,"state":"waiting","reason":"route-exhausted"}`, false},
{"failed on admission",
`{"type":"route-status","revision":3,"state":"failed","reason":"sfu-admission"}`, false},
{"with a retry hint",
`{"type":"route-status","revision":3,"state":"waiting","reason":"sfu-admission",` +
`"retryAfterMs":1000}`, false},
{"with a peer id",
`{"type":"route-status","revision":3,"state":"waiting","reason":"sfu-admission",` +
`"peerId":"private-peer-id"}`, false},
} {
assertServerMessage(t, sample.name, []byte(sample.raw), sample.want)
}
}
// "accepts a strict, unique and bounded Viewer presence snapshot".
func TestViewerPresence(t *testing.T) {
const viewer = `{"role":"viewer","peerId":"viewer_12345678","displayName":"小明",` +
`"upstream":{"kind":"peer","peerId":"viewer_parent_12345678"}}`
for _, sample := range []struct {
name string
raw string
want bool
}{
{"sfu upstream with mediaReady",
`{"type":"viewer-presence","viewers":[{"role":"viewer","peerId":"viewer_12345678",` +
`"displayName":"小明","upstream":{"kind":"sfu"},"mediaReady":true}]}`, true},
{"mediaReady false", `{"type":"viewer-presence","viewers":[{"role":"viewer",` +
`"peerId":"viewer_12345678","displayName":"小明",` +
`"upstream":{"kind":"peer","peerId":"viewer_parent_12345678"},` +
`"mediaReady":false}]}`, false},
{"duplicate peer ids",
`{"type":"viewer-presence","viewers":[` + viewer + `,` + viewer + `]}`, false},
{"leaked topology", `{"type":"viewer-presence","viewers":[{"role":"viewer",` +
`"peerId":"viewer_12345678","displayName":"小明",` +
`"upstream":{"kind":"none"},"mediaTopology":"peer-relay"}]}`, false},
{"leaked address", `{"type":"viewer-presence","viewers":[{"role":"viewer",` +
`"peerId":"viewer_12345678","displayName":"小明",` +
`"upstream":{"kind":"none"},"ip":"203.0.113.1"}]}`, false},
{"host entry", `{"type":"viewer-presence","viewers":[` + viewer + `,` +
`{"role":"host","peerId":"host_12345678","displayName":"分享者",` +
`"upstream":{"kind":"none"}}]}`, true},
{"host entry with an upstream", `{"type":"viewer-presence","viewers":[` +
`{"role":"host","peerId":"host_12345678","displayName":"分享者",` +
`"upstream":{"kind":"sfu"}}]}`, false},
{"host entry with mediaReady", `{"type":"viewer-presence","viewers":[` +
`{"role":"host","peerId":"host_12345678","displayName":"分享者",` +
`"upstream":{"kind":"none"},"mediaReady":true}]}`, false},
} {
assertServerMessage(t, sample.name, []byte(sample.raw), sample.want)
}
}
func TestViewerPresenceConstructors(t *testing.T) {
host := HostPresenceEntry("host_12345678", "分享者")
if host.Upstream != NoUpstream() || host.MediaReady {
t.Fatalf("host presence entry must carry {kind:\"none\"} and no mediaReady: %+v", host)
}
encoded, err := marshalJSON(NewViewerPresenceEntry(
"viewer_12345678", "小明", SfuUpstream(), false))
if err != nil {
t.Fatal(err)
}
if bytes.Contains(encoded, []byte("mediaReady")) {
t.Fatalf("mediaReady must be omitted when false: %s", encoded)
}
encoded, err = marshalJSON(NewViewerPresenceEntry(
"viewer_12345678", "小明", SfuUpstream(), true))
if err != nil {
t.Fatal(err)
}
if !bytes.Contains(encoded, []byte(`"mediaReady":true`)) {
t.Fatalf("mediaReady must be emitted when true: %s", encoded)
}
}
// "accepts only the privacy-safe route snapshot payload" plus the superRefine.
func TestRouteDiagnosticSnapshot(t *testing.T) {
const childOne = `{"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":6000,"freezeWindows":1,` +
`"freezeCount":1,"freezeDurationMs":250,"pauseCount":0,"pauseDurationMs":0}}`
childTwo := func(parent string) string {
return `{"ordinal":2,"parent":` + parent + `,"effectiveCapacity":0,"childCount":0,` +
`"demandAgeMs":90,"queueWaitMs":null,"candidateStartMs":null,` +
`"firstDecodedFrameMs":null,"finalMs":null,"finalRoute":"waiting",` +
`"rejectionBucket":"sfu-admission","quality":null}`
}
snapshot := func(children, operation string) []byte {
return []byte(`{"type":"route-diagnostic-snapshot","snapshot":{"children":` +
children + `,"operation":` + operation + `}}`)
}
const operation = `{"childOrdinal":2,"reason":"join","stage":"admission",` +
`"cursor":1,"candidateCount":2}`
assertServerMessage(t, "full snapshot",
snapshot(`[`+childOne+`,`+childTwo(`{"kind":"viewer","ordinal":1}`)+`]`, operation), true)
assertServerMessage(t, "empty snapshot", snapshot(`[]`, `null`), true)
assertServerMessage(t, "leaked peer id",
[]byte(`{"type":"route-diagnostic-snapshot","snapshot":{"children":[],`+
`"operation":null,"peerId":"viewer_private_12345678"}}`), false)
assertServerMessage(t, "leaked connection id",
snapshot(`[{"ordinal":1,"parent":{"kind":"host"},"effectiveCapacity":2,"childCount":1,`+
`"demandAgeMs":100,"queueWaitMs":10,"candidateStartMs":20,`+
`"firstDecodedFrameMs":80,"finalMs":80,"finalRoute":"direct",`+
`"rejectionBucket":"none","quality":null,`+
`"connectionId":"connection_private_12345678"}]`, `null`), false)
assertServerMessage(t, "negative freeze count",
snapshot(`[{"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":6000,"freezeWindows":1,"freezeCount":-1,`+
`"freezeDurationMs":250,"pauseCount":0,"pauseDurationMs":0}}]`, `null`), false)
assertServerMessage(t, "self parent",
snapshot(`[`+childOne+`,`+childTwo(`{"kind":"viewer","ordinal":2}`)+`]`, `null`), false)
assertServerMessage(t, "unknown parent ordinal",
snapshot(`[`+childOne+`,`+childTwo(`{"kind":"viewer","ordinal":7}`)+`]`, `null`), false)
assertServerMessage(t, "duplicate ordinals",
snapshot(`[`+childOne+`,`+childOne+`]`, `null`), false)
assertServerMessage(t, "operation names an absent child",
snapshot(`[`+childOne+`]`, operation), false)
assertServerMessage(t, "cursor past the candidate count",
snapshot(`[`+childOne+`,`+childTwo(`{"kind":"viewer","ordinal":1}`)+`]`,
`{"childOrdinal":2,"reason":"join","stage":"admission","cursor":2,`+
`"candidateCount":2}`), false)
assertServerMessage(t, "raw rejection bucket on the operation",
snapshot(`[`+childOne+`,`+childTwo(`{"kind":"viewer","ordinal":1}`)+`]`,
`{"childOrdinal":2,"reason":"join","stage":"admission","cursor":1,`+
`"candidateCount":2,"rejectionBucket":"raw-error"}`), false)
assertServerMessage(t, "parent ordinal on a host parent",
snapshot(`[{"ordinal":1,"parent":{"kind":"host","ordinal":1},"effectiveCapacity":2,`+
`"childCount":1,"demandAgeMs":null,"queueWaitMs":null,"candidateStartMs":null,`+
`"firstDecodedFrameMs":null,"finalMs":null,"finalRoute":"direct",`+
`"rejectionBucket":"none","quality":null}]`, `null`), false)
}
// "keeps route messages strict alongside the single authenticated mode" and
// "accepts every bounded hybrid upstream shape".
func TestParticipantRouteAssignment(t *testing.T) {
routeUpdate := func(assignment string) []byte {
return []byte(`{"type":"route-update","revision":9,"phase":"active","assignment":` +
assignment + `}`)
}
for _, sample := range []struct {
name string
assignment string
want bool
}{
{"no upstream", testAssignmentNone, true},
{"peer upstream", `{"upstream":{"kind":"peer","peerId":"parent_12345678"},` +
`"childPeerIds":["child_12345678","child_87654321"],` +
`"sfuPublicationGeneration":null}`, true},
{"sfu upstream", `{"upstream":{"kind":"sfu"},"childPeerIds":[],` +
`"sfuPublicationGeneration":"generation_12345678"}`, true},
{"sfu upstream without a generation", `{"upstream":{"kind":"sfu"},` +
`"childPeerIds":[],"sfuPublicationGeneration":null}`, false},
{"peer upstream owning a generation",
`{"upstream":{"kind":"peer","peerId":"parent_12345678"},"childPeerIds":[],` +
`"sfuPublicationGeneration":"generation_12345678"}`, false},
{"too many children", `{"upstream":{"kind":"none"},"childPeerIds":` +
`["child_12345678","child_87654321","child_third_1234","child_overflow_1"],` +
`"sfuPublicationGeneration":null}`, false},
{"duplicate children", `{"upstream":{"kind":"none"},` +
`"childPeerIds":["child_12345678","child_12345678"],` +
`"sfuPublicationGeneration":null}`, false},
{"absent generation key", `{"upstream":{"kind":"none"},"childPeerIds":[]}`, false},
{"peer id on a none upstream", `{"upstream":{"kind":"none",` +
`"peerId":"parent_12345678"},"childPeerIds":[],` +
`"sfuPublicationGeneration":null}`, false},
} {
assertServerMessage(t, "assignment "+sample.name,
routeUpdate(sample.assignment), sample.want)
}
assertServerMessage(t, "prepare without a candidate",
[]byte(`{"type":"route-update","revision":9,"phase":"prepare","assignment":`+
testAssignmentNone+`}`), false)
assertServerMessage(t, "active with a candidate",
[]byte(`{"type":"route-update","revision":9,"phase":"active","assignment":`+
testAssignmentNone+`,"candidate":{"childPeerId":"child_12345678",`+
`"connectionId":"connection_12345678","transport":"direct","qualityProbe":false}}`),
false)
assertServerMessage(t, "prepare with a room-wide field",
[]byte(`{"type":"route-update","revision":9,"phase":"prepare","assignment":`+
testAssignmentNone+`,"roomAssignments":[]}`), false)
}
// "accepts only bounded connection-attempt progress on a prepared route".
func TestPreparedRouteCandidate(t *testing.T) {
prepared := func(candidate string) []byte {
return []byte(`{"type":"route-update","revision":9,"phase":"prepare","assignment":` +
testAssignmentNone + `,"candidate":` + candidate + `}`)
}
const base = `"childPeerId":"child_12345678","connectionId":"connection_12345678",` +
`"transport":"direct","qualityProbe":false`
for _, sample := range []struct {
attempt string
want bool
}{
{`{"current":1,"total":3}`, true},
{`{"current":2,"total":3}`, true},
{`{"current":3,"total":3}`, true},
{`{"current":0,"total":3}`, false},
{`{"current":4,"total":3}`, false},
{`{"current":1,"total":4}`, true},
{`{"current":4,"total":4}`, true},
{`{"current":5,"total":4}`, false},
{`{"current":1,"total":5}`, false},
{`{"current":1.5,"total":3}`, false},
} {
assertServerMessage(t, "connectionAttempt "+sample.attempt,
prepared(`{`+base+`,"connectionAttempt":`+sample.attempt+`}`), sample.want)
}
assertServerMessage(t, "candidate without an attempt", prepared(`{`+base+`}`), true)
assertServerMessage(t, "candidate with an unknown key",
prepared(`{`+base+`,"unexpected":null}`), false)
assertServerMessage(t, "candidate with a null attempt",
prepared(`{`+base+`,"connectionAttempt":null}`), false)
}
// "accepts only canonical server-derived viewer evidence envelopes" and
// "keeps route messages strict" for sfu-config.
func TestForwardedEvidenceAndSfuConfig(t *testing.T) {
const metrics = `{"natTraversalPath":"ordinary","width":null,"height":null,` +
`"framesPerSecond":null,"bitrateKbps":null,"packetsReceivedDelta":null,` +
`"packetsLostDelta":null,"rttMs":null,"jitterMs":null,"framesDecodedDelta":null,` +
`"framesDroppedDelta":null,"decodeMsPerFrame":null,"freezeCountDelta":null,` +
`"freezeDurationMsDelta":null,"pauseCountDelta":null,"pauseDurationMsDelta":null,` +
`"codec":null,"codecProfile":null,"codecParameters":null,"audioBitrateKbps":null,` +
`"audioPacketLossPercent":null,"audioJitterMs":null,"audioVideoPlayoutDeltaMs":null,` +
`"videoJitterBufferDelayMs":null,"audioJitterBufferDelayMs":null,` +
`"audioConcealedSamplesPercent":null,"audioConcealmentEventsDelta":null,` +
`"audioCodec":null}`
forwarded := func(extra string, upstream string) []byte {
return []byte(`{"type":"viewer-quality-evidence","viewerPeerId":"viewer_12345678",` +
`"upstream":` + upstream + `,"guard":{"connectionId":"connection_12345678",` +
`"routeRevision":0,"presentationEpoch":0},"sequence":0,"windowMs":2000,` +
`"metrics":` + metrics + extra + `}`)
}
assertServerMessage(t, "peer upstream",
forwarded("", `{"kind":"peer","peerId":"host_12345678"}`), true)
assertServerMessage(t, "sfu upstream", forwarded("", `{"kind":"sfu"}`), true)
assertServerMessage(t, "no upstream", forwarded("", `{"kind":"none"}`), false)
assertServerMessage(t, "leaked room id",
forwarded(`,"roomId":"1234"`, `{"kind":"sfu"}`), false)
assertServerMessage(t, "missing upstream",
[]byte(`{"type":"viewer-quality-evidence","viewerPeerId":"viewer_12345678",`+
`"guard":{"connectionId":"connection_12345678","routeRevision":0,`+
`"presentationEpoch":0},"sequence":0,"windowMs":2000,"metrics":`+metrics+`}`), false)
assertServerMessage(t, "sfu config",
[]byte(`{"type":"sfu-config","revision":9,"publicationGeneration":"publication_12345678","connectionId":"connection_12345678"}`), true)
assertServerMessage(t, "sfu config missing connection fence",
[]byte(`{"type":"sfu-config","revision":9,"publicationGeneration":"publication_12345678"}`), false)
}
// zod's z.number().int() accepts an integral JSON number in any spelling.
func TestIntAcceptsIntegralNumberForms(t *testing.T) {
for _, sample := range []struct {
raw string
want bool
}{
{`7`, true}, {`7.0`, true}, {`7e0`, true}, {`1e3`, true},
{`7.5`, false}, {`"7"`, false}, {`true`, false},
} {
assertClientMessage(t, "revision "+sample.raw,
[]byte(`{"type":"route-media-unavailable","revision":`+sample.raw+`}`), sample.want)
}
}
// JSON.parse keeps the last occurrence of a duplicate key.
func TestDuplicateKeysKeepTheLastOccurrence(t *testing.T) {
message, err := DecodeClientMessage(
[]byte(`{"type":"relay-capacity","downstreamEdges":9,"downstreamEdges":2}`))
if err != nil {
t.Fatalf("the last occurrence must win: %v", err)
}
if capacity, ok := message.(RelayCapacityMessage); !ok || capacity.DownstreamEdges != 2 {
t.Fatalf("decoded %#v, want downstreamEdges 2", message)
}
if _, err := DecodeClientMessage(
[]byte(`{"type":"relay-capacity","downstreamEdges":2,"downstreamEdges":9}`)); err == nil {
t.Fatal("the last occurrence must be the one validated")
}
// A duplicated object is replaced, not merged.
if _, err := DecodeClientMessage(
[]byte(`{"type":"set-quality-settings","qualitySettings":{"resolution":"480p"},` +
`"qualitySettings":` + testQualitySettings + `}`)); err != nil {
t.Fatalf("a duplicated object must be replaced wholesale: %v", err)
}
}
// JSON.stringify does not escape "<", ">" or "&"; display names may hold them.
func TestEncodeServerMessageDoesNotEscapeHTML(t *testing.T) {
encoded, err := EncodeServerMessage(ViewerPresenceMessage{
Type: "viewer-presence",
Viewers: []ParticipantPresenceEntry{
HostPresenceEntry("host_12345678", "a<b>&c"),
},
})
if err != nil {
t.Fatal(err)
}
if !bytes.Contains(encoded, []byte(`"displayName":"a<b>&c"`)) {
t.Fatalf("display name must survive unescaped: %s", encoded)
}
if bytes.HasSuffix(encoded, []byte("\n")) {
t.Fatalf("the encoder newline must be dropped: %q", encoded)
}
}
// Empty collections encode as [] the way the TypeScript literals do.
func TestEncodeServerMessageEmitsEmptyArrays(t *testing.T) {
encoded, err := EncodeServerMessage(ViewerPresenceMessage{Type: "viewer-presence"})
if err != nil {
t.Fatal(err)
}
if string(encoded) != `{"type":"viewer-presence","viewers":[]}` {
t.Fatalf("got %s", encoded)
}
encoded, err = EncodeServerMessage(RouteDiagnosticSnapshotMessage{
Type: "route-diagnostic-snapshot"})
if err != nil {
t.Fatal(err)
}
if string(encoded) !=
`{"type":"route-diagnostic-snapshot","snapshot":{"children":[],"operation":null}}` {
t.Fatalf("got %s", encoded)
}
}
// The authenticated key order follows the object literal in signaling.ts.
func TestAuthenticatedKeyOrder(t *testing.T) {
paused := true
encoded, err := EncodeServerMessage(AuthenticatedViewerMessage{
Type: "authenticated", Protocol: SignalingProtocol, PeerID: "viewer_12345678",
MaxViewers: 8, EndpointMediaCopyCapacity: 2, HostOnline: true, HostPaused: &paused,
IceConfig: IceConfig{}, RoutePolicy: DefaultRoutePolicy, CodeEntryPolicy: CodeEntryOpen,
ViewerAuthorizationGeneration: "viewer_generation_12345678",
MediaMode: "peer-assisted", RouteRevision: 0,
QualitySettings: DefaultQualitySettings, Role: RoleViewer,
})
if err != nil {
t.Fatal(err)
}
var order []string
decoder := json.NewDecoder(bytes.NewReader(encoded))
if _, err := decoder.Token(); err != nil {
t.Fatal(err)
}
for decoder.More() {
key, err := decoder.Token()
if err != nil {
t.Fatal(err)
}
order = append(order, key.(string))
var skip json.RawMessage
if err := decoder.Decode(&skip); err != nil {
t.Fatal(err)
}
}
want := []string{
"type", "protocol", "peerId", "maxViewers",
"endpointMediaCopyCapacity", "hostOnline", "hostPaused", "connectionId",
"iceConfig", "routePolicy", "codeEntryPolicy", "viewerAuthorizationGeneration",
"mediaMode", "shareGeneration", "routeRevision", "routeAssignment",
"qualitySettings", "role",
}
if strings.Join(order, ",") != strings.Join(want, ",") {
t.Fatalf("key order\n got: %v\nwant: %v", order, want)
}
}
// Optional keys reject an explicit null; nullable keys reject absence.
func TestOptionalAndNullableAreExact(t *testing.T) {
for _, sample := range []struct {
name string
raw string
want bool
}{
{"null optional shareGeneration",
`{"type":"stop-sharing","shareGeneration":null}`, false},
{"absent optional shareGeneration", `{"type":"stop-sharing"}`, true},
{"null optional targetPeerId",
`{"type":"restart-request","targetPeerId":null,` +
`"connectionId":"connection_12345678","rebuild":true}`, false},
{"null optional qualityApproved",
`{"type":"route-ready","revision":1,"phase":"prepare","qualityApproved":null}`, false},
{"null nullable connectionId",
`{"type":"route-failed","revision":1,"phase":"active","connectionId":null}`, true},
{"absent nullable connectionId",
`{"type":"route-failed","revision":1,"phase":"active"}`, false},
} {
assertClientMessage(t, sample.name, []byte(sample.raw), sample.want)
}
}
// A host authenticate without routePolicy takes DEFAULT_ROUTE_POLICY.
func TestAuthenticateConnectionProgressOptIn(t *testing.T) {
for _, role := range []string{"host", "viewer"} {
base := `"type":"authenticate","protocol":"` + SignalingProtocol + `","roomId":"1234","clientId":"client_12345678","role":"` + role + `"`
if role == "host" {
base += `,"token":"` + repeat("a", 43) + `"`
}
for _, value := range []string{"true", "false", "null", "4", `"true"`} {
assertClientMessage(t, role+value, []byte(`{`+base+`,"connectionAttemptProgress4":`+value+`}`), value == "true")
}
assertClientMessage(t, role+" baseline", []byte(`{`+base+`}`), true)
}
}
func TestAuthenticateAppliesTheRoutePolicyDefault(t *testing.T) {
message, err := DecodeClientMessage([]byte(
`{"type":"authenticate","protocol":"piik-v23","roomId":"1234","role":"host",` +
`"token":"` + repeat("a", 43) + `","clientId":"client_12345678"}`))
if err != nil {
t.Fatal(err)
}
host, ok := message.(AuthenticateHostMessage)
if !ok {
t.Fatalf("decoded %#v, want AuthenticateHostMessage", message)
}
if host.RoutePolicy != DefaultRoutePolicy {
t.Fatalf("routePolicy = %+v, want %+v", host.RoutePolicy, DefaultRoutePolicy)
}
}
func TestAuthenticateAcceptsPersistentRoomSessionOptIn(t *testing.T) {
message, err := DecodeClientMessage([]byte(
`{"type":"authenticate","protocol":"piik-v23","roomId":"1234","role":"host",` +
`"token":"` + repeat("a", 43) + `","clientId":"client_12345678","roomSession":true,"roomOnly":true}`))
if err != nil {
t.Fatal(err)
}
host, ok := message.(AuthenticateHostMessage)
if !ok || !host.RoomSession || !host.RoomOnly {
t.Fatalf("decoded %#v, want room-session opt-in and room-only state", message)
}
if _, err := DecodeClientMessage([]byte(
`{"type":"authenticate","protocol":"piik-v23","roomId":"1234","role":"host",` +
`"token":"` + repeat("a", 43) + `","clientId":"client_12345678","roomOnly":true}`)); err == nil {
t.Fatal("accepted roomOnly without roomSession opt-in")
}
}
func TestStartSharingRequiresAnOpaqueGenerationAndRoutePolicy(t *testing.T) {
message, err := DecodeClientMessage([]byte(
`{"type":"start-sharing","shareGeneration":"share_12345678",` +
`"routePolicy":{"peerOnly":true,"topologyOptimization":false,"natPrediction":false}}`))
if err != nil {
t.Fatal(err)
}
if _, ok := message.(StartSharingMessage); !ok {
t.Fatalf("decoded %#v, want StartSharingMessage", message)
}
for _, raw := range []string{
`{"type":"start-sharing","shareGeneration":"short","routePolicy":{"peerOnly":true,"topologyOptimization":false,"natPrediction":false}}`,
`{"type":"start-sharing","shareGeneration":"share_12345678"}`,
} {
if _, err := DecodeClientMessage([]byte(raw)); err == nil {
t.Errorf("accepted invalid start-sharing message %s", raw)
}
}
}
// The sealed unions accept nothing outside their own message structs.
func TestDecodeRejectsUnknownEnvelopes(t *testing.T) {
for _, raw := range []string{`{}`, `[]`, `null`, `"authenticate"`, `{"type":42}`,
`{"type":"unknown"}`, `{"kind":"signal"}`} {
if _, err := DecodeClientMessage([]byte(raw)); err == nil {
t.Errorf("client decode accepted %s", raw)
}
if _, err := DecodeServerMessage([]byte(raw)); err == nil {
t.Errorf("server decode accepted %s", raw)
}
}
}
Reference in new issue View Git Blame Copy Permalink