internal: rename VersionState to ModuleVersionState

VersionState is renamed to ModuleVersionState because a
PackageVersionState will be introduced in a future CL.

Updates b/133187024

Change-Id: If21c0feee9bd1c996b43cd16c7a5d0e79aa8c7ce
Reviewed-on: https://team-review.git.corp.google.com/c/golang/discovery/+/632662
CI-Result: Cloud Build <devtools-proctor-result-processor@system.gserviceaccount.com>
Reviewed-by: Jonathan Amsterdam <jba@google.com>

8 files changed, 73 insertions, 73 deletions

diff --git a/internal/discovery.go b/internal/discovery.go
index 087a3a2a..cb516f1c 100644
--- a/internal/discovery.go
+++ b/internal/discovery.go
@@ -112,8 +112,8 @@ type IndexVersion struct {
 	Timestamp time.Time
 }
 
-// VersionState holds the ETL version state.
-type VersionState struct {
+// ModuleVersionState holds an ETL module version state.
+type ModuleVersionState struct {
 	ModulePath string
 	Version    string
 
@@ -122,7 +122,7 @@ type VersionState struct {
 	// Index.
 	IndexTimestamp time.Time
 	// CreatedAt is the time this version was originally inserted into the
-	// version state table.
+	// module version state table.
 	CreatedAt time.Time
 
 	// Status is the most recent HTTP status code received from the Fetch service
diff --git a/internal/etl/fetch.go b/internal/etl/fetch.go
index f28db0e1..22237512 100644
--- a/internal/etl/fetch.go
+++ b/internal/etl/fetch.go
@@ -125,15 +125,15 @@ func fetchAndUpdateState(ctx context.Context, modulePath, version string, client
 	// module@version. This must happen last, because if it succeeds with a
 	// code < 500 but a later action fails, we will never retry the later action.
 
-	// TODO(b/139178863): Split UpsertVersionState into InsertVersionState and UpdateVersionState.
-	if err := db.UpsertVersionState(ctx, modulePath, version, config.AppVersionLabel(), time.Time{}, code, goModPath, fetchErr); err != nil {
+	// TODO(b/139178863): Split UpsertModuleVersionState into InsertModuleVersionState and UpdateModuleVersionState.
+	if err := db.UpsertModuleVersionState(ctx, modulePath, version, config.AppVersionLabel(), time.Time{}, code, goModPath, fetchErr); err != nil {
 		log.Error(ctx, err)
 		if fetchErr != nil {
-			err = fmt.Errorf("error updating version state: %v, original error: %v", err, fetchErr)
+			err = fmt.Errorf("error updating module version state: %v, original error: %v", err, fetchErr)
 		}
 		return http.StatusInternalServerError, err
 	}
-	log.Infof(ctx, "Updated version state for %s@%s: code=%d, hasIncompletePackages=%t err=%v",
+	log.Infof(ctx, "Updated module version state for %s@%s: code=%d, hasIncompletePackages=%t err=%v",
 		modulePath, version, code, hasIncompletePackages, fetchErr)
 	return code, fetchErr
 }
diff --git a/internal/etl/fetch_test.go b/internal/etl/fetch_test.go
index 2f0c1cfe..a01b61a7 100644
--- a/internal/etl/fetch_test.go
+++ b/internal/etl/fetch_test.go
@@ -50,12 +50,12 @@ func TestFetchAndUpdateState_NotFound(t *testing.T) {
 
 	checkStatus := func(want int) {
 		t.Helper()
-		vs, err := testDB.GetVersionState(ctx, modulePath, version)
+		vs, err := testDB.GetModuleVersionState(ctx, modulePath, version)
 		if err != nil {
 			t.Fatal(err)
 		}
 		if vs.Status == nil || *vs.Status != want {
-			t.Fatalf("testDB.GetVersionState(ctx, %q, %q): status=%v, want %d", modulePath, version, vs.Status, want)
+			t.Fatalf("testDB.GetModuleVersionState(ctx, %q, %q): status=%v, want %d", modulePath, version, vs.Status, want)
 		}
 	}
 
@@ -124,7 +124,7 @@ func checkModuleNotFound(t *testing.T, ctx context.Context, modulePath, version
 	if !errors.Is(err, derrors.NotFound) {
 		t.Fatalf("got %v, want Is(NotFound)", err)
 	}
-	vs, err := testDB.GetVersionState(ctx, modulePath, version)
+	vs, err := testDB.GetModuleVersionState(ctx, modulePath, version)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -133,7 +133,7 @@ func checkModuleNotFound(t *testing.T, ctx context.Context, modulePath, version
 		gotStatus = *vs.Status
 	}
 	if gotStatus != wantCode {
-		t.Fatalf("testDB.GetVersionState(ctx, %q, %q): status=%v, want %d", modulePath, version, gotStatus, wantCode)
+		t.Fatalf("testDB.GetModuleVersionState(ctx, %q, %q): status=%v, want %d", modulePath, version, gotStatus, wantCode)
 	}
 }
 
@@ -160,12 +160,12 @@ func TestFetchAndUpdateState_Incomplete(t *testing.T) {
 	if code != want {
 		t.Fatalf("got code %d, want %d", code, want)
 	}
-	vs, err := testDB.GetVersionState(ctx, modulePath, version)
+	vs, err := testDB.GetModuleVersionState(ctx, modulePath, version)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if vs.Status == nil || *vs.Status != want {
-		t.Fatalf("testDB.GetVersionState(ctx, %q, %q): status=%v, want %d", modulePath, version, vs.Status, want)
+		t.Fatalf("testDB.GetModuleVersionState(ctx, %q, %q): status=%v, want %d", modulePath, version, vs.Status, want)
 	}
 }
 
@@ -199,7 +199,7 @@ func TestFetchAndUpdateState_Mismatch(t *testing.T) {
 	if !errors.Is(err, derrors.NotFound) {
 		t.Fatalf("got %v, want Is(NotFound)", err)
 	}
-	vs, err := testDB.GetVersionState(ctx, modulePath, version)
+	vs, err := testDB.GetModuleVersionState(ctx, modulePath, version)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -209,7 +209,7 @@ func TestFetchAndUpdateState_Mismatch(t *testing.T) {
 		gotStatus = *vs.Status
 	}
 	if gotStatus != wantCode {
-		t.Errorf("testDB.GetVersionState(ctx, %q, %q): status=%v, want %d", modulePath, version, gotStatus, wantCode)
+		t.Errorf("testDB.GetModuleVersionState(ctx, %q, %q): status=%v, want %d", modulePath, version, gotStatus, wantCode)
 	}
 
 	var gotGoModPath string
@@ -217,7 +217,7 @@ func TestFetchAndUpdateState_Mismatch(t *testing.T) {
 		gotGoModPath = *vs.GoModPath
 	}
 	if gotGoModPath != goModPath {
-		t.Errorf("testDB.GetVersionState(ctx, %q, %q): goModPath=%q, want %q", modulePath, version, gotGoModPath, goModPath)
+		t.Errorf("testDB.GetModuleVersionState(ctx, %q, %q): goModPath=%q, want %q", modulePath, version, gotGoModPath, goModPath)
 	}
 }
 
diff --git a/internal/etl/server.go b/internal/etl/server.go
index 6f3b9f4c..30daf99a 100644
--- a/internal/etl/server.go
+++ b/internal/etl/server.go
@@ -357,7 +357,7 @@ func (s *Server) doStatusPage(w http.ResponseWriter, r *http.Request) (string, e
 		ServicePrefix                string
 		LatestTimestamp              *time.Time
 		Counts                       []*count
-		Next, Recent, RecentFailures []*internal.VersionState
+		Next, Recent, RecentFailures []*internal.ModuleVersionState
 	}{
 		Project:         "go-discovery",
 		ServicePrefix:   strings.TrimSuffix(config.ServiceID(), "etl"),
@@ -416,7 +416,7 @@ func (s *Server) handleReprocess(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
 		return
 	}
-	if err := s.db.UpdateVersionStatesForReprocessing(r.Context(), appVersion); err != nil {
+	if err := s.db.UpdateModuleVersionStatesForReprocessing(r.Context(), appVersion); err != nil {
 		log.Error(ctx, err)
 		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
 		return
diff --git a/internal/etl/server_test.go b/internal/etl/server_test.go
index f7269535..cbdf3f7f 100644
--- a/internal/etl/server_test.go
+++ b/internal/etl/server_test.go
@@ -76,7 +76,7 @@ func TestETL(t *testing.T) {
 			"go.mod": "module foo.com/bar",
 			"bar.go": "package bar\nconst Bar = \"Bar\"",
 		})
-		state = func(version *internal.IndexVersion, code, tryCount int) *internal.VersionState {
+		state = func(version *internal.IndexVersion, code, tryCount int) *internal.ModuleVersionState {
 			status := &code
 			goModPath := version.Path
 			if code == 0 {
@@ -85,7 +85,7 @@ func TestETL(t *testing.T) {
 			if code >= 300 {
 				goModPath = ""
 			}
-			return &internal.VersionState{
+			return &internal.ModuleVersionState{
 				ModulePath:     version.Path,
 				IndexTimestamp: version.Timestamp,
 				Status:         status,
@@ -94,10 +94,10 @@ func TestETL(t *testing.T) {
 				GoModPath:      &goModPath,
 			}
 		}
-		fooState = func(code, tryCount int) *internal.VersionState {
+		fooState = func(code, tryCount int) *internal.ModuleVersionState {
 			return state(fooIndex, code, tryCount)
 		}
-		barState = func(code, tryCount int) *internal.VersionState {
+		barState = func(code, tryCount int) *internal.ModuleVersionState {
 			return state(barIndex, code, tryCount)
 		}
 	)
@@ -107,8 +107,8 @@ func TestETL(t *testing.T) {
 		index    []*internal.IndexVersion
 		proxy    []*proxy.TestVersion
 		requests []*http.Request
-		wantFoo  *internal.VersionState
-		wantBar  *internal.VersionState
+		wantFoo  *internal.ModuleVersionState
+		wantBar  *internal.ModuleVersionState
 	}{
 		{
 			label: "full fetch",
@@ -175,13 +175,13 @@ func TestETL(t *testing.T) {
 
 			// To avoid being a change detector, only look at ModulePath, Version,
 			// Timestamp, and Status.
-			ignore := cmpopts.IgnoreFields(internal.VersionState{},
+			ignore := cmpopts.IgnoreFields(internal.ModuleVersionState{},
 				"CreatedAt", "NextProcessedAfter", "LastProcessedAt", "Error")
 
-			got, err := testDB.GetVersionState(ctx, fooIndex.Path, fooIndex.Version)
+			got, err := testDB.GetModuleVersionState(ctx, fooIndex.Path, fooIndex.Version)
 			if err == nil {
 				if diff := cmp.Diff(test.wantFoo, got, ignore); diff != "" {
-					t.Errorf("testDB.GetVersionState(ctx, %q, %q) mismatch (-want +got):\n%s",
+					t.Errorf("testDB.GetModuleVersionState(ctx, %q, %q) mismatch (-want +got):\n%s",
 						fooIndex.Path, fooIndex.Version, diff)
 				}
 			} else if test.wantFoo == nil {
@@ -191,10 +191,10 @@ func TestETL(t *testing.T) {
 			} else {
 				t.Fatal(err)
 			}
-			got, err = testDB.GetVersionState(ctx, barIndex.Path, barIndex.Version)
+			got, err = testDB.GetModuleVersionState(ctx, barIndex.Path, barIndex.Version)
 			if err == nil {
 				if diff := cmp.Diff(test.wantBar, got, ignore); diff != "" {
-					t.Errorf("testDB.GetVersionState(ctx, %q, %q) mismatch (-want +got):\n%s",
+					t.Errorf("testDB.GetModuleVersionState(ctx, %q, %q) mismatch (-want +got):\n%s",
 						barIndex.Path, barIndex.Version, diff)
 				}
 			} else if test.wantBar == nil {
diff --git a/internal/postgres/alternative_test.go b/internal/postgres/alternative_test.go
index d34b8d54..f2f219a7 100644
--- a/internal/postgres/alternative_test.go
+++ b/internal/postgres/alternative_test.go
@@ -107,15 +107,15 @@ func TestInsertAndDeleteAlternatives(t *testing.T) {
 	if err := testDB.InsertIndexVersions(ctx, versionStates); err != nil {
 		t.Fatal(err)
 	}
-	gotVersionStates, err := testDB.GetNextVersionsToFetch(ctx, len(pkgData))
+	gotModuleVersionStates, err := testDB.GetNextVersionsToFetch(ctx, len(pkgData))
 	if err != nil {
 		t.Fatal(err)
 	}
-	if len(gotVersionStates) != len(pkgData) {
+	if len(gotModuleVersionStates) != len(pkgData) {
 		t.Fatalf("testDB.GetNextVersionsToFetch(ctx, %d) returned %d version states; want = %d",
-			len(pkgData), len(gotVersionStates), len(pkgData))
+			len(pkgData), len(gotModuleVersionStates), len(pkgData))
 	}
-	for _, vs := range gotVersionStates {
+	for _, vs := range gotModuleVersionStates {
 		if vs.Status != nil && *vs.Status != http.StatusOK {
 			t.Fatalf("version state %q has status = %d; want = %d", vs.ModulePath, *vs.Status, http.StatusOK)
 		}
@@ -148,13 +148,13 @@ func TestInsertAndDeleteAlternatives(t *testing.T) {
 				t.Errorf("testDB.GetPackage(%q, latest) = %q, %q; want = %q, %q)", data.pkgPath, got.Path, got.ModulePath, data.pkgPath, data.modulePath)
 			}
 
-			gotVersionState, err := testDB.GetVersionState(ctx, data.modulePath, sample.VersionString)
+			gotModuleVersionState, err := testDB.GetModuleVersionState(ctx, data.modulePath, sample.VersionString)
 			if err != nil {
 				t.Fatal(err)
 			}
 			wantCode := derrors.ToHTTPStatus(derrors.AlternativeModule)
-			if gotVersionState.Status != nil && *gotVersionState.Status != wantCode {
-				t.Fatalf("testDB.GetVersionState(ctx, %q, %q) returned status = %d; want = %d", data.modulePath, sample.VersionString, gotVersionState.Status, wantCode)
+			if gotModuleVersionState.Status != nil && *gotModuleVersionState.Status != wantCode {
+				t.Fatalf("testDB.GetModuleVersionState(ctx, %q, %q) returned status = %d; want = %d", data.modulePath, sample.VersionString, gotModuleVersionState.Status, wantCode)
 			}
 		})
 	}
diff --git a/internal/postgres/versionstate.go b/internal/postgres/versionstate.go
index 2d79298c..f6a04207 100644
--- a/internal/postgres/versionstate.go
+++ b/internal/postgres/versionstate.go
@@ -40,13 +40,13 @@ func (db *DB) InsertIndexVersions(ctx context.Context, versions []*internal.Inde
 	})
 }
 
-// UpsertVersionState inserts or updates the module_version_state table with
+// UpsertModuleVersionState inserts or updates the module_version_state table with
 // the results of a fetch operation for a given module version.
-func (db *DB) UpsertVersionState(ctx context.Context, modulePath, vers, appVersion string, timestamp time.Time, status int, goModPath string, fetchErr error) (err error) {
-	derrors.Wrap(&err, "UpsertVersionState(ctx, %q, %q, %q, %s, %d, %q, %v",
+func (db *DB) UpsertModuleVersionState(ctx context.Context, modulePath, vers, appVersion string, timestamp time.Time, status int, goModPath string, fetchErr error) (err error) {
+	derrors.Wrap(&err, "UpsertModuleVersionState(ctx, %q, %q, %q, %s, %d, %q, %v",
 		modulePath, vers, appVersion, timestamp, status, goModPath, fetchErr)
 
-	ctx, span := trace.StartSpan(ctx, "UpsertVersionState")
+	ctx, span := trace.StartSpan(ctx, "UpsertModuleVersionState")
 	defer span.End()
 	query := `
 		INSERT INTO module_version_states AS mvs (module_path, version, sort_version, app_version, index_timestamp, status, go_mod_path, error)
@@ -83,7 +83,7 @@ func (db *DB) UpsertVersionState(ctx context.Context, modulePath, vers, appVersi
 		return fmt.Errorf("result.RowsAffected(): %v", err)
 	}
 	if affected != 1 {
-		return fmt.Errorf("version state update affected %d rows, expected exactly 1", affected)
+		return fmt.Errorf("module version state update affected %d rows, expected exactly 1", affected)
 	}
 	return nil
 }
@@ -110,8 +110,8 @@ func (db *DB) LatestIndexTimestamp(ctx context.Context) (_ time.Time, err error)
 	}
 }
 
-func (db *DB) UpdateVersionStatesForReprocessing(ctx context.Context, appVersion string) (err error) {
-	defer derrors.Wrap(&err, "UpdateVersionStatesForReprocessing(ctx, %q)", appVersion)
+func (db *DB) UpdateModuleVersionStatesForReprocessing(ctx context.Context, appVersion string) (err error) {
+	defer derrors.Wrap(&err, "UpdateModuleVersionStatesForReprocessing(ctx, %q)", appVersion)
 
 	query := `
 		UPDATE module_version_states
@@ -146,9 +146,9 @@ const versionStateColumns = `
 			app_version,
 			go_mod_path`
 
-// scanVersionState constructs an *internal.VersionState from the given
+// scanModuleVersionState constructs an *internal.ModuleModuleVersionState from the given
 // scanner. It expects columns to be in the order of versionStateColumns.
-func scanVersionState(scan func(dest ...interface{}) error) (*internal.VersionState, error) {
+func scanModuleVersionState(scan func(dest ...interface{}) error) (*internal.ModuleVersionState, error) {
 	var (
 		modulePath, version, appVersion               string
 		indexTimestamp, createdAt, nextProcessedAfter time.Time
@@ -161,7 +161,7 @@ func scanVersionState(scan func(dest ...interface{}) error) (*internal.VersionSt
 		&tryCount, &lastProcessedAt, &nextProcessedAfter, &appVersion, &goModPath); err != nil {
 		return nil, err
 	}
-	v := &internal.VersionState{
+	v := &internal.ModuleVersionState{
 		ModulePath:         modulePath,
 		Version:            version,
 		IndexTimestamp:     indexTimestamp,
@@ -189,10 +189,10 @@ func scanVersionState(scan func(dest ...interface{}) error) (*internal.VersionSt
 	return v, nil
 }
 
-// queryVersionStates executes a query for VersionState rows. It expects the
+// queryModuleVersionStates executes a query for ModuleModuleVersionState rows. It expects the
 // given queryFormat be a format specifier with exactly one argument: a %s verb
 // for the query columns.
-func (db *DB) queryVersionStates(ctx context.Context, queryFormat string, args ...interface{}) ([]*internal.VersionState, error) {
+func (db *DB) queryModuleVersionStates(ctx context.Context, queryFormat string, args ...interface{}) ([]*internal.ModuleVersionState, error) {
 	query := fmt.Sprintf(queryFormat, versionStateColumns)
 	rows, err := db.db.Query(ctx, query, args...)
 	if err != nil {
@@ -200,9 +200,9 @@ func (db *DB) queryVersionStates(ctx context.Context, queryFormat string, args .
 	}
 	defer rows.Close()
 
-	var versions []*internal.VersionState
+	var versions []*internal.ModuleVersionState
 	for rows.Next() {
-		v, err := scanVersionState(rows.Scan)
+		v, err := scanModuleVersionState(rows.Scan)
 		if err != nil {
 			return nil, fmt.Errorf("rows.Scan(): %v", err)
 		}
@@ -215,7 +215,7 @@ func (db *DB) queryVersionStates(ctx context.Context, queryFormat string, args .
 // GetNextVersionsToFetch returns the next batch of versions that must be
 // processed.
 // Prefer release versions to prerelease, and higher versions to lower.
-func (db *DB) GetNextVersionsToFetch(ctx context.Context, limit int) (_ []*internal.VersionState, err error) {
+func (db *DB) GetNextVersionsToFetch(ctx context.Context, limit int) (_ []*internal.ModuleVersionState, err error) {
 	defer derrors.Wrap(&err, "GetNextVersionsToFetch(ctx, %d)", limit)
 
 	queryFormat := `
@@ -229,11 +229,11 @@ func (db *DB) GetNextVersionsToFetch(ctx context.Context, limit int) (_ []*inter
 			right(sort_version, 1) = '~' DESC,
 			sort_version DESC
 		LIMIT $1`
-	return db.queryVersionStates(ctx, queryFormat, limit)
+	return db.queryModuleVersionStates(ctx, queryFormat, limit)
 }
 
 // GetRecentFailedVersions returns versions that have most recently failed.
-func (db *DB) GetRecentFailedVersions(ctx context.Context, limit int) (_ []*internal.VersionState, err error) {
+func (db *DB) GetRecentFailedVersions(ctx context.Context, limit int) (_ []*internal.ModuleVersionState, err error) {
 	defer derrors.Wrap(&err, "GetRecentFailedVersions(ctx, %d)", limit)
 
 	queryFormat := `
@@ -244,11 +244,11 @@ func (db *DB) GetRecentFailedVersions(ctx context.Context, limit int) (_ []*inte
 		  (status >= 400)
 		ORDER BY last_processed_at DESC
 		LIMIT $1`
-	return db.queryVersionStates(ctx, queryFormat, limit)
+	return db.queryModuleVersionStates(ctx, queryFormat, limit)
 }
 
 // GetRecentVersions returns recent versions that have been processed.
-func (db *DB) GetRecentVersions(ctx context.Context, limit int) (_ []*internal.VersionState, err error) {
+func (db *DB) GetRecentVersions(ctx context.Context, limit int) (_ []*internal.ModuleVersionState, err error) {
 	defer derrors.Wrap(&err, "GetRecentVersions(ctx, %d)", limit)
 
 	queryFormat := `
@@ -257,13 +257,13 @@ func (db *DB) GetRecentVersions(ctx context.Context, limit int) (_ []*internal.V
 			module_version_states
 		ORDER BY created_at DESC
 		LIMIT $1`
-	return db.queryVersionStates(ctx, queryFormat, limit)
+	return db.queryModuleVersionStates(ctx, queryFormat, limit)
 }
 
-// GetVersionState returns the current version state for modulePath and
-// version.
-func (db *DB) GetVersionState(ctx context.Context, modulePath, version string) (_ *internal.VersionState, err error) {
-	defer derrors.Wrap(&err, "GetVersionState(ctx, %q, %q)", modulePath, version)
+// GetModuleVersionState returns the current module version state for
+// modulePath and version.
+func (db *DB) GetModuleVersionState(ctx context.Context, modulePath, version string) (_ *internal.ModuleVersionState, err error) {
+	defer derrors.Wrap(&err, "GetModuleVersionState(ctx, %q, %q)", modulePath, version)
 
 	query := fmt.Sprintf(`
 		SELECT %s
@@ -274,7 +274,7 @@ func (db *DB) GetVersionState(ctx context.Context, modulePath, version string) (
 			AND version = $2;`, versionStateColumns)
 
 	row := db.db.QueryRow(ctx, query, modulePath, version)
-	v, err := scanVersionState(row.Scan)
+	v, err := scanModuleVersionState(row.Scan)
 	switch err {
 	case nil:
 		return v, nil
diff --git a/internal/postgres/versionstate_test.go b/internal/postgres/versionstate_test.go
index 45ae26d6..13c43abb 100644
--- a/internal/postgres/versionstate_test.go
+++ b/internal/postgres/versionstate_test.go
@@ -17,7 +17,7 @@ import (
 	"golang.org/x/discovery/internal/testing/sample"
 )
 
-func TestVersionState(t *testing.T) {
+func TestModuleVersionState(t *testing.T) {
 	defer ResetTestDB(testDB, t)
 	ctx, cancel := context.WithTimeout(context.Background(), testTimeout)
 	defer cancel()
@@ -62,11 +62,11 @@ func TestVersionState(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	wantVersions := []*internal.VersionState{
+	wantVersions := []*internal.ModuleVersionState{
 		{ModulePath: "baz.com/quux", Version: "v2.0.1", IndexTimestamp: bazVersion.Timestamp},
 		{ModulePath: "foo.com/bar", Version: "v1.0.0", IndexTimestamp: fooVersion.Timestamp},
 	}
-	ignore := cmpopts.IgnoreFields(internal.VersionState{}, "CreatedAt", "LastProcessedAt", "NextProcessedAfter")
+	ignore := cmpopts.IgnoreFields(internal.ModuleVersionState{}, "CreatedAt", "LastProcessedAt", "NextProcessedAfter")
 	if diff := cmp.Diff(wantVersions, gotVersions, ignore); diff != "" {
 		t.Fatalf("testDB.GetVersionsToFetch(ctx, 10) mismatch (-want +got):\n%s", diff)
 	}
@@ -76,11 +76,11 @@ func TestVersionState(t *testing.T) {
 		fetchErr   = errors.New("bad request")
 		goModPath  = "goModPath"
 	)
-	if err := testDB.UpsertVersionState(ctx, fooVersion.Path, fooVersion.Version, "", fooVersion.Timestamp, statusCode, goModPath, fetchErr); err != nil {
+	if err := testDB.UpsertModuleVersionState(ctx, fooVersion.Path, fooVersion.Version, "", fooVersion.Timestamp, statusCode, goModPath, fetchErr); err != nil {
 		t.Fatal(err)
 	}
 	errString := fetchErr.Error()
-	wantFooState := &internal.VersionState{
+	wantFooState := &internal.ModuleVersionState{
 		ModulePath:         "foo.com/bar",
 		Version:            "v1.0.0",
 		IndexTimestamp:     now,
@@ -90,12 +90,12 @@ func TestVersionState(t *testing.T) {
 		Status:             &statusCode,
 		NextProcessedAfter: gotVersions[1].CreatedAt.Add(1 * time.Minute),
 	}
-	gotFooState, err := testDB.GetVersionState(ctx, wantFooState.ModulePath, wantFooState.Version)
+	gotFooState, err := testDB.GetModuleVersionState(ctx, wantFooState.ModulePath, wantFooState.Version)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if diff := cmp.Diff(wantFooState, gotFooState, ignore); diff != "" {
-		t.Errorf("testDB.GetVersionState(ctx, %q, %q) mismatch (-want +got)\n%s", wantFooState.ModulePath, wantFooState.Version, diff)
+		t.Errorf("testDB.GetModuleVersionState(ctx, %q, %q) mismatch (-want +got)\n%s", wantFooState.ModulePath, wantFooState.Version, diff)
 	}
 
 	stats, err := testDB.GetVersionStats(ctx)
@@ -114,7 +114,7 @@ func TestVersionState(t *testing.T) {
 	}
 }
 
-func TestUpdateVersionStatesForReprocessing(t *testing.T) {
+func TestUpdateModuleVersionStatesForReprocessing(t *testing.T) {
 	defer ResetTestDB(testDB, t)
 	ctx, cancel := context.WithTimeout(context.Background(), testTimeout)
 	defer cancel()
@@ -133,7 +133,7 @@ func TestUpdateVersionStatesForReprocessing(t *testing.T) {
 			Timestamp: now,
 		},
 	} {
-		if err := testDB.UpsertVersionState(ctx, v.Path, v.Version, "", v.Timestamp, http.StatusOK, goModPath, nil); err != nil {
+		if err := testDB.UpsertModuleVersionState(ctx, v.Path, v.Version, "", v.Timestamp, http.StatusOK, goModPath, nil); err != nil {
 			t.Fatal(err)
 		}
 	}
@@ -145,7 +145,7 @@ func TestUpdateVersionStatesForReprocessing(t *testing.T) {
 	if len(gotVersions) != 0 {
 		t.Fatalf("testDB.GetVersionsToFetch(ctx, 10) = %v; wanted 0 versions", gotVersions)
 	}
-	if err := testDB.UpdateVersionStatesForReprocessing(ctx, "20190709t112655"); err != nil {
+	if err := testDB.UpdateModuleVersionStatesForReprocessing(ctx, "20190709t112655"); err != nil {
 		t.Fatal(err)
 	}
 
@@ -155,11 +155,11 @@ func TestUpdateVersionStatesForReprocessing(t *testing.T) {
 	}
 
 	code := http.StatusHTTPVersionNotSupported
-	wantVersions := []*internal.VersionState{
+	wantVersions := []*internal.ModuleVersionState{
 		{ModulePath: "baz.com/quux", Version: "v2.0.1", IndexTimestamp: now, GoModPath: &goModPath, Status: &code},
 		{ModulePath: "foo.com/bar", Version: "v1.0.0", IndexTimestamp: now, GoModPath: &goModPath, Status: &code},
 	}
-	ignore := cmpopts.IgnoreFields(internal.VersionState{}, "CreatedAt", "LastProcessedAt", "NextProcessedAfter")
+	ignore := cmpopts.IgnoreFields(internal.ModuleVersionState{}, "CreatedAt", "LastProcessedAt", "NextProcessedAfter")
 	if diff := cmp.Diff(wantVersions, gotVersions, ignore); diff != "" {
 		t.Fatalf("testDB.GetVersionsToFetch(ctx, 10) mismatch (-want +got):\n%s", diff)
 	}