--- /dev/null
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package lsprpc
+
+import (
+ "context"
+ "regexp"
+ "sync"
+ "testing"
+ "time"
+
+ "golang.org/x/tools/internal/event"
+ "golang.org/x/tools/internal/jsonrpc2"
+ "golang.org/x/tools/internal/jsonrpc2/servertest"
+ "golang.org/x/tools/internal/lsp/cache"
+ "golang.org/x/tools/internal/lsp/debug"
+ "golang.org/x/tools/internal/lsp/fake"
+ "golang.org/x/tools/internal/lsp/protocol"
+ "golang.org/x/tools/internal/testenv"
+)
+
+type fakeClient struct {
+ protocol.Client
+
+ logs chan string
+}
+
+func (c fakeClient) LogMessage(ctx context.Context, params *protocol.LogMessageParams) error {
+ c.logs <- params.Message
+ return nil
+}
+
+// fakeServer is intended to be embedded in the test fakes below, to trivially
+// implement Shutdown.
+type fakeServer struct {
+ protocol.Server
+}
+
+func (fakeServer) Shutdown(ctx context.Context) error {
+ return nil
+}
+
+type pingServer struct{ fakeServer }
+
+func (s pingServer) DidOpen(ctx context.Context, params *protocol.DidOpenTextDocumentParams) error {
+ event.Log(ctx, "ping")
+ return nil
+}
+
+func TestClientLogging(t *testing.T) {
+ ctx, cancel := context.WithCancel(context.Background())
+ defer cancel()
+
+ server := pingServer{}
+ client := fakeClient{logs: make(chan string, 10)}
+
+ ctx = debug.WithInstance(ctx, "", "")
+ ss := NewStreamServer(cache.New(ctx, nil), false)
+ ss.serverForTest = server
+ ts := servertest.NewPipeServer(ctx, ss, nil)
+ defer checkClose(t, ts.Close)
+ cc := ts.Connect(ctx)
+ cc.Go(ctx, protocol.ClientHandler(client, jsonrpc2.MethodNotFound))
+
+ protocol.ServerDispatcher(cc).DidOpen(ctx, &protocol.DidOpenTextDocumentParams{})
+
+ select {
+ case got := <-client.logs:
+ want := "ping"
+ matched, err := regexp.MatchString(want, got)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !matched {
+ t.Errorf("got log %q, want a log containing %q", got, want)
+ }
+ case <-time.After(1 * time.Second):
+ t.Error("timeout waiting for client log")
+ }
+}
+
+// waitableServer instruments LSP request so that we can control their timing.
+// The requests chosen are arbitrary: we simply needed one that blocks, and
+// another that doesn't.
+type waitableServer struct {
+ fakeServer
+
+ started chan struct{}
+}
+
+func (s waitableServer) Hover(ctx context.Context, _ *protocol.HoverParams) (*protocol.Hover, error) {
+ s.started <- struct{}{}
+ select {
+ case <-ctx.Done():
+ return nil, ctx.Err()
+ case <-time.After(200 * time.Millisecond):
+ }
+ return &protocol.Hover{}, nil
+}
+
+func (s waitableServer) Resolve(_ context.Context, item *protocol.CompletionItem) (*protocol.CompletionItem, error) {
+ return item, nil
+}
+
+func checkClose(t *testing.T, closer func() error) {
+ t.Helper()
+ if err := closer(); err != nil {
+ t.Errorf("closing: %v", err)
+ }
+}
+
+func setupForwarding(ctx context.Context, t *testing.T, s protocol.Server) (direct, forwarded servertest.Connector, cleanup func()) {
+ t.Helper()
+ serveCtx := debug.WithInstance(ctx, "", "")
+ ss := NewStreamServer(cache.New(serveCtx, nil), false)
+ ss.serverForTest = s
+ tsDirect := servertest.NewTCPServer(serveCtx, ss, nil)
+
+ forwarderCtx := debug.WithInstance(ctx, "", "")
+ forwarder := NewForwarder("tcp", tsDirect.Addr)
+ tsForwarded := servertest.NewPipeServer(forwarderCtx, forwarder, nil)
+ return tsDirect, tsForwarded, func() {
+ checkClose(t, tsDirect.Close)
+ checkClose(t, tsForwarded.Close)
+ }
+}
+
+func TestRequestCancellation(t *testing.T) {
+ ctx := context.Background()
+ server := waitableServer{
+ started: make(chan struct{}),
+ }
+ tsDirect, tsForwarded, cleanup := setupForwarding(ctx, t, server)
+ defer cleanup()
+ tests := []struct {
+ serverType string
+ ts servertest.Connector
+ }{
+ {"direct", tsDirect},
+ {"forwarder", tsForwarded},
+ }
+
+ for _, test := range tests {
+ t.Run(test.serverType, func(t *testing.T) {
+ cc := test.ts.Connect(ctx)
+ sd := protocol.ServerDispatcher(cc)
+ cc.Go(ctx,
+ protocol.Handlers(
+ jsonrpc2.MethodNotFound))
+
+ ctx := context.Background()
+ ctx1, cancel1 := context.WithCancel(ctx)
+ var (
+ err1, err2 error
+ wg sync.WaitGroup
+ )
+ wg.Add(2)
+ go func() {
+ defer wg.Done()
+ _, err1 = sd.Hover(ctx1, &protocol.HoverParams{})
+ }()
+ go func() {
+ defer wg.Done()
+ _, err2 = sd.Resolve(ctx, &protocol.CompletionItem{})
+ }()
+ // Wait for the Hover request to start.
+ <-server.started
+ cancel1()
+ wg.Wait()
+ if err1 == nil {
+ t.Errorf("cancelled Hover(): got nil err")
+ }
+ if err2 != nil {
+ t.Errorf("uncancelled Hover(): err: %v", err2)
+ }
+ if _, err := sd.Resolve(ctx, &protocol.CompletionItem{}); err != nil {
+ t.Errorf("subsequent Hover(): %v", err)
+ }
+ })
+ }
+}
+
+const exampleProgram = `
+-- go.mod --
+module mod
+
+go 1.12
+-- main.go --
+package main
+
+import "fmt"
+
+func main() {
+ fmt.Println("Hello World.")
+}`
+
+func TestDebugInfoLifecycle(t *testing.T) {
+ sb, err := fake.NewSandbox(&fake.SandboxConfig{Files: exampleProgram})
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer func() {
+ if err := sb.Close(); err != nil {
+ // TODO(golang/go#38490): we can't currently make this an error because
+ // it fails on Windows: the workspace directory is still locked by a
+ // separate Go process.
+ // Once we have a reliable way to wait for proper shutdown, make this an
+ // error.
+ t.Logf("closing workspace failed: %v", err)
+ }
+ }()
+
+ baseCtx, cancel := context.WithCancel(context.Background())
+ defer cancel()
+ clientCtx := debug.WithInstance(baseCtx, "", "")
+ serverCtx := debug.WithInstance(baseCtx, "", "")
+
+ cache := cache.New(serverCtx, nil)
+ ss := NewStreamServer(cache, false)
+ tsBackend := servertest.NewTCPServer(serverCtx, ss, nil)
+
+ forwarder := NewForwarder("tcp", tsBackend.Addr)
+ tsForwarder := servertest.NewPipeServer(clientCtx, forwarder, nil)
+
+ conn1 := tsForwarder.Connect(clientCtx)
+ ed1, err := fake.NewEditor(sb, fake.EditorConfig{}).Connect(clientCtx, conn1, fake.ClientHooks{})
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer ed1.Close(clientCtx)
+ conn2 := tsBackend.Connect(baseCtx)
+ ed2, err := fake.NewEditor(sb, fake.EditorConfig{}).Connect(baseCtx, conn2, fake.ClientHooks{})
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer ed2.Close(baseCtx)
+
+ serverDebug := debug.GetInstance(serverCtx)
+ if got, want := len(serverDebug.State.Clients()), 2; got != want {
+ t.Errorf("len(server:Clients) = %d, want %d", got, want)
+ }
+ if got, want := len(serverDebug.State.Sessions()), 2; got != want {
+ t.Errorf("len(server:Sessions) = %d, want %d", got, want)
+ }
+ clientDebug := debug.GetInstance(clientCtx)
+ if got, want := len(clientDebug.State.Servers()), 1; got != want {
+ t.Errorf("len(client:Servers) = %d, want %d", got, want)
+ }
+ // Close one of the connections to verify that the client and session were
+ // dropped.
+ if err := ed1.Close(clientCtx); err != nil {
+ t.Fatal(err)
+ }
+ /*TODO: at this point we have verified the editor is closed
+ However there is no way currently to wait for all associated go routines to
+ go away, and we need to wait for those to trigger the client drop
+ for now we just give it a little bit of time, but we need to fix this
+ in a principled way
+ */
+ start := time.Now()
+ delay := time.Millisecond
+ const maxWait = time.Second
+ for len(serverDebug.State.Clients()) > 1 {
+ if time.Since(start) > maxWait {
+ break
+ }
+ time.Sleep(delay)
+ delay *= 2
+ }
+ if got, want := len(serverDebug.State.Clients()), 1; got != want {
+ t.Errorf("len(server:Clients) = %d, want %d", got, want)
+ }
+ if got, want := len(serverDebug.State.Sessions()), 1; got != want {
+ t.Errorf("len(server:Sessions()) = %d, want %d", got, want)
+ }
+}
+
+type initServer struct {
+ fakeServer
+
+ params *protocol.ParamInitialize
+}
+
+func (s *initServer) Initialize(ctx context.Context, params *protocol.ParamInitialize) (*protocol.InitializeResult, error) {
+ s.params = params
+ return &protocol.InitializeResult{}, nil
+}
+
+func TestEnvForwarding(t *testing.T) {
+ testenv.NeedsGo1Point(t, 13)
+ server := &initServer{}
+ ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+ defer cancel()
+ _, tsForwarded, cleanup := setupForwarding(ctx, t, server)
+ defer cleanup()
+
+ conn := tsForwarded.Connect(ctx)
+ conn.Go(ctx, jsonrpc2.MethodNotFound)
+ dispatch := protocol.ServerDispatcher(conn)
+ initParams := &protocol.ParamInitialize{}
+ initParams.InitializationOptions = map[string]interface{}{
+ "env": map[string]interface{}{
+ "GONOPROXY": "example.com",
+ },
+ }
+ _, err := dispatch.Initialize(ctx, initParams)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if server.params == nil {
+ t.Fatalf("initialize params are unset")
+ }
+ env := server.params.InitializationOptions.(map[string]interface{})["env"].(map[string]interface{})
+
+ // Check for an arbitrary Go variable. It should be set.
+ if _, ok := env["GOPRIVATE"]; !ok {
+ t.Errorf("Go environment variable GOPRIVATE unset in initialization options")
+ }
+ // Check that the variable present in our user config was not overwritten.
+ if v := env["GONOPROXY"]; v != "example.com" {
+ t.Errorf("GONOPROXY environment variable was overwritten")
+ }
+}
projects / dotfiles / .git / blobdiff