gopls/cache: add test for imports of non-ambiguous non-default modules

This is a separate CL because of its size. Creating a fake and
pre-populated registry, and threading it through the test framework.

Signed-off-by: Matthew Sackman <[email protected]>
Change-Id: Ic43e21001ef08d7a6ef731b7b12b75875ad26a92
Reviewed-on: https://review.gerrithub.io/c/cue-lang/cue/+/1218701
Reviewed-by: Roger Peppe <[email protected]>
TryBot-Result: CUEcueckoo <[email protected]>
Unity-Result: CUE porcuepine <[email protected]>

Author: cuematthew

cmd/cue/cmd/integration/workspace/imports_test.go

@@ -0,0 +1,90 @@
+package workspace
+
+import (
+	"io/fs"
+	"testing"
+
+	"cuelang.org/go/internal/golangorgx/gopls/cache"
+	"cuelang.org/go/internal/golangorgx/gopls/protocol"
+	. "cuelang.org/go/internal/golangorgx/gopls/test/integration"
+	"cuelang.org/go/mod/modcache"
+	"cuelang.org/go/mod/modconfig"
+	"cuelang.org/go/mod/modregistrytest"
+
+	"github.com/go-quicktest/qt"
+	"golang.org/x/tools/txtar"
+)
+
+func TestImports(t *testing.T) {
+	registryFS, err := txtar.FS(txtar.Parse([]byte(`
+-- _registry/example.com_foo_v0.0.1/cue.mod/module.cue --
+module: "example.com/foo@v0"
+language: version: "v0.11.0"
+-- _registry/example.com_foo_v0.0.1/x/y.cue --
+package x
+`)))
+
+	qt.Assert(t, qt.IsNil(err))
+	reg := newRegistry(t, registryFS)
+
+	const files = `
+-- cue.mod/module.cue --
+module: "example.com/bar"
+language: version: "v0.11.0"
+deps: {
+	"example.com/foo@v0": {
+		v: "v0.0.1"
+	}
+}
+-- a/a.cue --
+package a
+
+import "example.com/foo/x"
+`
+
+	t.Run("open", func(t *testing.T) {
+		WithOptions(
+			RootURIAsDefaultFolder(), Registry(reg), Modes(DefaultModes()&^Forwarded),
+		).Run(t, files, func(t *testing.T, env *Env) {
+			rootURI := env.Sandbox.Workdir.RootURI()
+			env.Await(
+				LogExactf(protocol.Debug, 1, false, "Workspace folder added: %v", rootURI),
+			)
+			env.OpenFile("a/a.cue")
+			env.Await(
+				env.DoneWithOpen(),
+				LogExactf(protocol.Debug, 1, false, "Module dir=%v module=unknown Created", rootURI),
+				LogExactf(protocol.Debug, 1, false, "Module dir=%v module=example.com/bar@v0 Reloaded", rootURI),
+				LogExactf(protocol.Debug, 1, false, "Module dir=%v module=example.com/bar@v0 For file %v/a/a.cue found [Package dir=%v/a importPath=example.com/bar/a@v0]", rootURI, rootURI, rootURI),
+				LogExactf(protocol.Debug, 1, false, "Module dir=%v module=example.com/bar@v0 Loading packages [example.com/bar/a@v0]", rootURI),
+				LogExactf(protocol.Debug, 1, false, "Module dir=%v module=example.com/bar@v0 Loaded Package dir=%v/a importPath=example.com/bar/a@v0", rootURI, rootURI),
+			)
+		})
+	})
+}
+
+func newRegistry(t *testing.T, fsys fs.FS) cache.Registry {
+	t.Helper()
+	fsys, err := fs.Sub(fsys, "_registry")
+	qt.Assert(t, qt.IsNil(err))
+	regSrv, err := modregistrytest.New(fsys, "")
+	qt.Assert(t, qt.IsNil(err))
+	cacheDir := t.TempDir()
+	// t.TempDir calls Cleanup internally. Cleanups are invoked in
+	// "last added, first called". We need to stop the server before we
+	// attempt to delete the temp dir. The modcache code is very
+	// thorough at setting permissions on files so we need a special
+	// cleanup so that t.TempDir's cleanup doesn't error!
+	t.Cleanup(func() { modcache.RemoveAll(cacheDir) })
+	t.Cleanup(regSrv.Close)
+	modcfg := &modconfig.Config{
+		Env: []string{
+			"CUE_REGISTRY=" + regSrv.Host(),
+			// Set an empty cache dir so that a developer's ~/.cache/cue doesn't influence the tests!
+			"CUE_CACHE_DIR=" + cacheDir,
+		},
+	}
+	reg, err := modconfig.NewRegistry(modcfg)
+	qt.Assert(t, qt.IsNil(err))
+	return reg
+}

