wip, rework bridge

internal/bridge/protocol_test.go

@@ -0,0 +1,214 @@
+package bridge
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+func messageID(id uint64) *uint64 {
+	return &id
+}
+
+func TestMessageValidate(t *testing.T) {
+	tests := []struct {
+		name    string
+		message Message
+		wantErr string
+	}{
+		{
+			name: "request",
+			message: Message{
+				Version:   ProtocolVersion,
+				Type:      Request,
+				RequestId: messageID(1),
+				Name:      "locals/get",
+			},
+		},
+		{
+			name: "successful response",
+			message: Message{
+				Version:   ProtocolVersion,
+				Type:      Response,
+				RequestId: messageID(1),
+				Name:      "locals/get",
+				Body:      json.RawMessage(`{"variables":{}}`),
+			},
+		},
+		{
+			name: "error response",
+			message: Message{
+				Version:   ProtocolVersion,
+				Type:      Response,
+				RequestId: messageID(1),
+				Name:      "locals/get",
+				Error: &ProtocolError{
+					Code:    "not_paused",
+					Message: "execution is not paused",
+				},
+			},
+		},
+		{
+			name: "event",
+			message: Message{
+				Version: ProtocolVersion,
+				Type:    Event,
+				Name:    "execution/stopped",
+				Body:    json.RawMessage(`{"reason":"step","file":"test.py","line":1}`),
+			},
+		},
+		{
+			name: "unsupported version",
+			message: Message{
+				Version:   ProtocolVersion + 1,
+				Type:      Request,
+				RequestId: messageID(1),
+				Name:      "locals/get",
+			},
+			wantErr: "unsupported protocol version",
+		},
+		{
+			name: "missing name",
+			message: Message{
+				Version:   ProtocolVersion,
+				Type:      Request,
+				RequestId: messageID(1),
+			},
+			wantErr: "message name is required",
+		},
+		{
+			name: "request without ID",
+			message: Message{
+				Version: ProtocolVersion,
+				Type:    Request,
+				Name:    "locals/get",
+			},
+			wantErr: "request ID is required",
+		},
+		{
+			name: "request with error",
+			message: Message{
+				Version:   ProtocolVersion,
+				Type:      Request,
+				RequestId: messageID(1),
+				Name:      "locals/get",
+				Error:     &ProtocolError{Code: "invalid"},
+			},
+			wantErr: "request cannot contain an error",
+		},
+		{
+			name: "response without ID",
+			message: Message{
+				Version: ProtocolVersion,
+				Type:    Response,
+				Name:    "locals/get",
+			},
+			wantErr: "response ID is required",
+		},
+		{
+			name: "response with body and error",
+			message: Message{
+				Version:   ProtocolVersion,
+				Type:      Response,
+				RequestId: messageID(1),
+				Name:      "locals/get",
+				Body:      json.RawMessage(`{}`),
+				Error:     &ProtocolError{Code: "invalid"},
+			},
+			wantErr: "response cannot contain both body and error",
+		},
+		{
+			name: "event with ID",
+			message: Message{
+				Version:   ProtocolVersion,
+				Type:      Event,
+				RequestId: messageID(1),
+				Name:      "execution/stopped",
+			},
+			wantErr: "event cannot contain a request ID",
+		},
+		{
+			name: "event with error",
+			message: Message{
+				Version: ProtocolVersion,
+				Type:    Event,
+				Name:    "execution/stopped",
+				Error:   &ProtocolError{Code: "invalid"},
+			},
+			wantErr: "event cannot contain an error",
+		},
+		{
+			name: "unknown type",
+			message: Message{
+				Version:   ProtocolVersion,
+				Type:      MessageType("notification"),
+				RequestId: messageID(1),
+				Name:      "locals/get",
+			},
+			wantErr: "unknown message type",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.message.Validate()
+			if tt.wantErr == "" {
+				if err != nil {
+					t.Fatalf("Validate() error = %v", err)
+				}
+				return
+			}
+
+			if err == nil {
+				t.Fatalf("Validate() error = nil, want error containing %q", tt.wantErr)
+			}
+			if !strings.Contains(err.Error(), tt.wantErr) {
+				t.Fatalf("Validate() error = %q, want error containing %q", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestNewMessageEncodesTypedBody(t *testing.T) {
+	id := uint64(7)
+	msg, err := newMessage(Request, &id, "breakpoint/set", SetBreakpointRequest{
+		File: "example.py",
+		Line: 42,
+	})
+	if err != nil {
+		t.Fatalf("newMessage() error = %v", err)
+	}
+
+	if err := msg.Validate(); err != nil {
+		t.Fatalf("Validate() error = %v", err)
+	}
+
+	var body SetBreakpointRequest
+	if err := json.Unmarshal(msg.Body, &body); err != nil {
+		t.Fatalf("unmarshal body: %v", err)
+	}
+
+	if body.File != "example.py" || body.Line != 42 {
+		t.Fatalf("decoded body = %+v", body)
+	}
+}
+
+func TestProtocolErrorString(t *testing.T) {
+	tests := []struct {
+		name string
+		err  *ProtocolError
+		want string
+	}{
+		{name: "code and message", err: &ProtocolError{Code: "not_paused", Message: "execution is not paused"}, want: "not_paused: execution is not paused"},
+		{name: "message only", err: &ProtocolError{Message: "execution is not paused"}, want: "execution is not paused"},
+		{name: "nil", err: nil, want: ""},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := tt.err.Error(); got != tt.want {
+				t.Fatalf("Error() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+}