internal: rename GetPackage to LegacyGetPackage
Change-Id: Ia9123b6551d950a7ecfdf808e3da5c788512d60a
Reviewed-on: https://go-review.googlesource.com/c/pkgsite/+/238026
Reviewed-by: Jonathan Amsterdam <jba@google.com>
diff --git a/internal/datasource.go b/internal/datasource.go
index 9782f13..db61d69 100644
--- a/internal/datasource.go
+++ b/internal/datasource.go
@@ -50,10 +50,10 @@
// LegacyGetModuleLicenses returns all top-level Licenses for the given modulePath
// and version. (i.e., Licenses contained in the module root directory)
LegacyGetModuleLicenses(ctx context.Context, modulePath, version string) ([]*licenses.License, error)
- // GetPackage returns the LegacyVersionedPackage corresponding to the given package
+ // LegacyGetPackage returns the LegacyVersionedPackage corresponding to the given package
// pkgPath, modulePath, and version. When multiple package paths satisfy this query, it
// should prefer the module with the longest path.
- GetPackage(ctx context.Context, pkgPath, modulePath, version string) (*LegacyVersionedPackage, error)
+ LegacyGetPackage(ctx context.Context, pkgPath, modulePath, version string) (*LegacyVersionedPackage, error)
// LegacyGetPackageLicenses returns all Licenses that apply to pkgPath, within the
// module version specified by modulePath and version.
LegacyGetPackageLicenses(ctx context.Context, pkgPath, modulePath, version string) ([]*licenses.License, error)
diff --git a/internal/frontend/latest_version.go b/internal/frontend/latest_version.go
index 3a3026f..67fc90e 100644
--- a/internal/frontend/latest_version.go
+++ b/internal/frontend/latest_version.go
@@ -40,7 +40,7 @@
return "", err
}
case "pkg":
- pkg, err := s.ds.GetPackage(ctx, packagePath, modulePath, internal.LatestVersion)
+ pkg, err := s.ds.LegacyGetPackage(ctx, packagePath, modulePath, internal.LatestVersion)
if err != nil {
return "", err
}
diff --git a/internal/frontend/package.go b/internal/frontend/package.go
index 099c581..e5461b3 100644
--- a/internal/frontend/package.go
+++ b/internal/frontend/package.go
@@ -36,7 +36,7 @@
// 3. If there is another version that contains this package path: serve a
// 404 and suggest these versions.
// 4. Just serve a 404
- pkg, err := s.ds.GetPackage(ctx, pkgPath, modulePath, version)
+ pkg, err := s.ds.LegacyGetPackage(ctx, pkgPath, modulePath, version)
if err == nil {
return s.servePackagePageWithPackage(ctx, w, r, pkg, version)
}
@@ -65,14 +65,14 @@
// whatever response we resolve below might be inconsistent or misleading.
return fmt.Errorf("checking for directory: %v", err)
}
- _, err = s.ds.GetPackage(ctx, pkgPath, modulePath, internal.LatestVersion)
+ _, err = s.ds.LegacyGetPackage(ctx, pkgPath, modulePath, internal.LatestVersion)
if err == nil {
return pathFoundAtLatestError(ctx, "package", pkgPath, version)
}
if !errors.Is(err, derrors.NotFound) {
// Unlike the error handling for LegacyGetDirectory above, we don't serve an
// InternalServerError here. The reasoning for this is that regardless of
- // the result of GetPackage(..., "latest"), we're going to serve a NotFound
+ // the result of LegacyGetPackage(..., "latest"), we're going to serve a NotFound
// response code. So the semantics of the endpoint are the same whether or
// not we get an unexpected error from GetPackage -- we just don't serve a
// more informative error response.
diff --git a/internal/frontend/search.go b/internal/frontend/search.go
index f25fbb7..b8966cd 100644
--- a/internal/frontend/search.go
+++ b/internal/frontend/search.go
@@ -154,7 +154,7 @@
return fmt.Sprintf("/mod/%s", requestedPath)
}
- pkg, err := ds.GetPackage(ctx, requestedPath, internal.UnknownModulePath, internal.LatestVersion)
+ pkg, err := ds.LegacyGetPackage(ctx, requestedPath, internal.UnknownModulePath, internal.LatestVersion)
if err == nil {
return fmt.Sprintf("/%s", pkg.Path)
} else if !errors.Is(err, derrors.NotFound) {
diff --git a/internal/postgres/insert_module_test.go b/internal/postgres/insert_module_test.go
index fb3e809..bdbbbe5 100644
--- a/internal/postgres/insert_module_test.go
+++ b/internal/postgres/insert_module_test.go
@@ -94,7 +94,7 @@
}
for _, wantp := range want.LegacyPackages {
- got, err := testDB.GetPackage(ctx, wantp.Path, want.ModulePath, want.Version)
+ got, err := testDB.LegacyGetPackage(ctx, wantp.Path, want.ModulePath, want.Version)
if err != nil {
t.Fatal(err)
}
@@ -106,7 +106,7 @@
cmpopts.EquateEmpty(),
}
if diff := cmp.Diff(*wantp, got.LegacyPackage, opts...); diff != "" {
- t.Fatalf("testDB.GetPackage(%q, %q) mismatch (-want +got):\n%s", wantp.Path, want.Version, diff)
+ t.Fatalf("testDB.LegacyGetPackage(%q, %q) mismatch (-want +got):\n%s", wantp.Path, want.Version, diff)
}
}
diff --git a/internal/postgres/package.go b/internal/postgres/package.go
index 803b45d..8f1e310 100644
--- a/internal/postgres/package.go
+++ b/internal/postgres/package.go
@@ -16,7 +16,7 @@
"golang.org/x/pkgsite/internal/stdlib"
)
-// GetPackage returns the a package from the database with the corresponding
+// LegacyGetPackage returns the a package from the database with the corresponding
// pkgPath, modulePath and version.
//
// If version = internal.LatestVersion, the package corresponding to
@@ -41,8 +41,8 @@
// The returned error may be checked with
// errors.Is(err, derrors.InvalidArgument) to determine if it was caused by an
// invalid path or version.
-func (db *DB) GetPackage(ctx context.Context, pkgPath, modulePath, version string) (_ *internal.LegacyVersionedPackage, err error) {
- defer derrors.Wrap(&err, "DB.GetPackage(ctx, %q, %q)", pkgPath, version)
+func (db *DB) LegacyGetPackage(ctx context.Context, pkgPath, modulePath, version string) (_ *internal.LegacyVersionedPackage, err error) {
+ defer derrors.Wrap(&err, "DB.LegacyGetPackage(ctx, %q, %q)", pkgPath, version)
if pkgPath == "" || modulePath == "" || version == "" {
return nil, fmt.Errorf("none of pkgPath, modulePath, or version can be empty: %w", derrors.InvalidArgument)
}
diff --git a/internal/postgres/package_test.go b/internal/postgres/package_test.go
index 88996ca..61cb6fa 100644
--- a/internal/postgres/package_test.go
+++ b/internal/postgres/package_test.go
@@ -19,7 +19,7 @@
"golang.org/x/pkgsite/internal/testing/sample"
)
-func TestGetPackage(t *testing.T) {
+func TestLegacyGetPackage(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), testTimeout)
defer cancel()
@@ -56,7 +56,7 @@
cmpopts.IgnoreFields(licenses.Metadata{}, "Coverage"),
}
if diff := cmp.Diff(want, got, opts...); diff != "" {
- t.Errorf("testDB.GetPackage(ctx, %q, %q, %q) mismatch (-want +got):\n%s", pkgPath, modulePath, version, diff)
+ t.Errorf("testDB.LegacyGetPackage(ctx, %q, %q, %q) mismatch (-want +got):\n%s", pkgPath, modulePath, version, diff)
}
}
@@ -188,7 +188,7 @@
},
} {
t.Run(tc.name, func(t *testing.T) {
- got, err := testDB.GetPackage(ctx, tc.pkgPath, tc.modulePath, tc.version)
+ got, err := testDB.LegacyGetPackage(ctx, tc.pkgPath, tc.modulePath, tc.version)
if tc.wantNotFoundErr {
if !errors.Is(err, derrors.NotFound) {
t.Fatalf("want derrors.NotFound; got = %v", err)
@@ -203,7 +203,7 @@
}
}
-func TestGetPackageInvalidArguments(t *testing.T) {
+func TestLegacyGetPackageInvalidArguments(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), testTimeout)
defer cancel()
@@ -227,7 +227,7 @@
},
} {
t.Run(tc.name, func(t *testing.T) {
- got, err := testDB.GetPackage(ctx, tc.modulePath+"/package", tc.modulePath, tc.version)
+ got, err := testDB.LegacyGetPackage(ctx, tc.modulePath+"/package", tc.modulePath, tc.version)
if !errors.Is(err, derrors.InvalidArgument) {
t.Fatalf("want %v; got = \n%+v, %v", derrors.InvalidArgument, got, err)
}
diff --git a/internal/proxydatasource/datasource.go b/internal/proxydatasource/datasource.go
index ee3cd5e..583a66d 100644
--- a/internal/proxydatasource/datasource.go
+++ b/internal/proxydatasource/datasource.go
@@ -107,7 +107,7 @@
// GetImports returns package imports as extracted from the module zip.
func (ds *DataSource) GetImports(ctx context.Context, pkgPath, modulePath, version string) (_ []string, err error) {
defer derrors.Wrap(&err, "GetImports(%q, %q, %q)", pkgPath, modulePath, version)
- vp, err := ds.GetPackage(ctx, pkgPath, modulePath, version)
+ vp, err := ds.LegacyGetPackage(ctx, pkgPath, modulePath, version)
if err != nil {
return nil, err
}
@@ -131,12 +131,12 @@
return filtered, nil
}
-// GetPackage returns a LegacyVersionedPackage for the given pkgPath and version. If
+// LegacyGetPackage returns a LegacyVersionedPackage for the given pkgPath and version. If
// such a package exists in the cache, it will be returned without querying the
// proxy. Otherwise, the proxy is queried to find the longest module path at
// that version containing the package.
-func (ds *DataSource) GetPackage(ctx context.Context, pkgPath, modulePath, version string) (_ *internal.LegacyVersionedPackage, err error) {
- defer derrors.Wrap(&err, "GetPackage(%q, %q)", pkgPath, version)
+func (ds *DataSource) LegacyGetPackage(ctx context.Context, pkgPath, modulePath, version string) (_ *internal.LegacyVersionedPackage, err error) {
+ defer derrors.Wrap(&err, "LegacyGetPackage(%q, %q)", pkgPath, version)
var m *internal.Module
if modulePath != internal.UnknownModulePath {
diff --git a/internal/proxydatasource/datasource_test.go b/internal/proxydatasource/datasource_test.go
index 0181496..621a5c7 100644
--- a/internal/proxydatasource/datasource_test.go
+++ b/internal/proxydatasource/datasource_test.go
@@ -111,7 +111,7 @@
func TestDataSource_GetPackage_Latest(t *testing.T) {
ctx, ds, teardown := setup(t)
defer teardown()
- got, err := ds.GetPackage(ctx, "foo.com/bar/baz", internal.UnknownModulePath, internal.LatestVersion)
+ got, err := ds.LegacyGetPackage(ctx, "foo.com/bar/baz", internal.UnknownModulePath, internal.LatestVersion)
if err != nil {
t.Fatal(err)
}
@@ -145,10 +145,10 @@
}
}
-func TestDataSource_GetPackage(t *testing.T) {
+func TestDataSource_LegacyGetPackage(t *testing.T) {
ctx, ds, teardown := setup(t)
defer teardown()
- got, err := ds.GetPackage(ctx, "foo.com/bar/baz", internal.UnknownModulePath, "v1.2.0")
+ got, err := ds.LegacyGetPackage(ctx, "foo.com/bar/baz", internal.UnknownModulePath, "v1.2.0")
if err != nil {
t.Fatal(err)
}
diff --git a/internal/worker/fetch_test.go b/internal/worker/fetch_test.go
index 7c96b30..9139c23 100644
--- a/internal/worker/fetch_test.go
+++ b/internal/worker/fetch_test.go
@@ -460,11 +460,11 @@
}
pkgFoo := modulePath + "/foo"
- if _, err := testDB.GetPackage(ctx, pkgFoo, internal.UnknownModulePath, version); err != nil {
+ if _, err := testDB.LegacyGetPackage(ctx, pkgFoo, internal.UnknownModulePath, version); err != nil {
t.Errorf("got %v, want nil", err)
}
pkgBar := modulePath + "/bar"
- if _, err := testDB.GetPackage(ctx, pkgBar, internal.UnknownModulePath, version); !errors.Is(err, derrors.NotFound) {
+ if _, err := testDB.LegacyGetPackage(ctx, pkgBar, internal.UnknownModulePath, version); !errors.Is(err, derrors.NotFound) {
t.Errorf("got %v, want NotFound", err)
}
}
@@ -528,15 +528,15 @@
}
pkgFoo := modulePath + "/foo"
- if _, err := testDB.GetPackage(ctx, pkgFoo, internal.UnknownModulePath, version); err != nil {
+ if _, err := testDB.LegacyGetPackage(ctx, pkgFoo, internal.UnknownModulePath, version); err != nil {
t.Errorf("got %v, want nil", err)
}
pkgBar := modulePath + "/bar"
- if _, err := testDB.GetPackage(ctx, pkgBar, internal.UnknownModulePath, version); err != nil {
+ if _, err := testDB.LegacyGetPackage(ctx, pkgBar, internal.UnknownModulePath, version); err != nil {
t.Errorf("got %v, want nil", err)
}
pkgBaz := modulePath + "/baz"
- if _, err := testDB.GetPackage(ctx, pkgBaz, internal.UnknownModulePath, version); err != nil {
+ if _, err := testDB.LegacyGetPackage(ctx, pkgBaz, internal.UnknownModulePath, version); err != nil {
t.Errorf("got %v, want nil", err)
}
}
@@ -560,7 +560,7 @@
if _, err := FetchAndUpdateState(ctx, "my.mod/foo", "v1.0.0", proxyClient, sourceClient, testDB); err != nil {
t.Fatalf("FetchAndUpdateState: %v", err)
}
- pkg, err := testDB.GetPackage(ctx, "my.mod/foo", internal.UnknownModulePath, "v1.0.0")
+ pkg, err := testDB.LegacyGetPackage(ctx, "my.mod/foo", internal.UnknownModulePath, "v1.0.0")
if err != nil {
t.Fatal(err)
}
@@ -611,7 +611,7 @@
t.Fatalf("FetchAndUpdateState(%q, %q, %v, %v, %v): %v", modulePath, version, proxyClient, sourceClient, testDB, err)
}
- if _, err := testDB.GetPackage(ctx, pkgFoo, internal.UnknownModulePath, version); err != nil {
+ if _, err := testDB.LegacyGetPackage(ctx, pkgFoo, internal.UnknownModulePath, version); err != nil {
t.Error(err)
}
@@ -656,12 +656,12 @@
GOARCH: "amd64",
},
}
- got, err := testDB.GetPackage(ctx, pkgBar, internal.UnknownModulePath, version)
+ got, err := testDB.LegacyGetPackage(ctx, pkgBar, internal.UnknownModulePath, version)
if err != nil {
t.Fatal(err)
}
if diff := cmp.Diff(want, got, cmpopts.IgnoreFields(internal.LegacyPackage{}, "DocumentationHTML"), cmp.AllowUnexported(source.Info{})); diff != "" {
- t.Errorf("testDB.GetPackage(ctx, %q, %q) mismatch (-want +got):\n%s", pkgBar, version, diff)
+ t.Errorf("testDB.LegacyGetPackage(ctx, %q, %q) mismatch (-want +got):\n%s", pkgBar, version, diff)
}
// Now re-fetch and verify that contents were overwritten.
@@ -1061,7 +1061,7 @@
t.Fatalf("testDB.GetModuleInfo(ctx, %q, %q) mismatch (-want +got):\n%s", test.modulePath, test.version, diff)
}
- gotPkg, err := testDB.GetPackage(ctx, test.pkg, internal.UnknownModulePath, test.version)
+ gotPkg, err := testDB.LegacyGetPackage(ctx, test.pkg, internal.UnknownModulePath, test.version)
if err != nil {
t.Fatal(err)
}
@@ -1070,7 +1070,7 @@
return gotPkg.Licenses[i].FilePath < gotPkg.Licenses[j].FilePath
})
if diff := cmp.Diff(test.want, gotPkg, cmpopts.IgnoreFields(internal.LegacyPackage{}, "DocumentationHTML"), cmp.AllowUnexported(source.Info{})); diff != "" {
- t.Errorf("testDB.GetPackage(ctx, %q, %q) mismatch (-want +got):\n%s", test.pkg, test.version, diff)
+ t.Errorf("testDB.LegacyGetPackage(ctx, %q, %q) mismatch (-want +got):\n%s", test.pkg, test.version, diff)
}
if got, want := gotPkg.DocumentationHTML, test.want.DocumentationHTML; len(want) == 0 && len(got) != 0 {
t.Errorf("got non-empty documentation but want empty:\ngot: %q\nwant: %q", got, want)
