FilesExpand file tree

main

/

main_test.go

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

178 lines (154 loc) · 5.09 KB

main

/

main_test.go

Copy path

Top

File metadata and controls

• Code
• Blame

178 lines (154 loc) · 5.09 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

package main

import (

"bufio"

"encoding/json"

"strings"

"testing"

)

func TestReadJSONRPCResponse_DirectResponse(t *testing.T) {

t.Parallel()

input := `{"jsonrpc":"2.0","id":1,"result":{"tools":[]}}` + "\n"

scanner := bufio.NewScanner(strings.NewReader(input))

got, err := readJSONRPCResponse(scanner)

if err != nil {

t.Fatalf("unexpected error: %v", err)

}

if got != `{"jsonrpc":"2.0","id":1,"result":{"tools":[]}}` {

t.Fatalf("unexpected response: %s", got)

}

}

func TestReadJSONRPCResponse_SkipsNotifications(t *testing.T) {

t.Parallel()

input := strings.Join([]string{

`{"jsonrpc":"2.0","method":"notifications/resources/list_changed","params":{}}`,

`{"jsonrpc":"2.0","method":"notifications/tools/list_changed"}`,

`{"jsonrpc":"2.0","id":42,"result":{"content":[{"type":"text","text":"hello"}]}}`,

}, "\n") + "\n"

scanner := bufio.NewScanner(strings.NewReader(input))

got, err := readJSONRPCResponse(scanner)

if err != nil {

t.Fatalf("unexpected error: %v", err)

}

var msg map[string]json.RawMessage

if err := json.Unmarshal([]byte(got), &msg); err != nil {

t.Fatalf("response is not valid JSON: %v", err)

}

// Verify we got the response with id:42, not a notification

var id int

if err := json.Unmarshal(msg["id"], &id); err != nil {

t.Fatalf("failed to parse id: %v", err)

}

if id != 42 {

t.Fatalf("expected id 42, got %d", id)

}

}

func TestReadJSONRPCResponse_NoResponse(t *testing.T) {

t.Parallel()

// Only notifications, no response

input := `{"jsonrpc":"2.0","method":"notifications/resources/list_changed","params":{}}` + "\n"

scanner := bufio.NewScanner(strings.NewReader(input))

_, err := readJSONRPCResponse(scanner)

if err == nil {

t.Fatal("expected error for missing response, got nil")

}

if !strings.Contains(err.Error(), "unexpected end of output") {

t.Fatalf("expected 'unexpected end of output' error, got: %v", err)

}

}

func TestReadJSONRPCResponse_EmptyInput(t *testing.T) {

t.Parallel()

scanner := bufio.NewScanner(strings.NewReader(""))

_, err := readJSONRPCResponse(scanner)

if err == nil {

t.Fatal("expected error for empty input, got nil")

}

}

func TestReadJSONRPCResponse_InvalidJSON(t *testing.T) {

t.Parallel()

input := "not valid json\n"

scanner := bufio.NewScanner(strings.NewReader(input))

_, err := readJSONRPCResponse(scanner)

if err == nil {

t.Fatal("expected error for invalid JSON, got nil")

}

if !strings.Contains(err.Error(), "failed to parse JSON-RPC message") {

t.Fatalf("expected parse error, got: %v", err)

}

}

func TestReadJSONRPCResponse_ServerError(t *testing.T) {

t.Parallel()

input := `{"jsonrpc":"2.0","id":1,"error":{"code":-32601,"message":"method not found"}}` + "\n"

scanner := bufio.NewScanner(strings.NewReader(input))

_, err := readJSONRPCResponse(scanner)

if err == nil {

t.Fatal("expected error for server error response, got nil")

}

if !strings.Contains(err.Error(), "server returned error") {

t.Fatalf("expected 'server returned error', got: %v", err)

}

if !strings.Contains(err.Error(), "method not found") {

t.Fatalf("expected error to contain server message, got: %v", err)

}

}

func TestBuildInitializeRequest(t *testing.T) {

t.Parallel()

got, err := buildInitializeRequest()

if err != nil {

t.Fatalf("unexpected error: %v", err)

}

var msg map[string]json.RawMessage

if err := json.Unmarshal([]byte(got), &msg); err != nil {

t.Fatalf("result is not valid JSON: %v", err)

}

// Verify required fields

for _, field := range []string{"jsonrpc", "id", "method", "params"} {

if _, ok := msg[field]; !ok {

t.Errorf("missing required field %q", field)

}

}

// Verify method

var method string

if err := json.Unmarshal(msg["method"], &method); err != nil {

t.Fatalf("failed to parse method: %v", err)

}

if method != "initialize" {

t.Errorf("expected method 'initialize', got %q", method)

}

// Verify params contain protocolVersion and clientInfo

var params map[string]json.RawMessage

if err := json.Unmarshal(msg["params"], &params); err != nil {

t.Fatalf("failed to parse params: %v", err)

}

for _, field := range []string{"protocolVersion", "capabilities", "clientInfo"} {

if _, ok := params[field]; !ok {

t.Errorf("missing params field %q", field)

}

}

var version string

if err := json.Unmarshal(params["protocolVersion"], &version); err != nil {

t.Fatalf("failed to parse protocolVersion: %v", err)

}

if version != "2024-11-05" {

t.Errorf("expected protocolVersion '2024-11-05', got %q", version)

}

}

func TestBuildInitializedNotification(t *testing.T) {

t.Parallel()

got := buildInitializedNotification()

var msg map[string]json.RawMessage

if err := json.Unmarshal([]byte(got), &msg); err != nil {

t.Fatalf("result is not valid JSON: %v", err)

}

// Must have jsonrpc and method

var method string

if err := json.Unmarshal(msg["method"], &method); err != nil {

t.Fatalf("failed to parse method: %v", err)

}

if method != "notifications/initialized" {

t.Errorf("expected method 'notifications/initialized', got %q", method)

}

// Must NOT have an id (it's a notification)

if _, hasID := msg["id"]; hasID {

t.Error("notification should not have an 'id' field")

}

}