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>

3 files changed, 44 insertions, 44 deletions

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)
 	}