internal/golangorgx/gopls/cache/cache.go

@@ -16,26 +16,32 @@ func New() (*Cache, error) {
 	modcfg := &modconfig.Config{
 		ClientType: "cuelsp",
 	}
-	var err error
-	registry, err := modconfig.NewRegistry(modcfg)
+	reg, err := modconfig.NewRegistry(modcfg)
 	if err != nil {
 		return nil, err
 	}
+	return NewWithRegistry(reg), nil
+}
 
+// NewWithRegistry creates a new cache, using the specified registry.
+func NewWithRegistry(reg Registry) *Cache {
+	if reg == nil {
+		panic("nil registry")
+	}
 	return &Cache{
 		fs:       fscache.NewCUECachedFS(),
-		registry: registry,
-	}, nil
+		registry: reg,
+	}
 }
 
 // A Cache holds content that is shared across multiple cuelsp
 // client/editor connections.
 type Cache struct {
 	fs       *fscache.CUECacheFS
-	registry modregistry
+	registry Registry
 }
 
-type modregistry interface {
+type Registry interface {
 	modrequirements.Registry
 	modpkgload.Registry
 }

internal/golangorgx/gopls/cache/module.go

@@ -35,7 +35,7 @@ import (
 type Module struct {
 	// immutable fields: all set at construction only
 
-	registry modregistry
+	registry Registry
 	fs       *fscache.OverlayFS
 
 	debugLog func(string)
@@ -76,7 +76,7 @@ type Module struct {
 // NewModule creates a new Module. The CUE module itself (that is, the
 // cue.mod/module.cue file) is not loaded until [Module.ReloadModule]
 // is called.
-func NewModule(modFileUri protocol.DocumentURI, registry modregistry, overlayFS *fscache.OverlayFS, debugLog func(string)) *Module {
+func NewModule(modFileUri protocol.DocumentURI, registry Registry, overlayFS *fscache.OverlayFS, debugLog func(string)) *Module {
 	return &Module{
 		rootURI:    modFileUri.Dir().Dir(),
 		modFileURI: modFileUri,

internal/golangorgx/gopls/cache/workspace.go

@@ -28,7 +28,7 @@ import (
 // configures one workspace. A workspace may have several workspace
 // folders [WorkspaceFolder].
 type Workspace struct {
-	registry  modregistry // shared with other Workspaces
+	registry  Registry // shared with other Workspaces
 	fs        *fscache.CUECacheFS
 	overlayFS *fscache.OverlayFS
 

internal/golangorgx/gopls/test/integration/options.go

@@ -5,6 +5,7 @@
 package integration
 
 import (
+	"cuelang.org/go/internal/golangorgx/gopls/cache"
 	"cuelang.org/go/internal/golangorgx/gopls/protocol"
 	"cuelang.org/go/internal/golangorgx/gopls/test/integration/fake"
 )
@@ -20,6 +21,7 @@ type runConfig struct {
 	//
 	// TODO(myitcv): is there a better place for this?
 	initializeErrorMatches string
+	reg                    cache.Registry
 }
 
 func defaultConfig() runConfig {
@@ -181,3 +183,11 @@ func MessageResponder(f func(*protocol.ShowMessageRequestParams) (*protocol.Mess
 		opts.editor.MessageResponder = f
 	})
 }
+
+// Registry configures the server to use the provided [cache.Registry]
+// instead of the default registry.
+func Registry(reg cache.Registry) RunOption {
+	return optionSetter(func(opts *runConfig) {
+		opts.reg = reg
+	})
+}

internal/golangorgx/gopls/test/integration/runner.go

@@ -140,7 +140,7 @@ func (r *Runner) Run(t *testing.T, files string, test TestFunc, opts ...RunOptio
 	tests := []struct {
 		name      string
 		mode      Mode
-		getServer func(func(*settings.Options)) jsonrpc2.StreamServer
+		getServer func(runConfig, func(*settings.Options)) jsonrpc2.StreamServer
 	}{
 		{"default", Default, r.defaultServer},
 		{"forwarded", Forwarded, r.forwardedServer},
@@ -205,7 +205,7 @@ func (r *Runner) Run(t *testing.T, files string, test TestFunc, opts ...RunOptio
 				}
 			}()
 
-			ss := tc.getServer(r.OptionsHook)
+			ss := tc.getServer(config, r.OptionsHook)
 
 			framer := jsonrpc2.NewRawStream
 			ls := &loggingFramer{}
@@ -308,17 +308,17 @@ func (s *loggingFramer) printBuffers(testname string, w io.Writer) {
 }
 
 // defaultServer handles the Default execution mode.
-func (r *Runner) defaultServer(optsHook func(*settings.Options)) jsonrpc2.StreamServer {
-	c, err := cache.New()
+func (r *Runner) defaultServer(config runConfig, optsHook func(*settings.Options)) jsonrpc2.StreamServer {
+	c, err := newCache(config)
 	if err != nil {
 		panic(err)
 	}
 	return lsprpc.NewStreamServer(c, false, optsHook)
 }
 
 // experimentalServer handles the Experimental execution mode.
-func (r *Runner) experimentalServer(optsHook func(*settings.Options)) jsonrpc2.StreamServer {
-	c, err := cache.New()
+func (r *Runner) experimentalServer(config runConfig, optsHook func(*settings.Options)) jsonrpc2.StreamServer {
+	c, err := newCache(config)
 	if err != nil {
 		panic(err)
 	}
@@ -330,9 +330,15 @@ func (r *Runner) experimentalServer(optsHook func(*settings.Options)) jsonrpc2.S
 }
 
 // forwardedServer handles the Forwarded execution mode.
-func (r *Runner) forwardedServer(optsHook func(*settings.Options)) jsonrpc2.StreamServer {
+func (r *Runner) forwardedServer(config runConfig, optsHook func(*settings.Options)) jsonrpc2.StreamServer {
+	if config.reg != nil {
+		// This is because the server may be long-lived and used for
+		// several tests, possibly even in parallel. So we cannot allow
+		// tests to attempt to reconfigure the server.
+		panic("explicit registry cannot be set for separate process execution mode")
+	}
 	r.tsOnce.Do(func() {
-		c, err := cache.New()
+		c, err := newCache(config)
 		if err != nil {
 			panic(err)
 		}
@@ -343,16 +349,27 @@ func (r *Runner) forwardedServer(optsHook func(*settings.Options)) jsonrpc2.Stre
 	return newForwarder("tcp", r.ts.Addr)
 }
 
+func newCache(config runConfig) (*cache.Cache, error) {
+	if config.reg == nil {
+		return cache.New()
+	} else {
+		return cache.NewWithRegistry(config.reg), nil
+	}
+}
+
 // 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"
 
 // separateProcessServer handles the SeparateProcess execution mode.
-func (r *Runner) separateProcessServer(optsHook func(*settings.Options)) jsonrpc2.StreamServer {
+func (r *Runner) separateProcessServer(config runConfig, optsHook func(*settings.Options)) jsonrpc2.StreamServer {
 	if runtime.GOOS != "linux" {
 		panic("separate process execution mode is only supported on linux")
 	}
+	if config.reg != nil {
+		panic("explicit registry cannot be set for separate process execution mode")
+	}
 
 	r.startRemoteOnce.Do(func() {
 		socketDir, err := os.MkdirTemp(r.tempDir, "cue-lsp-test-socket")