diff --git a/server/pkg/handler/migrate.go b/server/pkg/handler/migrate.go index b5d8e59..424a8b2 100644 --- a/server/pkg/handler/migrate.go +++ b/server/pkg/handler/migrate.go @@ -88,10 +88,7 @@ func (h *Handler) ForwardMigrate(ctx *fasthttp.RequestCtx) error { }) if err != nil { - if _, ok := err.(websocket.HandshakeError); ok { - return fmt.Errorf("websocket handshake: %v", err) - } - return fmt.Errorf("websocket upgrade error: %v", err) + return wrapUpgradeError(err) } return nil diff --git a/server/pkg/handler/websocket.go b/server/pkg/handler/websocket.go index ac5d7c1..37b6ae7 100644 --- a/server/pkg/handler/websocket.go +++ b/server/pkg/handler/websocket.go @@ -72,6 +72,16 @@ func (h *Handler) newWSUpgrader() *websocket.FastHTTPUpgrader { } } +// wrapUpgradeError classifies a WebSocket upgrade failure: a +// websocket.HandshakeError means the handshake request was malformed; +// anything else is a generic upgrade error. +func wrapUpgradeError(err error) error { + if _, ok := err.(websocket.HandshakeError); ok { + return fmt.Errorf("websocket handshake: %v", err) + } + return fmt.Errorf("websocket upgrade error: %v", err) +} + // Upgrade upgrades the connection to a websocket connection. An oversized // or malformed `peerMetadata` is rejected up front with a 413/400 // (returned as a nil error with responseWritten=true); any other failure is @@ -235,10 +245,7 @@ func (h *Handler) Upgrade(ctx *fasthttp.RequestCtx, zh zerohub.ZeroHub, hub hub. }) if upgradeErr != nil { - if _, ok := upgradeErr.(websocket.HandshakeError); ok { - return fmt.Errorf("websocket handshake: %v", upgradeErr), false - } - return fmt.Errorf("websocket upgrade error: %v", upgradeErr), false + return wrapUpgradeError(upgradeErr), false } return nil, false diff --git a/server/pkg/handler/wrap_upgrade_error_test.go b/server/pkg/handler/wrap_upgrade_error_test.go new file mode 100644 index 0000000..fc48da7 --- /dev/null +++ b/server/pkg/handler/wrap_upgrade_error_test.go @@ -0,0 +1,41 @@ +package handler + +import ( + "errors" + "strings" + "testing" + + "github.com/fasthttp/websocket" +) + +// TestWrapUpgradeErrorHandshakeError pins the first branch: a +// websocket.HandshakeError is labeled "websocket handshake" (the zero-value +// struct is constructible from outside the library because its only field +// is unexported). +func TestWrapUpgradeErrorHandshakeError(t *testing.T) { + got := wrapUpgradeError(websocket.HandshakeError{}) + if !strings.HasPrefix(got.Error(), "websocket handshake: ") { + t.Fatalf("got %q, want prefix %q", got.Error(), "websocket handshake: ") + } +} + +// TestWrapUpgradeErrorGenericError pins the default branch: any non- +// HandshakeError error is labeled "websocket upgrade error" and keeps the +// original message. +func TestWrapUpgradeErrorGenericError(t *testing.T) { + got := wrapUpgradeError(errors.New("connection reset by peer")) + want := "websocket upgrade error: connection reset by peer" + if got.Error() != want { + t.Fatalf("got %q, want %q", got.Error(), want) + } +} + +// TestWrapUpgradeErrorNil pins the boundary: nil is not a HandshakeError, so +// it falls through to the generic branch. Callers guard against nil today, +// but the behavior must stay stable if that guard ever moves. +func TestWrapUpgradeErrorNil(t *testing.T) { + got := wrapUpgradeError(nil) + if !strings.HasPrefix(got.Error(), "websocket upgrade error: ") { + t.Fatalf("got %q, want prefix %q", got.Error(), "websocket upgrade error: ") + } +}