| package types |
| |
| import ( |
| "context" |
| "testing" |
| |
| "github.com/stretchr/testify/require" |
| "go.skia.org/infra/go/common" |
| "go.skia.org/infra/go/deepequal/assertdeep" |
| "go.skia.org/infra/go/git/repograph" |
| "go.skia.org/infra/go/git/testutils/mem_git" |
| "go.skia.org/infra/go/gitstore" |
| "go.skia.org/infra/go/gitstore/mem_gitstore" |
| ) |
| |
| func TestCopyPatch(t *testing.T) { |
| v := Patch{ |
| Issue: "1", |
| Patchset: "2", |
| PatchRepo: "https://dummy-repo.git", |
| Server: "volley.com", |
| } |
| assertdeep.Copy(t, v, v.Copy()) |
| } |
| |
| func TestCopyRepoState(t *testing.T) { |
| v := RepoState{ |
| Patch: Patch{ |
| Issue: "1", |
| Patchset: "2", |
| PatchRepo: "https://dummy-repo.git", |
| Server: "volley.com", |
| }, |
| Repo: "nou.git", |
| Revision: "1", |
| } |
| assertdeep.Copy(t, v, v.Copy()) |
| } |
| |
| // repoMapSetup creates two test repos, and returns a map from repo URL to |
| // commits (from c0 to c4), a repograph.Map, and a cleanup function. The layout |
| // of the repos look like this: |
| // |
| // fake1.git: |
| // |
| // c0--c1------c3--c4-- |
| // |
| // \-c2-----/ |
| // |
| // fake2.git: |
| // |
| // c0--c1--c2------c4--c5-- |
| // |
| // \-c3-----/ |
| func repoMapSetup(t *testing.T) (map[string][]string, repograph.Map) { |
| |
| ctx := context.Background() |
| |
| gs1 := mem_gitstore.New() |
| mg1 := mem_git.New(t, gs1) |
| ri1, err := gitstore.NewGitStoreRepoImpl(ctx, gs1) |
| require.NoError(t, err) |
| repo1, err := repograph.NewWithRepoImpl(ctx, ri1) |
| require.NoError(t, err) |
| mg1.AddUpdater(repo1) |
| commits1 := mem_git.FillWithBranchingHistory(mg1) |
| |
| gs2 := mem_gitstore.New() |
| mg2 := mem_git.New(t, gs2) |
| ri2, err := gitstore.NewGitStoreRepoImpl(ctx, gs2) |
| require.NoError(t, err) |
| repo2, err := repograph.NewWithRepoImpl(ctx, ri2) |
| require.NoError(t, err) |
| mg2.AddUpdater(repo2) |
| initialCommitInRepo2 := mg2.Commit("Fake initial commit to ensure that hashes are different between repos") |
| commits2 := []string{initialCommitInRepo2} |
| commits2 = append(commits2, mem_git.FillWithBranchingHistory(mg2)...) |
| |
| commitMap := map[string][]string{ |
| "fake1.git": commits1, |
| "fake2.git": commits2, |
| } |
| repoMap := repograph.Map{ |
| "fake1.git": repo1, |
| "fake2.git": repo2, |
| } |
| return commitMap, repoMap |
| } |
| |
| func TestGetCommit(t *testing.T) { |
| commitMap, repoMap := repoMapSetup(t) |
| |
| for repo, commits := range commitMap { |
| for _, commit := range commits { |
| graphCommit := repoMap[repo].Get(commit) |
| require.NotNil(t, graphCommit) |
| rs := RepoState{ |
| Repo: repo, |
| Revision: commit, |
| } |
| rsCommit, err := rs.GetCommit(repoMap) |
| require.NoError(t, err) |
| require.Equal(t, graphCommit, rsCommit) |
| rs.Patch = Patch{ |
| Issue: "1", |
| Patchset: "2", |
| Server: "volley.com", |
| } |
| rsCommit, err = rs.GetCommit(repoMap) |
| require.NoError(t, err) |
| require.Equal(t, graphCommit, rsCommit) |
| } |
| } |
| } |
| |
| func TestGetCommitError(t *testing.T) { |
| commitMap, repoMap := repoMapSetup(t) |
| |
| existingRepo := "" |
| existingRevision := "" |
| for repo, commits := range commitMap { |
| existingRepo = repo |
| existingRevision = commits[0] |
| break |
| } |
| |
| _, err := RepoState{ |
| Repo: "nou.git", |
| Revision: existingRevision, |
| }.GetCommit(repoMap) |
| require.Error(t, err) |
| require.Contains(t, err.Error(), "Unknown repo") |
| |
| _, err = RepoState{ |
| Repo: existingRepo, |
| Revision: "abc123", |
| }.GetCommit(repoMap) |
| require.Error(t, err) |
| require.Contains(t, err.Error(), "Unknown revision") |
| |
| // Verify test data. |
| c, err := RepoState{ |
| Repo: existingRepo, |
| Revision: existingRevision, |
| }.GetCommit(repoMap) |
| require.NoError(t, err) |
| require.NotNil(t, c) |
| } |
| |
| func TestParentsTryJob(t *testing.T) { |
| input := RepoState{ |
| Patch: Patch{ |
| Issue: "1", |
| Patchset: "2", |
| Server: "volley.com", |
| }, |
| Repo: "nou.git", |
| Revision: "1", |
| } |
| // Unused. |
| var repoMap repograph.Map |
| parents, err := input.Parents(repoMap) |
| require.NoError(t, err) |
| require.Equal(t, 1, len(parents)) |
| assertdeep.Equal(t, RepoState{ |
| Repo: "nou.git", |
| Revision: "1", |
| }, parents[0]) |
| } |
| |
| func TestParentsSingle(t *testing.T) { |
| commitMap, repoMap := repoMapSetup(t) |
| |
| test := func(repo, commit, parent string) { |
| input := RepoState{ |
| Repo: repo, |
| Revision: commit, |
| } |
| actual, err := input.Parents(repoMap) |
| require.NoError(t, err) |
| require.Equal(t, 1, len(actual)) |
| expected := RepoState{ |
| Repo: repo, |
| Revision: parent, |
| } |
| assertdeep.Equal(t, expected, actual[0]) |
| } |
| |
| repo := "fake1.git" |
| commits := commitMap[repo] |
| test(repo, commits[1], commits[0]) |
| test(repo, commits[2], commits[1]) |
| test(repo, commits[3], commits[1]) |
| |
| repo = "fake2.git" |
| commits = commitMap[repo] |
| test(repo, commits[1], commits[0]) |
| test(repo, commits[2], commits[1]) |
| test(repo, commits[3], commits[2]) |
| test(repo, commits[4], commits[2]) |
| } |
| |
| func TestParentsDouble(t *testing.T) { |
| commitMap, repoMap := repoMapSetup(t) |
| |
| test := func(repo, commit string, parents []string) { |
| input := RepoState{ |
| Repo: repo, |
| Revision: commit, |
| } |
| actual, err := input.Parents(repoMap) |
| require.NoError(t, err) |
| require.Len(t, actual, len(parents)) |
| for idx, parent := range parents { |
| expected := RepoState{ |
| Repo: repo, |
| Revision: parent, |
| } |
| assertdeep.Equal(t, expected, actual[idx]) |
| } |
| } |
| |
| repo1 := "fake1.git" |
| commits1 := commitMap[repo1] |
| test(repo1, commits1[4], []string{commits1[3], commits1[2]}) |
| |
| repo2 := "fake2.git" |
| commits2 := commitMap[repo2] |
| test(repo2, commits2[5], []string{commits2[4], commits2[3]}) |
| } |
| |
| func TestParentsNone(t *testing.T) { |
| commitMap, repoMap := repoMapSetup(t) |
| |
| for repo, commits := range commitMap { |
| input := RepoState{ |
| Repo: repo, |
| Revision: commits[0], |
| } |
| actual, err := input.Parents(repoMap) |
| require.NoError(t, err) |
| require.Equal(t, 0, len(actual)) |
| } |
| } |
| |
| func TestParentsError(t *testing.T) { |
| // Empty. |
| var repoMap repograph.Map |
| input := RepoState{ |
| Repo: "nou.git", |
| Revision: "1", |
| } |
| _, err := input.Parents(repoMap) |
| require.Error(t, err) |
| require.Contains(t, err.Error(), "Unknown repo") |
| } |
| |
| func TestRepoStateRowKey(t *testing.T) { |
| |
| check := func(rs RepoState, expect string) { |
| require.Equal(t, expect, rs.RowKey()) |
| } |
| |
| // Simple, no patch. |
| check(RepoState{ |
| Repo: common.REPO_SKIA, |
| Revision: "abc123", |
| }, "2#abc123#skia.googlesource.com/skia#####") |
| // Add a patch. |
| check(RepoState{ |
| Repo: common.REPO_SKIA, |
| Revision: "abc123", |
| Patch: Patch{ |
| Issue: "12345", |
| Patchset: "2", |
| Server: "fake.server.com", |
| PatchRepo: "https://skia.googlesource.com/other.git", |
| }, |
| }, "2#abc123#skia.googlesource.com/skia#45#12345#2#skia.googlesource.com/other#fake.server.com") |
| // Patches are valid without a PatchRepo. |
| check(RepoState{ |
| Repo: common.REPO_SKIA, |
| Revision: "abc123", |
| Patch: Patch{ |
| Issue: "12345", |
| Patchset: "2", |
| Server: "fake.server.com", |
| }, |
| }, "2#abc123#skia.googlesource.com/skia#45#12345#2##fake.server.com") |
| } |
