| // Copyright (C) 2017 The Android Open Source Project |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| package com.google.gerrit.server.notedb; |
| |
| import static com.google.common.base.Preconditions.checkArgument; |
| import static com.google.common.collect.ImmutableMap.toImmutableMap; |
| import static com.google.common.truth.Truth.assertThat; |
| |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.collect.ImmutableListMultimap; |
| import com.google.common.collect.ImmutableMap; |
| import com.google.common.collect.ListMultimap; |
| import com.google.common.collect.Multimaps; |
| import com.google.gerrit.reviewdb.client.Change; |
| import com.google.gerrit.reviewdb.client.Comment; |
| import com.google.gerrit.reviewdb.client.PatchLineComment.Status; |
| import com.google.gerrit.reviewdb.client.PatchSet; |
| import com.google.gerrit.reviewdb.client.Project; |
| import com.google.gerrit.reviewdb.client.RefNames; |
| import com.google.gerrit.reviewdb.client.RevId; |
| import com.google.gerrit.server.CommentsUtil; |
| import com.google.gerrit.server.IdentifiedUser; |
| import com.google.gerrit.server.config.AllUsersName; |
| import com.google.gerrit.server.notedb.CommentJsonMigrator.ProjectMigrationResult; |
| import com.google.gerrit.server.util.time.TimeUtil; |
| import com.google.gerrit.testing.TestChanges; |
| import com.google.inject.Inject; |
| import java.io.ByteArrayOutputStream; |
| import java.util.Collection; |
| import java.util.List; |
| import java.util.concurrent.atomic.AtomicInteger; |
| import org.eclipse.jgit.junit.TestRepository; |
| import org.eclipse.jgit.lib.ObjectId; |
| import org.eclipse.jgit.lib.ObjectReader; |
| import org.eclipse.jgit.lib.Ref; |
| import org.eclipse.jgit.lib.Repository; |
| import org.eclipse.jgit.notes.NoteMap; |
| import org.eclipse.jgit.revwalk.RevCommit; |
| import org.eclipse.jgit.revwalk.RevSort; |
| import org.eclipse.jgit.revwalk.RevWalk; |
| import org.junit.Before; |
| import org.junit.Test; |
| |
| public class CommentJsonMigratorTest extends AbstractChangeNotesTest { |
| private CommentJsonMigrator migrator; |
| @Inject private ChangeNoteUtil noteUtil; |
| @Inject private CommentsUtil commentsUtil; |
| @Inject private LegacyChangeNoteWrite legacyChangeNoteWrite; |
| @Inject private AllUsersName allUsersName; |
| |
| private AtomicInteger uuidCounter; |
| |
| @Before |
| public void setUpCounter() { |
| uuidCounter = new AtomicInteger(); |
| migrator = new CommentJsonMigrator(new ChangeNoteJson(), "gerrit", allUsersName); |
| } |
| |
| @Test |
| public void noOpIfAllCommentsAreJson() throws Exception { |
| Change c = newChange(); |
| incrementPatchSet(c); |
| |
| ChangeNotes notes = newNotes(c); |
| ChangeUpdate update = newUpdate(c, changeOwner); |
| Comment ps1Comment = newComment(notes, 1, "comment on ps1"); |
| update.putComment(Status.PUBLISHED, ps1Comment); |
| update.commit(); |
| |
| notes = newNotes(c); |
| update = newUpdate(c, changeOwner); |
| Comment ps2Comment = newComment(notes, 2, "comment on ps2"); |
| update.putComment(Status.PUBLISHED, ps2Comment); |
| update.commit(); |
| |
| notes = newNotes(c); |
| assertThat(getToStringRepresentations(notes.getComments())) |
| .containsExactly( |
| getRevId(notes, 1), ps1Comment.toString(), |
| getRevId(notes, 2), ps2Comment.toString()); |
| |
| ChangeNotes oldNotes = notes; |
| checkMigrate(project, ImmutableList.of()); |
| assertNoDifferences(notes, oldNotes); |
| assertThat(notes.getMetaId()).isEqualTo(oldNotes.getMetaId()); |
| } |
| |
| @Test |
| public void migratePublishedComments() throws Exception { |
| Change c = newChange(); |
| incrementPatchSet(c); |
| |
| ChangeNotes notes = newNotes(c); |
| |
| Comment ps1Comment1 = newComment(notes, 1, "first comment on ps1"); |
| Comment ps2Comment1 = newComment(notes, 2, "first comment on ps2"); |
| Comment ps1Comment2 = newComment(notes, 1, "second comment on ps1"); |
| |
| // Construct legacy format 'by hand'. |
| ByteArrayOutputStream out1 = new ByteArrayOutputStream(0); |
| legacyChangeNoteWrite.buildNote( |
| ImmutableListMultimap.<Integer, Comment>builder().put(1, ps1Comment1).build(), out1); |
| |
| ByteArrayOutputStream out2 = new ByteArrayOutputStream(0); |
| legacyChangeNoteWrite.buildNote( |
| ImmutableListMultimap.<Integer, Comment>builder().put(2, ps2Comment1).build(), out2); |
| |
| ByteArrayOutputStream out3 = new ByteArrayOutputStream(0); |
| legacyChangeNoteWrite.buildNote( |
| ImmutableListMultimap.<Integer, Comment>builder() |
| .put(1, ps1Comment2) |
| .put(1, ps1Comment1) |
| .build(), |
| out3); |
| |
| TestRepository<Repository> testRepository = new TestRepository<>(repo, rw); |
| |
| String metaRefName = RefNames.changeMetaRef(c.getId()); |
| testRepository |
| .branch(metaRefName) |
| .commit() |
| .message("Review ps 1\n\nPatch-set: 1") |
| .add(ps1Comment1.revId, out1.toString()) |
| .author(serverIdent) |
| .committer(serverIdent) |
| .create(); |
| |
| testRepository |
| .branch(metaRefName) |
| .commit() |
| .message("Review ps 2\n\nPatch-set: 2") |
| .add(ps2Comment1.revId, out2.toString()) |
| .add(ps1Comment1.revId, out3.toString()) |
| .author(serverIdent) |
| .committer(serverIdent) |
| .create(); |
| |
| notes = newNotes(c); |
| assertThat(getToStringRepresentations(notes.getComments())) |
| .containsExactly( |
| getRevId(notes, 1), ps1Comment1.toString(), |
| getRevId(notes, 1), ps1Comment2.toString(), |
| getRevId(notes, 2), ps2Comment1.toString()); |
| |
| // Comments at each commit all have legacy format. |
| ImmutableList<RevCommit> oldLog = log(project, RefNames.changeMetaRef(c.getId())); |
| assertThat(oldLog).hasSize(4); |
| assertThat(getLegacyFormatMapForPublishedComments(notes, oldLog.get(0))).isEmpty(); |
| assertThat(getLegacyFormatMapForPublishedComments(notes, oldLog.get(1))).isEmpty(); |
| assertThat(getLegacyFormatMapForPublishedComments(notes, oldLog.get(2))) |
| .containsExactly(ps1Comment1.key, true); |
| assertThat(getLegacyFormatMapForPublishedComments(notes, oldLog.get(3))) |
| .containsExactly(ps1Comment1.key, true, ps1Comment2.key, true, ps2Comment1.key, true); |
| |
| // Check that dryRun doesn't touch anything. |
| String refName = RefNames.changeMetaRef(c.getId()); |
| ObjectId before = repo.getRefDatabase().getRef(refName).getObjectId(); |
| ProjectMigrationResult dryRunResult = migrator.migrateProject(project, repo, true); |
| ObjectId after = repo.getRefDatabase().getRef(refName).getObjectId(); |
| assertThat(before).isEqualTo(after); |
| assertThat(dryRunResult.refsUpdated).isEqualTo(ImmutableList.of(refName)); |
| |
| ChangeNotes oldNotes = notes; |
| checkMigrate(project, ImmutableList.of(refName)); |
| |
| // Comment content is the same. |
| notes = newNotes(c); |
| assertNoDifferences(notes, oldNotes); |
| assertThat(getToStringRepresentations(notes.getComments())) |
| .containsExactly( |
| getRevId(notes, 1), ps1Comment1.toString(), |
| getRevId(notes, 1), ps1Comment2.toString(), |
| getRevId(notes, 2), ps2Comment1.toString()); |
| |
| // Comments at each commit all have JSON format. |
| ImmutableList<RevCommit> newLog = log(project, RefNames.changeMetaRef(c.getId())); |
| assertThat(getLegacyFormatMapForPublishedComments(notes, newLog.get(0))).isEmpty(); |
| assertThat(getLegacyFormatMapForPublishedComments(notes, newLog.get(1))).isEmpty(); |
| assertThat(getLegacyFormatMapForPublishedComments(notes, newLog.get(2))) |
| .containsExactly(ps1Comment1.key, false); |
| assertThat(getLegacyFormatMapForPublishedComments(notes, newLog.get(3))) |
| .containsExactly(ps1Comment1.key, false, ps1Comment2.key, false, ps2Comment1.key, false); |
| } |
| |
| @Test |
| public void migrateDraftComments() throws Exception { |
| Change c = newChange(); |
| incrementPatchSet(c); |
| |
| ChangeNotes notes = newNotes(c); |
| ObjectId origMetaId = notes.getMetaId(); |
| |
| Comment ownerCommentPs1 = newComment(notes, 1, "owner comment on ps1", changeOwner); |
| Comment ownerCommentPs2 = newComment(notes, 2, "owner comment on ps2", changeOwner); |
| Comment otherCommentPs1 = newComment(notes, 1, "other user comment on ps1", otherUser); |
| |
| ByteArrayOutputStream out1 = new ByteArrayOutputStream(0); |
| legacyChangeNoteWrite.buildNote( |
| ImmutableListMultimap.<Integer, Comment>builder().put(1, ownerCommentPs1).build(), out1); |
| |
| ByteArrayOutputStream out2 = new ByteArrayOutputStream(0); |
| legacyChangeNoteWrite.buildNote( |
| ImmutableListMultimap.<Integer, Comment>builder().put(2, ownerCommentPs2).build(), out2); |
| |
| ByteArrayOutputStream out3 = new ByteArrayOutputStream(0); |
| legacyChangeNoteWrite.buildNote( |
| ImmutableListMultimap.<Integer, Comment>builder().put(1, otherCommentPs1).build(), out3); |
| |
| try (Repository allUsersRepo = repoManager.openRepository(allUsers); |
| RevWalk allUsersRw = new RevWalk(allUsersRepo)) { |
| TestRepository<Repository> testRepository = new TestRepository<>(allUsersRepo, allUsersRw); |
| |
| testRepository |
| .branch(RefNames.refsDraftComments(c.getId(), changeOwner.getAccountId())) |
| .commit() |
| .message("Review ps 1\n\nPatch-set: 1") |
| .add(ownerCommentPs1.revId, out1.toString()) |
| .author(serverIdent) |
| .committer(serverIdent) |
| .create(); |
| |
| testRepository |
| .branch(RefNames.refsDraftComments(c.getId(), changeOwner.getAccountId())) |
| .commit() |
| .message("Review ps 1\n\nPatch-set: 2") |
| .add(ownerCommentPs2.revId, out2.toString()) |
| .author(serverIdent) |
| .committer(serverIdent) |
| .create(); |
| |
| testRepository |
| .branch(RefNames.refsDraftComments(c.getId(), otherUser.getAccountId())) |
| .commit() |
| .message("Review ps 2\n\nPatch-set: 2") |
| .add(otherCommentPs1.revId, out3.toString()) |
| .author(serverIdent) |
| .committer(serverIdent) |
| .create(); |
| } |
| |
| notes = newNotes(c); |
| assertThat(getToStringRepresentations(notes.getDraftComments(changeOwner.getAccountId()))) |
| .containsExactly( |
| getRevId(notes, 1), ownerCommentPs1.toString(), |
| getRevId(notes, 2), ownerCommentPs2.toString()); |
| assertThat(getToStringRepresentations(notes.getDraftComments(otherUser.getAccountId()))) |
| .containsExactly(getRevId(notes, 1), otherCommentPs1.toString()); |
| |
| // Comments at each commit all have legacy format. |
| ImmutableList<RevCommit> oldOwnerLog = |
| log(allUsers, RefNames.refsDraftComments(c.getId(), changeOwner.getAccountId())); |
| assertThat(oldOwnerLog).hasSize(2); |
| assertThat(getLegacyFormatMapForDraftComments(notes, oldOwnerLog.get(0))) |
| .containsExactly(ownerCommentPs1.key, true); |
| assertThat(getLegacyFormatMapForDraftComments(notes, oldOwnerLog.get(1))) |
| .containsExactly(ownerCommentPs1.key, true, ownerCommentPs2.key, true); |
| |
| ImmutableList<RevCommit> oldOtherLog = |
| log(allUsers, RefNames.refsDraftComments(c.getId(), otherUser.getAccountId())); |
| assertThat(oldOtherLog).hasSize(1); |
| assertThat(getLegacyFormatMapForDraftComments(notes, oldOtherLog.get(0))) |
| .containsExactly(otherCommentPs1.key, true); |
| |
| ChangeNotes oldNotes = notes; |
| checkMigrate( |
| allUsers, |
| ImmutableList.of( |
| RefNames.refsDraftComments(c.getId(), changeOwner.getAccountId()), |
| RefNames.refsDraftComments(c.getId(), otherUser.getAccountId()))); |
| assertNoDifferences(notes, oldNotes); |
| |
| // Migration doesn't touch change ref. |
| assertThat(repo.exactRef(RefNames.changeMetaRef(c.getId())).getObjectId()) |
| .isEqualTo(origMetaId); |
| |
| // Comment content is the same. |
| notes = newNotes(c); |
| assertThat(getToStringRepresentations(notes.getDraftComments(changeOwner.getAccountId()))) |
| .containsExactly( |
| getRevId(notes, 1), ownerCommentPs1.toString(), |
| getRevId(notes, 2), ownerCommentPs2.toString()); |
| assertThat(getToStringRepresentations(notes.getDraftComments(otherUser.getAccountId()))) |
| .containsExactly(getRevId(notes, 1), otherCommentPs1.toString()); |
| |
| // Comments at each commit all have JSON format. |
| ImmutableList<RevCommit> newOwnerLog = |
| log(allUsers, RefNames.refsDraftComments(c.getId(), changeOwner.getAccountId())); |
| assertThat(getLegacyFormatMapForDraftComments(notes, newOwnerLog.get(0))) |
| .containsExactly(ownerCommentPs1.key, false); |
| assertThat(getLegacyFormatMapForDraftComments(notes, newOwnerLog.get(1))) |
| .containsExactly(ownerCommentPs1.key, false, ownerCommentPs2.key, false); |
| |
| ImmutableList<RevCommit> newOtherLog = |
| log(allUsers, RefNames.refsDraftComments(c.getId(), otherUser.getAccountId())); |
| assertThat(getLegacyFormatMapForDraftComments(notes, newOtherLog.get(0))) |
| .containsExactly(otherCommentPs1.key, false); |
| } |
| |
| @Test |
| public void migrateMixOfJsonAndLegacyComments() throws Exception { |
| // 3 comments: legacy, JSON, legacy. Because adding a comment necessarily rewrites the entire |
| // note, these comments need to be on separate patch sets. |
| Change c = newChange(); |
| incrementPatchSet(c); |
| incrementPatchSet(c); |
| |
| ChangeNotes notes = newNotes(c); |
| |
| Comment ps1Comment = newComment(notes, 1, "comment on ps1 (legacy)"); |
| |
| ByteArrayOutputStream out1 = new ByteArrayOutputStream(0); |
| legacyChangeNoteWrite.buildNote( |
| ImmutableListMultimap.<Integer, Comment>builder().put(1, ps1Comment).build(), out1); |
| |
| TestRepository<Repository> testRepository = new TestRepository<>(repo, rw); |
| |
| String metaRefName = RefNames.changeMetaRef(c.getId()); |
| testRepository |
| .branch(metaRefName) |
| .commit() |
| .message("Review ps 1\n\nPatch-set: 1") |
| .add(ps1Comment.revId, out1.toString()) |
| .author(serverIdent) |
| .committer(serverIdent) |
| .create(); |
| |
| notes = newNotes(c); |
| ChangeUpdate update = newUpdate(c, changeOwner); |
| Comment ps2Comment = newComment(notes, 2, "comment on ps2 (JSON)"); |
| update.putComment(Status.PUBLISHED, ps2Comment); |
| update.commit(); |
| |
| Comment ps3Comment = newComment(notes, 3, "comment on ps3 (legacy)"); |
| ByteArrayOutputStream out3 = new ByteArrayOutputStream(0); |
| legacyChangeNoteWrite.buildNote( |
| ImmutableListMultimap.<Integer, Comment>builder().put(3, ps3Comment).build(), out3); |
| |
| testRepository |
| .branch(metaRefName) |
| .commit() |
| .message("Review ps 3\n\nPatch-set: 3") |
| .add(ps3Comment.revId, out3.toString()) |
| .author(serverIdent) |
| .committer(serverIdent) |
| .create(); |
| |
| notes = newNotes(c); |
| assertThat(getToStringRepresentations(notes.getComments())) |
| .containsExactly( |
| getRevId(notes, 1), ps1Comment.toString(), |
| getRevId(notes, 2), ps2Comment.toString(), |
| getRevId(notes, 3), ps3Comment.toString()); |
| |
| // Comments at each commit match expected format. |
| ImmutableList<RevCommit> oldLog = log(project, RefNames.changeMetaRef(c.getId())); |
| assertThat(oldLog).hasSize(6); |
| assertThat(getLegacyFormatMapForPublishedComments(notes, oldLog.get(0))).isEmpty(); |
| assertThat(getLegacyFormatMapForPublishedComments(notes, oldLog.get(1))).isEmpty(); |
| assertThat(getLegacyFormatMapForPublishedComments(notes, oldLog.get(2))).isEmpty(); |
| assertThat(getLegacyFormatMapForPublishedComments(notes, oldLog.get(3))) |
| .containsExactly(ps1Comment.key, true); |
| assertThat(getLegacyFormatMapForPublishedComments(notes, oldLog.get(4))) |
| .containsExactly(ps1Comment.key, true, ps2Comment.key, false); |
| assertThat(getLegacyFormatMapForPublishedComments(notes, oldLog.get(5))) |
| .containsExactly(ps1Comment.key, true, ps2Comment.key, false, ps3Comment.key, true); |
| |
| ChangeNotes oldNotes = notes; |
| checkMigrate(project, ImmutableList.of(RefNames.changeMetaRef(c.getId()))); |
| assertNoDifferences(notes, oldNotes); |
| |
| // Comment content is the same. |
| notes = newNotes(c); |
| assertThat(getToStringRepresentations(notes.getComments())) |
| .containsExactly( |
| getRevId(notes, 1), ps1Comment.toString(), |
| getRevId(notes, 2), ps2Comment.toString(), |
| getRevId(notes, 3), ps3Comment.toString()); |
| |
| // Comments at each commit all have JSON format. |
| ImmutableList<RevCommit> newLog = log(project, RefNames.changeMetaRef(c.getId())); |
| assertThat(getLegacyFormatMapForPublishedComments(notes, newLog.get(0))).isEmpty(); |
| assertThat(getLegacyFormatMapForPublishedComments(notes, newLog.get(1))).isEmpty(); |
| assertThat(getLegacyFormatMapForPublishedComments(notes, newLog.get(2))).isEmpty(); |
| assertThat(getLegacyFormatMapForPublishedComments(notes, newLog.get(3))) |
| .containsExactly(ps1Comment.key, false); |
| assertThat(getLegacyFormatMapForPublishedComments(notes, newLog.get(4))) |
| .containsExactly(ps1Comment.key, false, ps2Comment.key, false); |
| assertThat(getLegacyFormatMapForPublishedComments(notes, newLog.get(5))) |
| .containsExactly(ps1Comment.key, false, ps2Comment.key, false, ps3Comment.key, false); |
| } |
| |
| private void checkMigrate(Project.NameKey project, List<String> expectedRefs) throws Exception { |
| try (Repository repo = repoManager.openRepository(project)) { |
| ProjectMigrationResult progress = migrator.migrateProject(project, repo, false); |
| |
| assertThat(progress.ok).isTrue(); |
| assertThat(progress.refsUpdated).isEqualTo(expectedRefs); |
| } |
| } |
| |
| private Comment newComment(ChangeNotes notes, int psNum, String message) { |
| return newComment(notes, psNum, message, changeOwner); |
| } |
| |
| private Comment newComment( |
| ChangeNotes notes, int psNum, String message, IdentifiedUser commenter) { |
| return newComment( |
| new PatchSet.Id(notes.getChangeId(), psNum), |
| "filename", |
| "uuid-" + uuidCounter.getAndIncrement(), |
| null, |
| 0, |
| commenter, |
| null, |
| TimeUtil.nowTs(), |
| message, |
| (short) 1, |
| getRevId(notes, psNum).get(), |
| false); |
| } |
| |
| private void incrementPatchSet(Change c) throws Exception { |
| TestChanges.incrementPatchSet(c); |
| RevCommit commit = tr.commit().message("PS" + c.currentPatchSetId().get()).create(); |
| ChangeUpdate update = newUpdate(c, changeOwner); |
| update.setCommit(rw, commit); |
| update.commit(); |
| } |
| |
| private static RevId getRevId(ChangeNotes notes, int psNum) { |
| PatchSet.Id psId = new PatchSet.Id(notes.getChangeId(), psNum); |
| PatchSet ps = notes.getPatchSets().get(psId); |
| checkArgument(ps != null, "no patch set %s: %s", psNum, notes.getPatchSets()); |
| return ps.getRevision(); |
| } |
| |
| private static ListMultimap<RevId, String> getToStringRepresentations( |
| ListMultimap<RevId, Comment> comments) { |
| // Use string representation for equality comparison in this test, because Comment#equals only |
| // compares keys. |
| return Multimaps.transformValues(comments, Comment::toString); |
| } |
| |
| private ImmutableMap<Comment.Key, Boolean> getLegacyFormatMapForPublishedComments( |
| ChangeNotes notes, ObjectId metaId) throws Exception { |
| return getLegacyFormatMap(project, notes.getChangeId(), metaId, Status.PUBLISHED); |
| } |
| |
| private ImmutableMap<Comment.Key, Boolean> getLegacyFormatMapForDraftComments( |
| ChangeNotes notes, ObjectId metaId) throws Exception { |
| return getLegacyFormatMap(allUsers, notes.getChangeId(), metaId, Status.DRAFT); |
| } |
| |
| private ImmutableMap<Comment.Key, Boolean> getLegacyFormatMap( |
| Project.NameKey project, Change.Id changeId, ObjectId metaId, Status status) |
| throws Exception { |
| try (Repository repo = repoManager.openRepository(project); |
| ObjectReader reader = repo.newObjectReader(); |
| RevWalk rw = new RevWalk(reader)) { |
| NoteMap noteMap = NoteMap.read(reader, rw.parseCommit(metaId)); |
| RevisionNoteMap<ChangeRevisionNote> revNoteMap = |
| RevisionNoteMap.parse( |
| noteUtil.getChangeNoteJson(), |
| noteUtil.getLegacyChangeNoteRead(), |
| changeId, |
| reader, |
| noteMap, |
| status); |
| return revNoteMap.revisionNotes.values().stream() |
| .flatMap(crn -> crn.getEntities().stream()) |
| .collect(toImmutableMap(c -> c.key, c -> c.legacyFormat)); |
| } |
| } |
| |
| private ImmutableList<RevCommit> log(Project.NameKey project, String refName) throws Exception { |
| try (Repository repo = repoManager.openRepository(project)) { |
| return log(repo, refName); |
| } |
| } |
| |
| private ImmutableList<RevCommit> log(Repository repo, String refName) throws Exception { |
| try (RevWalk rw = new RevWalk(repo)) { |
| rw.sort(RevSort.TOPO); |
| rw.sort(RevSort.REVERSE); |
| Ref ref = repo.exactRef(refName); |
| if (ref == null) { |
| return ImmutableList.of(); |
| } |
| rw.markStart(rw.parseCommit(ref.getObjectId())); |
| return ImmutableList.copyOf(rw); |
| } |
| } |
| |
| private ImmutableListMultimap<String, RevCommit> logAll( |
| Project.NameKey project, Collection<Ref> refs) throws Exception { |
| ImmutableListMultimap.Builder<String, RevCommit> logs = ImmutableListMultimap.builder(); |
| try (Repository repo = repoManager.openRepository(project)) { |
| for (Ref r : refs) { |
| logs.putAll(r.getName(), log(repo, r.getName())); |
| } |
| } |
| return logs.build(); |
| } |
| |
| private static void assertLogEqualExceptTrees( |
| ImmutableList<RevCommit> actualLog, ImmutableList<RevCommit> expectedLog) { |
| assertThat(actualLog).hasSize(expectedLog.size()); |
| for (int i = 0; i < expectedLog.size(); i++) { |
| RevCommit actual = actualLog.get(i); |
| RevCommit expected = expectedLog.get(i); |
| assertThat(actual.getAuthorIdent()) |
| .named("author of entry %s", i) |
| .isEqualTo(expected.getAuthorIdent()); |
| assertThat(actual.getCommitterIdent()) |
| .named("committer of entry %s", i) |
| .isEqualTo(expected.getCommitterIdent()); |
| assertThat(actual.getFullMessage()).named("message of entry %s", i).isNotNull(); |
| assertThat(actual.getFullMessage()) |
| .named("message of entry %s", i) |
| .isEqualTo(expected.getFullMessage()); |
| } |
| } |
| |
| private void assertNoDifferences(ChangeNotes actual, ChangeNotes expected) throws Exception { |
| checkArgument( |
| actual.getChangeId().equals(expected.getChangeId()), |
| "must be same change: %s != %s", |
| actual.getChangeId(), |
| expected.getChangeId()); |
| |
| // Parsed comment representations are equal. |
| // TODO(dborowitz): Comparing collections directly would be much easier, but Comment doesn't |
| // have a proper equals; switch to that when the issues with |
| // https://gerrit-review.googlesource.com/c/gerrit/+/207013 are resolved. |
| assertCommentsEqual(commentsUtil.draftByChange(actual), commentsUtil.draftByChange(expected)); |
| assertCommentsEqual( |
| commentsUtil.publishedByChange(actual), commentsUtil.publishedByChange(expected)); |
| |
| // Change metadata is equal. |
| assertLogEqualExceptTrees( |
| log(project, actual.getRefName()), log(project, expected.getRefName())); |
| |
| // Logs of all draft refs are equal. |
| ImmutableListMultimap<String, RevCommit> actualDraftLogs = |
| logAll(allUsersName, commentsUtil.getDraftRefs(actual.getChangeId())); |
| ImmutableListMultimap<String, RevCommit> expectedDraftLogs = |
| logAll(allUsersName, commentsUtil.getDraftRefs(expected.getChangeId())); |
| assertThat(actualDraftLogs.keySet()) |
| .named("draft ref names") |
| .containsExactlyElementsIn(expectedDraftLogs.keySet()); |
| for (String refName : actualDraftLogs.keySet()) { |
| assertLogEqualExceptTrees(actualDraftLogs.get(refName), actualDraftLogs.get(refName)); |
| } |
| } |
| |
| private static void assertCommentsEqual(List<Comment> actualList, List<Comment> expectedList) { |
| ImmutableMap<Comment.Key, Comment> actualMap = byKey(actualList); |
| ImmutableMap<Comment.Key, Comment> expectedMap = byKey(expectedList); |
| assertThat(actualMap.keySet()).isEqualTo(expectedMap.keySet()); |
| for (Comment.Key key : actualMap.keySet()) { |
| Comment actual = actualMap.get(key); |
| Comment expected = expectedMap.get(key); |
| assertThat(actual.key).isEqualTo(expected.key); |
| assertThat(actual.lineNbr).isEqualTo(expected.lineNbr); |
| assertThat(actual.author).isEqualTo(expected.author); |
| assertThat(actual.getRealAuthor()).isEqualTo(expected.getRealAuthor()); |
| assertThat(actual.writtenOn).isEqualTo(expected.writtenOn); |
| assertThat(actual.side).isEqualTo(expected.side); |
| assertThat(actual.message).isEqualTo(expected.message); |
| assertThat(actual.parentUuid).isEqualTo(expected.parentUuid); |
| assertThat(actual.range).isEqualTo(expected.range); |
| assertThat(actual.tag).isEqualTo(expected.tag); |
| assertThat(actual.revId).isEqualTo(expected.revId); |
| assertThat(actual.serverId).isEqualTo(expected.serverId); |
| assertThat(actual.unresolved).isEqualTo(expected.unresolved); |
| } |
| } |
| |
| private static ImmutableMap<Comment.Key, Comment> byKey(List<Comment> comments) { |
| return comments.stream().collect(toImmutableMap(c -> c.key, c -> c)); |
| } |
| } |
