internal/postgres: ensure good version not later than cooked

The good latest version of a module should never be later than the
cooked latest version. If it is, then pkgsite will show a different
version than the go command will download.

One way this can happen is if a module retracts all tagged versions,
and pseudo-versions were built on top of some of them. For example,
initially it could have versions

	v0.1.0
	v0.1.0-DATE-HASH (a pseudo-version)

Then v0.1.0 is retracted and a new pseudo-version appears at
head:

	v0.1.0 (retracted)
	v0.1.0-DATE-HASH
	v0.0.0-DATE-HASH (head of default branch)

The go command will get the v0.0.0 version, but technically
the v0.1.0 is later.

For golang/go#43265

Change-Id: I8ff30de4eb2dcdf108205de99af93d2f31772cff
Reviewed-on: https://go-review.googlesource.com/c/pkgsite/+/318069
Trust: Jonathan Amsterdam <[email protected]>
Run-TryBot: Jonathan Amsterdam <[email protected]>
Reviewed-by: Julie Qiu <[email protected]>

Author: jba

internal/postgres/search_test.go

@@ -787,15 +787,19 @@ func TestUpsertSearchDocument(t *testing.T) {
 		return sd
 	}
 
-	insertModule := func(version string, gomod bool) {
+	insertModule := func(version string, gomod, latest bool) {
 		m := sample.Module(sample.ModulePath, version, "A")
 		m.HasGoMod = gomod
 		m.Packages()[0].Documentation[0].Synopsis = "syn-" + version
-		MustInsertModule(ctx, t, testDB, m)
+		if latest {
+			MustInsertModule(ctx, t, testDB, m)
+		} else {
+			MustInsertModuleNotLatest(ctx, t, testDB, m)
+		}
 	}
 
 	const v1 = "v1.0.0"
-	insertModule(v1, false)
+	insertModule(v1, false, true)
 	sd1 := getSearchDocument()
 	if sd1.version != v1 {
 		t.Fatalf("got %s, want %s", sd1.version, v1)
@@ -804,22 +808,22 @@ func TestUpsertSearchDocument(t *testing.T) {
 	// Since the latest compatible version has no go.mod file, this incompatible version
 	// is the latest.
 	const vInc = "v2.0.0+incompatible"
-	insertModule(vInc, false)
+	insertModule(vInc, false, true)
 	sdInc := getSearchDocument()
 	if sdInc.version != vInc {
 		t.Fatalf("got %s, want %s", sdInc.version, vInc)
 	}
 
 	// Inserting an older module doesn't change anything.
-	insertModule("v0.5.0", true)
+	insertModule("v0.5.0", true, false)
 	sdOlder := getSearchDocument()
 	if diff := cmp.Diff(sdInc, sdOlder, cmp.AllowUnexported(searchDocument{})); diff != "" {
 		t.Fatalf("mismatch (-want, +got):\n%s", diff)
 	}
 
 	// A later compatible version with a go.mod file. This becomes the new latest version.
 	const v15 = "v1.5.2"
-	insertModule(v15, true)
+	insertModule(v15, true, true)
 	sdNewer := getSearchDocument()
 	if sdNewer.version != v15 {
 		t.Fatalf("got %s, want %s", sdNewer.version, v15)

internal/postgres/test_helper.go

@@ -202,17 +202,25 @@ func RunDBTestsInParallel(dbBaseName string, numDBs int, m *testing.M, acquirep
 // MustInsertModule inserts m into db, calling t.Fatal on error.
 // It also updates the latest-version information for m.
 func MustInsertModule(ctx context.Context, t *testing.T, db *DB, m *internal.Module) {
-	MustInsertModuleGoMod(ctx, t, db, m, "")
+	mustInsertModule(ctx, t, db, m, "", true)
 }
 
 func MustInsertModuleGoMod(ctx context.Context, t *testing.T, db *DB, m *internal.Module, goMod string) {
+	mustInsertModule(ctx, t, db, m, goMod, true)
+}
+
+func MustInsertModuleNotLatest(ctx context.Context, t *testing.T, db *DB, m *internal.Module) {
+	mustInsertModule(ctx, t, db, m, "", false)
+}
+
+func mustInsertModule(ctx context.Context, t *testing.T, db *DB, m *internal.Module, goMod string, latest bool) {
 	t.Helper()
 	var lmv *internal.LatestModuleVersions
 	if goMod == "-" {
 		if err := db.UpdateLatestModuleVersionsStatus(ctx, m.ModulePath, 404); err != nil {
 			t.Fatal(err)
 		}
-	} else {
+	} else if latest {
 		lmv = addLatest(ctx, t, db, m.ModulePath, m.Version, goMod)
 	}
 	if _, err := db.InsertModule(ctx, m, lmv); err != nil {

internal/postgres/unit.go

@@ -188,6 +188,21 @@ func (db *DB) getLatestUnitVersion(ctx context.Context, fullPath, requestedModul
 		if !version.IsIncompatible(lmv.CookedVersion) {
 			unretractedVersions = version.RemoveIf(unretractedVersions, version.IsIncompatible)
 		}
+		// The good version should never be later than the cooked version.
+		// https://golang.org/issue/43265 documents how that could happen:
+		// 1. A pseudo-version is created off of a tagged version. In this case,
+		//    golang.zx2c4.com/[email protected].
+		// 2. All tagged versions are retracted.
+		// 3. A new pseudo-version is published. In this case, v0.0.0-20210506092213-60a26371f42f.
+		// Technically, the first pseudo-version is higher than the second, so it
+		// is the latest good version. But the proxy's latest endpoint returns
+		// the second pseudo-version, so that is the cooked version (and what the
+		// go command will download).
+		if lmv.CookedVersion != "" {
+			unretractedVersions = version.RemoveIf(unretractedVersions, func(v string) bool {
+				return version.Later(v, lmv.CookedVersion)
+			})
+		}
 		latestVersion = version.LatestOf(unretractedVersions)
 		break
 	}

internal/postgres/version.go

@@ -388,10 +388,18 @@ func getLatestGoodVersion(ctx context.Context, tx *database.DB, modulePath strin
 	if err != nil {
 		return "", err
 	}
-	// Choose the latest good version from the unretracted versions.
+	// Choose the latest good version from a filtered list of versions.
 	if lmv != nil {
+		// Remove retracted versions.
 		vs = version.RemoveIf(vs, lmv.IsRetracted)
+		// The good version should never be later than the cooked version.
+		if lmv.CookedVersion != "" {
+			vs = version.RemoveIf(vs, func(v string) bool {
+				return version.Later(v, lmv.CookedVersion)
+			})
+		}
 	}
+
 	return version.LatestOf(vs), nil
 }