package agentwire import ( "bytes" "context" "errors" "net/http" "net/http/httptest" "strings" "sync" "sync/atomic" "testing" "time" "github.com/coder/websocket" ) func TestNegotiationFallbackAndBackgroundPong_HP_CHUNK_02(t *testing.T) { t.Parallel() for _, scenario := range []struct { name string server, client bool }{ {"both", true, true}, {"old server", false, true}, {"old client", true, false}, } { t.Run(scenario.name, func(t *testing.T) { t.Parallel() ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() payload := bytes.Repeat([]byte{0x53}, 64<<10) pong := make(chan error, 1) var activity atomic.Uint32 server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { options := &websocket.AcceptOptions{} if scenario.server { options.Subprotocols = []string{Subprotocol} } raw, err := websocket.Accept(w, r, options) if err != nil { pong <- err return } connection, err := Wrap(raw, 1<<20, func() { activity.Add(1) }) if err != nil { _ = raw.CloseNow() pong <- err return } defer connection.CloseNow() _, got, err := connection.Read(ctx) if err == nil && !bytes.Equal(got, payload) { err = errors.New("payload changed") } if err == nil { err = connection.Write(ctx, websocket.MessageBinary, got) } if err == nil { err = connection.Ping(ctx) } pong <- err _, _, _ = connection.Read(ctx) })) defer server.Close() options := &websocket.DialOptions{HTTPClient: server.Client()} if scenario.client { options.Subprotocols = []string{Subprotocol} } raw, _, err := websocket.Dial(ctx, "wss"+strings.TrimPrefix(server.URL, "https"), options) if err != nil { t.Fatal(err) } connection, err := Wrap(raw, 1<<20, nil) if err != nil { _ = raw.CloseNow() t.Fatal(err) } defer connection.Close(websocket.StatusNormalClosure, "") if connection.chunked != (scenario.client && scenario.server) { t.Fatal("wrong negotiated mode") } if err := connection.Write(ctx, websocket.MessageBinary, payload); err != nil { t.Fatal(err) } // Do not call Read yet: the read pump must still service Ping while // the echoed complete message waits for the application. select { case err := <-pong: if err != nil { t.Fatal(err) } case <-ctx.Done(): t.Fatal("Ping blocked behind application read") } _, got, err := connection.Read(ctx) if err != nil || !bytes.Equal(got, payload) { t.Fatalf("echo bytes=%d error=%v", len(got), err) } if connection.chunked && activity.Load() <= 1 { t.Fatal("large message was not chunked") } }) } } func TestConcurrentLogicalWrites_RACE_CHUNK_01(t *testing.T) { t.Parallel() ctx, cancel := context.WithTimeout(context.Background(), 8*time.Second) defer cancel() result := make(chan error, 1) server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { raw, err := websocket.Accept(w, r, &websocket.AcceptOptions{Subprotocols: []string{Subprotocol}}) if err != nil { result <- err return } connection, err := Wrap(raw, 1<<20, nil) if err != nil { _ = raw.CloseNow() result <- err return } defer connection.CloseNow() seen := map[byte]bool{} for len(seen) < 8 { _, payload, err := connection.Read(ctx) if err != nil { result <- err return } if len(payload) != 128<<10 || seen[payload[0]] || !bytes.Equal(payload, bytes.Repeat(payload[:1], len(payload))) { result <- errors.New("concurrent messages interleaved or duplicated") return } seen[payload[0]] = true } result <- nil })) defer server.Close() raw, _, err := websocket.Dial(ctx, "wss"+strings.TrimPrefix(server.URL, "https"), &websocket.DialOptions{HTTPClient: server.Client(), Subprotocols: []string{Subprotocol}}) if err != nil { t.Fatal(err) } connection, err := Wrap(raw, 1<<20, nil) if err != nil { t.Fatal(err) } defer connection.CloseNow() var workers sync.WaitGroup for i := byte(0); i < 8; i++ { workers.Go(func() { if err := connection.Write(ctx, websocket.MessageBinary, bytes.Repeat([]byte{i}, 128<<10)); err != nil { t.Error(err) } }) } workers.Wait() select { case err := <-result: if err != nil { t.Fatal(err) } case <-ctx.Done(): t.Fatal("concurrent write test stalled") } } func TestInterruptedPacketNeverDelivered_REC_CHUNK_02(t *testing.T) { t.Parallel() ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() result := make(chan incoming, 2) server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { raw, err := websocket.Accept(w, r, &websocket.AcceptOptions{Subprotocols: []string{Subprotocol}}) if err != nil { result <- incoming{err: err} return } connection, err := Wrap(raw, 1<<20, nil) if err != nil { _ = raw.CloseNow() result <- incoming{err: err} return } defer connection.CloseNow() _, payload, err := connection.Read(ctx) result <- incoming{payload: payload, err: err} })) defer server.Close() connect := func() *websocket.Conn { t.Helper() connection, _, err := websocket.Dial(ctx, "wss"+strings.TrimPrefix(server.URL, "https"), &websocket.DialOptions{HTTPClient: server.Client(), Subprotocols: []string{Subprotocol}}) if err != nil { t.Fatal(err) } return connection } payload := bytes.Repeat([]byte{0x55}, 64<<10) first := connect() if err := first.Write(ctx, websocket.MessageBinary, packets(t, payload, false)[0]); err != nil { t.Fatal(err) } _ = first.CloseNow() if got := <-result; got.err == nil || got.payload != nil { t.Fatal("partial message delivered") } second := connect() defer second.CloseNow() for _, packet := range packets(t, payload, false) { if err := second.Write(ctx, websocket.MessageBinary, packet); err != nil { t.Fatal(err) } } if got := <-result; got.err != nil || !bytes.Equal(got.payload, payload) { t.Fatalf("replay: %v", got.err) } }