| package gitiles |
| |
| import ( |
| "context" |
| "encoding/base64" |
| "fmt" |
| "sort" |
| "strings" |
| "testing" |
| "time" |
| |
| "github.com/stretchr/testify/require" |
| "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/mockhttpclient" |
| "go.skia.org/infra/go/testutils" |
| "go.skia.org/infra/go/testutils/unittest" |
| "go.skia.org/infra/go/vcsinfo" |
| "golang.org/x/time/rate" |
| ) |
| |
| func TestLog(t *testing.T) { |
| unittest.MediumTest(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 := 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", "master") |
| 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, "master") |
| 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, "master") |
| 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(DATE_FORMAT_NO_TZ), |
| }, |
| Committer: &Author{ |
| Name: "don't care", |
| Email: "don't care", |
| Time: d.Timestamp.Format(DATE_FORMAT_NO_TZ), |
| }, |
| Message: d.Subject, |
| }) |
| } |
| js := testutils.MarshalJSON(t, results) |
| js = ")]}'\n" + js |
| urlMock.MockOnce(fmt.Sprintf(LOG_URL, 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) { |
| unittest.MediumTest(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(DATE_FORMAT_NO_TZ), |
| }, |
| Committer: &Author{ |
| Name: "don't care", |
| Email: "don't care", |
| Time: c.Timestamp.Format(DATE_FORMAT_NO_TZ), |
| }, |
| Message: "don't care", |
| }) |
| } |
| js := testutils.MarshalJSON(t, results) |
| js = ")]}'\n" + js |
| url1 := fmt.Sprintf(LOG_URL, repoUrl, git.LogFromTo(from.Hash, to.Hash)) |
| url2 := fmt.Sprintf(LOG_URL, 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 TestListDir(t *testing.T) { |
| unittest.SmallTest(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`)) |
| urlMock.MockOnce(repoUrl+"/+/my/ref/go/gitiles?format=TEXT", mockhttpclient.MockGetDialogue([]byte(resp1))) |
| |
| files, dirs, err := repo.ListDirAtRef(ctx, "go/gitiles", "my/ref") |
| require.NoError(t, err) |
| 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(repoUrl+"/+/my/other/ref?format=JSON", mockhttpclient.MockGetDialogue([]byte(resp2))) |
| urlMock.MockOnce(repoUrl+"/+/bbadbbadbbadbbadbbadbbadbbadbbadbbadbbad/go/gitiles?format=TEXT", mockhttpclient.MockGetDialogue([]byte(resp1))) |
| resp3 := base64.StdEncoding.EncodeToString([]byte(`100644 blob 6e5cdd994551045ab24a4246906c7723cb12c12e testutils.go`)) |
| urlMock.MockOnce(repoUrl+"/+/bbadbbadbbadbbadbbadbbadbbadbbadbbadbbad/go/gitiles/testutils?format=TEXT", mockhttpclient.MockGetDialogue([]byte(resp3))) |
| 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) |
| } |