111 lines
3.3 KiB
Go
111 lines
3.3 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"github.com/coder/websocket"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func readV2(t *testing.T, ws *websocket.Conn) map[string]any {
|
|
t.Helper()
|
|
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
|
|
defer cancel()
|
|
_, data, err := ws.Read(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var result map[string]any
|
|
if json.Unmarshal(data, &result) != nil {
|
|
t.Fatal("invalid json")
|
|
}
|
|
return result
|
|
}
|
|
func TestV2SignalRoleScopeAndPayloadRejection(t *testing.T) {
|
|
b, base := testServer(t)
|
|
b.cluster = &cluster{secret: strings.Repeat("s", 32), config: clusterConfig{Nodes: []NodeConfig{{ID: "n", URL: "ws://127.0.0.1:1"}}, ICEServers: []string{}, P2PTimeoutMS: 1000}, health: map[string]nodeHealth{}}
|
|
for _, path := range []string{"/v2/nodes", "/v2/connect"} {
|
|
if got := status(t, base, path, testAgentToken); got != 401 {
|
|
t.Fatal(got)
|
|
}
|
|
}
|
|
if got := status(t, base, "/v2/signal", testClientToken); got != 401 {
|
|
t.Fatal(got)
|
|
}
|
|
agent := dialTest(t, base, "/v1/agent?device=phone&v=2", testAgentToken)
|
|
readV2(t, agent)
|
|
owner := dialTest(t, base, "/v1/lease?device=phone&v=2", testClientToken)
|
|
lease := readV2(t, owner)
|
|
if lease["protocol"] != float64(2) {
|
|
t.Fatal(lease)
|
|
}
|
|
client := dialTest(t, base, "/v2/connect?device=phone&lease="+lease["lease"].(string), testClientToken)
|
|
manifest := readV2(t, client)
|
|
open := readV2(t, agent)
|
|
if manifest["protocol"] != float64(2) || open["type"] != "open_v2" {
|
|
t.Fatal(manifest, open)
|
|
}
|
|
if got := status(t, base, "/v2/signal?session="+open["session"].(string)+"&key=wrong", testAgentToken); got != 404 {
|
|
t.Fatal(got)
|
|
}
|
|
signal := dialTest(t, base, "/v2/signal?session="+open["session"].(string)+"&key="+open["signal_key"].(string), testAgentToken)
|
|
readV2(t, signal)
|
|
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
|
|
defer cancel()
|
|
if err := client.Write(ctx, websocket.MessageText, []byte(`{"type":"offer","sdp":"test"}`)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if readV2(t, signal)["sdp"] != "test" {
|
|
t.Fatal("signal not forwarded")
|
|
}
|
|
if err := client.Write(ctx, websocket.MessageBinary, []byte("adb-payload")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, _, err := signal.Read(ctx); err == nil {
|
|
t.Fatal("controller accepted binary data")
|
|
}
|
|
}
|
|
func TestSignalBridgeRejectsUnknownMessages(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
b := newBroker(ctx, testAgentToken, testClientToken)
|
|
b.cluster = &cluster{}
|
|
mux := http.NewServeMux()
|
|
var first *websocket.Conn
|
|
ready := make(chan struct{})
|
|
mux.HandleFunc("/first", func(w http.ResponseWriter, r *http.Request) {
|
|
a, e := accept(w, r)
|
|
if e != nil {
|
|
return
|
|
}
|
|
defer a.CloseNow()
|
|
first = a
|
|
close(ready)
|
|
<-ctx.Done()
|
|
})
|
|
mux.HandleFunc("/second", func(w http.ResponseWriter, r *http.Request) {
|
|
a, e := accept(w, r)
|
|
if e != nil {
|
|
return
|
|
}
|
|
defer a.CloseNow()
|
|
<-ready
|
|
b.bridgeSignals(ctx, first, a)
|
|
})
|
|
srv := httptest.NewServer(mux)
|
|
defer srv.Close()
|
|
a := dialTest(t, srv.URL, "/first", testClientToken)
|
|
z := dialTest(t, srv.URL, "/second", testClientToken)
|
|
deadline, stop := context.WithTimeout(ctx, time.Second)
|
|
defer stop()
|
|
a.Write(deadline, websocket.MessageText, []byte(`{"type":"arbitrary"}`))
|
|
if _, _, err := z.Read(deadline); err == nil {
|
|
t.Fatal("unknown signal accepted")
|
|
}
|
|
cancel()
|
|
}
|