test: refactor test suite to (hopefully) fix flakiness (#65)

A major test suite refactor that attempts to address two possible
sources of flakiness:

- use of a throwaway bufio.Reader when completing client handshake,
  which could potentially consume websocket frame bytes if written
  by the server too quickly.  fix here is to wrap the conn such that
  buffered bytes are still available after the handshake is completed.
  See newConnWithBufferedReader.

- rewriting all client/server tests to set up dedicated, separate client
  and server conns instead of setting up a single conn and "simulating"
  client/server reads/writes to that shared conn.

Unfortunately, this has not addressed all flakiness, but based on CI
runs it does seem to have improved things?

Author: mccutchen

proto.go

@@ -18,33 +18,14 @@ type Opcode uint8
 // See the RFC for the set of defined opcodes:
 // https://datatracker.ietf.org/doc/html/rfc6455#section-5.2
 const (
-	OpcodeContinuation Opcode = 0b0000_0000 // 0x0
-	OpcodeText         Opcode = 0b0000_0001 // 0x1
-	OpcodeBinary       Opcode = 0b0000_0010 // 0x2
-	OpcodeClose        Opcode = 0b0000_1000 // 0x8
-	OpcodePing         Opcode = 0b0000_1001 // 0x9
-	OpcodePong         Opcode = 0b0000_1010 // 0xA
+	OpcodeContinuation Opcode = 0x0
+	OpcodeText         Opcode = 0x1
+	OpcodeBinary       Opcode = 0x2
+	OpcodeClose        Opcode = 0x8
+	OpcodePing         Opcode = 0x9
+	OpcodePong         Opcode = 0xA
 )
 
-func (c Opcode) String() string {
-	switch c {
-	case OpcodeContinuation:
-		return "Cont"
-	case OpcodeText:
-		return "Text"
-	case OpcodeBinary:
-		return "Binary"
-	case OpcodeClose:
-		return "Close"
-	case OpcodePing:
-		return "Ping"
-	case OpcodePong:
-		return "Pong"
-	default:
-		panic(fmt.Sprintf("unknown opcode: %#v", c))
-	}
-}
-
 // StatusCode is a websocket close status code.
 type StatusCode uint16
 

websocket.go

@@ -201,18 +201,18 @@ func (ws *Websocket) ReadMessage(ctx context.Context) (*Message, error) {
 		switch opcode {
 		case OpcodeBinary, OpcodeText:
 			if msg != nil {
-				return nil, ws.startCloseOnReadError(ErrContinuationExpected)
+				return nil, ws.closeImmediately(ErrContinuationExpected)
 			}
 			msg = &Message{
 				Binary:  opcode == OpcodeBinary,
 				Payload: frame.Payload,
 			}
 		case OpcodeContinuation:
 			if msg == nil {
-				return nil, ws.startCloseOnReadError(ErrContinuationUnexpected)
+				return nil, ws.closeImmediately(ErrContinuationUnexpected)
 			}
 			if len(msg.Payload)+len(frame.Payload) > ws.maxMessageSize {
-				return nil, ws.startCloseOnReadError(ErrMessageTooLarge)
+				return nil, ws.closeImmediately(ErrMessageTooLarge)
 			}
 			msg.Payload = append(msg.Payload, frame.Payload...)
 		case OpcodeClose:
@@ -234,7 +234,7 @@ func (ws *Websocket) ReadMessage(ctx context.Context) (*Message, error) {
 
 		if frame.Fin() {
 			if !msg.Binary && !utf8.Valid(msg.Payload) {
-				return nil, ws.startCloseOnReadError(ErrInvalidFramePayload)
+				return nil, ws.closeImmediately(ErrInvalidFramePayload)
 			}
 			ws.hooks.OnReadMessage(ws.clientKey, msg)
 			return msg, nil
@@ -342,11 +342,6 @@ func (ws *Websocket) startCloseOnError(cause error) error {
 	return ws.doCloseHandshake(closeFrame, cause)
 }
 
-func (ws *Websocket) startCloseOnReadError(err error) error {
-	ws.hooks.OnReadError(ws.clientKey, err)
-	return ws.startCloseOnError(err)
-}
-
 func (ws *Websocket) startCloseOnWriteError(err error) error {
 	ws.hooks.OnWriteError(ws.clientKey, err)
 	return ws.startCloseOnError(err)