internal/modindex: update module cache index

This CL contains tests that the module cache
index can be updated. The tests cover all the
cases in modindex.go.
Change-Id: Ia5988fb0d2be1cbe5e26d9d5d0f0d43ce1e0e5d2
Reviewed-on: https://go-review.googlesource.com/c/tools/+/619695
Reviewed-by: Robert Findley <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>

Author: pjweinbgo

internal/modindex/dir_test.go

@@ -8,6 +8,8 @@ import (
 	"os"
 	"path/filepath"
 	"testing"
+
+	"github.com/google/go-cmp/cmp"
 )
 
 type id struct {
@@ -51,19 +53,123 @@ func testModCache(t *testing.T) string {
 	return dir
 }
 
+// add a trivial package to the test module cache
+func addPkg(cachedir, dir string) error {
+	if err := os.MkdirAll(filepath.Join(cachedir, dir), 0755); err != nil {
+		return err
+	}
+	return os.WriteFile(filepath.Join(cachedir, dir, "foo.go"),
+		[]byte("package foo\nfunc Foo() {}"), 0644)
+}
+
+// update, where new stuff is semantically better than old stuff
+func TestIncremental(t *testing.T) {
+	dir := testModCache(t)
+	// build old index
+	for _, it := range idtests {
+		for i, d := range it.dirs {
+			if it.best == i {
+				continue // wait for second pass
+			}
+			if err := addPkg(dir, d); err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+	if err := IndexModCache(dir, true); err != nil {
+		t.Fatal(err)
+	}
+	// add new stuff to the module cache
+	for _, it := range idtests {
+		for i, d := range it.dirs {
+			if it.best != i {
+				continue // only add the new stuff
+			}
+			if err := addPkg(dir, d); err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+	if err := IndexModCache(dir, false); err != nil {
+		t.Fatal(err)
+	}
+	index2, err := ReadIndex(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// build a fresh index
+	if err := IndexModCache(dir, true); err != nil {
+		t.Fatal(err)
+	}
+	index1, err := ReadIndex(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// they should be the same except maybe for the time
+	index1.Changed = index2.Changed
+	if diff := cmp.Diff(index1, index2); diff != "" {
+		t.Errorf("mismatching indexes (-updated +cleared):\n%s", diff)
+	}
+}
+
+// update, where new stuff is semantically worse than some old stuff
+func TestIncrementalNope(t *testing.T) {
+	dir := testModCache(t)
+	// build old index
+	for _, it := range idtests {
+		for i, d := range it.dirs {
+			if i == 0 {
+				continue // wait for second pass
+			}
+			if err := addPkg(dir, d); err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+	if err := IndexModCache(dir, true); err != nil {
+		t.Fatal(err)
+	}
+	// add new stuff to the module cache
+	for _, it := range idtests {
+		for i, d := range it.dirs {
+			if i > 0 {
+				break // only add the new one
+			}
+			if err := addPkg(dir, d); err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+	if err := IndexModCache(dir, false); err != nil {
+		t.Fatal(err)
+	}
+	index2, err := ReadIndex(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// build a fresh index
+	if err := IndexModCache(dir, true); err != nil {
+		t.Fatal(err)
+	}
+	index1, err := ReadIndex(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// they should be the same except maybe for the time
+	index1.Changed = index2.Changed
+	if diff := cmp.Diff(index1, index2); diff != "" {
+		t.Errorf("mismatching indexes (-updated +cleared):\n%s", diff)
+	}
+}
+
 // choose the semantically-latest version, with a single symbol
 func TestDirsSinglePath(t *testing.T) {
 	for _, itest := range idtests {
 		t.Run(itest.importPath, func(t *testing.T) {
 			// create a new test GOMODCACHE
 			dir := testModCache(t)
 			for _, d := range itest.dirs {
-				if err := os.MkdirAll(filepath.Join(dir, d), 0755); err != nil {
-					t.Fatal(err)
-				}
-				err := os.WriteFile(filepath.Join(dir, d, "foo.go"),
-					[]byte("package foo\nfunc Foo() {}"), 0600)
-				if err != nil {
+				if err := addPkg(dir, d); err != nil {
 					t.Fatal(err)
 				}
 			}

internal/modindex/directories.go

@@ -49,7 +49,7 @@ func byImportPath(dirs []Relpath) (map[string][]*directory, error) {
 	return ans, nil
 }
 
-// sort the directories by semantic version, lates first
+// sort the directories by semantic version, latest first
 func semanticSort(v []*directory) {
 	slices.SortFunc(v, func(l, r *directory) int {
 		if n := semver.Compare(l.version, r.version); n != 0 {

internal/modindex/modindex.go

@@ -13,7 +13,6 @@
 package modindex
 
 import (
-	"log"
 	"path/filepath"
 	"slices"
 	"strings"
@@ -91,34 +90,22 @@ func (w *work) buildIndex() error {
 	if err != nil {
 		return err
 	}
-	log.Printf("%d dirs, %d new", len(dirs), len(newdirs))
 	// for each import path it might occur only in newdirs,
 	// only in w.oldIndex, or in both.
 	// If it occurs in both, use the semantically later one
 	if w.oldIndex != nil {
-		killed := 0
 		for _, e := range w.oldIndex.Entries {
 			found, ok := newdirs[e.ImportPath]
 			if !ok {
-				continue
+				w.newIndex.Entries = append(w.newIndex.Entries, e)
+				continue // use this one, there is no new one
 			}
 			if semver.Compare(found[0].version, e.Version) > 0 {
-				// the new one is better, disable the old one
-				e.ImportPath = ""
-				killed++
+				// use the new one
 			} else {
 				// use the old one, forget the new one
-				delete(newdirs, e.ImportPath)
-			}
-		}
-		log.Printf("%d killed, %d new", killed, len(newdirs))
-	}
-	// Build the skeleton of the new index using newdirs,
-	// and include the surviving parts of the old index
-	if w.oldIndex != nil {
-		for _, e := range w.oldIndex.Entries {
-			if e.ImportPath != "" {
 				w.newIndex.Entries = append(w.newIndex.Entries, e)
+				delete(newdirs, e.ImportPath)
 			}
 		}
 	}