blob: 8f93105318f4bae63685edcdd9c4358521506b9d [file] [log] [blame]
// Copyright 2021 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 fetchdatasource
import (
"context"
"errors"
"fmt"
"log"
"os"
"regexp"
"testing"
"github.com/google/go-cmp/cmp"
"github.com/google/go-cmp/cmp/cmpopts"
"github.com/google/safehtml/template"
"golang.org/x/pkgsite/internal"
"golang.org/x/pkgsite/internal/derrors"
"golang.org/x/pkgsite/internal/fetch"
"golang.org/x/pkgsite/internal/godoc/dochtml"
"golang.org/x/pkgsite/internal/licenses"
"golang.org/x/pkgsite/internal/proxy"
"golang.org/x/pkgsite/internal/proxy/proxytest"
"golang.org/x/pkgsite/internal/source"
"golang.org/x/pkgsite/internal/stdlib"
"golang.org/x/pkgsite/internal/testing/testhelper"
"golang.org/x/pkgsite/internal/version"
)
var (
defaultTestModules []*proxytest.Module
localGetters []fetch.ModuleGetter
)
func TestMain(m *testing.M) {
dochtml.LoadTemplates(template.TrustedFSFromTrustedSource(template.TrustedSourceFromConstant("../../static")))
defaultTestModules = proxytest.LoadTestModules("../proxy/testdata")
var cleanup func()
localGetters, cleanup = buildLocalGetters()
defer cleanup()
licenses.OmitExceptions = true
os.Exit(m.Run())
}
func buildLocalGetters() ([]fetch.ModuleGetter, func()) {
modules := []map[string]string{
{
"go.mod": "module github.com/my/module\n\ngo 1.12",
"LICENSE": testhelper.BSD0License,
"README.md": "README FILE FOR TESTING.",
"bar/COPYING": testhelper.MITLicense,
"bar/README.md": "Another README FILE FOR TESTING.",
"bar/bar.go": `
// package bar
package bar
// Bar returns the string "bar".
func Bar() string {
return "bar"
}`,
"foo/LICENSE.md": testhelper.MITLicense,
"foo/foo.go": `
// package foo
package foo
import (
"fmt"
"github.com/my/module/bar"
)
// FooBar returns the string "foo bar".
func FooBar() string {
return fmt.Sprintf("foo %s", bar.Bar())
}`,
},
{
"go.mod": "module github.com/no/license\n\ngo 1.12",
"LICENSE": "unknown",
"bar/bar.go": `
// package bar
package bar
// Bar returns the string "bar".
func Bar() string {
return "bar"
}`,
},
}
var (
dirs []string
getters []fetch.ModuleGetter
)
ctx := context.Background()
for _, module := range modules {
directory, err := testhelper.CreateTestDirectory(module)
if err != nil {
log.Fatal(err)
}
dirs = append(dirs, directory)
mg, err := fetch.NewGoPackagesModuleGetter(ctx, directory, "./...")
if err != nil {
log.Fatal(err)
}
getters = append(getters, mg)
}
return getters, func() {
for _, d := range dirs {
os.RemoveAll(d)
}
}
}
func setup(t *testing.T, testModules []*proxytest.Module, bypassLicenseCheck bool) (context.Context, *FetchDataSource, func()) {
t.Helper()
ctx, cancel := context.WithCancel(context.Background())
var client *proxy.Client
teardownProxy := func() {}
if testModules != nil {
client, teardownProxy = proxytest.SetupTestClient(t, testModules)
}
getters := localGetters
if testModules != nil {
getters = append(getters, fetch.NewProxyModuleGetter(client, source.NewClientForTesting()))
}
return ctx, Options{
Getters: getters,
ProxyClientForLatest: client,
BypassLicenseCheck: bypassLicenseCheck,
}.New(), func() {
teardownProxy()
cancel()
}
}
func TestProxyGetUnitMeta(t *testing.T) {
ctx, ds, teardown := setup(t, defaultTestModules, false)
defer teardown()
singleModInfo := internal.ModuleInfo{
ModulePath: "example.com/single",
Version: "v1.0.0",
IsRedistributable: true,
CommitTime: proxytest.CommitTime,
HasGoMod: true,
}
for _, test := range []struct {
path, modulePath, version string
want *internal.UnitMeta
}{
{
path: "example.com/single",
modulePath: "example.com/single",
version: "v1.0.0",
want: &internal.UnitMeta{
ModuleInfo: singleModInfo,
IsRedistributable: true,
},
},
{
path: "example.com/single/pkg",
modulePath: "example.com/single",
version: "v1.0.0",
want: &internal.UnitMeta{
ModuleInfo: singleModInfo,
Name: "pkg",
IsRedistributable: true,
},
},
{
path: "example.com/single/pkg",
modulePath: internal.UnknownModulePath,
version: "v1.0.0",
want: &internal.UnitMeta{
ModuleInfo: singleModInfo,
Name: "pkg",
IsRedistributable: true,
},
},
{
path: "example.com/basic",
modulePath: internal.UnknownModulePath,
version: version.Latest,
want: &internal.UnitMeta{
ModuleInfo: internal.ModuleInfo{
ModulePath: "example.com/basic",
Version: "v1.1.0",
IsRedistributable: true,
CommitTime: proxytest.CommitTime,
HasGoMod: true,
},
Name: "basic",
IsRedistributable: true,
},
},
} {
t.Run(test.path, func(t *testing.T) {
got, err := ds.GetUnitMeta(ctx, test.path, test.modulePath, test.version)
if err != nil {
t.Fatal(err)
}
test.want.Path = test.path
if diff := cmp.Diff(test.want, got, cmpopts.IgnoreFields(internal.ModuleInfo{}, "SourceInfo")); diff != "" {
t.Errorf("mismatch (-want +got):\n%s", diff)
}
})
}
}
func TestBypass(t *testing.T) {
for _, bypass := range []bool{false, true} {
t.Run(fmt.Sprintf("bypass=%t", bypass), func(t *testing.T) {
// re-create the data source to get around caching
ctx, ds, teardown := setup(t, defaultTestModules, bypass)
defer teardown()
for _, test := range []struct {
path string
wantEmpty bool
}{
{"example.com/basic", false},
{"example.com/nonredist/unk", !bypass},
} {
t.Run(test.path, func(t *testing.T) {
um, err := ds.GetUnitMeta(ctx, test.path, internal.UnknownModulePath, "v1.0.0")
if err != nil {
t.Fatal(err)
}
got, err := ds.GetUnit(ctx, um, 0, internal.BuildContext{})
if err != nil {
t.Fatal(err)
}
// Assume internal.Module.RemoveNonRedistributableData is correct; we just
// need to check one value to confirm that it was called.
if gotEmpty := (got.Documentation == nil); gotEmpty != test.wantEmpty {
t.Errorf("got empty %t, want %t", gotEmpty, test.wantEmpty)
}
})
}
})
}
}
func TestGetLatestInfo(t *testing.T) {
testModules := []*proxytest.Module{
{
ModulePath: "foo.com/bar",
Version: "v1.1.0",
Files: map[string]string{
"baz.go": "package bar",
},
},
{
ModulePath: "foo.com/bar/v2",
Version: "v2.0.5",
},
{
ModulePath: "foo.com/bar/v3",
},
{
ModulePath: "bar.com/foo",
Version: "v1.1.0",
Files: map[string]string{
"baz.go": "package foo",
},
},
{
ModulePath: "incompatible.com/bar",
Version: "v2.1.1+incompatible",
Files: map[string]string{
"baz.go": "package bar",
},
},
{
ModulePath: "incompatible.com/bar/v3",
},
}
ctx, ds, teardown := setup(t, testModules, false)
defer teardown()
for _, test := range []struct {
fullPath string
modulePath string
wantModulePath string
wantPackagePath string
wantErr error
}{
{
fullPath: "foo.com/bar",
modulePath: "foo.com/bar",
wantModulePath: "foo.com/bar/v3",
wantPackagePath: "foo.com/bar/v3",
},
{
fullPath: "bar.com/foo",
modulePath: "bar.com/foo",
wantModulePath: "bar.com/foo",
wantPackagePath: "bar.com/foo",
},
{
fullPath: "boo.com/far",
modulePath: "boo.com/far",
wantErr: derrors.NotFound,
},
{
fullPath: "foo.com/bar/baz",
modulePath: "foo.com/bar",
wantErr: derrors.NotFound,
},
{
fullPath: "incompatible.com/bar",
modulePath: "incompatible.com/bar",
wantModulePath: "incompatible.com/bar/v3",
wantPackagePath: "incompatible.com/bar/v3",
},
} {
gotLatest, err := ds.GetLatestInfo(ctx, test.fullPath, test.modulePath, nil)
if err != nil {
if test.wantErr == nil {
t.Fatalf("got unexpected error %v", err)
}
if !errors.Is(err, test.wantErr) {
t.Errorf("got err = %v, want Is(%v)", err, test.wantErr)
}
}
if gotLatest.MajorModulePath != test.wantModulePath || gotLatest.MajorUnitPath != test.wantPackagePath {
t.Errorf("ds.GetLatestMajorVersion(%v, %v) = (%v, %v), want = (%v, %v)",
test.fullPath, test.modulePath, gotLatest.MajorModulePath, gotLatest.MajorUnitPath, test.wantModulePath, test.wantPackagePath)
}
}
}
func TestLocalGetUnitMeta(t *testing.T) {
ctx, ds, teardown := setup(t, defaultTestModules, true)
defer teardown()
sourceInfo := source.FilesInfo("XXX")
for _, test := range []struct {
path, modulePath string
want *internal.UnitMeta
wantErr error
}{
{
path: "github.com/my/module",
modulePath: "github.com/my/module",
want: &internal.UnitMeta{
Path: "github.com/my/module",
ModuleInfo: internal.ModuleInfo{
ModulePath: "github.com/my/module",
Version: fetch.LocalVersion,
IsRedistributable: true,
HasGoMod: true,
SourceInfo: sourceInfo,
},
IsRedistributable: true,
},
},
{
path: "github.com/my/module/bar",
modulePath: "github.com/my/module",
want: &internal.UnitMeta{
Path: "github.com/my/module/bar",
Name: "bar",
ModuleInfo: internal.ModuleInfo{
ModulePath: "github.com/my/module",
Version: fetch.LocalVersion,
IsRedistributable: true,
HasGoMod: true,
SourceInfo: sourceInfo,
},
IsRedistributable: true,
},
},
{
path: "github.com/my/module/foo",
modulePath: "github.com/my/module",
want: &internal.UnitMeta{
Path: "github.com/my/module/foo",
Name: "foo",
ModuleInfo: internal.ModuleInfo{
ModulePath: "github.com/my/module",
IsRedistributable: true,
Version: fetch.LocalVersion,
HasGoMod: true,
SourceInfo: sourceInfo,
},
IsRedistributable: true,
},
},
{
path: "github.com/my/module/bar",
modulePath: internal.UnknownModulePath,
want: &internal.UnitMeta{
Path: "github.com/my/module/bar",
Name: "bar",
IsRedistributable: true,
ModuleInfo: internal.ModuleInfo{
ModulePath: "github.com/my/module",
Version: fetch.LocalVersion,
IsRedistributable: true,
HasGoMod: true,
SourceInfo: sourceInfo,
},
},
},
{
path: "github.com/not/loaded",
modulePath: internal.UnknownModulePath,
wantErr: derrors.NotFound,
},
{
path: "net/http",
modulePath: stdlib.ModulePath,
wantErr: derrors.InvalidArgument,
},
{
// Module is known but path isn't in it.
path: "github.com/my/module/unk",
modulePath: "github.com/my/module",
wantErr: derrors.NotFound,
},
} {
t.Run(test.path, func(t *testing.T) {
got, err := ds.GetUnitMeta(ctx, test.path, test.modulePath, fetch.LocalVersion)
if test.wantErr != nil {
if !errors.Is(err, test.wantErr) {
t.Errorf("GetUnitMeta(%q, %q): %v; wantErr = %v)", test.path, test.modulePath, err, test.wantErr)
}
} else {
if err != nil {
t.Fatal(err)
}
var gotURL string
if got.SourceInfo != nil {
gotURL = got.SourceInfo.RepoURL()
}
const wantRegexp = "^/files/.*/github.com/my/module/$"
matched, err := regexp.MatchString(wantRegexp, gotURL)
if err != nil {
t.Fatal(err)
}
if !matched {
t.Errorf("RepoURL: got %q, want match of %q", gotURL, wantRegexp)
}
opts := []cmp.Option{
cmp.AllowUnexported(source.Info{}),
cmpopts.IgnoreFields(source.Info{}, "repoURL"),
cmpopts.IgnoreFields(internal.ModuleInfo{}, "CommitTime"), // commit time is volatile, based on file mtimes
}
diff := cmp.Diff(test.want, got, opts...)
if diff != "" {
t.Errorf("mismatch (-want +got):\n%s", diff)
}
}
})
}
}
func TestGetUnit(t *testing.T) {
// This is a simple test to verify that data is fetched correctly. The
// return value of FetchResult is tested in internal/fetch so no need
// to repeat it.
ctx, ds, teardown := setup(t, nil, true)
defer teardown()
for _, test := range []struct {
path, modulePath string
wantLoaded bool
}{
{
path: "github.com/my/module",
modulePath: "github.com/my/module",
wantLoaded: true,
},
{
path: "github.com/my/module/foo",
modulePath: "github.com/my/module",
wantLoaded: true,
},
{
path: "github.com/no/license/bar",
modulePath: "github.com/no/license",
wantLoaded: true,
},
{
path: "github.com/not/loaded",
modulePath: internal.UnknownModulePath,
},
} {
t.Run(test.path, func(t *testing.T) {
um := &internal.UnitMeta{
Path: test.path,
ModuleInfo: internal.ModuleInfo{ModulePath: test.modulePath},
}
got, err := ds.GetUnit(ctx, um, 0, internal.BuildContext{})
if !test.wantLoaded {
if err == nil {
t.Fatal("returned not loaded module")
}
return
}
if err != nil {
t.Fatal(err)
}
if gotEmpty := (got.Documentation == nil && got.Readme == nil); gotEmpty {
t.Errorf("gotEmpty = %t", gotEmpty)
}
if got.Documentation != nil {
want := []internal.BuildContext{internal.BuildContextAll}
if !cmp.Equal(got.BuildContexts, want) {
t.Errorf("got %v, want %v", got.BuildContexts, want)
}
}
})
}
}
func TestBuildConstraints(t *testing.T) {
// The Unit returned by GetUnit should have a single Documentation that
// matches the BuildContext argument.
ctx, ds, teardown := setup(t, defaultTestModules, true)
defer teardown()
um := &internal.UnitMeta{
Path: "example.com/build-constraints/cpu",
ModuleInfo: internal.ModuleInfo{
ModulePath: "example.com/build-constraints",
Version: version.Latest,
},
}
for _, test := range []struct {
in, want internal.BuildContext
}{
{internal.BuildContext{}, internal.BuildContextLinux},
{internal.BuildContextLinux, internal.BuildContextLinux},
{internal.BuildContextDarwin, internal.BuildContextDarwin},
{internal.BuildContext{GOOS: "LiverPaté", GOARCH: "DeTriomphe"}, internal.BuildContext{}},
} {
t.Run(test.in.String(), func(t *testing.T) {
u, err := ds.GetUnit(ctx, um, internal.AllFields, test.in)
if err != nil {
t.Fatal(err)
}
if test.want == (internal.BuildContext{}) {
if len(u.Documentation) != 0 {
t.Error("got docs, want none")
}
} else if n := len(u.Documentation); n != 1 {
t.Errorf("got %d docs, want 1", n)
} else if got := u.Documentation[0].BuildContext(); got != test.want {
t.Errorf("got %s, want %s", got, test.want)
}
})
}
}
func TestCache(t *testing.T) {
ds := Options{}.New()
m1 := &internal.Module{}
ds.cachePut(nil, "m1", fetch.LocalVersion, m1, nil)
ds.cachePut(nil, "m2", "v1.0.0", nil, derrors.NotFound)
for _, test := range []struct {
path, version string
wantm *internal.Module
wante error
}{
{"m1", fetch.LocalVersion, m1, nil},
{"m1", "v1.2.3", m1, nil}, // find m1 under LocalVersion
{"m2", "v1.0.0", nil, derrors.NotFound},
{"m3", "v1.0.0", nil, nil},
} {
_, gotm, gote := ds.cacheGet(test.path, test.version)
if gotm != test.wantm || gote != test.wante {
t.Errorf("%s@%s: got (%v, %v), want (%v, %v)", test.path, test.version, gotm, gote, test.wantm, test.wante)
}
}
}