| // 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 regtest |
| |
| import ( |
| "bytes" |
| "context" |
| "fmt" |
| "io" |
| "io/ioutil" |
| "net" |
| "os" |
| "os/exec" |
| "path/filepath" |
| "runtime/pprof" |
| "strings" |
| "sync" |
| "testing" |
| "time" |
| |
| "golang.org/x/tools/gopls/internal/hooks" |
| "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/lsprpc" |
| "golang.org/x/tools/internal/lsp/protocol" |
| "golang.org/x/tools/internal/lsp/source" |
| ) |
| |
| // Mode is a bitmask that defines for which execution modes a test should run. |
| type Mode int |
| |
| const ( |
| // Singleton mode uses a separate in-process gopls instance for each test, |
| // and communicates over pipes to mimic the gopls sidecar execution mode, |
| // which communicates over stdin/stderr. |
| Singleton Mode = 1 << iota |
| // Forwarded forwards connections to a shared in-process gopls instance. |
| Forwarded |
| // SeparateProcess forwards connection to a shared separate gopls process. |
| SeparateProcess |
| // Experimental enables all of the experimental configurations that are |
| // being developed. Currently, it enables the workspace module. |
| Experimental |
| // WithoutExperiments are the modes that run without experimental features, |
| // like the workspace module. These should be used for tests that only work |
| // in the default modes. |
| WithoutExperiments = Singleton | Forwarded |
| // NormalModes are the global default execution modes, when unmodified by |
| // test flags or by individual test options. |
| NormalModes = Singleton | Experimental |
| ) |
| |
| // A Runner runs tests in gopls execution environments, as specified by its |
| // modes. For modes that share state (for example, a shared cache or common |
| // remote), any tests that execute on the same Runner will share the same |
| // state. |
| type Runner struct { |
| DefaultModes Mode |
| Timeout time.Duration |
| GoplsPath string |
| PrintGoroutinesOnFailure bool |
| TempDir string |
| SkipCleanup bool |
| |
| mu sync.Mutex |
| ts *servertest.TCPServer |
| socketDir string |
| // closers is a queue of clean-up functions to run at the end of the entire |
| // test suite. |
| closers []io.Closer |
| } |
| |
| type runConfig struct { |
| editor fake.EditorConfig |
| sandbox fake.SandboxConfig |
| modes Mode |
| timeout time.Duration |
| debugAddr string |
| skipLogs bool |
| skipHooks bool |
| nestWorkdir bool |
| } |
| |
| func (r *Runner) defaultConfig() *runConfig { |
| return &runConfig{ |
| modes: r.DefaultModes, |
| timeout: r.Timeout, |
| } |
| } |
| |
| // A RunOption augments the behavior of the test runner. |
| type RunOption interface { |
| set(*runConfig) |
| } |
| |
| type optionSetter func(*runConfig) |
| |
| func (f optionSetter) set(opts *runConfig) { |
| f(opts) |
| } |
| |
| // WithTimeout configures a custom timeout for this test run. |
| func WithTimeout(d time.Duration) RunOption { |
| return optionSetter(func(opts *runConfig) { |
| opts.timeout = d |
| }) |
| } |
| |
| // WithProxyFiles configures a file proxy using the given txtar-encoded string. |
| func WithProxyFiles(txt string) RunOption { |
| return optionSetter(func(opts *runConfig) { |
| opts.sandbox.ProxyFiles = txt |
| }) |
| } |
| |
| // WithModes configures the execution modes that the test should run in. |
| func WithModes(modes Mode) RunOption { |
| return optionSetter(func(opts *runConfig) { |
| opts.modes = modes |
| }) |
| } |
| |
| func SendPID() RunOption { |
| return optionSetter(func(opts *runConfig) { |
| opts.editor.SendPID = true |
| }) |
| } |
| |
| // EditorConfig is a RunOption option that configured the regtest editor. |
| type EditorConfig fake.EditorConfig |
| |
| func (c EditorConfig) set(opts *runConfig) { |
| opts.editor = fake.EditorConfig(c) |
| } |
| |
| // WithoutWorkspaceFolders prevents workspace folders from being sent as part |
| // of the sandbox's initialization. It is used to simulate opening a single |
| // file in the editor, without a workspace root. In that case, the client sends |
| // neither workspace folders nor a root URI. |
| func WithoutWorkspaceFolders() RunOption { |
| return optionSetter(func(opts *runConfig) { |
| opts.editor.WithoutWorkspaceFolders = true |
| }) |
| } |
| |
| // WithRootPath specifies the rootURI of the workspace folder opened in the |
| // editor. By default, the sandbox opens the top-level directory, but some |
| // tests need to check other cases. |
| func WithRootPath(path string) RunOption { |
| return optionSetter(func(opts *runConfig) { |
| opts.editor.WorkspaceRoot = path |
| }) |
| } |
| |
| // InGOPATH configures the workspace working directory to be GOPATH, rather |
| // than a separate working directory for use with modules. |
| func InGOPATH() RunOption { |
| return optionSetter(func(opts *runConfig) { |
| opts.sandbox.InGoPath = true |
| }) |
| } |
| |
| // WithDebugAddress configures a debug server bound to addr. This option is |
| // currently only supported when executing in Singleton mode. It is intended to |
| // be used for long-running stress tests. |
| func WithDebugAddress(addr string) RunOption { |
| return optionSetter(func(opts *runConfig) { |
| opts.debugAddr = addr |
| }) |
| } |
| |
| // SkipLogs skips the buffering of logs during test execution. It is intended |
| // for long-running stress tests. |
| func SkipLogs() RunOption { |
| return optionSetter(func(opts *runConfig) { |
| opts.skipLogs = true |
| }) |
| } |
| |
| // InExistingDir runs the test in a pre-existing directory. If set, no initial |
| // files may be passed to the runner. It is intended for long-running stress |
| // tests. |
| func InExistingDir(dir string) RunOption { |
| return optionSetter(func(opts *runConfig) { |
| opts.sandbox.Workdir = dir |
| }) |
| } |
| |
| // SkipHooks allows for disabling the test runner's client hooks that are used |
| // for instrumenting expectations (tracking diagnostics, logs, work done, |
| // etc.). It is intended for performance-sensitive stress tests or benchmarks. |
| func SkipHooks(skip bool) RunOption { |
| return optionSetter(func(opts *runConfig) { |
| opts.skipHooks = skip |
| }) |
| } |
| |
| // WithGOPROXY configures the test environment to have an explicit proxy value. |
| // This is intended for stress tests -- to ensure their isolation, regtests |
| // should instead use WithProxyFiles. |
| func WithGOPROXY(goproxy string) RunOption { |
| return optionSetter(func(opts *runConfig) { |
| opts.sandbox.GOPROXY = goproxy |
| }) |
| } |
| |
| // LimitWorkspaceScope sets the LimitWorkspaceScope configuration. |
| func LimitWorkspaceScope() RunOption { |
| return optionSetter(func(opts *runConfig) { |
| opts.editor.LimitWorkspaceScope = true |
| }) |
| } |
| |
| // NestWorkdir inserts the sandbox working directory in a subdirectory of the |
| // editor workspace. |
| func NestWorkdir() RunOption { |
| return optionSetter(func(opts *runConfig) { |
| opts.nestWorkdir = true |
| }) |
| } |
| |
| type TestFunc func(t *testing.T, env *Env) |
| |
| // Run executes the test function in the default configured gopls execution |
| // modes. For each a test run, a new workspace is created containing the |
| // un-txtared files specified by filedata. |
| func (r *Runner) Run(t *testing.T, files string, test TestFunc, opts ...RunOption) { |
| t.Helper() |
| |
| tests := []struct { |
| name string |
| mode Mode |
| getServer func(context.Context, *testing.T) jsonrpc2.StreamServer |
| }{ |
| {"singleton", Singleton, singletonServer}, |
| {"forwarded", Forwarded, r.forwardedServer}, |
| {"separate_process", SeparateProcess, r.separateProcessServer}, |
| {"experimental_workspace_module", Experimental, experimentalWorkspaceModule}, |
| } |
| |
| for _, tc := range tests { |
| tc := tc |
| config := r.defaultConfig() |
| for _, opt := range opts { |
| opt.set(config) |
| } |
| if config.modes&tc.mode == 0 { |
| continue |
| } |
| if config.debugAddr != "" && tc.mode != Singleton { |
| // Debugging is useful for running stress tests, but since the daemon has |
| // likely already been started, it would be too late to debug. |
| t.Fatalf("debugging regtest servers only works in Singleton mode, "+ |
| "got debug addr %q and mode %v", config.debugAddr, tc.mode) |
| } |
| |
| t.Run(tc.name, func(t *testing.T) { |
| ctx, cancel := context.WithTimeout(context.Background(), config.timeout) |
| defer cancel() |
| ctx = debug.WithInstance(ctx, "", "off") |
| if config.debugAddr != "" { |
| di := debug.GetInstance(ctx) |
| di.DebugAddress = config.debugAddr |
| di.Serve(ctx) |
| di.MonitorMemory(ctx) |
| } |
| |
| rootDir := filepath.Join(r.TempDir, filepath.FromSlash(t.Name())) |
| if err := os.MkdirAll(rootDir, 0755); err != nil { |
| t.Fatal(err) |
| } |
| if config.nestWorkdir { |
| config.sandbox.Workdir = "work/nested" |
| } |
| config.sandbox.Files = files |
| config.sandbox.RootDir = rootDir |
| sandbox, err := fake.NewSandbox(&config.sandbox) |
| if err != nil { |
| t.Fatal(err) |
| } |
| workdir := sandbox.Workdir.RootURI().SpanURI().Filename() |
| if config.nestWorkdir { |
| // Now that we know the actual workdir, set our workspace to be the |
| // parent directory. |
| config.editor.WorkspaceRoot = filepath.Clean(filepath.Join(workdir, "..")) |
| } |
| // Deferring the closure of ws until the end of the entire test suite |
| // has, in testing, given the LSP server time to properly shutdown and |
| // release any file locks held in workspace, which is a problem on |
| // Windows. This may still be flaky however, and in the future we need a |
| // better solution to ensure that all Go processes started by gopls have |
| // exited before we clean up. |
| r.AddCloser(sandbox) |
| ss := tc.getServer(ctx, t) |
| framer := jsonrpc2.NewRawStream |
| ls := &loggingFramer{} |
| if !config.skipLogs { |
| framer = ls.framer(jsonrpc2.NewRawStream) |
| } |
| ts := servertest.NewPipeServer(ctx, ss, framer) |
| env := NewEnv(ctx, t, sandbox, ts, config.editor, !config.skipHooks) |
| defer func() { |
| if t.Failed() && r.PrintGoroutinesOnFailure { |
| pprof.Lookup("goroutine").WriteTo(os.Stderr, 1) |
| } |
| if t.Failed() || testing.Verbose() { |
| ls.printBuffers(t.Name(), os.Stderr) |
| } |
| env.CloseEditor() |
| }() |
| // Always await the initial workspace load. |
| env.Await(InitialWorkspaceLoad) |
| test(t, env) |
| }) |
| } |
| } |
| |
| type loggingFramer struct { |
| mu sync.Mutex |
| buf *safeBuffer |
| } |
| |
| // safeBuffer is a threadsafe buffer for logs. |
| type safeBuffer struct { |
| mu sync.Mutex |
| buf bytes.Buffer |
| } |
| |
| func (b *safeBuffer) Write(p []byte) (int, error) { |
| b.mu.Lock() |
| defer b.mu.Unlock() |
| return b.buf.Write(p) |
| } |
| |
| func (s *loggingFramer) framer(f jsonrpc2.Framer) jsonrpc2.Framer { |
| return func(nc net.Conn) jsonrpc2.Stream { |
| s.mu.Lock() |
| framed := false |
| if s.buf == nil { |
| s.buf = &safeBuffer{buf: bytes.Buffer{}} |
| framed = true |
| } |
| s.mu.Unlock() |
| stream := f(nc) |
| if framed { |
| return protocol.LoggingStream(stream, s.buf) |
| } |
| return stream |
| } |
| } |
| |
| func (s *loggingFramer) printBuffers(testname string, w io.Writer) { |
| s.mu.Lock() |
| defer s.mu.Unlock() |
| |
| if s.buf == nil { |
| return |
| } |
| fmt.Fprintf(os.Stderr, "#### Start Gopls Test Logs for %q\n", testname) |
| s.buf.mu.Lock() |
| io.Copy(w, &s.buf.buf) |
| s.buf.mu.Unlock() |
| fmt.Fprintf(os.Stderr, "#### End Gopls Test Logs for %q\n", testname) |
| } |
| |
| func singletonServer(ctx context.Context, t *testing.T) jsonrpc2.StreamServer { |
| return lsprpc.NewStreamServer(cache.New(ctx, hooks.Options), false) |
| } |
| |
| func experimentalWorkspaceModule(ctx context.Context, t *testing.T) jsonrpc2.StreamServer { |
| options := func(o *source.Options) { |
| hooks.Options(o) |
| o.ExperimentalWorkspaceModule = true |
| } |
| return lsprpc.NewStreamServer(cache.New(ctx, options), false) |
| } |
| |
| func (r *Runner) forwardedServer(ctx context.Context, t *testing.T) jsonrpc2.StreamServer { |
| ts := r.getTestServer() |
| return lsprpc.NewForwarder("tcp", ts.Addr) |
| } |
| |
| // getTestServer gets the shared test server instance to connect to, or creates |
| // one if it doesn't exist. |
| func (r *Runner) getTestServer() *servertest.TCPServer { |
| r.mu.Lock() |
| defer r.mu.Unlock() |
| if r.ts == nil { |
| ctx := context.Background() |
| ctx = debug.WithInstance(ctx, "", "off") |
| ss := lsprpc.NewStreamServer(cache.New(ctx, hooks.Options), false) |
| r.ts = servertest.NewTCPServer(ctx, ss, nil) |
| } |
| return r.ts |
| } |
| |
| func (r *Runner) separateProcessServer(ctx context.Context, t *testing.T) jsonrpc2.StreamServer { |
| // TODO(rfindley): can we use the autostart behavior here, instead of |
| // pre-starting the remote? |
| socket := r.getRemoteSocket(t) |
| return lsprpc.NewForwarder("unix", socket) |
| } |
| |
| // runTestAsGoplsEnvvar triggers TestMain to run gopls instead of running |
| // tests. It's a trick to allow tests to find a binary to use to start a gopls |
| // subprocess. |
| const runTestAsGoplsEnvvar = "_GOPLS_TEST_BINARY_RUN_AS_GOPLS" |
| |
| func (r *Runner) getRemoteSocket(t *testing.T) string { |
| t.Helper() |
| r.mu.Lock() |
| defer r.mu.Unlock() |
| const daemonFile = "gopls-test-daemon" |
| if r.socketDir != "" { |
| return filepath.Join(r.socketDir, daemonFile) |
| } |
| |
| if r.GoplsPath == "" { |
| t.Fatal("cannot run tests with a separate process unless a path to a gopls binary is configured") |
| } |
| var err error |
| r.socketDir, err = ioutil.TempDir(r.TempDir, "gopls-regtest-socket") |
| if err != nil { |
| t.Fatalf("creating tempdir: %v", err) |
| } |
| socket := filepath.Join(r.socketDir, daemonFile) |
| args := []string{"serve", "-listen", "unix;" + socket, "-listen.timeout", "10s"} |
| cmd := exec.Command(r.GoplsPath, args...) |
| cmd.Env = append(os.Environ(), runTestAsGoplsEnvvar+"=true") |
| var stderr bytes.Buffer |
| cmd.Stderr = &stderr |
| go func() { |
| if err := cmd.Run(); err != nil { |
| panic(fmt.Sprintf("error running external gopls: %v\nstderr:\n%s", err, stderr.String())) |
| } |
| }() |
| return socket |
| } |
| |
| // AddCloser schedules a closer to be closed at the end of the test run. This |
| // is useful for Windows in particular, as |
| func (r *Runner) AddCloser(closer io.Closer) { |
| r.mu.Lock() |
| defer r.mu.Unlock() |
| r.closers = append(r.closers, closer) |
| } |
| |
| // Close cleans up resource that have been allocated to this workspace. |
| func (r *Runner) Close() error { |
| r.mu.Lock() |
| defer r.mu.Unlock() |
| |
| var errmsgs []string |
| if r.ts != nil { |
| if err := r.ts.Close(); err != nil { |
| errmsgs = append(errmsgs, err.Error()) |
| } |
| } |
| if r.socketDir != "" { |
| if err := os.RemoveAll(r.socketDir); err != nil { |
| errmsgs = append(errmsgs, err.Error()) |
| } |
| } |
| if !r.SkipCleanup { |
| for _, closer := range r.closers { |
| if err := closer.Close(); err != nil { |
| errmsgs = append(errmsgs, err.Error()) |
| } |
| } |
| if err := os.RemoveAll(r.TempDir); err != nil { |
| errmsgs = append(errmsgs, err.Error()) |
| } |
| } |
| if len(errmsgs) > 0 { |
| return fmt.Errorf("errors closing the test runner:\n\t%s", strings.Join(errmsgs, "\n\t")) |
| } |
| return nil |
| } |