1package cmd
2
3import (
4	"context"
5	"io/ioutil"
6	"os"
7	"path/filepath"
8	"testing"
9
10	"golang.org/x/tools/internal/lsp"
11	"golang.org/x/tools/internal/lsp/cache"
12	"golang.org/x/tools/internal/lsp/protocol"
13	errors "golang.org/x/xerrors"
14)
15
16// TestCapabilities does some minimal validation of the server's adherence to the LSP.
17// The checks in the test are added as changes are made and errors noticed.
18func TestCapabilities(t *testing.T) {
19	tmpDir, err := ioutil.TempDir("", "fake")
20	if err != nil {
21		t.Fatal(err)
22	}
23	tmpFile := filepath.Join(tmpDir, "fake.go")
24	if err := ioutil.WriteFile(tmpFile, []byte(""), 0775); err != nil {
25		t.Fatal(err)
26	}
27	if err := ioutil.WriteFile(filepath.Join(tmpDir, "go.mod"), []byte(`module fake`), 0775); err != nil {
28		t.Fatal(err)
29	}
30	defer os.RemoveAll(tmpDir)
31
32	app := New("gopls-test", tmpDir, os.Environ(), nil)
33	c := newConnection(app)
34	ctx := context.Background()
35	defer c.terminate(ctx)
36
37	params := &protocol.ParamInitialize{}
38	params.RootURI = protocol.URIFromPath(c.Client.app.wd)
39	params.Capabilities.Workspace.Configuration = true
40
41	// Send an initialize request to the server.
42	c.Server = lsp.NewServer(cache.New(app.options).NewSession(), c.Client)
43	result, err := c.Server.Initialize(ctx, params)
44	if err != nil {
45		t.Fatal(err)
46	}
47	// Validate initialization result.
48	if err := validateCapabilities(result); err != nil {
49		t.Error(err)
50	}
51	// Complete initialization of server.
52	if err := c.Server.Initialized(ctx, &protocol.InitializedParams{}); err != nil {
53		t.Fatal(err)
54	}
55
56	// Open the file on the server side.
57	uri := protocol.URIFromPath(tmpFile)
58	if err := c.Server.DidOpen(ctx, &protocol.DidOpenTextDocumentParams{
59		TextDocument: protocol.TextDocumentItem{
60			URI:        uri,
61			LanguageID: "go",
62			Version:    1,
63			Text:       `package main; func main() {};`,
64		},
65	}); err != nil {
66		t.Fatal(err)
67	}
68
69	// If we are sending a full text change, the change.Range must be nil.
70	// It is not enough for the Change to be empty, as that is ambiguous.
71	if err := c.Server.DidChange(ctx, &protocol.DidChangeTextDocumentParams{
72		TextDocument: protocol.VersionedTextDocumentIdentifier{
73			TextDocumentIdentifier: protocol.TextDocumentIdentifier{
74				URI: uri,
75			},
76			Version: 2,
77		},
78		ContentChanges: []protocol.TextDocumentContentChangeEvent{
79			{
80				Range: nil,
81				Text:  `package main; func main() { fmt.Println("") }`,
82			},
83		},
84	}); err != nil {
85		t.Fatal(err)
86	}
87
88	// Send a code action request to validate expected types.
89	actions, err := c.Server.CodeAction(ctx, &protocol.CodeActionParams{
90		TextDocument: protocol.TextDocumentIdentifier{
91			URI: uri,
92		},
93	})
94	if err != nil {
95		t.Fatal(err)
96	}
97	for _, action := range actions {
98		// Validate that an empty command is sent along with import organization responses.
99		if action.Kind == protocol.SourceOrganizeImports && action.Command != nil {
100			t.Errorf("unexpected command for import organization")
101		}
102	}
103
104	if err := c.Server.DidSave(ctx, &protocol.DidSaveTextDocumentParams{
105		TextDocument: protocol.VersionedTextDocumentIdentifier{
106			Version: 2,
107			TextDocumentIdentifier: protocol.TextDocumentIdentifier{
108				URI: uri,
109			},
110		},
111		// LSP specifies that a file can be saved with optional text, so this field must be nil.
112		Text: nil,
113	}); err != nil {
114		t.Fatal(err)
115	}
116
117	// Send a completion request to validate expected types.
118	list, err := c.Server.Completion(ctx, &protocol.CompletionParams{
119		TextDocumentPositionParams: protocol.TextDocumentPositionParams{
120			TextDocument: protocol.TextDocumentIdentifier{
121				URI: uri,
122			},
123			Position: protocol.Position{
124				Line:      0,
125				Character: 28,
126			},
127		},
128	})
129	if err != nil {
130		t.Fatal(err)
131	}
132	for _, item := range list.Items {
133		// We expect the "editor.action.triggerParameterHints" command for functions and methods.
134		if item.Kind == protocol.MethodCompletion || item.Kind == protocol.FunctionCompletion {
135			continue
136		}
137		// All other completion items should have nil commands.
138		// An empty command will be treated as a command with the name '' by VS Code.
139		// This causes VS Code to report errors to users about invalid commands.
140		if item.Command != nil {
141			t.Errorf("unexpected command for non-function completion item")
142		}
143		// The item's TextEdit must be a pointer, as VS Code considers TextEdits
144		// that don't contain the cursor position to be invalid.
145		var textEdit interface{} = item.TextEdit
146		if _, ok := textEdit.(*protocol.TextEdit); !ok {
147			t.Errorf("textEdit is not a *protocol.TextEdit, instead it is %T", textEdit)
148		}
149	}
150}
151
152func validateCapabilities(result *protocol.InitializeResult) error {
153	// If the client sends "false" for RenameProvider.PrepareSupport,
154	// the server must respond with a boolean.
155	if v, ok := result.Capabilities.RenameProvider.(bool); !ok {
156		return errors.Errorf("RenameProvider must be a boolean if PrepareSupport is false (got %T)", v)
157	}
158	// The same goes for CodeActionKind.ValueSet.
159	if v, ok := result.Capabilities.CodeActionProvider.(bool); !ok {
160		return errors.Errorf("CodeActionSupport must be a boolean if CodeActionKind.ValueSet has length 0 (got %T)", v)
161	}
162	return nil
163}
164