- 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>
174 lines
4.0 KiB
Go
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)
|
|
}
|
|
}
|