add backwards compatibility and test

mafredri · mafredri · commit bc076072c77b · 2025-09-04T15:35:30.000+03:00
diff --git a/conn_test.go b/conn_test.go
@@ -421,6 +421,25 @@ func TestConn(t *testing.T) {
 		err = c1.Close(websocket.StatusNormalClosure, "")
 		assert.Success(t, err)
 	})
+
+	t.Run("ReadLimitExceededReturnsErrMessageTooBig", func(t *testing.T) {
+		tt, c1, c2 := newConnTest(t, nil, nil)
+
+		c1.SetReadLimit(1024)
+		_ = c2.CloseRead(tt.ctx)
+
+		writeDone := xsync.Go(func() error {
+			payload := strings.Repeat("x", 4096)
+			return c2.Write(tt.ctx, websocket.MessageText, []byte(payload))
+		})
+
+		_, _, err := c1.Read(tt.ctx)
+		assert.ErrorIs(t, websocket.ErrMessageTooBig, err)
+		assert.Contains(t, err, "read limited at 1025 bytes")
+
+		_ = c2.CloseNow()
+		<-writeDone
+	})
 }
 
 func TestWasm(t *testing.T) {
diff --git a/errors.go b/errors.go
@@ -0,0 +1,8 @@
+package websocket
+
+import (
+	"errors"
+)
+
+// ErrMessageTooBig is returned when a message exceeds the read limit.
+var ErrMessageTooBig = errors.New("websocket: message too big")
diff --git a/read.go b/read.go
@@ -17,8 +17,6 @@ import (
 	"github.com/coder/websocket/internal/util"
 )
 
-var ErrMessageTooBig = errors.New("websocket: message too big")
-
 // Reader reads from the connection until there is a WebSocket
 // data message to be read. It will handle ping, pong and close frames as appropriate.
 //
@@ -92,7 +90,8 @@ func (c *Conn) CloseRead(ctx context.Context) context.Context {
 //
 // By default, the connection has a message read limit of 32768 bytes.
 //
-// When the limit is hit, the connection will be closed with StatusMessageTooBig.
+// When the limit is hit, reads return an error wrapping ErrMessageTooBig and
+// the connection is closed with StatusMessageTooBig.
 //
 // Set to -1 to disable.
 func (c *Conn) SetReadLimit(n int64) {
@@ -522,9 +521,9 @@ func (lr *limitReader) Read(p []byte) (int, error) {
 	}
 
 	if lr.n == 0 {
-		err := fmt.Errorf("%w: %d bytes", ErrMessageTooBig, lr.limit.Load())
-		lr.c.writeError(StatusMessageTooBig, err)
-		return 0, err
+		reason := fmt.Errorf("read limited at %d bytes", lr.limit.Load())
+		lr.c.writeError(StatusMessageTooBig, reason)
+		return 0, fmt.Errorf("%w: %v", ErrMessageTooBig, reason)
 	}
 
 	if int64(len(p)) > lr.n {
diff --git a/ws_js.go b/ws_js.go
@@ -19,8 +19,6 @@ import (
 	"github.com/coder/websocket/internal/wsjs"
 )
 
-var ErrMessageTooBig = errors.New("websocket: message too big")
-
 // opcode represents a WebSocket opcode.
 type opcode int
 
@@ -146,9 +144,9 @@ func (c *Conn) Read(ctx context.Context) (MessageType, []byte, error) {
 	}
 	readLimit := c.msgReadLimit.Load()
 	if readLimit >= 0 && int64(len(p)) > readLimit {
-		err := fmt.Errorf("%w: %d bytes", ErrMessageTooBig, c.msgReadLimit.Load())
-		c.Close(StatusMessageTooBig, err.Error())
-		return 0, nil, err
+		reason := fmt.Errorf("read limited at %d bytes", c.msgReadLimit.Load())
+		c.Close(StatusMessageTooBig, reason.Error())
+		return 0, nil, fmt.Errorf("%w: %v", ErrMessageTooBig, reason)
 	}
 	return typ, p, nil
 }

Original file line number	Diff line number	Diff line change
`@@ -19,8 +19,6 @@ import (`
`19`	`19`	`"github.com/coder/websocket/internal/wsjs"`
`20`	`20`	`)`
`21`	`21`
`22`		`-var ErrMessageTooBig = errors.New("websocket: message too big")`
`23`		`-`
`24`	`22`	`// opcode represents a WebSocket opcode.`
`25`	`23`	`type opcode int`
`26`	`24`
`@@ -146,9 +144,9 @@ func (c *Conn) Read(ctx context.Context) (MessageType, []byte, error) {`
`146`	`144`	`}`
`147`	`145`	`readLimit := c.msgReadLimit.Load()`
`148`	`146`	`if readLimit >= 0 && int64(len(p)) > readLimit {`
`149`		`- err := fmt.Errorf("%w: %d bytes", ErrMessageTooBig, c.msgReadLimit.Load())`
`150`		`- c.Close(StatusMessageTooBig, err.Error())`
`151`		`- return 0, nil, err`
	`147`	`+ reason := fmt.Errorf("read limited at %d bytes", c.msgReadLimit.Load())`
	`148`	`+ c.Close(StatusMessageTooBig, reason.Error())`
	`149`	`+ return 0, nil, fmt.Errorf("%w: %v", ErrMessageTooBig, reason)`
`152`	`150`	`}`
`153`	`151`	`return typ, p, nil`
`154`	`152`	`}`