internal/stdlib: refactor getGoRepo, add clone tests

Refactor getGoRepo to handle both test and cloned repos.  This will
enable adding a third option, getting the Go repo from a local copy.

Also add a test for checking the contents of a cloned repo, to make
sure the clone logic is correct. Flag-protect it because it's slow
and hits an external server.

Change-Id: I9de50bf12fccbd4fa35aa0566bdee3cddb25edf8
Reviewed-on: https://go-review.googlesource.com/c/pkgsite/+/347403
Trust: Jonathan Amsterdam <jba@google.com>
Run-TryBot: Jonathan Amsterdam <jba@google.com>
TryBot-Result: kokoro <noreply+kokoro@google.com>
Reviewed-by: Jamal Carvalho <jamal@golang.org>

1 files changed, 32 insertions, 23 deletions

diff --git a/internal/stdlib/stdlib.go b/internal/stdlib/stdlib.go
index d8757734..2c57d767 100644
--- a/internal/stdlib/stdlib.go
+++ b/internal/stdlib/stdlib.go
@@ -200,10 +200,19 @@ var (
 )
 
 // getGoRepo returns a repo object for the Go repo at version.
-func getGoRepo(v string) (_ *git.Repository, err error) {
-	defer derrors.Wrap(&err, "getGoRepo(%q)", v)
+func getGoRepo(version string) (_ *git.Repository, _ plumbing.ReferenceName, err error) {
+	defer derrors.Wrap(&err, "getGoRepo(%q)", version)
+	if UseTestData {
+		return getTestGoRepo(version)
+	}
+	return cloneGoRepo(version)
+}
+
+// cloneGoRepo returns a repo object for the Go repo at version by cloning the
+// Go repo.
+func cloneGoRepo(v string) (_ *git.Repository, ref plumbing.ReferenceName, err error) {
+	defer derrors.Wrap(&err, "cloneGoRepo(%q)", v)
 
-	var ref plumbing.ReferenceName
 	if v == version.Master {
 		ref = plumbing.HEAD
 	} else if SupportedBranches[v] {
@@ -211,21 +220,25 @@ func getGoRepo(v string) (_ *git.Repository, err error) {
 	} else {
 		tag, err := TagForVersion(v)
 		if err != nil {
-			return nil, err
+			return nil, "", err
 		}
 		ref = plumbing.NewTagReferenceName(tag)
 	}
-	return git.Clone(memory.NewStorage(), nil, &git.CloneOptions{
+	repo, err := git.Clone(memory.NewStorage(), nil, &git.CloneOptions{
 		URL:           GoRepoURL,
 		ReferenceName: ref,
 		SingleBranch:  true,
 		Depth:         1,
 		Tags:          git.NoTags,
 	})
+	if err != nil {
+		return nil, "", err
+	}
+	return repo, ref, nil
 }
 
 // getTestGoRepo gets a Go repo for testing.
-func getTestGoRepo(v string) (_ *git.Repository, err error) {
+func getTestGoRepo(v string) (_ *git.Repository, _ plumbing.ReferenceName, err error) {
 	defer derrors.Wrap(&err, "getTestGoRepo(%q)", v)
 	if v == TestMasterVersion {
 		v = version.Master
@@ -236,15 +249,15 @@ func getTestGoRepo(v string) (_ *git.Repository, err error) {
 	fs := osfs.New(filepath.Join(testhelper.TestDataPath("testdata"), v))
 	repo, err := git.Init(memory.NewStorage(), fs)
 	if err != nil {
-		return nil, fmt.Errorf("git.Initi: %v", err)
+		return nil, "", fmt.Errorf("git.Initi: %v", err)
 	}
 	wt, err := repo.Worktree()
 	if err != nil {
-		return nil, fmt.Errorf("repo.Worktree: %v", err)
+		return nil, "", fmt.Errorf("repo.Worktree: %v", err)
 	}
 	// Add all files in the directory.
 	if _, err := wt.Add(""); err != nil {
-		return nil, fmt.Errorf("wt.Add(): %v", err)
+		return nil, "", fmt.Errorf("wt.Add(): %v", err)
 	}
 	_, err = wt.Commit("", &git.CommitOptions{All: true, Author: &object.Signature{
 		Name:  "Joe Random",
@@ -252,9 +265,9 @@ func getTestGoRepo(v string) (_ *git.Repository, err error) {
 		When:  TestCommitTime,
 	}})
 	if err != nil {
-		return nil, fmt.Errorf("wt.Commit: %v", err)
+		return nil, "", fmt.Errorf("wt.Commit: %v", err)
 	}
-	return repo, nil
+	return repo, plumbing.HEAD, nil
 }
 
 // Versions returns all the versions of Go that are relevant to the discovery
@@ -316,28 +329,24 @@ func ZipInfo(requestedVersion string) (resolvedVersion string, err error) {
 }
 
 func zipInternal(requestedVersion string) (_ *zip.Reader, resolvedVersion string, commitTime time.Time, prefix string, err error) {
-	var repo *git.Repository
-	if UseTestData {
-		repo, err = getTestGoRepo(requestedVersion)
-	} else {
-		if requestedVersion == version.Latest {
-			requestedVersion, err = semanticVersion(requestedVersion)
-			if err != nil {
-				return nil, "", time.Time{}, "", err
-			}
+	if !UseTestData && requestedVersion == version.Latest {
+		requestedVersion, err = semanticVersion(requestedVersion)
+		if err != nil {
+			return nil, "", time.Time{}, "", err
 		}
-		repo, err = getGoRepo(requestedVersion)
 	}
+	repo, refName, err := getGoRepo(requestedVersion)
 	if err != nil {
 		return nil, "", time.Time{}, "", err
 	}
 	var buf bytes.Buffer
 	z := zip.NewWriter(&buf)
-	head, err := repo.Head()
+
+	ref, err := repo.Reference(refName, true)
 	if err != nil {
 		return nil, "", time.Time{}, "", err
 	}
-	commit, err := repo.CommitObject(head.Hash())
+	commit, err := repo.CommitObject(ref.Hash())
 	if err != nil {
 		return nil, "", time.Time{}, "", err
 	}