| // 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" |
| "fmt" |
| "io" |
| "net/http" |
| "net/http/httptest" |
| "net/url" |
| "os" |
| "regexp" |
| "strings" |
| "testing" |
| "time" |
| |
| "github.com/alicebob/miniredis/v2" |
| "github.com/go-redis/redis/v8" |
| "github.com/google/safehtml/template" |
| "github.com/jba/templatecheck" |
| "golang.org/x/net/html" |
| "golang.org/x/pkgsite/internal" |
| "golang.org/x/pkgsite/internal/cookie" |
| "golang.org/x/pkgsite/internal/derrors" |
| "golang.org/x/pkgsite/internal/experiment" |
| "golang.org/x/pkgsite/internal/middleware" |
| "golang.org/x/pkgsite/internal/postgres" |
| "golang.org/x/pkgsite/internal/proxy/proxytest" |
| "golang.org/x/pkgsite/internal/queue" |
| "golang.org/x/pkgsite/internal/source" |
| "golang.org/x/pkgsite/internal/testing/htmlcheck" |
| "golang.org/x/pkgsite/internal/testing/pagecheck" |
| "golang.org/x/pkgsite/internal/testing/sample" |
| "golang.org/x/pkgsite/internal/version" |
| "golang.org/x/pkgsite/static" |
| thirdparty "golang.org/x/pkgsite/third_party" |
| ) |
| |
| const testTimeout = 5 * time.Second |
| |
| var testDB *postgres.DB |
| |
| func TestMain(m *testing.M) { |
| postgres.RunDBTests("discovery_frontend_test", m, &testDB) |
| } |
| |
| func TestHTMLInjection(t *testing.T) { |
| _, handler, _ := newTestServer(t, nil, nil) |
| w := httptest.NewRecorder() |
| handler.ServeHTTP(w, httptest.NewRequest("GET", "/<em>UHOH</em>", nil)) |
| if strings.Contains(w.Body.String(), "<em>") { |
| t.Error("User input was rendered unescaped.") |
| } |
| } |
| |
| const pseudoVersion = "v0.0.0-20140414041502-123456789012" |
| |
| type testModule struct { |
| path string |
| redistributable bool |
| versions []string |
| packages []testPackage |
| } |
| |
| type testPackage struct { |
| name string |
| suffix string |
| readmeContents string |
| readmeFilePath string |
| docs []*internal.Documentation |
| } |
| |
| type serverTestCase struct { |
| // name of the test |
| name string |
| // path to use in an HTTP GET request |
| urlPath string |
| // statusCode we expect to see in the headers. |
| wantStatusCode int |
| // if non-empty, contents of Location header. For testing redirects. |
| wantLocation string |
| // if non-nil, call the checker on the HTML root node |
| want htmlcheck.Checker |
| // list of experiments that must be enabled for this test to run |
| requiredExperiments *experiment.Set |
| } |
| |
| // Units with this prefix will be marked as excluded. |
| const excludedModulePath = "github.com/module/excluded" |
| |
| const moduleLinksReadme = ` |
| # Heading |
| Stuff |
| |
| ## Links |
| - [title1](http://url1) |
| - [title2](javascript://pwned) |
| ` |
| |
| const packageLinksReadme = ` |
| # Links |
| - [pkg title](http://url2) |
| ` |
| |
| var testModules = []testModule{ |
| { |
| // An ordinary module, with three versions. |
| path: sample.ModulePath, |
| redistributable: true, |
| versions: []string{"v1.0.0", "v0.9.0", pseudoVersion}, |
| packages: []testPackage{ |
| { |
| suffix: "foo", |
| readmeContents: sample.ReadmeContents, |
| readmeFilePath: sample.ReadmeFilePath, |
| }, |
| { |
| suffix: "foo/directory/hello", |
| }, |
| }, |
| }, |
| { |
| // A module with a greater major version available. |
| path: "github.com/v2major/module_name", |
| redistributable: true, |
| versions: []string{"v1.0.0"}, |
| packages: []testPackage{ |
| { |
| suffix: "bar", |
| readmeContents: sample.ReadmeContents, |
| readmeFilePath: sample.ReadmeFilePath, |
| }, |
| { |
| suffix: "bar/directory/hello", |
| }, |
| { |
| suffix: "buz", |
| readmeContents: sample.ReadmeContents, |
| readmeFilePath: sample.ReadmeFilePath, |
| }, |
| { |
| suffix: "buz/directory/hello", |
| }, |
| }, |
| }, |
| { |
| // A v2 of the previous module, with one version. |
| path: "github.com/v2major/module_name/v2", |
| redistributable: true, |
| versions: []string{"v2.0.0"}, |
| packages: []testPackage{ |
| { |
| suffix: "bar", |
| readmeContents: sample.ReadmeContents, |
| readmeFilePath: sample.ReadmeFilePath, |
| }, |
| { |
| suffix: "bar/directory/hello", |
| }, |
| }, |
| }, |
| { |
| // A non-redistributable module. |
| path: "github.com/non_redistributable", |
| redistributable: false, |
| versions: []string{"v1.0.0"}, |
| packages: []testPackage{ |
| { |
| suffix: "bar", |
| }, |
| }, |
| }, |
| { |
| // A module whose latest version is a pseudoversion. |
| path: "github.com/pseudo", |
| redistributable: true, |
| versions: []string{pseudoVersion}, |
| packages: []testPackage{ |
| { |
| suffix: "dir/baz", |
| }, |
| }, |
| }, |
| { |
| // A module whose latest version is has "+incompatible". |
| path: "github.com/incompatible", |
| redistributable: true, |
| versions: []string{"v1.0.0+incompatible"}, |
| packages: []testPackage{ |
| { |
| suffix: "dir/inc", |
| }, |
| }, |
| }, |
| { |
| // A standard library module. |
| path: "std", |
| redistributable: true, |
| versions: []string{"v1.13.0"}, |
| packages: []testPackage{ |
| { |
| name: "main", |
| suffix: "cmd/go", |
| }, |
| { |
| name: "http", |
| suffix: "net/http", |
| }, |
| }, |
| }, |
| { |
| // A module with links. |
| path: "github.com/links/mod", |
| redistributable: true, |
| versions: []string{"v1.0.0"}, |
| packages: []testPackage{ |
| { |
| suffix: "", |
| readmeFilePath: sample.ReadmeFilePath, // required |
| readmeContents: moduleLinksReadme, |
| }, |
| { |
| // This package has no readme, just links in its godoc. So the |
| // UnitMeta (right sidebar) links will be from the godoc and |
| // module readme. |
| suffix: "no_readme", |
| }, |
| { |
| // This package has a readme as well as godoc links, so the |
| // UnitMeta links will be from all three places. |
| suffix: "has_readme", |
| readmeFilePath: "has_readme/README.md", // required |
| readmeContents: packageLinksReadme, |
| }, |
| }, |
| }, |
| { |
| path: excludedModulePath, |
| redistributable: true, |
| versions: []string{sample.VersionString}, |
| packages: []testPackage{ |
| { |
| name: "pkg", |
| suffix: "pkg", |
| }, |
| }, |
| }, |
| { |
| path: "cloud.google.com/go", |
| redistributable: true, |
| versions: []string{"v0.69.0"}, |
| packages: []testPackage{ |
| { |
| name: "pubsublite", |
| suffix: "pubsublite", |
| }, |
| }, |
| }, |
| { |
| path: "cloud.google.com/go/pubsublite", |
| redistributable: true, |
| versions: []string{"v0.4.0"}, |
| packages: []testPackage{ |
| { |
| name: "pubsublite", |
| suffix: "", |
| }, |
| }, |
| }, |
| // A module with a package that is not in the module's latest version. Since |
| // our testModule struct can only describe modules where all packages are at |
| // all versions, we need two of them. |
| { |
| path: "golang.org/x/tools", |
| redistributable: true, |
| versions: []string{"v1.1.0"}, |
| packages: []testPackage{ |
| {name: "blog", suffix: "blog"}, |
| {name: "vet", suffix: "cmd/vet"}, |
| }, |
| }, |
| { |
| path: "golang.org/x/tools", |
| redistributable: true, |
| versions: []string{"v1.2.0"}, |
| packages: []testPackage{ |
| {name: "blog", suffix: "blog"}, |
| }, |
| }, |
| // A module with a package that has documentation for two build contexts. |
| { |
| path: "a.com/two", |
| redistributable: true, |
| versions: []string{"v1.2.3"}, |
| packages: []testPackage{ |
| { |
| name: "pkg", |
| suffix: "pkg", |
| docs: []*internal.Documentation{ |
| sample.Documentation("linux", "amd64", `package p; var L int`), |
| sample.Documentation("windows", "amd64", `package p; var W int`), |
| }, |
| }, |
| }, |
| }, |
| } |
| |
| func insertTestModules(ctx context.Context, t *testing.T, mods []testModule) { |
| for _, mod := range mods { |
| var ( |
| suffixes []string |
| pkgs = make(map[string]testPackage) |
| ) |
| for _, pkg := range mod.packages { |
| suffixes = append(suffixes, pkg.suffix) |
| pkgs[pkg.suffix] = pkg |
| } |
| for _, ver := range mod.versions { |
| m := sample.Module(mod.path, ver, suffixes...) |
| m.SourceInfo = source.NewGitHubInfo(sample.RepositoryURL, "", ver) |
| m.IsRedistributable = mod.redistributable |
| if !m.IsRedistributable { |
| m.Licenses = nil |
| } |
| for _, u := range m.Units { |
| if pkg, ok := pkgs[internal.Suffix(u.Path, m.ModulePath)]; ok { |
| if pkg.name != "" { |
| u.Name = pkg.name |
| } |
| if pkg.readmeContents != "" { |
| u.Readme = &internal.Readme{ |
| Contents: pkg.readmeContents, |
| Filepath: pkg.readmeFilePath, |
| } |
| } |
| if pkg.docs != nil { |
| u.Documentation = pkg.docs |
| } |
| } |
| if !mod.redistributable { |
| u.IsRedistributable = false |
| u.Licenses = nil |
| u.Documentation = nil |
| u.Readme = nil |
| } |
| } |
| postgres.MustInsertModule(ctx, t, testDB, m) |
| } |
| } |
| } |
| |
| var ( |
| in = htmlcheck.In |
| notIn = htmlcheck.NotIn |
| hasText = htmlcheck.HasText |
| attr = htmlcheck.HasAttr |
| |
| // href checks for an exact match in an href attribute. |
| href = func(val string) htmlcheck.Checker { |
| return attr("href", "^"+regexp.QuoteMeta(val)+"$") |
| } |
| ) |
| |
| var notAtLatestPkg = &pagecheck.Page{ |
| ModulePath: "golang.org/x/tools", |
| Suffix: "cmd/vet", |
| Title: "vet", |
| ModuleURL: "github.com/golang/tools", |
| Version: "v1.1.0", |
| FormattedVersion: "v1.1.0", |
| LicenseType: "MIT", |
| LicenseFilePath: "LICENSE", |
| MissingInMinor: true, |
| IsLatestMajor: true, |
| UnitURLFormat: "/golang.org/x/tools/cmd/vet%s", |
| LatestLink: "/golang.org/x/tools/cmd/vet", |
| LatestMajorVersionLink: "/golang.org/x/tools", |
| } |
| |
| // serverTestCases are the test cases valid for any experiment. For experiments |
| // that modify any part of the behaviour covered by the test cases in |
| // serverTestCase(), a new test generator should be created and added to |
| // TestServer(). |
| func serverTestCases() []serverTestCase { |
| const ( |
| versioned = true |
| unversioned = false |
| isPackage = true |
| isDirectory = false |
| ) |
| |
| pkgV100 := &pagecheck.Page{ |
| Title: "foo", |
| ModulePath: sample.ModulePath, |
| Version: sample.VersionString, |
| FormattedVersion: sample.VersionString, |
| Suffix: sample.Suffix, |
| IsLatestMinor: true, |
| IsLatestMajor: true, |
| LatestLink: "/" + sample.ModulePath + "/" + sample.Suffix, |
| LatestMajorVersionLink: "/" + sample.ModulePath + "/" + sample.Suffix, |
| LicenseType: sample.LicenseType, |
| LicenseFilePath: sample.LicenseFilePath, |
| UnitURLFormat: "/" + sample.ModulePath + "%s/" + sample.Suffix, |
| ModuleURL: "/" + sample.ModulePath, |
| CommitTime: absoluteTime(sample.NowTruncated()), |
| } |
| |
| v2pkgV100 := &pagecheck.Page{ |
| Title: "bar", |
| ModulePath: "github.com/v2major/module_name", |
| Version: "v1.0.0", |
| FormattedVersion: "v1.0.0", |
| Suffix: "bar", |
| IsLatestMinor: true, |
| IsLatestMajor: false, |
| LatestLink: "/github.com/v2major/module_name/bar", |
| LatestMajorVersion: "v2", |
| LatestMajorVersionLink: "/github.com/v2major/module_name/v2/bar", |
| LicenseType: sample.LicenseType, |
| LicenseFilePath: sample.LicenseFilePath, |
| UnitURLFormat: "/github.com/v2major/module_name%s/bar", |
| ModuleURL: "/github.com/v2major/module_name", |
| CommitTime: absoluteTime(sample.NowTruncated()), |
| } |
| |
| v2pkgV1Buz := *v2pkgV100 |
| v2pkgV1Buz.Title = "buz" |
| v2pkgV1Buz.Suffix = "buz" |
| v2pkgV1Buz.IsLatestMajor = false |
| v2pkgV1Buz.IsLatestMinor = true |
| v2pkgV1Buz.LatestLink = "/github.com/v2major/module_name/buz" |
| v2pkgV1Buz.LatestMajorVersionLink = "/github.com/v2major/module_name/v2" |
| v2pkgV1Buz.UnitURLFormat = "/github.com/v2major/module_name%s/buz" |
| |
| v2pkgV200 := &pagecheck.Page{ |
| Title: "bar", |
| ModulePath: "github.com/v2major/module_name/v2", |
| Version: "v2.0.0", |
| FormattedVersion: "v2.0.0", |
| Suffix: "bar", |
| IsLatestMinor: true, |
| IsLatestMajor: true, |
| LatestLink: "/github.com/v2major/module_name/v2/bar", |
| LatestMajorVersion: "v2", |
| LatestMajorVersionLink: "/github.com/v2major/module_name/v2/bar", |
| LicenseType: sample.LicenseType, |
| LicenseFilePath: sample.LicenseFilePath, |
| UnitURLFormat: "/github.com/v2major/module_name/v2%s/bar", |
| ModuleURL: "/github.com/v2major/module_name/v2", |
| CommitTime: absoluteTime(sample.NowTruncated()), |
| } |
| |
| p9 := *pkgV100 |
| p9.Version = "v0.9.0" |
| p9.FormattedVersion = "v0.9.0" |
| p9.IsLatestMinor = false |
| p9.IsLatestMajor = true |
| pkgV090 := &p9 |
| |
| pp := *pkgV100 |
| pp.Version = pseudoVersion |
| pp.FormattedVersion = "v0.0.0-...-1234567" |
| pp.IsLatestMinor = false |
| pkgPseudo := &pp |
| |
| pkgInc := &pagecheck.Page{ |
| Title: "inc", |
| ModulePath: "github.com/incompatible", |
| Version: "v1.0.0+incompatible", |
| FormattedVersion: "v1.0.0+incompatible", |
| Suffix: "dir/inc", |
| IsLatestMinor: true, |
| IsLatestMajor: true, |
| LatestLink: "/github.com/incompatible/dir/inc", |
| LatestMajorVersionLink: "/github.com/incompatible/dir/inc", |
| LicenseType: "MIT", |
| LicenseFilePath: "LICENSE", |
| UnitURLFormat: "/github.com/incompatible%s/dir/inc", |
| ModuleURL: "/github.com/incompatible", |
| CommitTime: absoluteTime(sample.NowTruncated()), |
| } |
| |
| pkgNonRedist := &pagecheck.Page{ |
| Title: "bar", |
| ModulePath: "github.com/non_redistributable", |
| Version: "v1.0.0", |
| FormattedVersion: "v1.0.0", |
| Suffix: "bar", |
| IsLatestMinor: true, |
| IsLatestMajor: true, |
| LatestLink: "/github.com/non_redistributable/bar", |
| LatestMajorVersionLink: "/github.com/non_redistributable/bar", |
| LicenseType: "", |
| UnitURLFormat: "/github.com/non_redistributable%s/bar", |
| ModuleURL: "/github.com/non_redistributable", |
| CommitTime: absoluteTime(sample.NowTruncated()), |
| } |
| |
| dir := &pagecheck.Page{ |
| Title: "directory/", |
| ModulePath: sample.ModulePath, |
| Version: "v1.0.0", |
| FormattedVersion: "v1.0.0", |
| Suffix: "foo/directory", |
| LicenseType: "MIT", |
| LicenseFilePath: "LICENSE", |
| IsLatestMinor: true, |
| IsLatestMajor: true, |
| ModuleURL: "/" + sample.ModulePath, |
| UnitURLFormat: "/" + sample.ModulePath + "%s/foo/directory", |
| LatestMajorVersionLink: "/github.com/valid/module_name/foo/directory", |
| LatestLink: "/github.com/valid/module_name/foo/directory", |
| CommitTime: absoluteTime(sample.NowTruncated()), |
| } |
| |
| mod := &pagecheck.Page{ |
| ModulePath: sample.ModulePath, |
| Title: "module_name", |
| ModuleURL: "/" + sample.ModulePath, |
| Version: "v1.0.0", |
| FormattedVersion: "v1.0.0", |
| LicenseType: "MIT", |
| LicenseFilePath: "LICENSE", |
| IsLatestMinor: true, |
| IsLatestMajor: true, |
| LatestLink: "/" + sample.ModulePath + "@v1.0.0", |
| LatestMajorVersionLink: "/" + sample.ModulePath, |
| CommitTime: absoluteTime(sample.NowTruncated()), |
| } |
| mp := *mod |
| mp.Version = pseudoVersion |
| mp.FormattedVersion = "v0.0.0-...-1234567" |
| mp.IsLatestMinor = false |
| mp.IsLatestMajor = true |
| |
| dirPseudo := &pagecheck.Page{ |
| ModulePath: "github.com/pseudo", |
| Title: "dir/", |
| ModuleURL: "/github.com/pseudo", |
| LatestLink: "/github.com/pseudo/dir", |
| LatestMajorVersionLink: "/github.com/pseudo/dir", |
| Suffix: "dir", |
| Version: pseudoVersion, |
| FormattedVersion: mp.FormattedVersion, |
| LicenseType: "MIT", |
| LicenseFilePath: "LICENSE", |
| IsLatestMinor: true, |
| IsLatestMajor: true, |
| UnitURLFormat: "/github.com/pseudo%s/dir", |
| CommitTime: absoluteTime(sample.NowTruncated()), |
| } |
| |
| dirCmd := &pagecheck.Page{ |
| Title: "cmd", |
| ModulePath: "std", |
| Version: "go1.13", |
| FormattedVersion: "go1.13", |
| Suffix: "cmd", |
| LicenseType: "MIT", |
| LicenseFilePath: "LICENSE", |
| IsLatestMajor: true, |
| IsLatestMinor: true, |
| ModuleURL: "/std", |
| LatestLink: "/cmd", |
| UnitURLFormat: "/cmd%s", |
| LatestMajorVersionLink: "/cmd", |
| CommitTime: absoluteTime(sample.NowTruncated()), |
| } |
| |
| netHttp := &pagecheck.Page{ |
| Title: "http", |
| ModulePath: "http", |
| Version: "go1.13", |
| FormattedVersion: "go1.13", |
| LicenseType: sample.LicenseType, |
| LicenseFilePath: sample.LicenseFilePath, |
| ModuleURL: "/net/http", |
| UnitURLFormat: "/net/http%s", |
| IsLatestMinor: true, |
| IsLatestMajor: true, |
| LatestLink: "/net/http", |
| LatestMajorVersionLink: "/net/http", |
| CommitTime: absoluteTime(sample.NowTruncated()), |
| } |
| |
| cloudMod := &pagecheck.Page{ |
| ModulePath: "cloud.google.com/go", |
| ModuleURL: "cloud.google.com/go", |
| Title: "go", |
| Suffix: "go", |
| Version: "v0.69.0", |
| FormattedVersion: "v0.69.0", |
| LicenseType: "MIT", |
| LicenseFilePath: "LICENSE", |
| IsLatestMinor: true, |
| IsLatestMajor: true, |
| UnitURLFormat: "/cloud.google.com/go%s", |
| LatestLink: "/cloud.google.com/go", |
| LatestMajorVersionLink: "/cloud.google.com/go", |
| } |
| |
| pubsubliteDir := &pagecheck.Page{ |
| ModulePath: "cloud.google.com/go", |
| ModuleURL: "cloud.google.com/go", |
| Title: "pubsublite", |
| Suffix: "pubsublite", |
| Version: "v0.69.0", |
| FormattedVersion: "v0.69.0", |
| LicenseType: "MIT", |
| LicenseFilePath: "LICENSE", |
| IsLatestMinor: false, |
| IsLatestMajor: true, |
| UnitURLFormat: "/cloud.google.com/go%s/pubsublite", |
| LatestLink: "/cloud.google.com/go/pubsublite", |
| LatestMajorVersionLink: "/cloud.google.com/go/pubsublite", |
| } |
| |
| pubsubliteMod := &pagecheck.Page{ |
| ModulePath: "cloud.google.com/go/pubsublite", |
| Title: "pubsublite", |
| ModuleURL: "cloud.google.com/go/pubsublite", |
| Version: "v0.4.0", |
| FormattedVersion: "v0.4.0", |
| LicenseType: "MIT", |
| LicenseFilePath: "LICENSE", |
| IsLatestMinor: true, |
| IsLatestMajor: true, |
| UnitURLFormat: "/cloud.google.com/go/pubsublite%s", |
| LatestLink: "/cloud.google.com/go/pubsublite", |
| LatestMajorVersionLink: "/cloud.google.com/go/pubsublite", |
| } |
| |
| return []serverTestCase{ |
| { |
| name: "C", |
| urlPath: "/C", |
| wantStatusCode: http.StatusMovedPermanently, |
| wantLocation: "/cmd/cgo", |
| }, |
| { |
| name: "github golang std", |
| urlPath: "/github.com/golang/go", |
| wantStatusCode: http.StatusMovedPermanently, |
| wantLocation: "/std", |
| }, |
| { |
| name: "github golang std src", |
| urlPath: "/github.com/golang/go/src", |
| wantStatusCode: http.StatusMovedPermanently, |
| wantLocation: "/std", |
| }, |
| { |
| name: "github golang time", |
| urlPath: "/github.com/golang/go/time", |
| wantStatusCode: http.StatusMovedPermanently, |
| wantLocation: "/time", |
| }, |
| { |
| name: "github golang time src", |
| urlPath: "/github.com/golang/go/src/time", |
| wantStatusCode: http.StatusMovedPermanently, |
| wantLocation: "/time", |
| }, |
| { |
| name: "github golang x tools repo 404 instead of redirect", |
| urlPath: "/github.com/golang/tools", |
| wantStatusCode: http.StatusNotFound, |
| }, |
| { |
| name: "github golang x tools go packages 404 instead of redirect", |
| urlPath: "/github.com/golang/tools/go/packages", |
| wantStatusCode: http.StatusNotFound, |
| }, |
| { |
| name: "static", |
| urlPath: "/static/", |
| wantStatusCode: http.StatusOK, |
| want: in("", hasText("doc"), hasText("frontend"), hasText("shared"), hasText("worker")), |
| }, |
| { |
| name: "license policy", |
| urlPath: "/license-policy", |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| in("h1", hasText("License Disclaimer")), |
| in(".go-Content", |
| hasText("The Go website displays license information"), |
| hasText("this is not legal advice"))), |
| }, |
| { |
| // just check that it returns 200 |
| name: "favicon", |
| urlPath: "/favicon.ico", |
| wantStatusCode: http.StatusOK, |
| want: nil, |
| }, |
| { |
| name: "robots.txt", |
| urlPath: "/robots.txt", |
| wantStatusCode: http.StatusOK, |
| want: in("", hasText("User-agent: *"), hasText(regexp.QuoteMeta("Disallow: /search?*"))), |
| }, |
| { |
| name: "search large offset", |
| urlPath: "/search?q=github.com&page=1002", |
| wantStatusCode: http.StatusBadRequest, |
| }, |
| { |
| name: "bad version", |
| urlPath: fmt.Sprintf("/%s@%s/%s", sample.ModulePath, "v1-2", sample.Suffix), |
| wantStatusCode: http.StatusBadRequest, |
| want: in("", |
| in("h3.Error-message", hasText("v1-2 is not a valid semantic version.")), |
| in("p.Error-message a", href(`/search?q=github.com%2fvalid%2fmodule_name%2ffoo`))), |
| }, |
| { |
| name: "unknown version", |
| urlPath: fmt.Sprintf("/%s@%s/%s", sample.ModulePath, "v99.99.0", sample.Suffix), |
| wantStatusCode: http.StatusNotFound, |
| want: in("", |
| in("h3.Fetch-message.js-fetchMessage", hasText(sample.ModulePath+"/foo@v99.99.0"))), |
| }, |
| { |
| |
| name: "path not found", |
| urlPath: "/example.com/unknown", |
| wantStatusCode: http.StatusNotFound, |
| want: in("", |
| in("h3.Fetch-message.js-fetchMessage", hasText("example.com/unknown"))), |
| }, |
| { |
| name: "bad request, invalid github module path", |
| urlPath: "/github.com/foo", |
| wantStatusCode: http.StatusBadRequest, |
| want: in("h3.Error-message", hasText("is not a valid import path")), |
| }, |
| { |
| name: "excluded", |
| urlPath: "/" + excludedModulePath + "/pkg", |
| wantStatusCode: http.StatusNotFound, |
| }, |
| { |
| name: "stdlib shortcut (net/http)", |
| urlPath: "/http", |
| wantStatusCode: http.StatusFound, |
| wantLocation: "/net/http", |
| }, |
| { |
| name: "stdlib shortcut (net/http) strip args", |
| urlPath: "/http@go1.13", |
| wantStatusCode: http.StatusFound, |
| wantLocation: "/net/http", |
| }, |
| { |
| name: "stdlib shortcut with trailing slash", |
| urlPath: "/http/", |
| wantStatusCode: http.StatusMovedPermanently, |
| wantLocation: "/http", |
| }, |
| { |
| name: "stdlib shortcut with args and trailing slash", |
| urlPath: "/http@go1.13/", |
| wantStatusCode: http.StatusMovedPermanently, |
| wantLocation: "/http@go1.13", |
| }, |
| { |
| name: "package page with trailiing slash", |
| urlPath: "/github.com/my/module/", |
| wantStatusCode: http.StatusMovedPermanently, |
| wantLocation: "/github.com/my/module", |
| }, |
| { |
| name: "package default", |
| urlPath: fmt.Sprintf("/%s", sample.PackagePath), |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| pagecheck.UnitHeader(pkgV100, unversioned, isPackage), |
| notIn(".UnitBuildContext-titleContext")), |
| }, |
| { |
| name: "package default redirect", |
| urlPath: fmt.Sprintf("/%s?tab=doc", sample.PackagePath), |
| wantStatusCode: http.StatusFound, |
| wantLocation: "/" + sample.ModulePath + "/foo", |
| }, |
| { |
| name: "package default nonredistributable", |
| urlPath: "/github.com/non_redistributable/bar", |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| pagecheck.UnitHeader(pkgNonRedist, unversioned, isPackage), |
| in(".UnitDetails-content", hasText(`not displayed due to license restrictions`)), |
| ), |
| }, |
| { |
| name: "v2 package at v1", |
| urlPath: fmt.Sprintf("/%s@%s/%s", v2pkgV100.ModulePath, v2pkgV100.Version, v2pkgV100.Suffix), |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| pagecheck.UnitHeader(v2pkgV100, versioned, isPackage), |
| pagecheck.UnitReadme(), |
| pagecheck.UnitDoc(), |
| pagecheck.UnitDirectories(fmt.Sprintf("/%s@%s/%s/directory/hello", v2pkgV100.ModulePath, v2pkgV100.Version, v2pkgV100.Suffix), "hello"), |
| pagecheck.CanonicalURLPath("/github.com/v2major/module_name@v1.0.0/bar")), |
| }, |
| { |
| name: "v2 module with v1 package that does not exist in v2", |
| urlPath: fmt.Sprintf("/%s@%s/%s", v2pkgV1Buz.ModulePath, v2pkgV1Buz.Version, v2pkgV1Buz.Suffix), |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| pagecheck.UnitHeader(&v2pkgV1Buz, versioned, isPackage), |
| pagecheck.UnitReadme(), |
| pagecheck.UnitDoc(), |
| pagecheck.UnitDirectories(fmt.Sprintf("/%s@%s/%s/directory/hello", v2pkgV1Buz.ModulePath, v2pkgV1Buz.Version, v2pkgV1Buz.Suffix), "hello"), |
| pagecheck.CanonicalURLPath("/github.com/v2major/module_name@v1.0.0/buz")), |
| }, |
| { |
| name: "v2 package at v2", |
| urlPath: fmt.Sprintf("/%s@%s/%s", v2pkgV200.ModulePath, v2pkgV200.Version, v2pkgV200.Suffix), |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| pagecheck.UnitHeader(v2pkgV200, versioned, isPackage), |
| pagecheck.UnitReadme(), |
| pagecheck.UnitDoc(), |
| pagecheck.UnitDirectories(fmt.Sprintf("/%s@%s/%s/directory/hello", v2pkgV200.ModulePath, v2pkgV200.Version, v2pkgV200.Suffix), "hello"), |
| pagecheck.CanonicalURLPath("/github.com/v2major/module_name/v2@v2.0.0/bar")), |
| }, |
| { |
| name: "package at version default", |
| urlPath: fmt.Sprintf("/%s@%s/%s", sample.ModulePath, sample.VersionString, sample.Suffix), |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| pagecheck.UnitHeader(pkgV100, versioned, isPackage), |
| pagecheck.UnitReadme(), |
| pagecheck.UnitDoc(), |
| pagecheck.UnitDirectories(fmt.Sprintf("/%s@%s/%s/directory/hello", sample.ModulePath, sample.VersionString, sample.Suffix), "hello"), |
| pagecheck.CanonicalURLPath("/github.com/valid/module_name@v1.0.0/foo")), |
| }, |
| { |
| name: "package at version default specific version nonredistributable", |
| urlPath: "/github.com/non_redistributable@v1.0.0/bar", |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| pagecheck.UnitHeader(pkgNonRedist, versioned, isPackage), |
| in(".UnitDetails-content", hasText(`not displayed due to license restrictions`)), |
| ), |
| }, |
| { |
| name: "package at version", |
| urlPath: fmt.Sprintf("/%s@%s/%s", sample.ModulePath, "v0.9.0", sample.Suffix), |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| pagecheck.UnitHeader(pkgV090, versioned, isPackage), |
| pagecheck.UnitReadme(), |
| pagecheck.UnitDoc(), |
| pagecheck.CanonicalURLPath("/github.com/valid/module_name@v0.9.0/foo")), |
| }, |
| { |
| name: "package at version nonredistributable", |
| urlPath: "/github.com/non_redistributable@v1.0.0/bar", |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| pagecheck.UnitHeader(pkgNonRedist, versioned, isPackage), |
| in(".UnitDetails-content", hasText(`not displayed due to license restrictions`))), |
| }, |
| { |
| name: "package at version versions page", |
| urlPath: fmt.Sprintf("/%s@%s/%s?tab=versions", sample.ModulePath, sample.VersionString, sample.Suffix), |
| wantStatusCode: http.StatusOK, |
| want: in(".Versions", |
| hasText(`v1`), |
| in("a", |
| href("/"+sample.ModulePath+"@v1.0.0/foo"), |
| hasText("v1.0.0"))), |
| }, |
| { |
| name: "package at version imports page", |
| urlPath: fmt.Sprintf("/%s@%s/%s?tab=imports", sample.ModulePath, sample.VersionString, sample.Suffix), |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| in(".Imports-heading", hasText(`Standard library imports`)), |
| in(".Imports-list", |
| in("li:nth-child(1) a", href("/fmt"), hasText("fmt")), |
| in("li:nth-child(2) a", href("/path/to/bar"), hasText("path/to/bar")))), |
| }, |
| { |
| name: "package at version imported by tab", |
| urlPath: fmt.Sprintf("/%s@%s/%s?tab=importedby", sample.ModulePath, sample.VersionString, sample.Suffix), |
| wantStatusCode: http.StatusOK, |
| want: in(`[data-test-id="gopher-message"]`, hasText(`No known importers for this package`)), |
| }, |
| { |
| name: "package at version imported by tab second page", |
| urlPath: fmt.Sprintf("/%s@%s/%s?tab=importedby&page=2", sample.ModulePath, sample.VersionString, sample.Suffix), |
| wantStatusCode: http.StatusOK, |
| want: in(`[data-test-id="gopher-message"]`, hasText(`No known importers for this package`)), |
| }, |
| { |
| name: "package at version licenses tab", |
| urlPath: fmt.Sprintf("/%s@%s/%s?tab=licenses", sample.ModulePath, sample.VersionString, sample.Suffix), |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| pagecheck.LicenseDetails("MIT", "Lorem Ipsum", sample.ModulePath+"@v1.0.0/LICENSE")), |
| }, |
| { |
| name: "package at version, pseudoversion", |
| urlPath: fmt.Sprintf("/%s@%s/%s", sample.ModulePath, pseudoVersion, sample.Suffix), |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| pagecheck.UnitHeader(pkgPseudo, versioned, isPackage)), |
| }, |
| { |
| name: "stdlib no shortcut (net/http)", |
| urlPath: "/net/http", |
| wantStatusCode: http.StatusOK, |
| want: pagecheck.UnitHeader(netHttp, unversioned, isPackage), |
| }, |
| { |
| name: "stdlib no shortcut (net/http) versioned", |
| urlPath: "/net/http@go1.13", |
| wantStatusCode: http.StatusOK, |
| want: pagecheck.UnitHeader(netHttp, versioned, isPackage), |
| }, |
| { |
| name: "package at version, +incompatible", |
| urlPath: "/github.com/incompatible@v1.0.0+incompatible/dir/inc", |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| pagecheck.UnitHeader(pkgInc, versioned, isPackage)), |
| }, |
| { |
| name: "directory subdirectories", |
| urlPath: fmt.Sprintf("/%s", sample.PackagePath+"/directory"), |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| pagecheck.UnitHeader(dir, unversioned, isDirectory), |
| // TODO(golang/go#39630) link should be unversioned. |
| pagecheck.UnitDirectories("/"+sample.ModulePath+"@v1.0.0/foo/directory/hello", "hello")), |
| }, |
| { |
| name: "directory@version subdirectories", |
| urlPath: "/" + sample.ModulePath + "@v1.0.0/foo/directory", |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| pagecheck.UnitHeader(dir, versioned, isDirectory), |
| pagecheck.UnitDirectories("/"+sample.ModulePath+"@v1.0.0/foo/directory/hello", "hello")), |
| }, |
| { |
| name: "directory@version subdirectories pseudoversion", |
| urlPath: "/github.com/pseudo@" + pseudoVersion + "/dir", |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| pagecheck.UnitHeader(dirPseudo, versioned, isDirectory), |
| pagecheck.UnitDirectories("/github.com/pseudo@"+pseudoVersion+"/dir/baz", "baz")), |
| }, |
| { |
| name: "directory subdirectories pseudoversion", |
| urlPath: "/github.com/pseudo/dir", |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| pagecheck.UnitHeader(dirPseudo, unversioned, isDirectory), |
| // TODO(golang/go#39630) link should be unversioned. |
| pagecheck.UnitDirectories("/github.com/pseudo@"+pseudoVersion+"/dir/baz", "baz")), |
| }, |
| { |
| name: "directory", |
| urlPath: fmt.Sprintf("/%s", sample.PackagePath+"/directory"), |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| pagecheck.UnitHeader(dir, unversioned, isDirectory), |
| pagecheck.CanonicalURLPath("/github.com/valid/module_name@v1.0.0/foo")), |
| }, |
| { |
| name: "directory licenses", |
| urlPath: fmt.Sprintf("/%s?tab=licenses", sample.PackagePath+"/directory"), |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| pagecheck.LicenseDetails("MIT", "Lorem Ipsum", sample.ModulePath+"@v1.0.0/LICENSE")), |
| }, |
| { |
| name: "stdlib directory default", |
| urlPath: "/cmd", |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| pagecheck.UnitHeader(dirCmd, unversioned, isDirectory), |
| pagecheck.UnitDirectories("", "")), |
| }, |
| { |
| name: "stdlib directory versioned", |
| urlPath: "/cmd@go1.13", |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| pagecheck.UnitHeader(dirCmd, versioned, isDirectory), |
| pagecheck.UnitDirectories("", "")), |
| }, |
| { |
| name: "stdlib directory licenses", |
| urlPath: "/cmd@go1.13?tab=licenses", |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| pagecheck.LicenseDetails("MIT", "Lorem Ipsum", "go.googlesource.com/go/+/refs/tags/go1.13/LICENSE")), |
| }, |
| { |
| name: "pubsublite unversioned", |
| urlPath: "/cloud.google.com/go/pubsublite", |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| pagecheck.UnitHeader(pubsubliteMod, unversioned, isPackage)), |
| }, |
| { |
| name: "pubsublite module", |
| urlPath: "/cloud.google.com/go/pubsublite@v0.4.0", |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| pagecheck.UnitHeader(pubsubliteMod, versioned, isPackage)), |
| }, |
| { |
| name: "pubsublite directory", |
| urlPath: "/cloud.google.com/go@v0.69.0/pubsublite", |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| pagecheck.UnitHeader(pubsubliteDir, versioned, isDirectory)), |
| }, |
| { |
| name: "cloud.google.com/go module", |
| urlPath: "/cloud.google.com/go", |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| pagecheck.UnitHeader(cloudMod, unversioned, isDirectory)), |
| }, |
| { |
| name: "two docs default", |
| urlPath: "/a.com/two/pkg", |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| in(".Documentation-variables", hasText("var L")), |
| in(".UnitBuildContext-titleContext", hasText("linux/amd64"))), |
| }, |
| { |
| name: "two docs linux", |
| urlPath: "/a.com/two/pkg?GOOS=linux", |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| in(".Documentation-variables", hasText("var L")), |
| in(".UnitBuildContext-titleContext", hasText("linux/amd64"))), |
| }, |
| { |
| name: "two docs windows", |
| urlPath: "/a.com/two/pkg?GOOS=windows", |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| in(".Documentation-variables", hasText("var W")), |
| in(".UnitBuildContext-titleContext", hasText("windows/amd64"))), |
| }, |
| { |
| name: "two docs no match", |
| urlPath: "/a.com/two/pkg?GOOS=dragonfly", |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| notIn(".Documentation-variables"), |
| notIn(".UnitBuildContext-titleContext")), |
| }, |
| } |
| } |
| |
| func checkLink(title, url string) htmlcheck.Checker { |
| // The first div under .UnitMeta is "Repository", the second is "Links", |
| // and each subsequent div contains a <a> tag with a custom link. |
| return in(fmt.Sprintf(`[data-test-id="meta-link-%s"]`, title), href(url), hasText(title)) |
| } |
| |
| var linksTestCases = []serverTestCase{ |
| { |
| name: "module links", |
| urlPath: "/github.com/links/mod", |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| // Module readme links. |
| checkLink("title1", "http://url1"), |
| checkLink("title2", "about:invalid#zGoSafez"), |
| ), |
| }, |
| { |
| name: "no_readme package links", |
| urlPath: "/github.com/links/mod/no_readme", |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| // Package doc links are first. |
| checkLink("pkg.go.dev", "https://pkg.go.dev"), |
| // Then module readmes. |
| checkLink("title1", "http://url1"), |
| checkLink("title2", "about:invalid#zGoSafez"), |
| ), |
| }, |
| { |
| name: "has_readme package links", |
| urlPath: "/github.com/links/mod/has_readme", |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| // Package readme links are first. |
| checkLink("pkg title", "http://url2"), |
| // Package doc links are second. |
| checkLink("pkg.go.dev", "https://pkg.go.dev"), |
| // Module readme links are third. |
| checkLink("title1", "http://url1"), |
| checkLink("title2", "about:invalid#zGoSafez"), |
| ), |
| }, |
| { |
| name: "not at latest", |
| // A package which is at its own latest minor version but not at the |
| // latest minor version of its module. |
| urlPath: "/golang.org/x/tools/cmd/vet", |
| wantStatusCode: http.StatusOK, |
| want: in("", pagecheck.UnitHeader(notAtLatestPkg, false, true)), |
| }, |
| } |
| |
| var searchGroupingTestCases = []serverTestCase{ |
| { |
| name: "search", |
| urlPath: fmt.Sprintf("/search?q=%s", sample.PackageName), |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| in(`[data-test-id="pagination"]`, hasText("See search help")), |
| in(`[data-test-id="snippet-title"]`, |
| href("/"+sample.ModulePath+"/foo"), |
| hasText("foo"))), |
| }, |
| { |
| name: "pageless search", |
| urlPath: fmt.Sprintf("/search?q=%s", sample.PackageName), |
| wantStatusCode: http.StatusOK, |
| want: in("", |
| in(`[data-test-id="pagination"]`, hasText("See search help")), |
| notIn(".Pagination-navInner")), |
| }, |
| { |
| name: "search large limit", |
| urlPath: fmt.Sprintf("/search?q=%s&limit=101", sample.PackageName), |
| wantStatusCode: http.StatusBadRequest, |
| }, |
| { |
| name: "no results", |
| urlPath: "/search?q=xyzzy", |
| wantStatusCode: http.StatusOK, |
| want: notIn(".Pagination-nav"), |
| }, |
| } |
| |
| // TestServer checks the contents of served pages by looking for |
| // strings and elements in the parsed HTML response body. |
| // |
| // Other than search and static content, our pages vary along five dimensions: |
| // |
| // 1. module / package / directory |
| // 2. stdlib / other (since the standard library is a special case in several ways) |
| // 3. redistributable / non-redistributable |
| // 4. versioned / unversioned URL (whether the URL for the page contains "@version") |
| // 5. the tab (overview / doc / imports / ...) |
| // |
| // We aim to test all combinations of these. |
| func TestServer(t *testing.T) { |
| for _, test := range []struct { |
| name string |
| testCasesFunc func() []serverTestCase |
| experiments []string |
| }{ |
| { |
| name: "no experiments", |
| testCasesFunc: func() []serverTestCase { |
| cases := serverTestCases() |
| cases = append(cases, linksTestCases...) |
| return append(cases, searchGroupingTestCases...) |
| }, |
| }, |
| } { |
| t.Run(test.name, func(t *testing.T) { |
| testServer(t, test.testCasesFunc(), test.experiments...) |
| }) |
| } |
| } |
| |
| func testServer(t *testing.T, testCases []serverTestCase, experimentNames ...string) { |
| ctx, cancel := context.WithTimeout(context.Background(), testTimeout) |
| defer cancel() |
| defer postgres.ResetTestDB(testDB, t) |
| |
| // Experiments need to be set in the context, for DB work, and as a |
| // middleware, for request handling. |
| ctx = experiment.NewContext(ctx, experimentNames...) |
| insertTestModules(ctx, t, testModules) |
| if err := testDB.InsertExcludedPrefix(ctx, excludedModulePath, "testuser", "testreason"); err != nil { |
| t.Fatal(err) |
| } |
| _, handler, _ := newTestServer(t, nil, nil, experimentNames...) |
| |
| experimentsSet := experiment.NewSet(experimentNames...) |
| |
| for _, test := range testCases { |
| if !isSubset(test.requiredExperiments, experimentsSet) { |
| continue |
| } |
| |
| t.Run(test.name, func(t *testing.T) { // remove initial '/' for name |
| w := httptest.NewRecorder() |
| handler.ServeHTTP(w, httptest.NewRequest("GET", test.urlPath, nil)) |
| res := w.Result() |
| if res.StatusCode != test.wantStatusCode { |
| t.Fatalf("GET %q = %d, want %d", test.urlPath, res.StatusCode, test.wantStatusCode) |
| } |
| if test.wantLocation != "" { |
| if got := res.Header.Get("Location"); got != test.wantLocation { |
| t.Errorf("Location: got %q, want %q", got, test.wantLocation) |
| } |
| } |
| doc, err := html.Parse(res.Body) |
| if err != nil { |
| t.Fatal(err) |
| } |
| _ = res.Body.Close() |
| |
| if test.want != nil { |
| if err := test.want(doc); err != nil { |
| if testing.Verbose() { |
| html.Render(os.Stdout, doc) |
| } |
| t.Error(err) |
| } |
| } |
| }) |
| } |
| } |
| |
| func isSubset(subset, set *experiment.Set) bool { |
| for _, e := range subset.Active() { |
| if !set.IsActive(e) { |
| return false |
| } |
| } |
| |
| return true |
| } |
| |
| func TestServerErrors(t *testing.T) { |
| _, handler, _ := newTestServer(t, nil, nil) |
| for _, test := range []struct { |
| name, path string |
| wantCode int |
| }{ |
| {"not found", "/invalid-page", http.StatusNotFound}, |
| {"bad request", "/gocloud.dev/@latest/blob", http.StatusBadRequest}, |
| } { |
| t.Run(test.name, func(t *testing.T) { |
| w := httptest.NewRecorder() |
| handler.ServeHTTP(w, httptest.NewRequest("GET", test.path, nil)) |
| if w.Code != test.wantCode { |
| t.Errorf("%q: got status code = %d, want %d", test.path, w.Code, test.wantCode) |
| } |
| }) |
| } |
| } |
| |
| func TestServer404Redirect_NoLoop(t *testing.T) { |
| ctx, cancel := context.WithTimeout(context.Background(), testTimeout) |
| defer cancel() |
| |
| altPath := "module.path/alternative" |
| goModPath := "module.path/alternative/pkg" |
| defer postgres.ResetTestDB(testDB, t) |
| sampleModule := sample.DefaultModule() |
| postgres.MustInsertModule(ctx, t, testDB, sampleModule) |
| alternativeModule := &internal.VersionMap{ |
| ModulePath: altPath, |
| GoModPath: goModPath, |
| RequestedVersion: version.Latest, |
| ResolvedVersion: sample.VersionString, |
| Status: derrors.ToStatus(derrors.AlternativeModule), |
| } |
| alternativeModulePkg := &internal.VersionMap{ |
| ModulePath: goModPath, |
| GoModPath: goModPath, |
| RequestedVersion: version.Latest, |
| ResolvedVersion: sample.VersionString, |
| Status: http.StatusNotFound, |
| } |
| if err := testDB.UpsertVersionMap(ctx, alternativeModule); err != nil { |
| t.Fatal(err) |
| } |
| if err := testDB.UpsertVersionMap(ctx, alternativeModulePkg); err != nil { |
| t.Fatal(err) |
| } |
| |
| rs, err := miniredis.Run() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer rs.Close() |
| |
| _, handler, _ := newTestServer(t, nil, redis.NewClient(&redis.Options{Addr: rs.Addr()})) |
| |
| for _, test := range []struct { |
| name, path string |
| status int |
| }{ |
| {"do not redirect if alternative module does not successfully return", "/" + altPath, http.StatusNotFound}, |
| {"do not redirect go mod path endlessly", "/" + goModPath, http.StatusNotFound}, |
| } { |
| t.Run(test.name, func(t *testing.T) { |
| w := httptest.NewRecorder() |
| handler.ServeHTTP(w, httptest.NewRequest("GET", test.path, nil)) |
| // Check for http.StatusFound, which indicates a redirect. |
| if w.Code != test.status { |
| t.Errorf("%q: got status code = %d, want %d", test.path, w.Code, test.status) |
| } |
| }) |
| } |
| } |
| |
| // Verify that some paths that aren't found will redirect to valid pages. |
| // Sometimes redirection sets the AlternativeModuleFlash cookie and puts |
| // up a banner. |
| func TestServer404Redirect(t *testing.T) { |
| ctx, cancel := context.WithTimeout(context.Background(), testTimeout) |
| defer cancel() |
| |
| defer postgres.ResetTestDB(testDB, t) |
| sampleModule := sample.DefaultModule() |
| postgres.MustInsertModule(ctx, t, testDB, sampleModule) |
| alternativeModule := &internal.VersionMap{ |
| ModulePath: "module.path/alternative", |
| GoModPath: sample.ModulePath, |
| RequestedVersion: version.Latest, |
| ResolvedVersion: sample.VersionString, |
| Status: derrors.ToStatus(derrors.AlternativeModule), |
| } |
| if err := testDB.UpsertVersionMap(ctx, alternativeModule); err != nil { |
| t.Fatal(err) |
| } |
| |
| v1modpath := "notinv1.mod" |
| v1path := "notinv1.mod/foo" |
| postgres.MustInsertModule(ctx, t, testDB, sample.Module(v1modpath+"/v4", "v4.0.0", "foo")) |
| for _, mod := range []struct { |
| path, version string |
| status int |
| }{ |
| {v1modpath, "v1.0.0", http.StatusNotFound}, |
| {v1path, "v4.0.0", http.StatusNotFound}, |
| {v1modpath + "/v4", "v4.0.0", http.StatusOK}, |
| } { |
| if err := testDB.UpsertVersionMap(ctx, &internal.VersionMap{ |
| ModulePath: mod.path, |
| RequestedVersion: version.Latest, |
| ResolvedVersion: mod.version, |
| Status: mod.status, |
| GoModPath: mod.path, |
| }); err != nil { |
| t.Fatal(err) |
| } |
| } |
| if err := testDB.UpsertVersionMap(ctx, &internal.VersionMap{ |
| ModulePath: sample.ModulePath + "/blob/master", |
| RequestedVersion: version.Latest, |
| ResolvedVersion: sample.VersionString, |
| Status: http.StatusNotFound, |
| }); err != nil { |
| t.Fatal(err) |
| } |
| |
| rs, err := miniredis.Run() |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer rs.Close() |
| |
| _, handler, _ := newTestServer(t, nil, redis.NewClient(&redis.Options{Addr: rs.Addr()})) |
| |
| for _, test := range []struct { |
| name, path, flash string |
| }{ |
| {"github url", "/" + sample.ModulePath + "/blob/master", ""}, |
| {"alternative module", "/" + alternativeModule.ModulePath, "module.path/alternative"}, |
| {"module not in v1", "/" + v1modpath, "notinv1.mod"}, |
| {"import path not in v1", "/" + v1path, "notinv1.mod/foo"}, |
| } { |
| t.Run(test.name, func(t *testing.T) { |
| w := httptest.NewRecorder() |
| handler.ServeHTTP(w, httptest.NewRequest("GET", test.path, nil)) |
| // Check for http.StatusFound, which indicates a redirect. |
| if w.Code != http.StatusFound { |
| t.Errorf("%q: got status code = %d, want %d", test.path, w.Code, http.StatusFound) |
| } |
| res := w.Result() |
| c := findCookie(cookie.AlternativeModuleFlash, res.Cookies()) |
| if c == nil && test.flash != "" { |
| t.Error("got no flash cookie, expected one") |
| } else if c != nil { |
| val, err := cookie.Base64Value(c) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if val != test.flash { |
| t.Fatalf("got cookie value %q, want %q", val, test.flash) |
| } |
| // If we have a cookie, then following the redirect URL with the cookie |
| // should serve a "redirected from" banner. |
| loc := res.Header.Get("Location") |
| r := httptest.NewRequest("GET", loc, nil) |
| r.AddCookie(c) |
| w = httptest.NewRecorder() |
| handler.ServeHTTP(w, r) |
| err = checkBody(w.Result().Body, in(`[data-test-id="redirected-banner-text"]`, hasText(val))) |
| if err != nil { |
| t.Fatal(err) |
| } |
| // Visiting the same page again without the cookie should not |
| // display the banner. |
| r = httptest.NewRequest("GET", loc, nil) |
| w = httptest.NewRecorder() |
| handler.ServeHTTP(w, r) |
| err = checkBody(w.Result().Body, notIn(`[data-test-id="redirected-banner-text"]`)) |
| if err != nil { |
| t.Fatal(err) |
| } |
| } |
| }) |
| } |
| } |
| |
| func findCookie(name string, cookies []*http.Cookie) *http.Cookie { |
| for _, c := range cookies { |
| if c.Name == name { |
| return c |
| } |
| } |
| return nil |
| } |
| |
| func checkBody(body io.ReadCloser, c htmlcheck.Checker) error { |
| doc, err := html.Parse(body) |
| if err != nil { |
| return err |
| } |
| _ = body.Close() |
| return c(doc) |
| } |
| |
| func mustRequest(urlPath string, t *testing.T) *http.Request { |
| t.Helper() |
| r, err := http.NewRequest(http.MethodGet, "http://localhost"+urlPath, nil) |
| if err != nil { |
| t.Fatal(err) |
| } |
| return r |
| } |
| |
| func TestDetailsTTL(t *testing.T) { |
| tests := []struct { |
| r *http.Request |
| want time.Duration |
| }{ |
| {mustRequest("/host.com/module@v1.2.3/suffix", t), longTTL}, |
| {mustRequest("/host.com/module/suffix", t), shortTTL}, |
| {mustRequest("/host.com/module@v1.2.3/suffix?tab=overview", t), longTTL}, |
| {mustRequest("/host.com/module@v1.2.3/suffix?tab=versions", t), defaultTTL}, |
| {mustRequest("/host.com/module@v1.2.3/suffix?tab=importedby", t), defaultTTL}, |
| { |
| func() *http.Request { |
| r := mustRequest("/host.com/module@v1.2.3/suffix?tab=overview", t) |
| r.Header.Set("user-agent", |
| "Mozilla/5.0 (compatible; AhrefsBot/7.0; +http://ahrefs.com/robot/)") |
| return r |
| }(), |
| tinyTTL, |
| }, |
| } |
| for _, test := range tests { |
| if got := detailsTTL(test.r); got != test.want { |
| t.Errorf("detailsTTL(%v) = %v, want %v", test.r, got, test.want) |
| } |
| } |
| } |
| |
| func TestTagRoute(t *testing.T) { |
| mustRequest := func(url string) *http.Request { |
| req, err := http.NewRequest("GET", url, nil) |
| if err != nil { |
| t.Fatal(err) |
| } |
| return req |
| } |
| tests := []struct { |
| route string |
| req *http.Request |
| want string |
| }{ |
| {"/pkg", mustRequest("http://localhost/pkg/foo?tab=versions"), "pkg-versions"}, |
| {"/", mustRequest("http://localhost/foo?tab=imports"), "imports"}, |
| } |
| for _, test := range tests { |
| t.Run(test.want, func(t *testing.T) { |
| if got := TagRoute(test.route, test.req); got != test.want { |
| t.Errorf("TagRoute(%q, %v) = %q, want %q", test.route, test.req, got, test.want) |
| } |
| }) |
| } |
| } |
| |
| func newTestServer(t *testing.T, proxyModules []*proxytest.Module, redisClient *redis.Client, experimentNames ...string) (*Server, http.Handler, func()) { |
| t.Helper() |
| proxyClient, teardown := proxytest.SetupTestClient(t, proxyModules) |
| sourceClient := source.NewClient(sourceTimeout) |
| ctx := context.Background() |
| |
| q := queue.NewInMemory(ctx, 1, experimentNames, |
| func(ctx context.Context, mpath, version string) (int, error) { |
| return FetchAndUpdateState(ctx, mpath, version, proxyClient, sourceClient, testDB) |
| }) |
| |
| s, err := NewServer(ServerConfig{ |
| DataSourceGetter: func(context.Context) internal.DataSource { return testDB }, |
| Queue: q, |
| TaskIDChangeInterval: 10 * time.Minute, |
| TemplateFS: template.TrustedFSFromEmbed(static.FS), |
| // Use the embedded FSs here to make sure they're tested. |
| // Integration tests will use the actual directories. |
| StaticFS: static.FS, |
| ThirdPartyFS: thirdparty.FS, |
| StaticPath: "../../static", |
| }) |
| if err != nil { |
| t.Fatal(err) |
| } |
| mux := http.NewServeMux() |
| s.Install(mux.Handle, redisClient, nil) |
| |
| var exps []*internal.Experiment |
| for _, n := range experimentNames { |
| exps = append(exps, &internal.Experiment{Name: n, Rollout: 100}) |
| } |
| exp, err := middleware.NewExperimenter(ctx, time.Hour, func(context.Context) ([]*internal.Experiment, error) { return exps, nil }, nil) |
| if err != nil { |
| t.Fatal(err) |
| } |
| mw := middleware.Experiment(exp) |
| return s, mw(mux), func() { |
| teardown() |
| postgres.ResetTestDB(testDB, t) |
| } |
| } |
| |
| func TestCheckTemplates(t *testing.T) { |
| // Perform additional checks on parsed templates. |
| staticFS := template.TrustedFSFromEmbed(static.FS) |
| templates, err := parsePageTemplates(staticFS) |
| if err != nil { |
| t.Fatal(err) |
| } |
| for _, c := range []struct { |
| name string |
| subs []string |
| typeval interface{} |
| }{ |
| {"badge", nil, badgePage{}}, |
| // error.tmpl omitted because relies on an associated "message" template |
| // that's parsed on demand; see renderErrorPage above. |
| {"fetch", nil, errorPage{}}, |
| {"homepage", nil, homepage{}}, |
| {"license-policy", nil, licensePolicyPage{}}, |
| {"search", nil, SearchPage{}}, |
| {"search-help", nil, basePage{}}, |
| {"unit/main", nil, UnitPage{}}, |
| { |
| "unit/main", |
| []string{"unit-outline", "unit-readme", "unit-doc", "unit-files", "unit-directories"}, |
| MainDetails{}, |
| }, |
| {"unit/importedby", nil, UnitPage{}}, |
| {"unit/importedby", []string{"importedby"}, ImportedByDetails{}}, |
| {"unit/imports", nil, UnitPage{}}, |
| {"unit/imports", []string{"imports"}, ImportsDetails{}}, |
| {"unit/licenses", nil, UnitPage{}}, |
| {"unit/licenses", []string{"licenses"}, LicensesDetails{}}, |
| {"unit/versions", nil, UnitPage{}}, |
| {"unit/versions", []string{"versions"}, VersionsDetails{}}, |
| {"vuln", nil, basePage{}}, |
| {"vuln/list", nil, VulnListPage{}}, |
| {"vuln/entry", nil, VulnPage{}}, |
| } { |
| t.Run(c.name, func(t *testing.T) { |
| tm := templates[c.name] |
| if tm == nil { |
| t.Fatalf("no template %q", c.name) |
| } |
| if c.subs == nil { |
| if err := templatecheck.CheckSafe(tm, c.typeval); err != nil { |
| t.Fatal(err) |
| } |
| } else { |
| for _, n := range c.subs { |
| s := tm.Lookup(n) |
| if s == nil { |
| t.Fatalf("no sub-template %q of %q", n, c.name) |
| } |
| if err := templatecheck.CheckSafe(s, c.typeval); err != nil { |
| t.Fatalf("%s: %v", n, err) |
| } |
| } |
| } |
| }) |
| } |
| } |
| |
| func TestEmptyDirectoryBetweenNestedModulesRedirect(t *testing.T) { |
| ctx, cancel := context.WithTimeout(context.Background(), testTimeout) |
| defer cancel() |
| defer postgres.ResetTestDB(testDB, t) |
| |
| postgres.MustInsertModule(ctx, t, testDB, sample.Module(sample.ModulePath, sample.VersionString, "")) |
| postgres.MustInsertModule(ctx, t, testDB, sample.Module(sample.ModulePath+"/missing/dir/c", sample.VersionString, "")) |
| |
| missingPath := sample.ModulePath + "/missing" |
| notInsertedPath := sample.ModulePath + "/missing/dir" |
| if err := testDB.UpsertVersionMap(ctx, &internal.VersionMap{ |
| ModulePath: missingPath, |
| RequestedVersion: version.Latest, |
| ResolvedVersion: sample.VersionString, |
| }); err != nil { |
| t.Fatal(err) |
| } |
| |
| _, handler, _ := newTestServer(t, nil, nil) |
| for _, test := range []struct { |
| name, path string |
| wantStatus int |
| wantLocation string |
| }{ |
| {"want 404 for unknown version of module", sample.ModulePath + "@v0.5.0", http.StatusNotFound, ""}, |
| {"want 404 for never fetched directory", notInsertedPath, http.StatusNotFound, ""}, |
| {"want 302 for previously fetched directory", missingPath, http.StatusFound, "/search?q=" + url.PathEscape(missingPath)}, |
| } { |
| t.Run(test.name, func(t *testing.T) { |
| w := httptest.NewRecorder() |
| handler.ServeHTTP(w, httptest.NewRequest("GET", "/"+test.path, nil)) |
| if w.Code != test.wantStatus { |
| t.Errorf("%q: got status code = %d, want %d", "/"+test.path, w.Code, test.wantStatus) |
| } |
| if got := w.Header().Get("Location"); got != test.wantLocation { |
| t.Errorf("got location = %q, want %q", got, test.wantLocation) |
| } |
| }) |
| } |
| } |
| |
| func TestStripScheme(t *testing.T) { |
| for _, test := range []struct { |
| url, want string |
| }{ |
| {"http://github.com", "github.com"}, |
| {"https://github.com/path/to/something", "github.com/path/to/something"}, |
| {"example.com", "example.com"}, |
| {"chrome-extension://abcd", "abcd"}, |
| {"nonwellformed.com/path?://query=1", "query=1"}, |
| } { |
| if got := stripScheme(test.url); got != test.want { |
| t.Errorf("%q: got %q, want %q", test.url, got, test.want) |
| } |
| } |
| } |
| |
| func TestInstallFS(t *testing.T) { |
| s, handler, teardown := newTestServer(t, nil, nil) |
| defer teardown() |
| s.InstallFS("/dir", os.DirFS(".")) |
| // Request this file. |
| w := httptest.NewRecorder() |
| handler.ServeHTTP(w, httptest.NewRequest("GET", "/files/dir/server_test.go", nil)) |
| if w.Code != http.StatusOK { |
| t.Errorf("got status code = %d, want %d", w.Code, http.StatusOK) |
| } |
| if want := "TestInstallFS"; !strings.Contains(w.Body.String(), want) { |
| t.Errorf("body does not contain %q", want) |
| } |
| } |
