go/gitiles/gitiles_test.go - buildbot - Git at Google

 package gitiles

 import (
 	"context"
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"sort"
 	"strings"
 	"testing"
 	"time"

 	"github.com/stretchr/testify/require"
 	"golang.org/x/time/rate"

 	cipd_git "go.skia.org/infra/bazel/external/cipd/git"
 	"go.skia.org/infra/go/deepequal/assertdeep"
 	"go.skia.org/infra/go/git"
 	git_testutils "go.skia.org/infra/go/git/testutils"
 	"go.skia.org/infra/go/git/testutils/mem_git"
 	"go.skia.org/infra/go/gitstore/mem_gitstore"
 	"go.skia.org/infra/go/mockhttpclient"
 	"go.skia.org/infra/go/testutils"
 	"go.skia.org/infra/go/vcsinfo"
 )

 func TestLog(t *testing.T) {

 	// Setup. The test repo looks like this:
 	/*
 		$ git log --graph --date-order
 		* commit c8
 		|
 		*   commit c7
 		|\  Merge: c5 c6
 		| |
 		| * commit c6
 		| |
 		* | commit c5
 		| |
 		* | commit c4
 		| |
 		| * commit c3
 		| |
 		| * commit c2
 		|/
 		|
 		* commit c1
 		|
 		* commit c0
 	*/
 	ctx := cipd_git.UseGitFinder(context.Background())
 	gb := git_testutils.GitInit(t, ctx)
 	now := time.Now()
 	c0 := gb.CommitGenAt(ctx, "file1", now)
 	now = now.Add(time.Second)
 	c1 := gb.CommitGenAt(ctx, "file1", now)
 	now = now.Add(time.Second)
 	gb.CreateBranchTrackBranch(ctx, "branch2", git.MainBranch)
 	c2 := gb.CommitGenAt(ctx, "file2", now)
 	now = now.Add(time.Second)
 	c3 := gb.CommitGenAt(ctx, "file2", now)
 	now = now.Add(time.Second)
 	gb.CheckoutBranch(ctx, git.MainBranch)
 	c4 := gb.CommitGenAt(ctx, "file1", now)
 	now = now.Add(time.Second)
 	c5 := gb.CommitGenAt(ctx, "file1", now)
 	now = now.Add(time.Second)
 	gb.CheckoutBranch(ctx, "branch2")
 	c6 := gb.CommitGenAt(ctx, "file2", now)
 	now = now.Add(time.Second)
 	gb.CheckoutBranch(ctx, git.MainBranch)
 	c7 := gb.MergeBranch(ctx, "branch2")
 	now = now.Add(time.Second)
 	c8 := gb.CommitGenAt(ctx, "file1", now)

 	// Use all of the commit variables so the compiler doesn't complain.
 	repo := git.GitDir(gb.Dir())
 	commits := []string{c8, c7, c6, c5, c4, c3, c2, c1, c0}
 	details := make(map[string]*vcsinfo.LongCommit, len(commits))
 	for _, c := range commits {
 		d, err := repo.Details(ctx, c)
 		require.NoError(t, err)
 		details[c] = d
 	}

 	urlMock := mockhttpclient.NewURLMock()
 	r := NewRepo(gb.RepoUrl(), urlMock.Client())
 	r.rl.SetLimit(rate.Inf)

 	// Helper function for mocking gitiles API calls.
 	mockLog := func(from, to string, rvCommits []string) {
 		// Create the mock results.
 		results := &Log{
 			Log: make([]*Commit, 0, len(rvCommits)),
 		}
 		for _, c := range rvCommits {
 			d := details[c]
 			results.Log = append(results.Log, &Commit{
 				Commit:  d.Hash,
 				Parents: d.Parents,
 				Author: &Author{
 					Name:  "don't care",
 					Email: "don't care",
 					Time:  d.Timestamp.Format(dateFormatNoTZ),
 				},
 				Committer: &Author{
 					Name:  "don't care",
 					Email: "don't care",
 					Time:  d.Timestamp.Format(dateFormatNoTZ),
 				},
 				Message: d.Subject,
 			})
 		}
 		js := testutils.MarshalJSON(t, results)
 		js = ")]}'\n" + js
 		urlMock.MockOnce(fmt.Sprintf(LogURL, gb.RepoUrl(), git.LogFromTo(from, to)), mockhttpclient.MockGetDialogue([]byte(js)))
 	}

 	// Return a slice of the hashes for the given commits.
 	hashes := func(commits []*vcsinfo.LongCommit) []string {
 		rv := make([]string, 0, len(commits))
 		for _, c := range commits {
 			rv = append(rv, c.Hash)
 		}
 		return rv
 	}

 	// Verify that we got the correct list of commits from the call to Log.
 	checkGitiles := func(fn func(context.Context, string, ...LogOption) ([]*vcsinfo.LongCommit, error), from, to string, expect []string) {
 		mockLog(from, to, expect)
 		log, err := fn(ctx, git.LogFromTo(from, to))
 		require.NoError(t, err)
 		assertdeep.Equal(t, hashes(log), expect)
 		require.True(t, urlMock.Empty())
 	}

 	// Verify that we get the correct list of commits from Git. This is so
 	// that we can ensure that our test expectations of the library are
 	// consistent with the actual behavior of Git.
 	checkGit := func(from, to string, expect []string, args ...string) {
 		cmd := []string{"rev-list", "--date-order"}
 		cmd = append(cmd, args...)
 		cmd = append(cmd, string(git.LogFromTo(from, to)))
 		output, err := repo.Git(ctx, cmd...)
 		require.NoError(t, err)
 		log := strings.Split(strings.TrimSpace(output), "\n")
 		// Empty response results in a single-item list with one empty
 		// string...
 		if len(log) == 1 && log[0] == "" {
 			log = log[1:]
 		}
 		assertdeep.Equal(t, log, expect)
 	}

 	// Verify that we get the expected list of commits from both Gitiles
 	// (Repo.Log) and Git ("git log --date-order").
 	checkBasic := func(from, to string, expect []string) {
 		checkGit(from, to, expect)
 		checkGitiles(r.Log, from, to, expect)
 	}

 	// Verify that we get the expected list of commits from both Gitiles
 	// (Repo.LogFirstParent) and Git ("git log --date-order --first-parent").
 	checkFirstParent := func(from, to string, expect []string) {
 		checkGit(from, to, expect, "--first-parent")
 		mockLog(from, to, expect)
 		log, err := r.LogFirstParent(ctx, from, to)
 		require.NoError(t, err)
 		assertdeep.Equal(t, hashes(log), expect)
 		require.True(t, urlMock.Empty())
 	}

 	// Verify that we get the expected list of commits from both Gitiles
 	// (Repo.LogLinear) and Git
 	// ("git log --date-order --first-parent --ancestry-path).
 	checkLinear := func(from, to string, expect []string) {
 		checkGit(from, to, expect, "--first-parent", "--ancestry-path")
 		mockLog(from, to, expect)
 		log, err := r.LogLinear(ctx, from, to)
 		require.NoError(t, err)
 		assertdeep.Equal(t, hashes(log), expect)
 		require.True(t, urlMock.Empty())
 	}

 	// Test cases.
 	checkBasic(c0, c8, []string{c8, c7, c6, c5, c4, c3, c2, c1})
 	checkFirstParent(c0, c8, []string{c8, c7, c5, c4, c1})
 	checkLinear(c0, c8, []string{c8, c7, c5, c4, c1})
 	checkBasic(c0, c1, []string{c1})
 	checkFirstParent(c0, c1, []string{c1})
 	checkLinear(c0, c1, []string{c1})
 	checkBasic(c2, c4, []string{c4})
 	checkFirstParent(c2, c4, []string{c4})
 	checkLinear(c2, c4, []string{})
 	checkBasic(c1, c2, []string{c2})
 	checkFirstParent(c1, c2, []string{c2})
 	checkLinear(c1, c2, []string{c2})
 	checkBasic(c1, c4, []string{c4})
 	checkFirstParent(c1, c4, []string{c4})
 	checkLinear(c1, c4, []string{c4})
 	checkBasic(c5, c7, []string{c7, c6, c3, c2})
 	checkFirstParent(c5, c7, []string{c7})
 	checkLinear(c5, c7, []string{c7})
 	checkBasic(c2, c7, []string{c7, c6, c5, c4, c3})
 	checkFirstParent(c2, c7, []string{c7, c5, c4})
 	checkLinear(c2, c7, []string{})
 }

 func TestLogPagination(t *testing.T) {

 	// Gitiles API paginates logs over 100 commits long.
 	ctx := context.Background()
 	repoURL := "https://fake/repo"
 	urlMock := mockhttpclient.NewURLMock()
 	repo := NewRepo(repoURL, urlMock.Client())
 	repo.rl.SetLimit(rate.Inf)
 	next := 0
 	hash := func() string {
 		next++
 		return fmt.Sprintf("%040d", next)
 	}
 	ts := time.Now().Truncate(time.Second).UTC()
 	var last *vcsinfo.LongCommit
 	commit := func() *vcsinfo.LongCommit {
 		ts = ts.Add(time.Second)
 		rv := &vcsinfo.LongCommit{
 			ShortCommit: &vcsinfo.ShortCommit{
 				Hash:    hash(),
 				Author:  "don't care (don't care)",
 				Subject: "don't care",
 			},
 			Timestamp: ts,
 		}
 		if last != nil {
 			rv.Parents = []string{last.Hash}
 		}
 		last = rv
 		return rv
 	}
 	mock := func(from, to *vcsinfo.LongCommit, commits []*vcsinfo.LongCommit, start, next string) {
 		// Create the mock results.
 		results := &Log{
 			Log:  make([]*Commit, 0, len(commits)),
 			Next: next,
 		}
 		for i := len(commits) - 1; i >= 0; i-- {
 			c := commits[i]
 			results.Log = append(results.Log, &Commit{
 				Commit:  c.Hash,
 				Parents: c.Parents,
 				Author: &Author{
 					Name:  "don't care",
 					Email: "don't care",
 					Time:  c.Timestamp.Format(dateFormatNoTZ),
 				},
 				Committer: &Author{
 					Name:  "don't care",
 					Email: "don't care",
 					Time:  c.Timestamp.Format(dateFormatNoTZ),
 				},
 				Message: "don't care",
 			})
 		}
 		js := testutils.MarshalJSON(t, results)
 		js = ")]}'\n" + js
 		url1 := fmt.Sprintf(LogURL, repoURL, git.LogFromTo(from.Hash, to.Hash))
 		url2 := fmt.Sprintf(LogURL, repoURL, to.Hash)
 		if start != "" {
 			url1 += "&s=" + start
 			url2 += "&s=" + start
 		}
 		urlMock.MockOnce(url1, mockhttpclient.MockGetDialogue([]byte(js)))
 		urlMock.MockOnce(url2, mockhttpclient.MockGetDialogue([]byte(js)))
 	}
 	check := func(from, to *vcsinfo.LongCommit, expectCommits []*vcsinfo.LongCommit) {
 		// The expectations are in chronological order for convenience
 		// of the caller. But git logs are in reverse chronological
 		// order. Sort the expectations.
 		expect := make([]*vcsinfo.LongCommit, len(expectCommits))
 		copy(expect, expectCommits)
 		sort.Sort(vcsinfo.LongCommitSlice(expect))

 		// Test standard Log(from, to) function.
 		log, err := repo.Log(ctx, git.LogFromTo(from.Hash, to.Hash))
 		require.NoError(t, err)
 		assertdeep.Equal(t, expect, log)

 		// Test LogFn
 		log = make([]*vcsinfo.LongCommit, 0, len(expect))
 		require.NoError(t, repo.LogFn(ctx, to.Hash, func(ctx context.Context, c *vcsinfo.LongCommit) error {
 			if c.Hash == from.Hash {
 				return ErrStopIteration
 			}
 			log = append(log, c)
 			return nil
 		}))
 		assertdeep.Equal(t, expect, log)
 		require.True(t, urlMock.Empty())
 	}

 	// Create some fake commits.
 	commits := []*vcsinfo.LongCommit{}
 	for i := 0; i < 10; i++ {
 		commits = append(commits, commit())
 	}

 	// Most basic test case; no pagination.
 	mock(commits[0], commits[5], commits[1:5], "", "")
 	check(commits[0], commits[5], commits[1:5])

 	// Two pages.
 	split := 5
 	mock(commits[0], commits[len(commits)-1], commits[split:], "", commits[split].Hash)
 	mock(commits[0], commits[len(commits)-1], commits[1:split], commits[split].Hash, "")
 	check(commits[0], commits[len(commits)-1], commits[1:])

 	// Three pages.
 	split1 := 7
 	split2 := 3
 	mock(commits[0], commits[len(commits)-1], commits[split1:], "", commits[split1].Hash)
 	mock(commits[0], commits[len(commits)-1], commits[split2:split1], commits[split1].Hash, commits[split2].Hash)
 	mock(commits[0], commits[len(commits)-1], commits[1:split2], commits[split2].Hash, "")
 	check(commits[0], commits[len(commits)-1], commits[1:])
 }

 func TestLogLimit(t *testing.T) {

 	ctx := context.Background()
 	gs := mem_gitstore.New()
 	g := mem_git.New(t, gs)
 	hashes := g.CommitN(100)
 	commits, err := gs.Get(ctx, hashes)
 	require.NoError(t, err)
 	// Strip some extra info we don't expect to get back from Gitiles.
 	for _, c := range commits {
 		c.Author = c.Author + " ()"
 		c.Branches = nil
 		c.Index = 0
 	}

 	repoURL := "https://fake/repo"
 	urlMock := mockhttpclient.NewURLMock()
 	repo := NewRepo(repoURL, urlMock.Client())
 	repo.rl.SetLimit(rate.Inf)

 	mock := func(logExpr string, limit int, commits []*vcsinfo.LongCommit, start, next string) {
 		// Create the mock results.
 		results := &Log{
 			Log:  make([]*Commit, 0, len(commits)),
 			Next: next,
 		}
 		for _, c := range commits {
 			results.Log = append(results.Log, &Commit{
 				Commit:  c.Hash,
 				Parents: c.Parents,
 				Author: &Author{
 					Name: strings.TrimSuffix(c.Author, " ()"),
 					Time: c.Timestamp.Format(dateFormatNoTZ),
 				},
 				Committer: &Author{
 					Name: strings.TrimSuffix(c.Author, " ()"),
 					Time: c.Timestamp.Format(dateFormatNoTZ),
 				},
 				Message: c.Subject,
 			})
 		}
 		js := testutils.MarshalJSON(t, results)
 		js = ")]}'\n" + js
 		opt := LogLimit(limit)
 		url := fmt.Sprintf(LogURL, repo.URL(), logExpr) + fmt.Sprintf("&%s=%s", opt.Key(), opt.Value())
 		if start != "" {
 			url += "&s=" + start
 		}
 		urlMock.MockOnce(url, mockhttpclient.MockGetDialogue([]byte(js)))
 	}
 	var res []*vcsinfo.LongCommit

 	// Limit 1, matches the Gitiles batch size.
 	mock(commits[0].Hash, 1, commits[:1], "", commits[1].Hash)
 	res, err = repo.Log(ctx, commits[0].Hash, LogLimit(1))
 	require.NoError(t, err)
 	assertdeep.Equal(t, commits[:1], res)
 	require.True(t, urlMock.Empty())

 	// Limit 23, matches the Gitiles batch size.
 	mock(commits[0].Hash, 23, commits[:23], "", commits[23].Hash)
 	res, err = repo.Log(ctx, commits[0].Hash, LogLimit(23))
 	require.NoError(t, err)
 	assertdeep.Equal(t, commits[:23], res)
 	require.True(t, urlMock.Empty())

 	// Limit larger than Gitiles batch size.
 	mock(commits[0].Hash, 50, commits[:25], "", commits[25].Hash)
 	mock(commits[0].Hash, 50, commits[25:50], commits[25].Hash, commits[50].Hash)
 	res, err = repo.Log(ctx, commits[0].Hash, LogLimit(50))
 	require.NoError(t, err)
 	assertdeep.Equal(t, commits[:50], res)
 	require.True(t, urlMock.Empty())

 	// If both LogBatchSize and LogLimit are supplied, we should use the
 	// smaller of the two.
 	// 1. Limit is smaller.
 	mock(commits[0].Hash, 10, commits[:10], "", commits[10].Hash)
 	res, err = repo.Log(ctx, commits[0].Hash, LogLimit(10), LogBatchSize(50))
 	require.NoError(t, err)
 	assertdeep.Equal(t, commits[:10], res)
 	require.True(t, urlMock.Empty())
 	// 2. BatchSize is smaller.
 	mock(commits[0].Hash, 25, commits[:25], "", commits[25].Hash)
 	mock(commits[0].Hash, 25, commits[25:50], commits[25].Hash, commits[50].Hash)
 	res, err = repo.Log(ctx, commits[0].Hash, LogLimit(50), LogBatchSize(25))
 	require.NoError(t, err)
 	assertdeep.Equal(t, commits[:50], res)
 	require.True(t, urlMock.Empty())
 	// 3. BatchSize specified multiple times.
 	mock(commits[0].Hash, 10, commits[:10], "", commits[10].Hash)
 	mock(commits[0].Hash, 10, commits[10:20], commits[10].Hash, commits[20].Hash)
 	mock(commits[0].Hash, 10, commits[20:30], commits[20].Hash, commits[30].Hash)
 	res, err = repo.Log(ctx, commits[0].Hash, LogBatchSize(50), LogBatchSize(10), LogBatchSize(15), LogLimit(25))
 	require.NoError(t, err)
 	assertdeep.Equal(t, commits[:25], res)
 	require.True(t, urlMock.Empty())
 }

 func TestLogPath(t *testing.T) {

 	ctx := context.Background()
 	repoURL := "https://fake/repo"
 	urlMock := mockhttpclient.NewURLMock()
 	repo := NewRepo(repoURL, urlMock.Client())
 	repo.rl.SetLimit(rate.Inf)
 	b := append([]byte(")]}'\n"), []byte(testutils.MarshalJSON(t, &Log{
 		Log:  []*Commit{},
 		Next: "",
 	}))...)
 	// Just verify that we used the correct URL.
 	urlMock.MockOnce("https://fake/repo/+log/myref/mypath?format=JSON", mockhttpclient.MockGetDialogue(b))
 	commits, err := repo.Log(ctx, "myref", LogPath("mypath"))
 	require.NoError(t, err)
 	require.Equal(t, 0, len(commits))
 }

 func TestGetTreeDiffs(t *testing.T) {

 	ctx := context.Background()
 	repoURL := "https://skia.googlesource.com/buildbot.git"
 	urlMock := mockhttpclient.NewURLMock()
 	repo := NewRepo(repoURL, urlMock.Client())
 	repo.rl.SetLimit(rate.Inf)

 	resp := `)]}'
 {
   "commit": "bbadbbadbbadbbadbbadbbadbbadbbadbbadbbad",
   "tree": "beefbeefbeefbeefbeefbeefbeefbeefbeefbeef",
   "parents": [
     "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
   ],
   "author": {
     "name": "Me",
     "email": "me@google.com",
     "time": "Tue Oct 15 10:45:49 2019 -0400"
   },
   "committer": {
     "name": "Skia Commit-Bot",
     "email": "skia-commit-bot@chromium.org",
     "time": "Wed Oct 16 17:24:55 2019 +0000"
   },
   "message": "Subject\n\nblah blah blah",
   "tree_diff": [
     {
       "type": "modify",
       "old_path": "test/go/test.go",
       "new_path": "test/go/test.go"
     },
     {
       "type": "delete",
       "old_path": "test/go/test2.go",
       "new_path": "dev/null"
     }
   ]
 }
 `
 	urlMock.MockOnce(fmt.Sprintf(CommitURLJSON, repoURL, "my/other/ref"), mockhttpclient.MockGetDialogue([]byte(resp)))
 	treeDiffs, err := repo.GetTreeDiffs(ctx, "my/other/ref")
 	require.NoError(t, err)
 	require.Equal(t, 2, len(treeDiffs))
 	require.Equal(t, "modify", treeDiffs[0].Type)
 	require.Equal(t, "test/go/test.go", treeDiffs[0].OldPath)
 	require.Equal(t, "test/go/test.go", treeDiffs[0].NewPath)
 	require.Equal(t, "delete", treeDiffs[1].Type)
 	require.Equal(t, "test/go/test2.go", treeDiffs[1].OldPath)
 	require.Equal(t, "dev/null", treeDiffs[1].NewPath)
 }

 func TestListDir(t *testing.T) {

 	ctx := context.Background()
 	repoURL := "https://skia.googlesource.com/buildbot.git"
 	urlMock := mockhttpclient.NewURLMock()
 	repo := NewRepo(repoURL, urlMock.Client())
 	repo.rl.SetLimit(rate.Inf)

 	resp1 := base64.StdEncoding.EncodeToString([]byte(`100644 blob 573680d74f404d64a7c3441f8a502c007fdcd3b7    gitiles.go
 100644 blob c2b8be8049e8503391239bbf00877ebf5880493c    gitiles_test.go
 040000 tree 81b1fde7557bd75ad0392143a9d79ed78d0ed4ab    testutils`))
 	md := mockhttpclient.MockGetDialogue([]byte(resp1))
 	md.ResponseHeader(ModeHeader, "0644")
 	md.ResponseHeader(TypeHeader, "tree")
 	urlMock.MockOnce(fmt.Sprintf(DownloadURL, repoURL, "my/ref", "go/gitiles"), md)

 	infos, err := repo.ListDirAtRef(ctx, "go/gitiles", "my/ref")
 	require.NoError(t, err)
 	files := []string{}
 	dirs := []string{}
 	for _, fi := range infos {
 		if fi.IsDir() {
 			dirs = append(dirs, fi.Name())
 		} else {
 			files = append(files, fi.Name())
 		}
 	}
 	assertdeep.Equal(t, []string{"gitiles.go", "gitiles_test.go"}, files)
 	assertdeep.Equal(t, []string{"testutils"}, dirs)

 	resp2 := `)]}'
 {
   "commit": "bbadbbadbbadbbadbbadbbadbbadbbadbbadbbad",
   "tree": "beefbeefbeefbeefbeefbeefbeefbeefbeefbeef",
   "parents": [
     "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
   ],
   "author": {
     "name": "Me",
     "email": "me@google.com",
     "time": "Tue Oct 15 10:45:49 2019 -0400"
   },
   "committer": {
     "name": "Skia Commit-Bot",
     "email": "skia-commit-bot@chromium.org",
     "time": "Wed Oct 16 17:24:55 2019 +0000"
   },
   "message": "Subject\n\nblah blah blah",
   "tree_diff": []
 }
 `
 	urlMock.MockOnce(fmt.Sprintf(CommitURLJSON, repoURL, "my/other/ref"), mockhttpclient.MockGetDialogue([]byte(resp2)))
 	urlMock.MockOnce(fmt.Sprintf(DownloadURL, repoURL, "bbadbbadbbadbbadbbadbbadbbadbbadbbadbbad", "go/gitiles"), md)
 	resp3 := base64.StdEncoding.EncodeToString([]byte(`100644 blob 6e5cdd994551045ab24a4246906c7723cb12c12e    testutils.go`))
 	md = mockhttpclient.MockGetDialogue([]byte(resp3))
 	md.ResponseHeader(ModeHeader, "0644")
 	md.ResponseHeader(TypeHeader, "tree")
 	urlMock.MockOnce(fmt.Sprintf(DownloadURL, repoURL, "bbadbbadbbadbbadbbadbbadbbadbbadbbadbbad", "go/gitiles/testutils"), md)
 	files, err = repo.ListFilesRecursiveAtRef(ctx, "go/gitiles", "my/other/ref")
 	require.NoError(t, err)
 	assertdeep.Equal(t, []string{"gitiles.go", "gitiles_test.go", "testutils/testutils.go"}, files)
 }

 func TestLogOptionsToQuery(t *testing.T) {

 	test := func(expectPath string, expectQuery string, expectLimit int, opts ...LogOption) {
 		path, query, limit, err := LogOptionsToQuery(opts)
 		require.NoError(t, err)
 		require.Equal(t, expectPath, path)
 		require.Equal(t, expectQuery, query)
 		require.Equal(t, expectLimit, limit)
 	}
 	test("", "", 0)
 	test("", "reverse=true", 0, LogReverse())
 	test("", "n=1", 0, LogBatchSize(1))
 	test("", "n=2", 2, LogLimit(2))
 	test("", "n=5", 5, LogLimit(5), LogBatchSize(10))
 	test("", "n=5", 5, LogBatchSize(10), LogLimit(5))
 	test("", "n=5", 0, LogBatchSize(5), LogBatchSize(10))
 	test("", "n=3&reverse=true", 10, LogReverse(), LogLimit(10), LogBatchSize(3))
 	test("mypath", "n=3&reverse=true", 10, LogReverse(), LogLimit(10), LogBatchSize(3), LogPath("mypath"))
 }

 func TestDetails(t *testing.T) {

 	// Setup.
 	ctx := cipd_git.UseGitFinder(context.Background())
 	repoURL := "https://skia.googlesource.com/buildbot.git"
 	urlMock := mockhttpclient.NewURLMock()
 	repo := NewRepo(repoURL, urlMock.Client())
 	gb := git_testutils.GitInit(t, ctx)

 	// Helper function which creates a commit, retrieves it from both
 	// Gitiles and the real Git repo using Details, and assert that the
 	// results are identical.
 	check := func(msg string) {
 		// Create the commit.
 		hash := gb.CommitGenMsg(ctx, "fake", msg)

 		// Retrieve the commit from Git.
 		expect, err := git.GitDir(gb.Dir()).Details(ctx, hash)
 		require.NoError(t, err)

 		// Mock the request to Gitiles. Caveat: the test results are
 		// only as good as the quality of our mocks.
 		c, err := LongCommitToCommit(expect)
 		require.NoError(t, err)
 		b, err := json.Marshal(c)
 		require.NoError(t, err)
 		b = append([]byte(")]}'\n"), b...)
 		urlMock.MockOnce(fmt.Sprintf(CommitURLJSON, repoURL, hash), mockhttpclient.MockGetDialogue(b))

 		// Perform the request.
 		actual, err := repo.Details(ctx, hash)
 		require.NoError(t, err)

 		// Assert that the results from Gitiles are identical to those
 		// from Git.
 		assertdeep.Equal(t, expect, actual)
 	}

 	// Test cases.
 	check("blahblahblah")
 	check(`subject
 `)
 	check(`subject
 no empty second line
 more stuff`)
 	check(`subject

 body
 `)
 	check(`subject

 body`)
 	check(`subject

 body
 body2
 `)
 }

 func TestParseURL(t *testing.T) {
 	test := func(input, expectRepoURL, expectRef, expectPath, expectErr string) {
 		actualRepoURL, actualRef, actualPath, actualErr := ParseURL(input)
 		if expectErr != "" {
 			require.EqualError(t, actualErr, expectErr)
 		} else {
 			require.NoError(t, actualErr)
 		}
 		require.Equal(t, expectRepoURL, actualRepoURL)
 		require.Equal(t, expectRef, actualRef)
 		require.Equal(t, expectPath, actualPath)
 	}
 	test(
 		"https://example.googlesource.com/my-repo/+/refs/heads/main/path/to/file",
 		"https://example.googlesource.com/my-repo",
 		"refs/heads/main",
 		"path/to/file",
 		"",
 	)
 	test(
 		"https://example.googlesource.com/my-repo/+/main/path/to/file",
 		"https://example.googlesource.com/my-repo",
 		"main",
 		"path/to/file",
 		"",
 	)
 	test(
 		"https://example.googlesource.com/my-repo/+show/refs/heads/main/path/to/file?format=TEXT",
 		"https://example.googlesource.com/my-repo",
 		"refs/heads/main",
 		"path/to/file",
 		"",
 	)
 	test(
 		"https://example.googlesource.com/my-repo/+show/refs/heads/main?format=JSON",
 		"https://example.googlesource.com/my-repo",
 		"refs/heads/main",
 		"",
 		"",
 	)
 	test(
 		"https://example.googlesource.com/my-repo/+log/main/path/to/file?format=JSON",
 		"https://example.googlesource.com/my-repo",
 		"main",
 		"path/to/file",
 		"",
 	)
 }
	package gitiles

	import (
	"context"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"sort"
	"strings"
	"testing"
	"time"

	"github.com/stretchr/testify/require"
	"golang.org/x/time/rate"

	cipd_git "go.skia.org/infra/bazel/external/cipd/git"
	"go.skia.org/infra/go/deepequal/assertdeep"
	"go.skia.org/infra/go/git"
	git_testutils "go.skia.org/infra/go/git/testutils"
	"go.skia.org/infra/go/git/testutils/mem_git"
	"go.skia.org/infra/go/gitstore/mem_gitstore"
	"go.skia.org/infra/go/mockhttpclient"
	"go.skia.org/infra/go/testutils"
	"go.skia.org/infra/go/vcsinfo"
	)

	func TestLog(t *testing.T) {

	// Setup. The test repo looks like this:
	/*
	$ git log --graph --date-order
	* commit c8
	\|
	* commit c7
	\|\ Merge: c5 c6
	\| \|
	\| * commit c6
	\| \|
	* \| commit c5
	\| \|
	* \| commit c4
	\| \|
	\| * commit c3
	\| \|
	\| * commit c2
	\|/
	\|
	* commit c1
	\|
	* commit c0
	*/
	ctx := cipd_git.UseGitFinder(context.Background())
	gb := git_testutils.GitInit(t, ctx)
	now := time.Now()
	c0 := gb.CommitGenAt(ctx, "file1", now)
	now = now.Add(time.Second)
	c1 := gb.CommitGenAt(ctx, "file1", now)
	now = now.Add(time.Second)
	gb.CreateBranchTrackBranch(ctx, "branch2", git.MainBranch)
	c2 := gb.CommitGenAt(ctx, "file2", now)
	now = now.Add(time.Second)
	c3 := gb.CommitGenAt(ctx, "file2", now)
	now = now.Add(time.Second)
	gb.CheckoutBranch(ctx, git.MainBranch)
	c4 := gb.CommitGenAt(ctx, "file1", now)
	now = now.Add(time.Second)
	c5 := gb.CommitGenAt(ctx, "file1", now)
	now = now.Add(time.Second)
	gb.CheckoutBranch(ctx, "branch2")
	c6 := gb.CommitGenAt(ctx, "file2", now)
	now = now.Add(time.Second)
	gb.CheckoutBranch(ctx, git.MainBranch)
	c7 := gb.MergeBranch(ctx, "branch2")
	now = now.Add(time.Second)
	c8 := gb.CommitGenAt(ctx, "file1", now)

	// Use all of the commit variables so the compiler doesn't complain.
	repo := git.GitDir(gb.Dir())
	commits := []string{c8, c7, c6, c5, c4, c3, c2, c1, c0}
	details := make(map[string]*vcsinfo.LongCommit, len(commits))
	for _, c := range commits {
	d, err := repo.Details(ctx, c)
	require.NoError(t, err)
	details[c] = d
	}

	urlMock := mockhttpclient.NewURLMock()
	r := NewRepo(gb.RepoUrl(), urlMock.Client())
	r.rl.SetLimit(rate.Inf)

	// Helper function for mocking gitiles API calls.
	mockLog := func(from, to string, rvCommits []string) {
	// Create the mock results.
	results := &Log{
	Log: make([]*Commit, 0, len(rvCommits)),
	}
	for _, c := range rvCommits {
	d := details[c]
	results.Log = append(results.Log, &Commit{
	Commit: d.Hash,
	Parents: d.Parents,
	Author: &Author{
	Name: "don't care",
	Email: "don't care",
	Time: d.Timestamp.Format(dateFormatNoTZ),
	},
	Committer: &Author{
	Name: "don't care",
	Email: "don't care",
	Time: d.Timestamp.Format(dateFormatNoTZ),
	},
	Message: d.Subject,
	})
	}
	js := testutils.MarshalJSON(t, results)
	js = ")]}'\n" + js
	urlMock.MockOnce(fmt.Sprintf(LogURL, gb.RepoUrl(), git.LogFromTo(from, to)), mockhttpclient.MockGetDialogue([]byte(js)))
	}

	// Return a slice of the hashes for the given commits.
	hashes := func(commits []*vcsinfo.LongCommit) []string {
	rv := make([]string, 0, len(commits))
	for _, c := range commits {
	rv = append(rv, c.Hash)
	}
	return rv
	}

	// Verify that we got the correct list of commits from the call to Log.
	checkGitiles := func(fn func(context.Context, string, ...LogOption) ([]*vcsinfo.LongCommit, error), from, to string, expect []string) {
	mockLog(from, to, expect)
	log, err := fn(ctx, git.LogFromTo(from, to))
	require.NoError(t, err)
	assertdeep.Equal(t, hashes(log), expect)
	require.True(t, urlMock.Empty())
	}

	// Verify that we get the correct list of commits from Git. This is so
	// that we can ensure that our test expectations of the library are
	// consistent with the actual behavior of Git.
	checkGit := func(from, to string, expect []string, args ...string) {
	cmd := []string{"rev-list", "--date-order"}
	cmd = append(cmd, args...)
	cmd = append(cmd, string(git.LogFromTo(from, to)))
	output, err := repo.Git(ctx, cmd...)
	require.NoError(t, err)
	log := strings.Split(strings.TrimSpace(output), "\n")
	// Empty response results in a single-item list with one empty
	// string...
	if len(log) == 1 && log[0] == "" {
	log = log[1:]
	}
	assertdeep.Equal(t, log, expect)
	}

	// Verify that we get the expected list of commits from both Gitiles
	// (Repo.Log) and Git ("git log --date-order").
	checkBasic := func(from, to string, expect []string) {
	checkGit(from, to, expect)
	checkGitiles(r.Log, from, to, expect)
	}

	// Verify that we get the expected list of commits from both Gitiles
	// (Repo.LogFirstParent) and Git ("git log --date-order --first-parent").
	checkFirstParent := func(from, to string, expect []string) {
	checkGit(from, to, expect, "--first-parent")
	mockLog(from, to, expect)
	log, err := r.LogFirstParent(ctx, from, to)
	require.NoError(t, err)
	assertdeep.Equal(t, hashes(log), expect)
	require.True(t, urlMock.Empty())
	}

	// Verify that we get the expected list of commits from both Gitiles
	// (Repo.LogLinear) and Git
	// ("git log --date-order --first-parent --ancestry-path).
	checkLinear := func(from, to string, expect []string) {
	checkGit(from, to, expect, "--first-parent", "--ancestry-path")
	mockLog(from, to, expect)
	log, err := r.LogLinear(ctx, from, to)
	require.NoError(t, err)
	assertdeep.Equal(t, hashes(log), expect)
	require.True(t, urlMock.Empty())
	}

	// Test cases.
	checkBasic(c0, c8, []string{c8, c7, c6, c5, c4, c3, c2, c1})
	checkFirstParent(c0, c8, []string{c8, c7, c5, c4, c1})
	checkLinear(c0, c8, []string{c8, c7, c5, c4, c1})
	checkBasic(c0, c1, []string{c1})
	checkFirstParent(c0, c1, []string{c1})
	checkLinear(c0, c1, []string{c1})
	checkBasic(c2, c4, []string{c4})
	checkFirstParent(c2, c4, []string{c4})
	checkLinear(c2, c4, []string{})
	checkBasic(c1, c2, []string{c2})
	checkFirstParent(c1, c2, []string{c2})
	checkLinear(c1, c2, []string{c2})
	checkBasic(c1, c4, []string{c4})
	checkFirstParent(c1, c4, []string{c4})
	checkLinear(c1, c4, []string{c4})
	checkBasic(c5, c7, []string{c7, c6, c3, c2})
	checkFirstParent(c5, c7, []string{c7})
	checkLinear(c5, c7, []string{c7})
	checkBasic(c2, c7, []string{c7, c6, c5, c4, c3})
	checkFirstParent(c2, c7, []string{c7, c5, c4})
	checkLinear(c2, c7, []string{})
	}

	func TestLogPagination(t *testing.T) {

	// Gitiles API paginates logs over 100 commits long.
	ctx := context.Background()
	repoURL := "https://fake/repo"
	urlMock := mockhttpclient.NewURLMock()
	repo := NewRepo(repoURL, urlMock.Client())
	repo.rl.SetLimit(rate.Inf)
	next := 0
	hash := func() string {
	next++
	return fmt.Sprintf("%040d", next)
	}
	ts := time.Now().Truncate(time.Second).UTC()
	var last *vcsinfo.LongCommit
	commit := func() *vcsinfo.LongCommit {
	ts = ts.Add(time.Second)
	rv := &vcsinfo.LongCommit{
	ShortCommit: &vcsinfo.ShortCommit{
	Hash: hash(),
	Author: "don't care (don't care)",
	Subject: "don't care",
	},
	Timestamp: ts,
	}
	if last != nil {
	rv.Parents = []string{last.Hash}
	}
	last = rv
	return rv
	}
	mock := func(from, to vcsinfo.LongCommit, commits []vcsinfo.LongCommit, start, next string) {
	// Create the mock results.
	results := &Log{
	Log: make([]*Commit, 0, len(commits)),
	Next: next,
	}
	for i := len(commits) - 1; i >= 0; i-- {
	c := commits[i]
	results.Log = append(results.Log, &Commit{
	Commit: c.Hash,
	Parents: c.Parents,
	Author: &Author{
	Name: "don't care",
	Email: "don't care",
	Time: c.Timestamp.Format(dateFormatNoTZ),
	},
	Committer: &Author{
	Name: "don't care",
	Email: "don't care",
	Time: c.Timestamp.Format(dateFormatNoTZ),
	},
	Message: "don't care",
	})
	}
	js := testutils.MarshalJSON(t, results)
	js = ")]}'\n" + js
	url1 := fmt.Sprintf(LogURL, repoURL, git.LogFromTo(from.Hash, to.Hash))
	url2 := fmt.Sprintf(LogURL, repoURL, to.Hash)
	if start != "" {
	url1 += "&s=" + start
	url2 += "&s=" + start
	}
	urlMock.MockOnce(url1, mockhttpclient.MockGetDialogue([]byte(js)))
	urlMock.MockOnce(url2, mockhttpclient.MockGetDialogue([]byte(js)))
	}
	check := func(from, to vcsinfo.LongCommit, expectCommits []vcsinfo.LongCommit) {
	// The expectations are in chronological order for convenience
	// of the caller. But git logs are in reverse chronological
	// order. Sort the expectations.
	expect := make([]*vcsinfo.LongCommit, len(expectCommits))
	copy(expect, expectCommits)
	sort.Sort(vcsinfo.LongCommitSlice(expect))

	// Test standard Log(from, to) function.
	log, err := repo.Log(ctx, git.LogFromTo(from.Hash, to.Hash))
	require.NoError(t, err)
	assertdeep.Equal(t, expect, log)

	// Test LogFn
	log = make([]*vcsinfo.LongCommit, 0, len(expect))
	require.NoError(t, repo.LogFn(ctx, to.Hash, func(ctx context.Context, c *vcsinfo.LongCommit) error {
	if c.Hash == from.Hash {
	return ErrStopIteration
	}
	log = append(log, c)
	return nil
	}))
	assertdeep.Equal(t, expect, log)
	require.True(t, urlMock.Empty())
	}

	// Create some fake commits.
	commits := []*vcsinfo.LongCommit{}
	for i := 0; i < 10; i++ {
	commits = append(commits, commit())
	}

	// Most basic test case; no pagination.
	mock(commits[0], commits[5], commits[1:5], "", "")
	check(commits[0], commits[5], commits[1:5])

	// Two pages.
	split := 5
	mock(commits[0], commits[len(commits)-1], commits[split:], "", commits[split].Hash)
	mock(commits[0], commits[len(commits)-1], commits[1:split], commits[split].Hash, "")
	check(commits[0], commits[len(commits)-1], commits[1:])

	// Three pages.
	split1 := 7
	split2 := 3
	mock(commits[0], commits[len(commits)-1], commits[split1:], "", commits[split1].Hash)
	mock(commits[0], commits[len(commits)-1], commits[split2:split1], commits[split1].Hash, commits[split2].Hash)
	mock(commits[0], commits[len(commits)-1], commits[1:split2], commits[split2].Hash, "")
	check(commits[0], commits[len(commits)-1], commits[1:])
	}

	func TestLogLimit(t *testing.T) {

	ctx := context.Background()
	gs := mem_gitstore.New()
	g := mem_git.New(t, gs)
	hashes := g.CommitN(100)
	commits, err := gs.Get(ctx, hashes)
	require.NoError(t, err)
	// Strip some extra info we don't expect to get back from Gitiles.
	for _, c := range commits {
	c.Author = c.Author + " ()"
	c.Branches = nil
	c.Index = 0
	}

	repoURL := "https://fake/repo"
	urlMock := mockhttpclient.NewURLMock()
	repo := NewRepo(repoURL, urlMock.Client())
	repo.rl.SetLimit(rate.Inf)

	mock := func(logExpr string, limit int, commits []*vcsinfo.LongCommit, start, next string) {
	// Create the mock results.
	results := &Log{
	Log: make([]*Commit, 0, len(commits)),
	Next: next,
	}
	for _, c := range commits {
	results.Log = append(results.Log, &Commit{
	Commit: c.Hash,
	Parents: c.Parents,
	Author: &Author{
	Name: strings.TrimSuffix(c.Author, " ()"),
	Time: c.Timestamp.Format(dateFormatNoTZ),
	},
	Committer: &Author{
	Name: strings.TrimSuffix(c.Author, " ()"),
	Time: c.Timestamp.Format(dateFormatNoTZ),
	},
	Message: c.Subject,
	})
	}
	js := testutils.MarshalJSON(t, results)
	js = ")]}'\n" + js
	opt := LogLimit(limit)
	url := fmt.Sprintf(LogURL, repo.URL(), logExpr) + fmt.Sprintf("&%s=%s", opt.Key(), opt.Value())
	if start != "" {
	url += "&s=" + start
	}
	urlMock.MockOnce(url, mockhttpclient.MockGetDialogue([]byte(js)))
	}
	var res []*vcsinfo.LongCommit

	// Limit 1, matches the Gitiles batch size.
	mock(commits[0].Hash, 1, commits[:1], "", commits[1].Hash)
	res, err = repo.Log(ctx, commits[0].Hash, LogLimit(1))
	require.NoError(t, err)
	assertdeep.Equal(t, commits[:1], res)
	require.True(t, urlMock.Empty())

	// Limit 23, matches the Gitiles batch size.
	mock(commits[0].Hash, 23, commits[:23], "", commits[23].Hash)
	res, err = repo.Log(ctx, commits[0].Hash, LogLimit(23))
	require.NoError(t, err)
	assertdeep.Equal(t, commits[:23], res)
	require.True(t, urlMock.Empty())

	// Limit larger than Gitiles batch size.
	mock(commits[0].Hash, 50, commits[:25], "", commits[25].Hash)
	mock(commits[0].Hash, 50, commits[25:50], commits[25].Hash, commits[50].Hash)
	res, err = repo.Log(ctx, commits[0].Hash, LogLimit(50))
	require.NoError(t, err)
	assertdeep.Equal(t, commits[:50], res)
	require.True(t, urlMock.Empty())

	// If both LogBatchSize and LogLimit are supplied, we should use the
	// smaller of the two.
	// 1. Limit is smaller.
	mock(commits[0].Hash, 10, commits[:10], "", commits[10].Hash)
	res, err = repo.Log(ctx, commits[0].Hash, LogLimit(10), LogBatchSize(50))
	require.NoError(t, err)
	assertdeep.Equal(t, commits[:10], res)
	require.True(t, urlMock.Empty())
	// 2. BatchSize is smaller.
	mock(commits[0].Hash, 25, commits[:25], "", commits[25].Hash)
	mock(commits[0].Hash, 25, commits[25:50], commits[25].Hash, commits[50].Hash)
	res, err = repo.Log(ctx, commits[0].Hash, LogLimit(50), LogBatchSize(25))
	require.NoError(t, err)
	assertdeep.Equal(t, commits[:50], res)
	require.True(t, urlMock.Empty())
	// 3. BatchSize specified multiple times.
	mock(commits[0].Hash, 10, commits[:10], "", commits[10].Hash)
	mock(commits[0].Hash, 10, commits[10:20], commits[10].Hash, commits[20].Hash)
	mock(commits[0].Hash, 10, commits[20:30], commits[20].Hash, commits[30].Hash)
	res, err = repo.Log(ctx, commits[0].Hash, LogBatchSize(50), LogBatchSize(10), LogBatchSize(15), LogLimit(25))
	require.NoError(t, err)
	assertdeep.Equal(t, commits[:25], res)
	require.True(t, urlMock.Empty())
	}

	func TestLogPath(t *testing.T) {

	ctx := context.Background()
	repoURL := "https://fake/repo"
	urlMock := mockhttpclient.NewURLMock()
	repo := NewRepo(repoURL, urlMock.Client())
	repo.rl.SetLimit(rate.Inf)
	b := append([]byte(")]}'\n"), []byte(testutils.MarshalJSON(t, &Log{
	Log: []*Commit{},
	Next: "",
	}))...)
	// Just verify that we used the correct URL.
	urlMock.MockOnce("https://fake/repo/+log/myref/mypath?format=JSON", mockhttpclient.MockGetDialogue(b))
	commits, err := repo.Log(ctx, "myref", LogPath("mypath"))
	require.NoError(t, err)
	require.Equal(t, 0, len(commits))
	}

	func TestGetTreeDiffs(t *testing.T) {

	ctx := context.Background()
	repoURL := "https://skia.googlesource.com/buildbot.git"
	urlMock := mockhttpclient.NewURLMock()
	repo := NewRepo(repoURL, urlMock.Client())
	repo.rl.SetLimit(rate.Inf)

	resp := `)]}'
	{
	"commit": "bbadbbadbbadbbadbbadbbadbbadbbadbbadbbad",
	"tree": "beefbeefbeefbeefbeefbeefbeefbeefbeefbeef",
	"parents": [
	"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
	],
	"author": {
	"name": "Me",
	"email": "me@google.com",
	"time": "Tue Oct 15 10:45:49 2019 -0400"
	},
	"committer": {
	"name": "Skia Commit-Bot",
	"email": "skia-commit-bot@chromium.org",
	"time": "Wed Oct 16 17:24:55 2019 +0000"
	},
	"message": "Subject\n\nblah blah blah",
	"tree_diff": [
	{
	"type": "modify",
	"old_path": "test/go/test.go",
	"new_path": "test/go/test.go"
	},
	{
	"type": "delete",
	"old_path": "test/go/test2.go",
	"new_path": "dev/null"
	}
	]
	}
	`
	urlMock.MockOnce(fmt.Sprintf(CommitURLJSON, repoURL, "my/other/ref"), mockhttpclient.MockGetDialogue([]byte(resp)))
	treeDiffs, err := repo.GetTreeDiffs(ctx, "my/other/ref")
	require.NoError(t, err)
	require.Equal(t, 2, len(treeDiffs))
	require.Equal(t, "modify", treeDiffs[0].Type)
	require.Equal(t, "test/go/test.go", treeDiffs[0].OldPath)
	require.Equal(t, "test/go/test.go", treeDiffs[0].NewPath)
	require.Equal(t, "delete", treeDiffs[1].Type)
	require.Equal(t, "test/go/test2.go", treeDiffs[1].OldPath)
	require.Equal(t, "dev/null", treeDiffs[1].NewPath)
	}

	func TestListDir(t *testing.T) {

	ctx := context.Background()
	repoURL := "https://skia.googlesource.com/buildbot.git"
	urlMock := mockhttpclient.NewURLMock()
	repo := NewRepo(repoURL, urlMock.Client())
	repo.rl.SetLimit(rate.Inf)

	resp1 := base64.StdEncoding.EncodeToString([]byte(`100644 blob 573680d74f404d64a7c3441f8a502c007fdcd3b7 gitiles.go
	100644 blob c2b8be8049e8503391239bbf00877ebf5880493c gitiles_test.go
	040000 tree 81b1fde7557bd75ad0392143a9d79ed78d0ed4ab testutils`))
	md := mockhttpclient.MockGetDialogue([]byte(resp1))
	md.ResponseHeader(ModeHeader, "0644")
	md.ResponseHeader(TypeHeader, "tree")
	urlMock.MockOnce(fmt.Sprintf(DownloadURL, repoURL, "my/ref", "go/gitiles"), md)

	infos, err := repo.ListDirAtRef(ctx, "go/gitiles", "my/ref")
	require.NoError(t, err)
	files := []string{}
	dirs := []string{}
	for _, fi := range infos {
	if fi.IsDir() {
	dirs = append(dirs, fi.Name())
	} else {
	files = append(files, fi.Name())
	}
	}
	assertdeep.Equal(t, []string{"gitiles.go", "gitiles_test.go"}, files)
	assertdeep.Equal(t, []string{"testutils"}, dirs)

	resp2 := `)]}'
	{
	"commit": "bbadbbadbbadbbadbbadbbadbbadbbadbbadbbad",
	"tree": "beefbeefbeefbeefbeefbeefbeefbeefbeefbeef",
	"parents": [
	"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
	],
	"author": {
	"name": "Me",
	"email": "me@google.com",
	"time": "Tue Oct 15 10:45:49 2019 -0400"
	},
	"committer": {
	"name": "Skia Commit-Bot",
	"email": "skia-commit-bot@chromium.org",
	"time": "Wed Oct 16 17:24:55 2019 +0000"
	},
	"message": "Subject\n\nblah blah blah",
	"tree_diff": []
	}
	`
	urlMock.MockOnce(fmt.Sprintf(CommitURLJSON, repoURL, "my/other/ref"), mockhttpclient.MockGetDialogue([]byte(resp2)))
	urlMock.MockOnce(fmt.Sprintf(DownloadURL, repoURL, "bbadbbadbbadbbadbbadbbadbbadbbadbbadbbad", "go/gitiles"), md)
	resp3 := base64.StdEncoding.EncodeToString([]byte(`100644 blob 6e5cdd994551045ab24a4246906c7723cb12c12e testutils.go`))
	md = mockhttpclient.MockGetDialogue([]byte(resp3))
	md.ResponseHeader(ModeHeader, "0644")
	md.ResponseHeader(TypeHeader, "tree")
	urlMock.MockOnce(fmt.Sprintf(DownloadURL, repoURL, "bbadbbadbbadbbadbbadbbadbbadbbadbbadbbad", "go/gitiles/testutils"), md)
	files, err = repo.ListFilesRecursiveAtRef(ctx, "go/gitiles", "my/other/ref")
	require.NoError(t, err)
	assertdeep.Equal(t, []string{"gitiles.go", "gitiles_test.go", "testutils/testutils.go"}, files)
	}

	func TestLogOptionsToQuery(t *testing.T) {

	test := func(expectPath string, expectQuery string, expectLimit int, opts ...LogOption) {
	path, query, limit, err := LogOptionsToQuery(opts)
	require.NoError(t, err)
	require.Equal(t, expectPath, path)
	require.Equal(t, expectQuery, query)
	require.Equal(t, expectLimit, limit)
	}
	test("", "", 0)
	test("", "reverse=true", 0, LogReverse())
	test("", "n=1", 0, LogBatchSize(1))
	test("", "n=2", 2, LogLimit(2))
	test("", "n=5", 5, LogLimit(5), LogBatchSize(10))
	test("", "n=5", 5, LogBatchSize(10), LogLimit(5))
	test("", "n=5", 0, LogBatchSize(5), LogBatchSize(10))
	test("", "n=3&reverse=true", 10, LogReverse(), LogLimit(10), LogBatchSize(3))
	test("mypath", "n=3&reverse=true", 10, LogReverse(), LogLimit(10), LogBatchSize(3), LogPath("mypath"))
	}

	func TestDetails(t *testing.T) {

	// Setup.
	ctx := cipd_git.UseGitFinder(context.Background())
	repoURL := "https://skia.googlesource.com/buildbot.git"
	urlMock := mockhttpclient.NewURLMock()
	repo := NewRepo(repoURL, urlMock.Client())
	gb := git_testutils.GitInit(t, ctx)

	// Helper function which creates a commit, retrieves it from both
	// Gitiles and the real Git repo using Details, and assert that the
	// results are identical.
	check := func(msg string) {
	// Create the commit.
	hash := gb.CommitGenMsg(ctx, "fake", msg)

	// Retrieve the commit from Git.
	expect, err := git.GitDir(gb.Dir()).Details(ctx, hash)
	require.NoError(t, err)

	// Mock the request to Gitiles. Caveat: the test results are
	// only as good as the quality of our mocks.
	c, err := LongCommitToCommit(expect)
	require.NoError(t, err)
	b, err := json.Marshal(c)
	require.NoError(t, err)
	b = append([]byte(")]}'\n"), b...)
	urlMock.MockOnce(fmt.Sprintf(CommitURLJSON, repoURL, hash), mockhttpclient.MockGetDialogue(b))

	// Perform the request.
	actual, err := repo.Details(ctx, hash)
	require.NoError(t, err)

	// Assert that the results from Gitiles are identical to those
	// from Git.
	assertdeep.Equal(t, expect, actual)
	}

	// Test cases.
	check("blahblahblah")
	check(`subject
	`)
	check(`subject
	no empty second line
	more stuff`)
	check(`subject

	body
	`)
	check(`subject

	body`)
	check(`subject

	body
	body2
	`)
	}

	func TestParseURL(t *testing.T) {
	test := func(input, expectRepoURL, expectRef, expectPath, expectErr string) {
	actualRepoURL, actualRef, actualPath, actualErr := ParseURL(input)
	if expectErr != "" {
	require.EqualError(t, actualErr, expectErr)
	} else {
	require.NoError(t, actualErr)
	}
	require.Equal(t, expectRepoURL, actualRepoURL)
	require.Equal(t, expectRef, actualRef)
	require.Equal(t, expectPath, actualPath)
	}
	test(
	"https://example.googlesource.com/my-repo/+/refs/heads/main/path/to/file",
	"https://example.googlesource.com/my-repo",
	"refs/heads/main",
	"path/to/file",
	"",
	)
	test(
	"https://example.googlesource.com/my-repo/+/main/path/to/file",
	"https://example.googlesource.com/my-repo",
	"main",
	"path/to/file",
	"",
	)
	test(
	"https://example.googlesource.com/my-repo/+show/refs/heads/main/path/to/file?format=TEXT",
	"https://example.googlesource.com/my-repo",
	"refs/heads/main",
	"path/to/file",
	"",
	)
	test(
	"https://example.googlesource.com/my-repo/+show/refs/heads/main?format=JSON",
	"https://example.googlesource.com/my-repo",
	"refs/heads/main",
	"",
	"",
	)
	test(
	"https://example.googlesource.com/my-repo/+log/main/path/to/file?format=JSON",
	"https://example.googlesource.com/my-repo",
	"main",
	"path/to/file",
	"",
	)
	}