Files
marqdo/plugins/web/internal/ws/route_test.go
cflmyandCursor 86b183e2d7 fix(web): harden WebSocket and net host boundaries
- WS handshake: same-origin CheckOrigin instead of allow-all
- route_ws require_auth/需要登录: broadcast/room need a session by default,
  explicit opt-out for public feeds; unauthenticated handshakes get 401
- WS limits: 1 MiB per message, 256 replies per connect; transport errors
  return {ok:false, error} instead of an empty success; empty rooms GC'd
- net host: enforce the 8 MiB response cap while reading (incl. error and
  SSE error paths) so a peer cannot exhaust memory
- url_encode: %20 for space (URL segment semantics, not form +)
- docs: sync 网页 (route_ws 需要登录, connect caps) and CHANGELOG
- tests: gold expectations, live fixture opt-out, hub GC, ws auth gate

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-09-22 15:14:35 +08:00

174 lines
4.0 KiB
Go

package ws_test
import (
"strings"
"testing"
"github.com/marqdo/marqdo/plugins/web/internal/app"
"github.com/marqdo/marqdo/plugins/web/internal/ws"
)
func TestRouteWSBroadcastMode(t *testing.T) {
a := app.New(map[string]any{"page": map[string]any{"title": "w6b"}})
out, err := ws.RouteWS(a, "/room", map[string]any{"mode": "broadcast"})
if err != nil {
t.Fatal(err)
}
mode, err := ws.ModeOf(out, "/room")
if err != nil {
t.Fatal(err)
}
if mode != ws.ModeBroadcast {
t.Fatalf("mode=%q want broadcast", mode)
}
routes := out["ws_routes"].(map[string]any)
room := routes["/room"].(map[string]any)
if room["mode"] != "broadcast" {
t.Fatalf("bag mode=%v", room["mode"])
}
if room["require_auth"] != true {
t.Fatalf("broadcast must require authentication by default: %v", room)
}
}
func TestRouteWSPublicBroadcastOptOut(t *testing.T) {
a := app.New(nil)
out, err := ws.RouteWS(a, "/live", map[string]any{
"mode": "broadcast",
"require_auth": false,
})
if err != nil {
t.Fatal(err)
}
spec, err := ws.RouteSpecOf(out, "/live")
if err != nil {
t.Fatal(err)
}
if spec.RequireAuth {
t.Fatalf("explicit public route unexpectedly requires authentication: %+v", spec)
}
}
func TestRouteWSEchoDefault(t *testing.T) {
a := app.New(nil)
out, err := ws.RouteWS(a, "/live", map[string]any{"echo": true})
if err != nil {
t.Fatal(err)
}
mode, err := ws.ModeOf(out, "/live")
if err != nil {
t.Fatal(err)
}
if mode != ws.ModeEcho {
t.Fatalf("mode=%q want echo", mode)
}
}
func TestRouteWSDrainFromEchoFalse(t *testing.T) {
a := app.New(nil)
out, err := ws.RouteWS(a, "/sink", map[string]any{"echo": false})
if err != nil {
t.Fatal(err)
}
mode, err := ws.ModeOf(out, "/sink")
if err != nil {
t.Fatal(err)
}
if mode != ws.ModeDrain {
t.Fatalf("mode=%q want drain", mode)
}
}
func TestParseModeVariants(t *testing.T) {
cases := []struct {
in any
want ws.Mode
}{
{true, ws.ModeEcho},
{false, ws.ModeDrain},
{"broadcast", ws.ModeBroadcast},
{"广播", ws.ModeBroadcast},
{"drain", ws.ModeDrain},
{"room", ws.ModeRoom},
{"房间", ws.ModeRoom},
{"nope", ws.ModeEcho},
}
for _, c := range cases {
if got := ws.ParseMode(c.in); got != c.want {
t.Fatalf("ParseMode(%#v)=%q want %q", c.in, got, c.want)
}
}
}
func TestRouteWSRoomModeWithKey(t *testing.T) {
a := app.New(nil)
out, err := ws.RouteWS(a, "/chat", map[string]any{
"mode": "room",
"room_key": "chat.room.{id}",
})
if err != nil {
t.Fatal(err)
}
spec, err := ws.RouteSpecOf(out, "/chat")
if err != nil {
t.Fatal(err)
}
if spec.Mode != ws.ModeRoom {
t.Fatalf("mode=%q want room", spec.Mode)
}
if spec.RoomKey != "chat.room.{id}" {
t.Fatalf("room_key=%q", spec.RoomKey)
}
routes := out["ws_routes"].(map[string]any)
room := routes["/chat"].(map[string]any)
if room["mode"] != "room" || room["room_key"] != "chat.room.{id}" {
t.Fatalf("bag=%v", room)
}
}
func TestRouteWSRoomRequiresKey(t *testing.T) {
a := app.New(nil)
_, err := ws.RouteWS(a, "/chat", map[string]any{"mode": "room"})
if err == nil {
t.Fatal("expected error without room_key")
}
}
func TestExpandTemplate(t *testing.T) {
got := ws.ExpandTemplate("chat.room.{id}", map[string]string{"id": "lobby"})
if got != "chat.room.lobby" {
t.Fatalf("got %q", got)
}
}
func TestRouteWSOnMessageAndPresence(t *testing.T) {
a := app.New(nil)
out, err := ws.RouteWS(a, "/chat/{id}", map[string]any{
"mode": "room",
"room_key": "chat.room.{id}",
"on_message": "chat.persist",
"presence": true,
})
if err != nil {
t.Fatal(err)
}
spec, err := ws.RouteSpecOf(out, "/chat/{id}")
if err != nil {
t.Fatal(err)
}
if spec.OnMessage != "chat.persist" || !spec.Presence {
t.Fatalf("spec=%+v", spec)
}
}
func TestConnectRefusesBadURL(t *testing.T) {
out := ws.Connect("http://127.0.0.1:1", "hi", nil, 1)
if out["ok"] == true {
t.Fatal("expected ok=false for http url")
}
err, _ := out["error"].(string)
if err == "" || !strings.Contains(err, "ws://") {
t.Fatalf("error=%q", err)
}
}