blob: eb281ebee251465cf6737e5a3d45b84a74207463 [file] [log] [blame]
// 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 frontend
import (
"context"
"errors"
"fmt"
"path"
"testing"
"github.com/google/go-cmp/cmp"
"github.com/google/safehtml"
"golang.org/x/pkgsite/internal"
"golang.org/x/pkgsite/internal/derrors"
"golang.org/x/pkgsite/internal/postgres"
"golang.org/x/pkgsite/internal/stdlib"
"golang.org/x/pkgsite/internal/testing/sample"
)
func TestFetchDirectoryDetails(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), testTimeout)
defer cancel()
defer postgres.ResetTestDB(testDB, t)
postgres.InsertSampleDirectoryTree(ctx, t, testDB)
checkDirectory := func(got *Directory, dirPath, modulePath, version string, suffixes []string) {
t.Helper()
mi := sample.ModuleInfo(modulePath, version)
var wantPkgs []*Package
for _, suffix := range suffixes {
fullPath := suffix
if modulePath != stdlib.ModulePath {
fullPath = path.Join(modulePath, suffix)
}
pm := sample.PackageMeta(fullPath)
pkg, err := createPackage(pm, mi, false)
if err != nil {
t.Fatal(err)
}
pkg.PathAfterDirectory = internal.Suffix(pm.Path, dirPath)
if pkg.PathAfterDirectory == "" {
pkg.PathAfterDirectory = effectiveName(pm.Path, pm.Name) + " (root)"
}
pkg.Synopsis = pm.Synopsis
pkg.PathAfterDirectory = internal.Suffix(pm.Path, dirPath)
if pkg.PathAfterDirectory == "" {
pkg.PathAfterDirectory = fmt.Sprintf("%s (root)", effectiveName(pm.Path, pm.Name))
}
wantPkgs = append(wantPkgs, pkg)
}
mod := createModule(mi, sample.LicenseMetadata, false)
want := &Directory{
DirectoryHeader: DirectoryHeader{
Module: *mod,
Path: dirPath,
URL: constructDirectoryURL(dirPath, mi.ModulePath, linkVersion(mi.Version, mi.ModulePath)),
},
Packages: wantPkgs,
NestedModules: nil,
}
if diff := cmp.Diff(want, got, cmp.AllowUnexported(safehtml.Identifier{})); diff != "" {
t.Errorf("fetchDirectoryDetails(ctx, %q, %q, %q) mismatch (-want +got):\n%s", dirPath, modulePath, version, diff)
}
}
for _, tc := range []struct {
name, dirPath, modulePath, version, wantModulePath, wantVersion string
wantPkgSuffixes []string
includeDirPath, wantInvalidArgumentErr bool
}{
{
name: "dirPath is modulePath, includeDirPath = true, want longest module path",
includeDirPath: true,
dirPath: "github.com/hashicorp/vault/api",
modulePath: "github.com/hashicorp/vault/api",
version: "v1.1.2",
wantModulePath: "github.com/hashicorp/vault/api",
wantVersion: "v1.1.2",
wantPkgSuffixes: []string{""},
},
{
name: "valid directory for modulePath@version/suffix, includeDirPath = false",
dirPath: "github.com/hashicorp/vault/builtin",
modulePath: "github.com/hashicorp/vault",
version: "v1.0.3",
wantModulePath: "github.com/hashicorp/vault",
wantVersion: "v1.0.3",
wantPkgSuffixes: []string{
"builtin/audit/file",
"builtin/audit/socket",
},
},
{
name: "standard library",
dirPath: stdlib.ModulePath,
modulePath: stdlib.ModulePath,
version: "v1.13.4",
wantModulePath: stdlib.ModulePath,
wantVersion: "v1.13.4",
wantPkgSuffixes: []string{
"archive/tar",
"archive/zip",
"cmd/go",
"cmd/internal/obj",
"cmd/internal/obj/arm",
"cmd/internal/obj/arm64",
},
},
{
name: "cmd",
dirPath: "cmd",
modulePath: stdlib.ModulePath,
version: "v1.13.4",
wantModulePath: stdlib.ModulePath,
wantVersion: "v1.13.4",
wantPkgSuffixes: []string{
"cmd/go",
"cmd/internal/obj",
"cmd/internal/obj/arm",
"cmd/internal/obj/arm64",
},
},
} {
t.Run(tc.name, func(t *testing.T) {
var (
got *Directory
err error
)
um := &internal.UnitMeta{
Path: tc.dirPath,
ModulePath: tc.modulePath,
Version: tc.version,
IsRedistributable: true,
CommitTime: sample.CommitTime,
Licenses: sample.LicenseMetadata,
}
got, err = fetchDirectoryDetails(ctx, testDB, um, tc.includeDirPath)
if err != nil {
t.Fatal(err)
}
checkDirectory(got, tc.dirPath, tc.wantModulePath, tc.wantVersion, tc.wantPkgSuffixes)
})
}
}
func TestFetchDirectoryDetailsInvalidArguments(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), testTimeout)
defer cancel()
defer postgres.ResetTestDB(testDB, t)
postgres.InsertSampleDirectoryTree(ctx, t, testDB)
for _, tc := range []struct {
name, dirPath, modulePath, version, wantModulePath, wantVersion string
includeDirPath bool
wantPkgPaths []string
}{
{
name: "dirPath is not modulePath, includeDirPath = true",
dirPath: "github.com/hashicorp/vault/api",
modulePath: "github.com/hashicorp/vault",
version: internal.LatestVersion,
includeDirPath: true,
},
} {
t.Run(tc.name, func(t *testing.T) {
mi := sample.ModuleInfo(tc.modulePath, tc.version)
um := &internal.UnitMeta{
Path: tc.dirPath,
ModulePath: mi.ModulePath,
Version: mi.Version,
IsRedistributable: true,
CommitTime: sample.CommitTime,
Licenses: sample.LicenseMetadata,
}
got, err := fetchDirectoryDetails(ctx, testDB, um, tc.includeDirPath)
if !errors.Is(err, derrors.InvalidArgument) {
t.Fatalf("expected err; got = \n%+v, %v", got, err)
}
})
}
}