| package midpoint |
| |
| import ( |
| "context" |
| "strconv" |
| "testing" |
| |
| "go.skia.org/infra/go/gitiles/mocks" |
| "go.skia.org/infra/go/mockhttpclient" |
| "go.skia.org/infra/go/skerr" |
| "go.skia.org/infra/go/testutils" |
| "go.skia.org/infra/go/vcsinfo" |
| |
| "github.com/stretchr/testify/assert" |
| "github.com/stretchr/testify/require" |
| |
| "go.skia.org/infra/pinpoint/go/common" |
| pb "go.skia.org/infra/pinpoint/proto/v1" |
| ) |
| |
| const ( |
| webrtcUrl = "https://webrtc.googlesource.com/src" |
| v8Url = "https://chromium.googlesource.com/v8/v8" |
| ) |
| |
| // generateCommitResponse will create a LongCommit slice response for gitiles.Repo.LogFirstParent. |
| func generateCommitResponse(num int) []*vcsinfo.LongCommit { |
| resp := make([]*vcsinfo.LongCommit, 0) |
| |
| for i := num; i >= 1; i-- { |
| resp = append(resp, &vcsinfo.LongCommit{ |
| ShortCommit: &vcsinfo.ShortCommit{ |
| Hash: strconv.Itoa(i), |
| }, |
| }) |
| } |
| |
| return resp |
| } |
| |
| func assertModifiedDepsEqual(t *testing.T, expected, target []*pb.Commit) { |
| require.NotNil(t, expected) |
| require.NotNil(t, target) |
| require.Equal(t, len(expected), len(target)) |
| |
| for i, firstDep := range expected { |
| secondDep := target[i] |
| |
| assert.Equal(t, firstDep.Repository, secondDep.Repository) |
| assert.Equal(t, firstDep.GitHash, secondDep.GitHash) |
| } |
| } |
| |
| func TestNewCombinedCommit_WithDeps_ReturnCombinedCommit(t *testing.T) { |
| main := common.NewChromiumCommit("1") |
| webrtc := &pb.Commit{ |
| Repository: "webrtc", |
| GitHash: "2", |
| } |
| v8 := &pb.Commit{ |
| Repository: "v8", |
| GitHash: "3", |
| } |
| |
| cc := common.NewCombinedCommit(main, webrtc, v8) |
| assert.Equal(t, "1", cc.Main.GitHash) |
| assert.Equal(t, 2, len(cc.ModifiedDeps)) |
| } |
| |
| func TestNewRepo_WithUrl_CreateNewRepo(t *testing.T) { |
| ctx := context.Background() |
| c := mockhttpclient.NewURLMock().Client() |
| r := New(ctx, c) |
| |
| repo := r.getOrCreateRepo(v8Url) |
| assert.NotNil(t, repo) |
| assert.NotNil(t, r.repos[v8Url]) |
| } |
| |
| func TestFetchGitDeps_ExcludingCIPDBasedDEP_ShouldReturnDEPS(t *testing.T) { |
| ctx := context.Background() |
| |
| const gitHash = "1" |
| |
| sampleDeps := ` |
| vars = { |
| 'chromium_git': 'https://chromium.googlesource.com', |
| 'webrtc_git': 'https://webrtc.googlesource.com', |
| 'webrtc_rev': 'deadbeef', |
| } |
| deps = { |
| 'src/v8': Var('chromium_git') + '/v8/v8.git' + '@' + '1', |
| 'src/third_party/lighttpd': { |
| 'url': Var('chromium_git') + '/deps/lighttpd.git' + '@' + '9dfa55d', |
| 'condition': 'checkout_mac or checkout_win', |
| }, |
| 'src/third_party/webrtc': { |
| 'url': '{webrtc_git}/src.git@{webrtc_rev}', |
| }, |
| 'src/third_party/intellij': { |
| 'packages': [{ |
| 'package': 'chromium/third_party/intellij', |
| 'version': 'version:12.0-cr0', |
| }], |
| 'condition': 'checkout_android', |
| 'dep_type': 'cipd', |
| }, |
| } |
| ` |
| gc := &mocks.GitilesRepo{} |
| gc.On("ReadFileAtRef", testutils.AnyContext, "DEPS", gitHash).Return([]byte(sampleDeps), nil) |
| |
| c := mockhttpclient.NewURLMock().Client() |
| r := New(ctx, c).WithRepo(ChromiumSrcGit, gc) |
| |
| res, err := r.fetchGitDeps(ctx, &pb.Commit{Repository: ChromiumSrcGit, GitHash: gitHash}) |
| require.NoError(t, err) |
| // intellij should be missing |
| assert.Equal(t, 3, len(res)) |
| assert.Equal(t, "1", res[v8Url].GitHash) |
| assert.Equal(t, "9dfa55d", res["https://chromium.googlesource.com/deps/lighttpd"].GitHash) |
| assert.Equal(t, "deadbeef", res[webrtcUrl].GitHash) |
| } |
| |
| func TestFindDepsCommit_OnExistingRepo_ShouldReturnCommit(t *testing.T) { |
| ctx := context.Background() |
| c := &pb.Commit{ |
| GitHash: "fake-hash", |
| Repository: "fake-url", |
| } |
| |
| fakeDEPS := ` |
| deps = { |
| 'path/to/dep': { |
| 'url': 'fake-dep.com@fake-dep-hash', |
| }, |
| } |
| ` |
| |
| gr := &mocks.GitilesRepo{} |
| gr.On("ReadFileAtRef", testutils.AnyContext, "DEPS", "fake-hash").Return([]byte(fakeDEPS), nil) |
| |
| m := New(ctx, nil).WithRepo("fake-url", gr) |
| dc, err := m.findDepsCommit(ctx, c, "https://fake-dep.com") |
| require.Nil(t, err, err) |
| require.Equal(t, dc, &pb.Commit{ |
| GitHash: "fake-dep-hash", |
| Repository: "https://fake-dep.com", |
| }) |
| } |
| |
| func TestFindDepsCommit_OnNonExistingRepo_ShouldReturnError(t *testing.T) { |
| ctx := context.Background() |
| c := &pb.Commit{ |
| GitHash: "fake-hash", |
| Repository: "fake-url", |
| } |
| |
| gr := &mocks.GitilesRepo{} |
| gr.On("ReadFileAtRef", testutils.AnyContext, "DEPS", "fake-hash").Return([]byte(""), nil) |
| |
| m := New(ctx, nil).WithRepo("fake-url", gr) |
| dc, err := m.findDepsCommit(ctx, c, "https://some-url.com") |
| require.Nil(t, dc) |
| require.ErrorContains(t, err, "https://some-url.com doesn't exist in DEPS") |
| } |
| |
| func TestCombinedCommitKey_MainNil_ReturnsEmptyString(t *testing.T) { |
| cc := &common.CombinedCommit{} |
| |
| expected := cc.Clone().Key() |
| assert.Equal(t, expected, cc.Key()) |
| } |
| |
| func TestCombinedCommitKey_GivenDEPS_ReturnsCombinedString(t *testing.T) { |
| cc := common.NewCombinedCommit(&pb.Commit{GitHash: "hash1"}, &pb.Commit{GitHash: "hash2"}, &pb.Commit{GitHash: "hash3"}) |
| |
| expected := cc.Clone().Key() |
| assert.Equal(t, expected, cc.Key()) |
| } |
| |
| func TestFindMidCombinedCommit_NoModifiedDeps_ValidMidpointFromMain(t *testing.T) { |
| ctx := context.Background() |
| |
| startGitHash := "1" |
| endGitHash := "5" |
| |
| gc := &mocks.GitilesRepo{} |
| resp := generateCommitResponse(5) |
| gc.On("LogFirstParent", testutils.AnyContext, startGitHash, endGitHash).Return(resp, nil) |
| |
| c := mockhttpclient.NewURLMock().Client() |
| m := New(ctx, c).WithRepo(ChromiumSrcGit, gc) |
| |
| start := common.NewCombinedCommit(common.NewChromiumCommit(startGitHash)) |
| end := common.NewCombinedCommit(common.NewChromiumCommit(endGitHash)) |
| |
| res, err := m.FindMidCombinedCommit(ctx, start, end) |
| require.NoError(t, err) |
| // endGitHash is popped off, leaving [4, 3, 2, 1] |
| // and since len == 4, mid index == 2 |
| assert.Equal(t, "2", res.Main.GitHash) |
| } |
| |
| func TestFindMidCombinedCommit_AdjacentChangesWithNoDeps_ValidMidpointFromDeps(t *testing.T) { |
| ctx := context.Background() |
| |
| startGitHash := "1" |
| endGitHash := "2" |
| |
| mainResp := []*vcsinfo.LongCommit{ |
| { |
| ShortCommit: &vcsinfo.ShortCommit{ |
| Hash: "2", |
| }, |
| }, |
| } |
| |
| // mocks for chromium, which will be adjacent. |
| gc := &mocks.GitilesRepo{} |
| gc.On("LogFirstParent", testutils.AnyContext, startGitHash, endGitHash).Return(mainResp, nil) |
| |
| sampleDeps := ` |
| vars = { |
| 'chromium_git': 'https://chromium.googlesource.com', |
| 'webrtc_git': 'https://webrtc.googlesource.com', |
| 'webrtc_rev': '1', |
| } |
| deps = { |
| 'src/v8': Var('chromium_git') + '/v8/v8.git' + '@' + '1', |
| 'src/third_party/lighttpd': { |
| 'url': Var('chromium_git') + '/deps/lighttpd.git' + '@' + '9dfa55d', |
| 'condition': 'checkout_mac or checkout_win', |
| }, |
| 'src/third_party/webrtc': { |
| 'url': '{webrtc_git}/src.git@{webrtc_rev}', |
| }, |
| 'src/third_party/intellij': { |
| 'packages': [{ |
| 'package': 'chromium/third_party/intellij', |
| 'version': 'version:12.0-cr0', |
| }], |
| 'condition': 'checkout_android', |
| 'dep_type': 'cipd', |
| }, |
| } |
| ` |
| |
| sampleDeps2 := ` |
| vars = { |
| 'webrtc_git': 'https://webrtc.googlesource.com', |
| 'webrtc_rev': '3', |
| } |
| deps = { |
| 'src/third_party/webrtc': { |
| 'url': '{webrtc_git}/src.git@{webrtc_rev}', |
| }, |
| } |
| ` |
| |
| gc.On("ReadFileAtRef", testutils.AnyContext, "DEPS", startGitHash).Return([]byte(sampleDeps), nil) |
| gc.On("ReadFileAtRef", testutils.AnyContext, "DEPS", endGitHash).Return([]byte(sampleDeps2), nil) |
| |
| // mocks for webrtc, which is parsed as a delta from DEPS |
| wStartGitHash := "1" |
| wEndGitHash := "3" |
| wResp := []*vcsinfo.LongCommit{ |
| { |
| ShortCommit: &vcsinfo.ShortCommit{ |
| Hash: "3", |
| }, |
| }, |
| { |
| ShortCommit: &vcsinfo.ShortCommit{ |
| Hash: "2", |
| }, |
| }, |
| } |
| |
| wgc := &mocks.GitilesRepo{} |
| wgc.On("LogFirstParent", testutils.AnyContext, wStartGitHash, wEndGitHash).Return(wResp, nil) |
| |
| c := mockhttpclient.NewURLMock().Client() |
| m := New(ctx, c).WithRepo(ChromiumSrcGit, gc).WithRepo(webrtcUrl, wgc) |
| |
| start := common.NewCombinedCommit(common.NewChromiumCommit(startGitHash)) |
| end := common.NewCombinedCommit(common.NewChromiumCommit(endGitHash)) |
| |
| // no modified deps in start and end, meaning we go through the regular workflow of searching |
| // for midpoint in chromium. |
| res, err := m.FindMidCombinedCommit(ctx, start, end) |
| assert.NoError(t, err) |
| // Next candidate should be 2, since LogFirstParent returns [3, 2], |
| // 3 is popped leaving [2]. |
| nextCommit := res.GetLatestModifiedDep() |
| assert.Equal(t, "2", nextCommit.GitHash) |
| } |
| |
| func TestFindMidCombinedCommit_WithModifiedDeps_NextCandidateInModifiedDeps(t *testing.T) { |
| ctx := context.Background() |
| wStartGitHash := "1" |
| wEndGitHash := "5" |
| |
| wgc := &mocks.GitilesRepo{} |
| wResp := generateCommitResponse(5) |
| wgc.On("LogFirstParent", testutils.AnyContext, wStartGitHash, wEndGitHash).Return(wResp, nil) |
| |
| start := common.NewCombinedCommit(common.NewChromiumCommit(wStartGitHash), |
| &pb.Commit{ |
| GitHash: wStartGitHash, |
| Repository: webrtcUrl, |
| }) |
| end := common.NewCombinedCommit(common.NewChromiumCommit(wStartGitHash), |
| &pb.Commit{ |
| GitHash: wEndGitHash, |
| Repository: webrtcUrl, |
| }) |
| |
| c := mockhttpclient.NewURLMock().Client() |
| m := New(ctx, c).WithRepo(webrtcUrl, wgc) |
| res, err := m.FindMidCombinedCommit(ctx, start, end) |
| assert.NoError(t, err) |
| // endGitHash is popped off, leaving [4, 3, 2, 1] |
| // and since len == 4, mid index == 2 |
| nextCommit := res.GetLatestModifiedDep() |
| assert.Equal(t, "2", nextCommit.GitHash) |
| } |
| |
| func TestFindMidCombinedCommit_AdjacentModifiedDeps_NextCandidateWithinDeps(t *testing.T) { |
| ctx := context.Background() |
| wStartGitHash := "1" |
| wEndGitHash := "2" |
| |
| // Test prep for webrtc mock. |
| wgc := &mocks.GitilesRepo{} |
| wResp := []*vcsinfo.LongCommit{ |
| { |
| ShortCommit: &vcsinfo.ShortCommit{ |
| Hash: "2", |
| }, |
| }, |
| } |
| wgc.On("LogFirstParent", testutils.AnyContext, wStartGitHash, wEndGitHash).Return(wResp, nil) |
| |
| sampleDeps := ` |
| vars = { |
| 'chromium_git': 'https://chromium.googlesource.com', |
| } |
| deps = { |
| 'src/v8': Var('chromium_git') + '/v8/v8.git' + '@' + '1', |
| } |
| ` |
| sampleDeps2 := ` |
| vars = { |
| 'chromium_git': 'https://chromium.googlesource.com', |
| } |
| deps = { |
| 'src/v8': Var('chromium_git') + '/v8/v8.git' + '@' + '3', |
| } |
| ` |
| wgc.On("ReadFileAtRef", testutils.AnyContext, "DEPS", wStartGitHash).Return([]byte(sampleDeps), nil) |
| wgc.On("ReadFileAtRef", testutils.AnyContext, "DEPS", wEndGitHash).Return([]byte(sampleDeps2), nil) |
| |
| // Test prep for v8 mock, which should be invoked after webrtc deps are parsed. |
| v8gc := &mocks.GitilesRepo{} |
| v8resp := []*vcsinfo.LongCommit{ |
| { |
| ShortCommit: &vcsinfo.ShortCommit{ |
| Hash: "3", |
| }, |
| }, |
| { |
| ShortCommit: &vcsinfo.ShortCommit{ |
| Hash: "2", |
| }, |
| }, |
| } |
| v8gc.On("LogFirstParent", testutils.AnyContext, "1", "3").Return(v8resp, nil) |
| |
| c := mockhttpclient.NewURLMock().Client() |
| m := New(ctx, c).WithRepo(webrtcUrl, wgc).WithRepo(v8Url, v8gc) |
| |
| start := common.NewCombinedCommit(common.NewChromiumCommit(wStartGitHash), |
| &pb.Commit{ |
| GitHash: wStartGitHash, |
| Repository: webrtcUrl, |
| }) |
| end := common.NewCombinedCommit(common.NewChromiumCommit(wStartGitHash), |
| &pb.Commit{ |
| GitHash: wEndGitHash, |
| Repository: webrtcUrl, |
| }) |
| |
| res, err := m.FindMidCombinedCommit(ctx, start, end) |
| assert.NoError(t, err) |
| |
| // The next candidate should be in v8/v8 with commit "2", because the midpoint |
| // from [3, 2] would be 2. |
| nextCommit := res.GetLatestModifiedDep() |
| assert.Equal(t, v8Url, nextCommit.Repository) |
| assert.Equal(t, "2", nextCommit.GitHash) |
| } |
| |
| func TestFindMidCombinedCommit_AdjacentModifiedDeps_NoMoreCandidates(t *testing.T) { |
| ctx := context.Background() |
| wStartGitHash := "1" |
| wEndGitHash := "2" |
| |
| // Test prep for webrtc repository mocks |
| wgc := &mocks.GitilesRepo{} |
| wResp := []*vcsinfo.LongCommit{ |
| { |
| ShortCommit: &vcsinfo.ShortCommit{ |
| Hash: "2", |
| }, |
| }, |
| } |
| wgc.On("LogFirstParent", testutils.AnyContext, wStartGitHash, wEndGitHash).Return(wResp, nil) |
| |
| sampleDeps := ` |
| vars = { |
| 'chromium_git': 'https://chromium.googlesource.com', |
| } |
| deps = { |
| 'src/v8': Var('chromium_git') + '/v8/v8.git' + '@' + '3', |
| } |
| ` |
| sampleDeps2 := ` |
| vars = { |
| 'chromium_git': 'https://chromium.googlesource.com', |
| } |
| deps = { |
| 'src/v8': Var('chromium_git') + '/v8/v8.git' + '@' + '4', |
| } |
| ` |
| wgc.On("ReadFileAtRef", testutils.AnyContext, "DEPS", wStartGitHash).Return([]byte(sampleDeps), nil) |
| wgc.On("ReadFileAtRef", testutils.AnyContext, "DEPS", wEndGitHash).Return([]byte(sampleDeps2), nil) |
| |
| // Test prep for v8/v8. Midpoint should be checked after webrtc DEPS files are parsed. |
| v8gc := &mocks.GitilesRepo{} |
| v8resp := []*vcsinfo.LongCommit{ |
| { |
| ShortCommit: &vcsinfo.ShortCommit{ |
| Hash: "4", |
| }, |
| }, |
| } |
| // If the roll was only to a n+1 commit, they are adjacent and we terminate saying there's |
| // no more candidates to go through. |
| v8gc.On("LogFirstParent", testutils.AnyContext, "3", "4").Return(v8resp, nil) |
| |
| start := common.NewCombinedCommit(common.NewChromiumCommit(wStartGitHash), |
| &pb.Commit{ |
| GitHash: wStartGitHash, |
| Repository: webrtcUrl, |
| }) |
| end := common.NewCombinedCommit(common.NewChromiumCommit(wStartGitHash), |
| &pb.Commit{ |
| GitHash: wEndGitHash, |
| Repository: webrtcUrl, |
| }) |
| |
| c := mockhttpclient.NewURLMock().Client() |
| m := New(ctx, c).WithRepo(webrtcUrl, wgc).WithRepo(v8Url, v8gc) |
| res, err := m.FindMidCombinedCommit(ctx, start, end) |
| assert.NoError(t, err) |
| // equality check through key |
| assert.Equal(t, start.Key(), res.Key()) |
| } |
| |
| func TestFindMidCombinedCommit_StartIsLastCommitInDEPS_ReturnsStartAsMidpoint(t *testing.T) { |
| ctx := context.Background() |
| wStartGitHash := "1" |
| wEndGitHash := "2" |
| |
| // Test prep for webrtc repository mocks |
| wgc := &mocks.GitilesRepo{} |
| wResp := []*vcsinfo.LongCommit{ |
| { |
| ShortCommit: &vcsinfo.ShortCommit{ |
| Hash: "2", |
| }, |
| }, |
| } |
| wgc.On("LogFirstParent", testutils.AnyContext, wStartGitHash, wEndGitHash).Return(wResp, nil) |
| |
| sampleDeps := ` |
| vars = { |
| 'webrtc_git': 'https://webrtc.googlesource.com', |
| 'webrtc_rev': '1', |
| } |
| deps = { |
| 'src/third_party/webrtc': { |
| 'url': '{webrtc_git}/src.git@{webrtc_rev}', |
| }, |
| } |
| ` |
| // This should be invoked as it fills modified deps for the end commit. |
| gc := &mocks.GitilesRepo{} |
| gc.On("ReadFileAtRef", testutils.AnyContext, "DEPS", wEndGitHash).Return([]byte(sampleDeps), nil) |
| |
| start := common.NewCombinedCommit(common.NewChromiumCommit(wStartGitHash), |
| &pb.Commit{ |
| GitHash: wStartGitHash, |
| Repository: webrtcUrl, |
| }) |
| end := common.NewCombinedCommit(common.NewChromiumCommit(wEndGitHash)) |
| |
| c := mockhttpclient.NewURLMock().Client() |
| m := New(ctx, c).WithRepo(ChromiumSrcGit, gc).WithRepo(webrtcUrl, wgc) |
| res, err := m.FindMidCombinedCommit(ctx, start, end) |
| assert.NoError(t, err) |
| assert.Equal(t, start.Key(), res.Key()) |
| } |
| |
| func TestFindMidCombinedCommit_EndIsFirstCommitInDEPS_ReturnsStartAsMidpoint(t *testing.T) { |
| ctx := context.Background() |
| wStartGitHash := "1" |
| wEndGitHash := "1" |
| |
| // Test prep for webrtc repository mocks |
| wgc := &mocks.GitilesRepo{} |
| wResp := []*vcsinfo.LongCommit{ |
| { |
| ShortCommit: &vcsinfo.ShortCommit{ |
| Hash: "2", |
| }, |
| }, |
| } |
| wgc.On("LogFirstParent", testutils.AnyContext, wStartGitHash, wEndGitHash).Return(wResp, nil) |
| |
| sampleDeps := ` |
| vars = { |
| 'webrtc_git': 'https://webrtc.googlesource.com', |
| 'webrtc_rev': '1', |
| } |
| deps = { |
| 'src/third_party/webrtc': { |
| 'url': '{webrtc_git}/src.git@{webrtc_rev}', |
| }, |
| } |
| ` |
| // This should be invoked as it fills modified deps for the end commit. |
| gc := &mocks.GitilesRepo{} |
| gc.On("ReadFileAtRef", testutils.AnyContext, "DEPS", wEndGitHash).Return([]byte(sampleDeps), nil) |
| |
| start := common.NewCombinedCommit(common.NewChromiumCommit(wStartGitHash)) |
| end := common.NewCombinedCommit(common.NewChromiumCommit(wEndGitHash), |
| &pb.Commit{ |
| GitHash: wEndGitHash, |
| Repository: webrtcUrl, |
| }) |
| origStart := start.Clone() |
| |
| c := mockhttpclient.NewURLMock().Client() |
| m := New(ctx, c).WithRepo(ChromiumSrcGit, gc).WithRepo(webrtcUrl, wgc) |
| res, err := m.FindMidCombinedCommit(ctx, start, end) |
| assert.NoError(t, err) |
| assert.Equal(t, origStart.Key(), res.Key()) |
| } |
| |
| func TestFindMidCombinedCommit_ComparisonWithUnbalancedModifiedDeps_ValidNextCandidate(t *testing.T) { |
| ctx := context.Background() |
| wStartGitHash := "1" |
| wEndGitHash := "5" |
| |
| wgc := &mocks.GitilesRepo{} |
| wResp := generateCommitResponse(5) |
| wgc.On("LogFirstParent", testutils.AnyContext, wStartGitHash, wEndGitHash).Return(wResp, nil) |
| |
| sampleDeps := ` |
| vars = { |
| 'webrtc_git': 'https://webrtc.googlesource.com', |
| 'webrtc_rev': '1', |
| } |
| deps = { |
| 'src/third_party/webrtc': { |
| 'url': '{webrtc_git}/src.git@{webrtc_rev}', |
| }, |
| } |
| ` |
| // This should be invoked as it fills modified deps for the start commit. |
| gc := &mocks.GitilesRepo{} |
| gc.On("ReadFileAtRef", testutils.AnyContext, "DEPS", wStartGitHash).Return([]byte(sampleDeps), nil) |
| |
| start := common.NewCombinedCommit(common.NewChromiumCommit(wStartGitHash)) |
| end := common.NewCombinedCommit(common.NewChromiumCommit(wStartGitHash), |
| &pb.Commit{ |
| GitHash: wEndGitHash, |
| Repository: webrtcUrl, |
| }) |
| |
| c := mockhttpclient.NewURLMock().Client() |
| m := New(ctx, c).WithRepo(ChromiumSrcGit, gc).WithRepo(webrtcUrl, wgc) |
| res, err := m.FindMidCombinedCommit(ctx, start, end) |
| assert.NoError(t, err) |
| // endGitHash is popped off, leaving [4, 3, 2, 1] |
| nextCommit := res.GetLatestModifiedDep() |
| assert.Equal(t, "2", nextCommit.GitHash) |
| } |
| |
| func TestFindMidCombinedCommit_ComparisonWithMultipleModifiedDepsAdjacent_DepsWithinDepsMidpoint(t *testing.T) { |
| ctx := context.Background() |
| chromiumStartGitHash := "1" |
| |
| wgc := &mocks.GitilesRepo{} |
| sampleDeps := ` |
| vars = { |
| 'chromium_git': 'https://chromium.googlesource.com', |
| } |
| deps = { |
| 'src/v8': Var('chromium_git') + '/v8/v8.git' + '@' + '2', |
| } |
| ` |
| // Start has V8, and end doesn't, meaning that end needs to be backfilled. |
| // Webrtc@2 should be used as reference to backfill. |
| wgc.On("ReadFileAtRef", testutils.AnyContext, "DEPS", "2").Return([]byte(sampleDeps), nil) |
| |
| v8gc := &mocks.GitilesRepo{} |
| v8Resp := []*vcsinfo.LongCommit{ |
| { |
| ShortCommit: &vcsinfo.ShortCommit{ |
| Hash: "2", |
| }, |
| }, |
| } |
| v8gc.On("LogFirstParent", testutils.AnyContext, "1", "2").Return(v8Resp, nil) |
| |
| v8sampleDeps1 := ` |
| vars = { |
| 'chromium_git': 'https://chromium.googlesource.com', |
| } |
| deps = { |
| 'random': Var('chromium_git') + '/random.git' + '@' + '3', |
| } |
| ` |
| v8sampleDeps2 := ` |
| vars = { |
| 'chromium_git': 'https://chromium.googlesource.com', |
| } |
| deps = { |
| 'random': Var('chromium_git') + '/random.git' + '@' + '5', |
| } |
| ` |
| // Since V8 is also adjacent, it assumes a DEPS roll and parses one level deeper into DEPS. |
| v8gc.On("ReadFileAtRef", testutils.AnyContext, "DEPS", "1").Return([]byte(v8sampleDeps1), nil) |
| v8gc.On("ReadFileAtRef", testutils.AnyContext, "DEPS", "2").Return([]byte(v8sampleDeps2), nil) |
| |
| randomUrl := "https://chromium.googlesource.com/random" |
| randomGc := &mocks.GitilesRepo{} |
| randomGcResp := []*vcsinfo.LongCommit{ |
| { |
| ShortCommit: &vcsinfo.ShortCommit{ |
| Hash: "5", |
| }, |
| }, |
| { |
| ShortCommit: &vcsinfo.ShortCommit{ |
| Hash: "4", |
| }, |
| }, |
| } |
| randomGc.On("LogFirstParent", testutils.AnyContext, "3", "5").Return(randomGcResp, nil) |
| start := common.NewCombinedCommit(common.NewChromiumCommit(chromiumStartGitHash), |
| &pb.Commit{ |
| GitHash: "1", |
| Repository: webrtcUrl, |
| }, |
| &pb.Commit{ |
| GitHash: "1", |
| Repository: v8Url, |
| }, |
| ) |
| end := common.NewCombinedCommit(common.NewChromiumCommit(chromiumStartGitHash), |
| &pb.Commit{ |
| GitHash: "2", |
| Repository: webrtcUrl, |
| }, |
| ) |
| |
| c := mockhttpclient.NewURLMock().Client() |
| m := New(ctx, c).WithRepo(v8Url, v8gc).WithRepo(webrtcUrl, wgc).WithRepo(randomUrl, randomGc) |
| res, err := m.FindMidCombinedCommit(ctx, start, end) |
| assert.NoError(t, err) |
| // [5, 4], top is popped off so midpoint = 4 |
| nextCommit := res.GetLatestModifiedDep() |
| assert.Equal(t, "4", nextCommit.GitHash) |
| } |
| |
| func TestFindMidCombinedCommit_DEPSFileDoesNotExist_NoMidpoint(t *testing.T) { |
| ctx := context.Background() |
| wStartGitHash := "1" |
| wEndGitHash := "2" |
| |
| // Test prep for webrtc mock. |
| wgc := &mocks.GitilesRepo{} |
| wResp := []*vcsinfo.LongCommit{ |
| { |
| ShortCommit: &vcsinfo.ShortCommit{ |
| Hash: "2", |
| }, |
| }, |
| } |
| wgc.On("LogFirstParent", testutils.AnyContext, wStartGitHash, wEndGitHash).Return(wResp, nil) |
| |
| sampleDeps := ` |
| vars = { |
| 'chromium_git': 'https://chromium.googlesource.com', |
| } |
| deps = { |
| 'src/v8': Var('chromium_git') + '/v8/v8.git' + '@' + '1', |
| } |
| ` |
| wgc.On("ReadFileAtRef", testutils.AnyContext, "DEPS", wStartGitHash).Return([]byte(sampleDeps), nil) |
| wgc.On("ReadFileAtRef", testutils.AnyContext, "DEPS", wEndGitHash).Return(nil, skerr.Fmt("Request got status \"404 Not Found\"")) |
| |
| start := common.NewCombinedCommit(common.NewChromiumCommit(wStartGitHash), |
| &pb.Commit{ |
| GitHash: wStartGitHash, |
| Repository: webrtcUrl, |
| }, |
| ) |
| end := common.NewCombinedCommit(common.NewChromiumCommit(wStartGitHash), |
| &pb.Commit{ |
| GitHash: wEndGitHash, |
| Repository: webrtcUrl, |
| }, |
| ) |
| |
| c := mockhttpclient.NewURLMock().Client() |
| m := New(ctx, c).WithRepo(webrtcUrl, wgc) |
| res, err := m.FindMidCombinedCommit(ctx, start, end) |
| assert.NoError(t, err) |
| assert.Equal(t, start.Key(), res.Key()) |
| } |
| |
| func TestFillModifiedDeps_EmptyEndCommitModifiedDeps(t *testing.T) { |
| startGitHash := "1" |
| start := common.NewCombinedCommit(common.NewChromiumCommit(startGitHash), |
| &pb.Commit{ |
| GitHash: startGitHash, |
| Repository: webrtcUrl, |
| }, |
| &pb.Commit{ |
| GitHash: startGitHash, |
| Repository: v8Url, |
| }, |
| ) |
| |
| endCommitDeps := ` |
| vars = { |
| 'chromium_git': 'https://chromium.googlesource.com', |
| 'webrtc_git': 'https://webrtc.googlesource.com', |
| 'webrtc_rev': '2', |
| } |
| deps = { |
| 'src/v8': Var('chromium_git') + '/v8/v8.git' + '@' + '2', |
| 'src/third_party/webrtc': { |
| 'url': '{webrtc_git}/src.git@{webrtc_rev}', |
| }, |
| } |
| ` |
| end := common.NewCombinedCommit(common.NewChromiumCommit(startGitHash)) |
| |
| chromiumClient := &mocks.GitilesRepo{} |
| chromiumClient.On("ReadFileAtRef", testutils.AnyContext, "DEPS", startGitHash).Return([]byte(endCommitDeps), nil) |
| |
| webrtcClient := &mocks.GitilesRepo{} |
| webrtcClient.On("ReadFileAtRef", testutils.AnyContext, "DEPS", "2").Return([]byte(endCommitDeps), nil) |
| |
| ctx := context.Background() |
| c := mockhttpclient.NewURLMock().Client() |
| m := New(ctx, c).WithRepo(ChromiumSrcGit, chromiumClient).WithRepo(webrtcUrl, webrtcClient) |
| |
| err := m.fillModifiedDeps(ctx, start, end) |
| require.NoError(t, err) |
| expected := []*pb.Commit{ |
| { |
| Repository: webrtcUrl, |
| GitHash: "2", |
| }, |
| { |
| Repository: v8Url, |
| GitHash: "2", |
| }, |
| } |
| assertModifiedDepsEqual(t, expected, end.ModifiedDeps) |
| } |
| |
| func TestFillModifiedDeps_EmptyStartCommitModifiedDeps(t *testing.T) { |
| startGitHash := "1" |
| startCommitDeps := ` |
| vars = { |
| 'chromium_git': 'https://chromium.googlesource.com', |
| 'webrtc_git': 'https://webrtc.googlesource.com', |
| 'webrtc_rev': '2', |
| } |
| deps = { |
| 'src/v8': Var('chromium_git') + '/v8/v8.git' + '@' + '2', |
| 'src/third_party/webrtc': { |
| 'url': '{webrtc_git}/src.git@{webrtc_rev}', |
| }, |
| } |
| ` |
| start := common.NewCombinedCommit(common.NewChromiumCommit(startGitHash)) |
| |
| end := common.NewCombinedCommit(common.NewChromiumCommit(startGitHash), |
| &pb.Commit{ |
| GitHash: startGitHash, |
| Repository: webrtcUrl, |
| }, |
| &pb.Commit{ |
| GitHash: startGitHash, |
| Repository: v8Url, |
| }, |
| ) |
| |
| chromiumClient := &mocks.GitilesRepo{} |
| chromiumClient.On("ReadFileAtRef", testutils.AnyContext, "DEPS", startGitHash).Return([]byte(startCommitDeps), nil) |
| |
| webrtcClient := &mocks.GitilesRepo{} |
| webrtcClient.On("ReadFileAtRef", testutils.AnyContext, "DEPS", "2").Return([]byte(startCommitDeps), nil) |
| |
| ctx := context.Background() |
| c := mockhttpclient.NewURLMock().Client() |
| m := New(ctx, c).WithRepo(ChromiumSrcGit, chromiumClient).WithRepo(webrtcUrl, webrtcClient) |
| |
| err := m.fillModifiedDeps(ctx, start, end) |
| require.NoError(t, err) |
| expected := []*pb.Commit{ |
| { |
| Repository: webrtcUrl, |
| GitHash: "2", |
| }, |
| { |
| Repository: v8Url, |
| GitHash: "2", |
| }, |
| } |
| assertModifiedDepsEqual(t, expected, start.ModifiedDeps) |
| } |