Remove use of math/rand.Init

Author: nhooyr

assert_test.go

@@ -2,38 +2,31 @@ package websocket_test
 
 import (
 	"context"
-	"math/rand"
+	"crypto/rand"
+	"io"
 	"strings"
 	"testing"
-	"time"
 
 	"nhooyr.io/websocket"
 	"nhooyr.io/websocket/internal/assert"
 	"nhooyr.io/websocket/wsjson"
 )
 
-func init() {
-	rand.Seed(time.Now().UnixNano())
-}
-
-func randBytes(n int) []byte {
+func randBytes(t *testing.T, n int) []byte {
 	b := make([]byte, n)
-	rand.Read(b)
+	_, err := io.ReadFull(rand.Reader, b)
+	assert.Success(t, err)
 	return b
 }
 
 func assertJSONEcho(t *testing.T, ctx context.Context, c *websocket.Conn, n int) {
 	t.Helper()
 
-	exp := randString(n)
+	exp := randString(t, n)
 	err := wsjson.Write(ctx, c, exp)
 	assert.Success(t, err)
 
-	var act interface{}
-	err = wsjson.Read(ctx, c, &act)
-	assert.Success(t, err)
-
-	assert.Equal(t, exp, act, "unexpected JSON")
+	assertJSONRead(t, ctx, c, exp)
 }
 
 func assertJSONRead(t *testing.T, ctx context.Context, c *websocket.Conn, exp interface{}) {
@@ -43,11 +36,11 @@ func assertJSONRead(t *testing.T, ctx context.Context, c *websocket.Conn, exp in
 	err := wsjson.Read(ctx, c, &act)
 	assert.Success(t, err)
 
-	assert.Equal(t, exp, act, "unexpected JSON")
+	assert.Equal(t, exp, act, "JSON")
 }
 
-func randString(n int) string {
-	s := strings.ToValidUTF8(string(randBytes(n)), "_")
+func randString(t *testing.T, n int) string {
+	s := strings.ToValidUTF8(string(randBytes(t, n)), "_")
 	if len(s) > n {
 		return s[:n]
 	}
@@ -62,25 +55,24 @@ func randString(n int) string {
 func assertEcho(t *testing.T, ctx context.Context, c *websocket.Conn, typ websocket.MessageType, n int) {
 	t.Helper()
 
-	p := randBytes(n)
+	p := randBytes(t, n)
 	err := c.Write(ctx, typ, p)
 	assert.Success(t, err)
 
 	typ2, p2, err := c.Read(ctx)
 	assert.Success(t, err)
 
-	assert.Equal(t, typ, typ2, "unexpected data type")
-	assert.Equal(t, p, p2, "unexpected payload")
+	assert.Equal(t, typ, typ2, "data type")
+	assert.Equal(t, p, p2, "payload")
 }
 
 func assertSubprotocol(t *testing.T, c *websocket.Conn, exp string) {
 	t.Helper()
 
-	assert.Equal(t, exp, c.Subprotocol(), "unexpected subprotocol")
+	assert.Equal(t, exp, c.Subprotocol(), "subprotocol")
 }
 
 func assertCloseStatus(t *testing.T, exp websocket.StatusCode, err error) {
 	t.Helper()
-
-	assert.Equal(t, exp, websocket.CloseStatus(err), "unexpected status code")
+	assert.Equal(t, exp, websocket.CloseStatus(err), "StatusCode")
 }

close.go

@@ -15,11 +15,13 @@ import (
 // https://tools.ietf.org/html/rfc6455#section-7.4
 type StatusCode int
 
-// These codes were retrieved from:
 // https://www.iana.org/assignments/websocket/websocket.xhtml#close-code-number
 //
-// The defined constants only represent the status codes registered with IANA.
-// The 4000-4999 range of status codes is reserved for arbitrary use by applications.
+// These are only the status codes defined by the protocol.
+//
+// You can define custom codes in the 3000-4999 range.
+// The 3000-3999 range is reserved for use by libraries, frameworks and applications.
+// The 4000-4999 range is reserved for private use.
 const (
 	StatusNormalClosure   StatusCode = 1000
 	StatusGoingAway       StatusCode = 1001
@@ -31,11 +33,12 @@ const (
 
 	// StatusNoStatusRcvd cannot be sent in a close message.
 	// It is reserved for when a close message is received without
-	// an explicit status.
+	// a status code.
 	StatusNoStatusRcvd StatusCode = 1005
 
-	// StatusAbnormalClosure is only exported for use with Wasm.
-	// In non Wasm Go, the returned error will indicate whether the connection was closed or not or what happened.
+	// StatusAbnormalClosure is exported for use only with Wasm.
+	// In non Wasm Go, the returned error will indicate whether the
+	// connection was closed abnormally.
 	StatusAbnormalClosure StatusCode = 1006
 
 	StatusInvalidFramePayloadData StatusCode = 1007
@@ -48,15 +51,15 @@ const (
 	StatusBadGateway              StatusCode = 1014
 
 	// StatusTLSHandshake is only exported for use with Wasm.
-	// In non Wasm Go, the returned error will indicate whether there was a TLS handshake failure.
+	// In non Wasm Go, the returned error will indicate whether there was
+	// a TLS handshake failure.
 	StatusTLSHandshake StatusCode = 1015
 )
 
-// CloseError represents a WebSocket close frame.
-// It is returned by Conn's methods when a WebSocket close frame is received from
-// the peer.
-// You will need to use the https://golang.org/pkg/errors/#As function, new in Go 1.13,
-// to check for this error. See the CloseError example.
+// CloseError is returned when the connection is closed with a status and reason.
+//
+// Use Go 1.13's errors.As to check for this error.
+// Also see the CloseStatus helper.
 type CloseError struct {
 	Code   StatusCode
 	Reason string
@@ -66,9 +69,10 @@ func (ce CloseError) Error() string {
 	return fmt.Sprintf("status = %v and reason = %q", ce.Code, ce.Reason)
 }
 
-// CloseStatus is a convenience wrapper around errors.As to grab
-// the status code from a *CloseError. If the passed error is nil
-// or not a *CloseError, the returned StatusCode will be -1.
+// CloseStatus is a convenience wrapper around Go 1.13's errors.As to grab
+// the status code from a CloseError.
+//
+// -1 will be returned if the passed error is nil or not a CloseError.
 func CloseStatus(err error) StatusCode {
 	var ce CloseError
 	if errors.As(err, &ce) {
@@ -77,19 +81,16 @@ func CloseStatus(err error) StatusCode {
 	return -1
 }
 
-// Close closes the WebSocket connection with the given status code and reason.
+// Close performs the WebSocket close handshake with the given status code and reason.
 //
 // It will write a WebSocket close frame with a timeout of 5s and then wait 5s for
 // the peer to send a close frame.
-// Thus, it implements the full WebSocket close handshake.
-// All data messages received from the peer during the close handshake
-// will be discarded.
+// All data messages received from the peer during the close handshake will be discarded.
 //
 // The connection can only be closed once. Additional calls to Close
 // are no-ops.
 //
-// The maximum length of reason must be 125 bytes otherwise an internal
-// error will be sent to the peer. For this reason, you should avoid
+// The maximum length of reason must be 125 bytes. Avoid
 // sending a dynamic reason.
 //
 // Close will unblock all goroutines interacting with the connection once

close_test.go

@@ -6,8 +6,6 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/google/go-cmp/cmp"
-
 	"nhooyr.io/websocket/internal/assert"
 )
 
@@ -51,8 +49,10 @@ func TestCloseError(t *testing.T) {
 			t.Parallel()
 
 			_, err := tc.ce.bytesErr()
-			if (err == nil) != tc.success {
-				t.Fatalf("unexpected error value: %+v", err)
+			if (tc.success) {
+				assert.Success(t, err)
+			} else {
+				assert.Error(t, err)
 			}
 		})
 	}
@@ -101,12 +101,11 @@ func Test_parseClosePayload(t *testing.T) {
 			t.Parallel()
 
 			ce, err := parseClosePayload(tc.p)
-			if (err == nil) != tc.success {
-				t.Fatalf("unexpected expected error value: %+v", err)
-			}
-
-			if tc.success && tc.ce != ce {
-				t.Fatalf("unexpected close error: %v", cmp.Diff(tc.ce, ce))
+			if (tc.success) {
+				assert.Success(t, err)
+				assert.Equal(t, tc.ce, ce, "CloseError")
+			} else {
+				assert.Error(t, err)
 			}
 		})
 	}
@@ -152,9 +151,7 @@ func Test_validWireCloseCode(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 
-			if valid := validWireCloseCode(tc.code); tc.valid != valid {
-				t.Fatalf("expected %v for %v but got %v", tc.valid, tc.code, valid)
-			}
+			assert.Equal(t, tc.code, validWireCloseCode(tc.code), "validWireCloseCode")
 		})
 	}
 }
@@ -191,7 +188,7 @@ func TestCloseStatus(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 
-			assert.Equal(t, tc.exp, CloseStatus(tc.in), "unexpected close status")
+			assert.Equal(t, tc.exp, CloseStatus(tc.in), "CloseStatus")
 		})
 	}
 }

doc.go

@@ -4,51 +4,26 @@
 //
 // https://tools.ietf.org/html/rfc6455
 //
-// Conn, Dial, and Accept are the main entrypoints into this package. Use Dial to dial
-// a WebSocket server, Accept to accept a WebSocket client dial and then Conn to interact
-// with the resulting WebSocket connections.
+// Use Dial to dial a WebSocket server and Accept to accept a WebSocket client.
+// Conn represents the resulting WebSocket connection.
 //
 // The examples are the best way to understand how to correctly use the library.
 //
-// The wsjson and wspb subpackages contain helpers for JSON and ProtoBuf messages.
+// The wsjson and wspb subpackages contain helpers for JSON and Protobuf messages.
 //
-// See https://nhooyr.io/websocket for more overview docs and a
-// comparison with existing implementations.
-//
-// Use the errors.As function new in Go 1.13 to check for websocket.CloseError.
-// Or use the CloseStatus function to grab the StatusCode out of a websocket.CloseError
-// See the CloseStatus example.
+// See https://nhooyr.io/websocket for further information.
 //
 // Wasm
 //
-// The client side fully supports compiling to Wasm.
+// The client side supports compiling to Wasm.
 // It wraps the WebSocket browser API.
 //
 // See https://developer.mozilla.org/en-US/docs/Web/API/WebSocket
 //
-// Thus the unsupported features (not compiled in) for Wasm are:
-//
-//  - Accept and AcceptOptions
-//  - Conn.Ping
-//  - HTTPClient and HTTPHeader fields in DialOptions
-//  - CompressionOptions
-//
-// The *http.Response returned by Dial will always either be nil or &http.Response{} as
-// we do not have access to the handshake response in the browser.
-//
-// The Writer method on the Conn buffers everything in memory and then sends it as a message
-// when the writer is closed.
-//
-// The Reader method also reads the entire response and then returns a reader that
-// reads from the byte slice.
-//
-// SetReadLimit cannot actually limit the number of bytes read from the connection so instead
-// when a message beyond the limit is fully read, it throws an error.
-//
-// Writes are also always async so the passed context is no-op.
+// Some important caveats to be aware of:
 //
-// Everything else is fully supported. This includes the wsjson and wspb helper packages.
+//  - Conn.Ping is no-op
+//  - HTTPClient, HTTPHeader and CompressionOptions in DialOptions are no-op
+//  - *http.Response from Dial is &http.Response{} on success
 //
-// Once https://github.com/gopherjs/gopherjs/issues/929 is closed, GopherJS should be supported
-// as well.
 package websocket // import "nhooyr.io/websocket"

frame.go

@@ -12,7 +12,7 @@ import (
 // opcode represents a WebSocket opcode.
 type opcode int
 
-// List at https://tools.ietf.org/html/rfc6455#section-11.8.
+// https://tools.ietf.org/html/rfc6455#section-11.8.
 const (
 	opContinuation opcode = iota
 	opText

frame_test.go

@@ -19,10 +19,6 @@ import (
 	"nhooyr.io/websocket/internal/assert"
 )
 
-func init() {
-	rand.Seed(time.Now().UnixNano())
-}
-
 func TestHeader(t *testing.T) {
 	t.Parallel()
 
@@ -56,8 +52,9 @@ func TestHeader(t *testing.T) {
 	t.Run("fuzz", func(t *testing.T) {
 		t.Parallel()
 
+		r := rand.New(rand.NewSource(time.Now().UnixNano()))
 		randBool := func() bool {
-			return rand.Intn(1) == 0
+			return r.Intn(1) == 0
 		}
 
 		for i := 0; i < 10000; i++ {
@@ -66,11 +63,11 @@ func TestHeader(t *testing.T) {
 				rsv1:   randBool(),
 				rsv2:   randBool(),
 				rsv3:   randBool(),
-				opcode: opcode(rand.Intn(16)),
+				opcode: opcode(r.Intn(16)),
 
 				masked:        randBool(),
-				maskKey:       rand.Uint32(),
-				payloadLength: rand.Int63(),
+				maskKey:       r.Uint32(),
+				payloadLength: r.Int63(),
 			}
 
 			testHeader(t, h)
@@ -91,7 +88,7 @@ func testHeader(t *testing.T, h header) {
 	h2, err := readFrameHeader(r)
 	assert.Success(t, err)
 
-	assert.Equal(t, h, h2, "written and read headers differ")
+	assert.Equal(t, h, h2, "header")
 }
 
 func Test_mask(t *testing.T) {
@@ -102,8 +99,8 @@ func Test_mask(t *testing.T) {
 	p := []byte{0xa, 0xb, 0xc, 0xf2, 0xc}
 	gotKey32 := mask(key32, p)
 
-	assert.Equal(t, []byte{0, 0, 0, 0x0d, 0x6}, p, "unexpected mask")
-	assert.Equal(t, bits.RotateLeft32(key32, -8), gotKey32, "unexpected mask key")
+	assert.Equal(t, []byte{0, 0, 0, 0x0d, 0x6}, p, "mask")
+	assert.Equal(t, bits.RotateLeft32(key32, -8), gotKey32, "mask key")
 }
 
 func basicMask(maskKey [4]byte, pos int, b []byte) int {
@@ -173,9 +170,7 @@ func Benchmark_mask(b *testing.B) {
 		},
 	}
 
-	var key [4]byte
-	_, err := rand.Read(key[:])
-	assert.Success(b, err)
+	key := [4]byte{1, 2, 3, 4}
 
 	for _, size := range sizes {
 		p := make([]byte, size)

go.mod

@@ -7,7 +7,7 @@ require (
 	github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee // indirect
 	github.com/gobwas/pool v0.2.0 // indirect
 	github.com/gobwas/ws v1.0.2
-	github.com/golang/protobuf v1.3.2 // indirect
+	github.com/golang/protobuf v1.3.2
 	github.com/google/go-cmp v0.3.1
 	github.com/gorilla/websocket v1.4.1
 	github.com/kr/pretty v0.1.0 // indirect