internal/proxydatasource: delete legacy methods
For golang/go#39629
Change-Id: Ib7e436b08605ebd0e3a91a760987a6fa450d1ee4
Reviewed-on: https://go-review.googlesource.com/c/pkgsite/+/258302
Reviewed-by: Jonathan Amsterdam <jba@google.com>
Trust: Julie Qiu <julie@golang.org>
diff --git a/internal/proxydatasource/datasource_test.go b/internal/proxydatasource/datasource_test.go
index fb17c9d..e1d2c00 100644
--- a/internal/proxydatasource/datasource_test.go
+++ b/internal/proxydatasource/datasource_test.go
@@ -8,7 +8,6 @@
"context"
"errors"
"fmt"
- "sort"
"strings"
"testing"
"time"
@@ -118,60 +117,6 @@
}, sample.LicenseCmpOpts...)
)
-func TestDataSource_LegacyGetDirectory(t *testing.T) {
- ctx, ds, teardown := setup(t)
- defer teardown()
- want := &internal.LegacyDirectory{
- LegacyModuleInfo: internal.LegacyModuleInfo{ModuleInfo: wantModuleInfo},
- Path: "foo.com/bar",
- Packages: []*internal.LegacyPackage{&wantPackage},
- }
- got, err := ds.LegacyGetDirectory(ctx, "foo.com/bar", internal.UnknownModulePath, "v1.2.0", internal.AllFields)
- if err != nil {
- t.Fatal(err)
- }
- if diff := cmp.Diff(want, got, cmpOpts...); diff != "" {
- t.Errorf("LegacyGetDirectory diff (-want +got):\n%s", diff)
- }
-}
-
-func TestDataSource_LegacyGetImports(t *testing.T) {
- ctx, ds, teardown := setup(t)
- defer teardown()
- want := []string{"net/http"}
- got, err := ds.LegacyGetImports(ctx, "foo.com/bar/baz", "foo.com/bar", "v1.2.0")
- if err != nil {
- t.Fatal(err)
- }
- if diff := cmp.Diff(want, got, cmpOpts...); diff != "" {
- t.Errorf("LegacyGetImports diff (-want +got):\n%s", diff)
- }
-}
-
-func TestDataSource_GetPackage_Latest(t *testing.T) {
- ctx, ds, teardown := setup(t)
- defer teardown()
- got, err := ds.LegacyGetPackage(ctx, "foo.com/bar/baz", internal.UnknownModulePath, internal.LatestVersion)
- if err != nil {
- t.Fatal(err)
- }
- if diff := cmp.Diff(wantVersionedPackage, got, cmpOpts...); diff != "" {
- t.Errorf("GetLatestPackage diff (-want +got):\n%s", diff)
- }
-}
-
-func TestDataSource_LegacyGetModuleInfo_Latest(t *testing.T) {
- ctx, ds, teardown := setup(t)
- defer teardown()
- got, err := ds.LegacyGetModuleInfo(ctx, "foo.com/bar", internal.LatestVersion)
- if err != nil {
- t.Fatal(err)
- }
- if diff := cmp.Diff(wantModuleInfo, got.ModuleInfo, cmpOpts...); diff != "" {
- t.Errorf("GetLatestModuleInfo diff (-want +got):\n%s", diff)
- }
-}
-
func TestDataSource_GetModuleInfo(t *testing.T) {
ctx, ds, teardown := setup(t)
defer teardown()
@@ -184,174 +129,6 @@
}
}
-func TestDataSource_LegacyGetLicenses(t *testing.T) {
- t.Helper()
- testModules := []*proxy.Module{
- {
- ModulePath: "foo.com/bar",
- Version: "v1.1.0",
- Files: map[string]string{
- "go.mod": "module foo.com/bar",
- "LICENSE": testhelper.MITLicense,
- "bar.go": "//Package bar provides a helpful constant.\npackage bar\nimport \"net/http\"\nconst OK = http.StatusOK",
-
- "baz/baz.go": "//Package baz provides a helpful constant.\npackage baz\nimport \"net/http\"\nconst OK = http.StatusOK",
-
- "qux/LICENSE": testhelper.BSD0License,
- "qux/qux.go": "//Package qux provides a helpful constant.\npackage qux\nimport \"net/http\"\nconst OK = http.StatusOK",
- },
- },
- }
- client, teardownProxy := proxy.SetupTestClient(t, testModules)
- ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
- ds := New(client)
- teardown := func() {
- teardownProxy()
- cancel()
- }
- defer teardown()
-
- tests := []struct {
- err error
- name string
- fullPath string
- modulePath string
- want []*licenses.License
- }{
- {name: "no license dir", fullPath: "foo.com", modulePath: "foo.com/bar", err: derrors.NotFound},
- {name: "invalid dir", fullPath: "foo.com/invalid", modulePath: "foo.com/invalid", err: derrors.NotFound},
- {name: "root dir", fullPath: "foo.com/bar", modulePath: "foo.com/bar", want: []*licenses.License{wantLicenseMIT}},
- {name: "package with no extra license", fullPath: "foo.com/bar/baz", modulePath: "foo.com/bar", want: []*licenses.License{wantLicenseMIT}},
- {name: "package with additional license", fullPath: "foo.com/bar/qux", modulePath: "foo.com/bar", want: []*licenses.License{wantLicenseMIT, wantLicenseBSD}},
- }
-
- for _, test := range tests {
- t.Run(test.name, func(t *testing.T) {
- got, err := ds.LegacyGetLicenses(ctx, test.fullPath, test.modulePath, "v1.1.0")
- if !errors.Is(err, test.err) {
- t.Fatal(err)
- }
-
- sort.Slice(got, func(i, j int) bool {
- return got[i].FilePath < got[j].FilePath
- })
- sort.Slice(test.want, func(i, j int) bool {
- return test.want[i].FilePath < test.want[j].FilePath
- })
-
- if diff := cmp.Diff(test.want, got); diff != "" {
- t.Errorf("LegacyGetLicenses diff (-want +got):\n%s", diff)
- }
- })
- }
-}
-
-func TestDataSource_LegacyGetModuleLicenses(t *testing.T) {
- ctx, ds, teardown := setup(t)
- defer teardown()
- got, err := ds.LegacyGetModuleLicenses(ctx, "foo.com/bar", "v1.2.0")
- if err != nil {
- t.Fatal(err)
- }
- want := []*licenses.License{wantLicense}
- if diff := cmp.Diff(want, got, cmpOpts...); diff != "" {
- t.Errorf("LegacyGetModuleLicenses diff (-want +got):\n%s", diff)
- }
-}
-
-func TestDataSource_LegacyGetPackage(t *testing.T) {
- ctx, ds, teardown := setup(t)
- defer teardown()
- got, err := ds.LegacyGetPackage(ctx, "foo.com/bar/baz", internal.UnknownModulePath, "v1.2.0")
- if err != nil {
- t.Fatal(err)
- }
- if diff := cmp.Diff(wantVersionedPackage, got, cmpOpts...); diff != "" {
- t.Errorf("GetPackage diff (-want +got):\n%s", diff)
- }
-}
-
-func TestDataSource_LegacyGetPackageLicenses(t *testing.T) {
- ctx, ds, teardown := setup(t)
- defer teardown()
- got, err := ds.LegacyGetPackageLicenses(ctx, "foo.com/bar/baz", "foo.com/bar", "v1.2.0")
- if err != nil {
- t.Fatal(err)
- }
- want := []*licenses.License{wantLicense}
- if diff := cmp.Diff(want, got, cmpOpts...); diff != "" {
- t.Errorf("LegacyGetPackageLicenses diff (-want +got):\n%s", diff)
- }
-}
-
-func TestDataSource_GetPackagesInVersion(t *testing.T) {
- ctx, ds, teardown := setup(t)
- defer teardown()
- got, err := ds.LegacyGetPackagesInModule(ctx, "foo.com/bar", "v1.2.0")
- if err != nil {
- t.Fatal(err)
- }
- want := []*internal.LegacyPackage{&wantPackage}
- if diff := cmp.Diff(want, got, cmpOpts...); diff != "" {
- t.Errorf("GetPackagesInVersion diff (-want +got):\n%s", diff)
- }
-}
-
-func TestDataSource_LegacyGetTaggedVersionsForModule(t *testing.T) {
- ctx, ds, teardown := setup(t)
- defer teardown()
- got, err := ds.LegacyGetTaggedVersionsForModule(ctx, "foo.com/bar")
- if err != nil {
- t.Fatal(err)
- }
- v110 := wantModuleInfo
- v110.Version = "v1.1.0"
- want := []*internal.ModuleInfo{
- &wantModuleInfo,
- &v110,
- }
- ignore := cmpopts.IgnoreFields(internal.ModuleInfo{}, "CommitTime", "IsRedistributable", "HasGoMod")
- if diff := cmp.Diff(want, got, ignore); diff != "" {
- t.Errorf("LegacyGetTaggedVersionsForPackageSeries diff (-want +got):\n%s", diff)
- }
-}
-
-func TestDataSource_LegacyGetTaggedVersionsForPackageSeries(t *testing.T) {
- ctx, ds, teardown := setup(t)
- defer teardown()
- // // TODO (rFindley): this shouldn't be necessary.
- // _, err := ds.GetLatestPackage(ctx, "foo.com/bar/baz")
- // if err != nil {
- // t.Fatal(err)
- // }
- got, err := ds.LegacyGetTaggedVersionsForPackageSeries(ctx, "foo.com/bar/baz")
- if err != nil {
- t.Fatal(err)
- }
- v110 := wantModuleInfo
- v110.Version = "v1.1.0"
- want := []*internal.ModuleInfo{
- &wantModuleInfo,
- &v110,
- }
- ignore := cmpopts.IgnoreFields(internal.ModuleInfo{}, "CommitTime", "IsRedistributable", "HasGoMod")
- if diff := cmp.Diff(want, got, ignore); diff != "" {
- t.Errorf("LegacyGetTaggedVersionsForPackageSeries diff (-want +got):\n%s", diff)
- }
-}
-
-func TestDataSource_LegacyGetModuleInfo(t *testing.T) {
- ctx, ds, teardown := setup(t)
- defer teardown()
- got, err := ds.LegacyGetModuleInfo(ctx, "foo.com/bar", "v1.2.0")
- if err != nil {
- t.Fatal(err)
- }
- if diff := cmp.Diff(wantModuleInfo, got.ModuleInfo, cmpOpts...); diff != "" {
- t.Errorf("LegacyGetModuleInfo diff (-want +got):\n%s", diff)
- }
-}
-
func TestDataSource_GetUnitMeta(t *testing.T) {
ctx, ds, teardown := setup(t)
defer teardown()
diff --git a/internal/proxydatasource/details.go b/internal/proxydatasource/details.go
index b7edde8..37da084 100644
--- a/internal/proxydatasource/details.go
+++ b/internal/proxydatasource/details.go
@@ -8,13 +8,9 @@
import (
"context"
- "fmt"
- "path"
- "strings"
"golang.org/x/pkgsite/internal"
"golang.org/x/pkgsite/internal/derrors"
- "golang.org/x/pkgsite/internal/licenses"
"golang.org/x/pkgsite/internal/proxy"
)
@@ -24,33 +20,6 @@
return ds.getUnit(ctx, um.Path, um.ModulePath, um.Version)
}
-// LegacyGetLicenses return licenses at path for the given module path and version.
-func (ds *DataSource) LegacyGetLicenses(ctx context.Context, fullPath, modulePath, resolvedVersion string) (_ []*licenses.License, err error) {
- defer derrors.Wrap(&err, "LegacyGetLicenses(%q, %q, %q)", fullPath, modulePath, resolvedVersion)
- v, err := ds.getModule(ctx, modulePath, resolvedVersion)
- if err != nil {
- return nil, err
- }
-
- var lics []*licenses.License
-
- // ds.getModule() returns all licenses for the module version. We need to
- // filter the licenses that applies to the specified fullPath, i.e.
- // A license in the current or any parent directory of the specified
- // fullPath applies to it.
- for _, license := range v.Licenses {
- licensePath := path.Join(modulePath, path.Dir(license.FilePath))
- if strings.HasPrefix(fullPath, licensePath) {
- lics = append(lics, license)
- }
- }
-
- if len(lics) == 0 {
- return nil, fmt.Errorf("path %s is missing from module %s: %w", fullPath, modulePath, derrors.NotFound)
- }
- return lics, nil
-}
-
// GetModuleInfo returns the ModuleInfo as fetched from the proxy for module
// version specified by modulePath and version.
func (ds *DataSource) GetModuleInfo(ctx context.Context, modulePath, version string) (_ *internal.ModuleInfo, err error) {
diff --git a/internal/proxydatasource/legacy_datasource.go b/internal/proxydatasource/legacy_datasource.go
deleted file mode 100644
index bc60ac1..0000000
--- a/internal/proxydatasource/legacy_datasource.go
+++ /dev/null
@@ -1,164 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package proxydatasource implements an internal.DataSource backed solely by a
-// proxy instance.
-package proxydatasource
-
-import (
- "context"
- "fmt"
- "strings"
-
- "golang.org/x/pkgsite/internal"
- "golang.org/x/pkgsite/internal/derrors"
- "golang.org/x/pkgsite/internal/licenses"
- "golang.org/x/pkgsite/internal/proxy"
-)
-
-// LegacyGetDirectory returns packages contained in the given subdirectory of a module version.
-func (ds *DataSource) LegacyGetDirectory(ctx context.Context, dirPath, modulePath, version string, _ internal.FieldSet) (_ *internal.LegacyDirectory, err error) {
- defer derrors.Wrap(&err, "LegacyGetDirectory(%q, %q, %q)", dirPath, modulePath, version)
-
- var info *proxy.VersionInfo
- if modulePath == internal.UnknownModulePath {
- modulePath, info, err = ds.findModule(ctx, dirPath, version)
- if err != nil {
- return nil, err
- }
- version = info.Version
- }
- v, err := ds.getModule(ctx, modulePath, version)
- if err != nil {
- return nil, err
- }
- return &internal.LegacyDirectory{
- LegacyModuleInfo: internal.LegacyModuleInfo{ModuleInfo: v.ModuleInfo},
- Path: dirPath,
- Packages: v.LegacyPackages,
- }, nil
-}
-
-// LegacyGetModuleLicenses returns root-level licenses detected within the module zip
-// for modulePath and version.
-func (ds *DataSource) LegacyGetModuleLicenses(ctx context.Context, modulePath, version string) (_ []*licenses.License, err error) {
- defer derrors.Wrap(&err, "LegacyGetModuleLicenses(%q, %q)", modulePath, version)
- v, err := ds.getModule(ctx, modulePath, version)
- if err != nil {
- return nil, err
- }
- var filtered []*licenses.License
- for _, lic := range v.Licenses {
- if !strings.Contains(lic.FilePath, "/") {
- filtered = append(filtered, lic)
- }
- }
- return filtered, nil
-}
-
-// 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) 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 {
- m, err = ds.getModule(ctx, modulePath, version)
- } else {
- m, err = ds.getPackageVersion(ctx, pkgPath, version)
- }
- if err != nil {
- return nil, err
- }
- return packageFromVersion(pkgPath, m)
-}
-
-// LegacyGetPackageLicenses returns the Licenses that apply to pkgPath within the
-// module version specified by modulePath and version.
-func (ds *DataSource) LegacyGetPackageLicenses(ctx context.Context, pkgPath, modulePath, version string) (_ []*licenses.License, err error) {
- defer derrors.Wrap(&err, "LegacyGetPackageLicenses(%q, %q, %q)", pkgPath, modulePath, version)
- v, err := ds.getModule(ctx, modulePath, version)
- if err != nil {
- return nil, err
- }
- for _, p := range v.LegacyPackages {
- if p.Path == pkgPath {
- var lics []*licenses.License
- for _, lmd := range p.Licenses {
- // lmd is just license metadata, the version has the actual licenses.
- for _, lic := range v.Licenses {
- if lic.FilePath == lmd.FilePath {
- lics = append(lics, lic)
- break
- }
- }
- }
- return lics, nil
- }
- }
- return nil, fmt.Errorf("package %s is missing from module %s: %w", pkgPath, modulePath, derrors.NotFound)
-}
-
-// LegacyGetPackagesInModule returns LegacyPackages contained in the module zip corresponding to modulePath and version.
-func (ds *DataSource) LegacyGetPackagesInModule(ctx context.Context, modulePath, version string) (_ []*internal.LegacyPackage, err error) {
- defer derrors.Wrap(&err, "LegacyGetPackagesInModule(%q, %q)", modulePath, version)
- v, err := ds.getModule(ctx, modulePath, version)
- if err != nil {
- return nil, err
- }
- return v.LegacyPackages, nil
-}
-
-// LegacyGetPsuedoVersionsForModule returns versions from the the proxy /list
-// endpoint, if they are pseudoversions. Otherwise, it returns an empty slice.
-func (ds *DataSource) LegacyGetPsuedoVersionsForModule(ctx context.Context, modulePath string) (_ []*internal.ModuleInfo, err error) {
- defer derrors.Wrap(&err, "LegacyGetPsuedoVersionsForModule(%q)", modulePath)
- return ds.listModuleVersions(ctx, modulePath, true)
-}
-
-// LegacyGetPsuedoVersionsForPackageSeries finds the longest module path containing
-// pkgPath, and returns its versions from the proxy /list endpoint, if they are
-// pseudoversions. Otherwise, it returns an empty slice.
-func (ds *DataSource) LegacyGetPsuedoVersionsForPackageSeries(ctx context.Context, pkgPath string) (_ []*internal.ModuleInfo, err error) {
- defer derrors.Wrap(&err, "LegacyGetPsuedoVersionsForPackageSeries(%q)", pkgPath)
- return ds.listPackageVersions(ctx, pkgPath, true)
-}
-
-// LegacyGetTaggedVersionsForModule returns versions from the the proxy /list
-// endpoint, if they are tagged versions. Otherwise, it returns an empty slice.
-func (ds *DataSource) LegacyGetTaggedVersionsForModule(ctx context.Context, modulePath string) (_ []*internal.ModuleInfo, err error) {
- defer derrors.Wrap(&err, "LegacyGetTaggedVersionsForModule(%q)", modulePath)
- return ds.listModuleVersions(ctx, modulePath, false)
-}
-
-// LegacyGetTaggedVersionsForPackageSeries finds the longest module path containing
-// pkgPath, and returns its versions from the proxy /list endpoint, if they are
-// tagged versions. Otherwise, it returns an empty slice.
-func (ds *DataSource) LegacyGetTaggedVersionsForPackageSeries(ctx context.Context, pkgPath string) (_ []*internal.ModuleInfo, err error) {
- defer derrors.Wrap(&err, "LegacyGetTaggedVersionsForPackageSeries(%q)", pkgPath)
- return ds.listPackageVersions(ctx, pkgPath, false)
-}
-
-// LegacyGetModuleInfo returns the LegacyModuleInfo as fetched from the proxy for module
-// version specified by modulePath and version.
-func (ds *DataSource) LegacyGetModuleInfo(ctx context.Context, modulePath, version string) (_ *internal.LegacyModuleInfo, err error) {
- defer derrors.Wrap(&err, "LegacyGetModuleInfo(%q, %q)", modulePath, version)
- m, err := ds.getModule(ctx, modulePath, version)
- if err != nil {
- return nil, err
- }
- return &m.LegacyModuleInfo, nil
-}
-
-// LegacyGetImports returns package imports as extracted from the module zip.
-func (ds *DataSource) LegacyGetImports(ctx context.Context, pkgPath, modulePath, version string) (_ []string, err error) {
- defer derrors.Wrap(&err, "LegacyGetImports(%q, %q, %q)", pkgPath, modulePath, version)
- vp, err := ds.LegacyGetPackage(ctx, pkgPath, modulePath, version)
- if err != nil {
- return nil, err
- }
- return vp.Imports, nil
-}
