gerrit-server/src/test/java/com/google/gerrit/server/notedb/ChangeNotesTest.java

// Copyright (C) 2013 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.gerrit.server.notedb.ReviewerState.CC;
import static com.google.gerrit.server.notedb.ReviewerState.REVIEWER;
import static com.google.gerrit.testutil.TestChanges.incrementPatchSet;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableListMultimap;
import com.google.common.collect.ImmutableSetMultimap;
import com.google.common.collect.Iterables;
import com.google.common.collect.LinkedListMultimap;
import com.google.common.collect.ListMultimap;
import com.google.common.collect.Lists;
import com.google.common.collect.Multimap;
import com.google.gerrit.common.TimeUtil;
import com.google.gerrit.common.data.SubmitRecord;
import com.google.gerrit.reviewdb.client.Account;
import com.google.gerrit.reviewdb.client.Change;
import com.google.gerrit.reviewdb.client.ChangeMessage;
import com.google.gerrit.reviewdb.client.CommentRange;
import com.google.gerrit.reviewdb.client.PatchLineComment;
import com.google.gerrit.reviewdb.client.PatchLineComment.Status;
import com.google.gerrit.reviewdb.client.PatchSet;
import com.google.gerrit.reviewdb.client.PatchSetApproval;
import com.google.gerrit.server.git.VersionedMetaData.BatchMetaDataUpdate;
import com.google.gwtorm.server.OrmException;

import org.eclipse.jgit.lib.BatchRefUpdate;
import org.eclipse.jgit.lib.CommitBuilder;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.NullProgressMonitor;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.notes.Note;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevWalk;
import org.eclipse.jgit.transport.ReceiveCommand;
import org.junit.Test;

import java.io.IOException;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;

public class ChangeNotesTest extends AbstractChangeNotesTest {
  @Test
  public void approvalsOnePatchSet() throws Exception {
    Change c = newChange();
    ChangeUpdate update = newUpdate(c, changeOwner);
    update.putApproval("Verified", (short) 1);
    update.putApproval("Code-Review", (short) -1);
    update.commit();

    ChangeNotes notes = newNotes(c);
    assertEquals(1, notes.getApprovals().keySet().size());
    List<PatchSetApproval> psas =
      notes.getApprovals().get(c.currentPatchSetId());
    assertEquals(2, psas.size());

    assertEquals(c.currentPatchSetId(), psas.get(0).getPatchSetId());
    assertEquals(1, psas.get(0).getAccountId().get());
    assertEquals("Code-Review", psas.get(0).getLabel());
    assertEquals((short) -1, psas.get(0).getValue());
    assertEquals(truncate(after(c, 1000)), psas.get(0).getGranted());

    assertEquals(c.currentPatchSetId(), psas.get(1).getPatchSetId());
    assertEquals(1, psas.get(1).getAccountId().get());
    assertEquals("Verified", psas.get(1).getLabel());
    assertEquals((short) 1, psas.get(1).getValue());
    assertEquals(psas.get(0).getGranted(), psas.get(1).getGranted());
  }

  @Test
  public void approvalsMultiplePatchSets() throws Exception {
    Change c = newChange();
    ChangeUpdate update = newUpdate(c, changeOwner);
    update.putApproval("Code-Review", (short) -1);
    update.commit();
    PatchSet.Id ps1 = c.currentPatchSetId();

    incrementPatchSet(c);
    update = newUpdate(c, changeOwner);
    update.putApproval("Code-Review", (short) 1);
    update.commit();
    PatchSet.Id ps2 = c.currentPatchSetId();

    ChangeNotes notes = newNotes(c);
    ListMultimap<PatchSet.Id, PatchSetApproval> psas = notes.getApprovals();
    assertEquals(2, notes.getApprovals().keySet().size());

    PatchSetApproval psa1 = Iterables.getOnlyElement(psas.get(ps1));
    assertEquals(ps1, psa1.getPatchSetId());
    assertEquals(1, psa1.getAccountId().get());
    assertEquals("Code-Review", psa1.getLabel());
    assertEquals((short) -1, psa1.getValue());
    assertEquals(truncate(after(c, 1000)), psa1.getGranted());

    PatchSetApproval psa2 = Iterables.getOnlyElement(psas.get(ps2));
    assertEquals(ps2, psa2.getPatchSetId());
    assertEquals(1, psa2.getAccountId().get());
    assertEquals("Code-Review", psa2.getLabel());
    assertEquals((short) +1, psa2.getValue());
    assertEquals(truncate(after(c, 2000)), psa2.getGranted());
  }

  @Test
  public void approvalsMultipleApprovals() throws Exception {
    Change c = newChange();
    ChangeUpdate update = newUpdate(c, changeOwner);
    update.putApproval("Code-Review", (short) -1);
    update.commit();

    ChangeNotes notes = newNotes(c);
    PatchSetApproval psa = Iterables.getOnlyElement(
        notes.getApprovals().get(c.currentPatchSetId()));
    assertEquals("Code-Review", psa.getLabel());
    assertEquals((short) -1, psa.getValue());

    update = newUpdate(c, changeOwner);
    update.putApproval("Code-Review", (short) 1);
    update.commit();

    notes = newNotes(c);
    psa = Iterables.getOnlyElement(
        notes.getApprovals().get(c.currentPatchSetId()));
    assertEquals("Code-Review", psa.getLabel());
    assertEquals((short) 1, psa.getValue());
  }

  @Test
  public void approvalsMultipleUsers() throws Exception {
    Change c = newChange();
    ChangeUpdate update = newUpdate(c, changeOwner);
    update.putApproval("Code-Review", (short) -1);
    update.commit();

    update = newUpdate(c, otherUser);
    update.putApproval("Code-Review", (short) 1);
    update.commit();

    ChangeNotes notes = newNotes(c);
    assertEquals(1, notes.getApprovals().keySet().size());
    List<PatchSetApproval> psas =
      notes.getApprovals().get(c.currentPatchSetId());
    assertEquals(2, psas.size());

    assertEquals(c.currentPatchSetId(), psas.get(0).getPatchSetId());
    assertEquals(1, psas.get(0).getAccountId().get());
    assertEquals("Code-Review", psas.get(0).getLabel());
    assertEquals((short) -1, psas.get(0).getValue());
    assertEquals(truncate(after(c, 1000)), psas.get(0).getGranted());

    assertEquals(c.currentPatchSetId(), psas.get(1).getPatchSetId());
    assertEquals(2, psas.get(1).getAccountId().get());
    assertEquals("Code-Review", psas.get(1).getLabel());
    assertEquals((short) 1, psas.get(1).getValue());
    assertEquals(truncate(after(c, 2000)), psas.get(1).getGranted());
  }

  @Test
  public void approvalsTombstone() throws Exception {
    Change c = newChange();
    ChangeUpdate update = newUpdate(c, changeOwner);
    update.putApproval("Not-For-Long", (short) 1);
    update.commit();

    ChangeNotes notes = newNotes(c);
    PatchSetApproval psa = Iterables.getOnlyElement(
        notes.getApprovals().get(c.currentPatchSetId()));
    assertEquals(1, psa.getAccountId().get());
    assertEquals("Not-For-Long", psa.getLabel());
    assertEquals((short) 1, psa.getValue());

    update = newUpdate(c, changeOwner);
    update.removeApproval("Not-For-Long");
    update.commit();

    notes = newNotes(c);
    assertTrue(notes.getApprovals().isEmpty());
  }

  @Test
  public void multipleReviewers() throws Exception {
    Change c = newChange();
    ChangeUpdate update = newUpdate(c, changeOwner);
    update.putReviewer(changeOwner.getAccount().getId(), REVIEWER);
    update.putReviewer(otherUser.getAccount().getId(), REVIEWER);
    update.commit();

    ChangeNotes notes = newNotes(c);
    assertEquals(ImmutableSetMultimap.of(
          REVIEWER, new Account.Id(1),
          REVIEWER, new Account.Id(2)),
        notes.getReviewers());
  }

  @Test
  public void reviewerTypes() throws Exception {
    Change c = newChange();
    ChangeUpdate update = newUpdate(c, changeOwner);
    update.putReviewer(changeOwner.getAccount().getId(), REVIEWER);
    update.putReviewer(otherUser.getAccount().getId(), CC);
    update.commit();

    ChangeNotes notes = newNotes(c);
    assertEquals(ImmutableSetMultimap.of(
          REVIEWER, new Account.Id(1),
          CC, new Account.Id(2)),
        notes.getReviewers());
  }

  @Test
  public void oneReviewerMultipleTypes() throws Exception {
    Change c = newChange();
    ChangeUpdate update = newUpdate(c, changeOwner);
    update.putReviewer(otherUser.getAccount().getId(), REVIEWER);
    update.commit();

    ChangeNotes notes = newNotes(c);
    assertEquals(ImmutableSetMultimap.of(
          REVIEWER, new Account.Id(2)),
        notes.getReviewers());

    update = newUpdate(c, otherUser);
    update.putReviewer(otherUser.getAccount().getId(), CC);
    update.commit();

    notes = newNotes(c);
    assertEquals(ImmutableSetMultimap.of(
          CC, new Account.Id(2)),
        notes.getReviewers());
  }

  @Test
  public void removeReviewer() throws Exception {
    Change c = newChange();
    ChangeUpdate update = newUpdate(c, changeOwner);
    update.putReviewer(otherUser.getAccount().getId(), REVIEWER);
    update.commit();

    update = newUpdate(c, changeOwner);
    update.putApproval("Code-Review", (short) 1);
    update.commit();

    update = newUpdate(c, otherUser);
    update.putApproval("Code-Review", (short) 1);
    update.commit();

    ChangeNotes notes = newNotes(c);
    List<PatchSetApproval> psas =
        notes.getApprovals().get(c.currentPatchSetId());
    assertEquals(2, psas.size());
    assertEquals(changeOwner.getAccount().getId(), psas.get(0).getAccountId());
    assertEquals(otherUser.getAccount().getId(), psas.get(1).getAccountId());

    update = newUpdate(c, changeOwner);
    update.removeReviewer(otherUser.getAccount().getId());
    update.commit();

    notes = newNotes(c);
    psas = notes.getApprovals().get(c.currentPatchSetId());
    assertEquals(1, psas.size());
    assertEquals(changeOwner.getAccount().getId(), psas.get(0).getAccountId());
  }

  @Test
  public void submitRecords() throws Exception {
    Change c = newChange();
    ChangeUpdate update = newUpdate(c, changeOwner);
    update.setSubject("Submit patch set 1");

    update.submit(ImmutableList.of(
        submitRecord("NOT_READY", null,
          submitLabel("Verified", "OK", changeOwner.getAccountId()),
          submitLabel("Code-Review", "NEED", null)),
        submitRecord("NOT_READY", null,
          submitLabel("Verified", "OK", changeOwner.getAccountId()),
          submitLabel("Alternative-Code-Review", "NEED", null))));
    update.commit();

    ChangeNotes notes = newNotes(c);
    List<SubmitRecord> recs = notes.getSubmitRecords();
    assertEquals(2, recs.size());
    assertEquals(submitRecord("NOT_READY", null,
        submitLabel("Verified", "OK", changeOwner.getAccountId()),
        submitLabel("Code-Review", "NEED", null)), recs.get(0));
    assertEquals(submitRecord("NOT_READY", null,
        submitLabel("Verified", "OK", changeOwner.getAccountId()),
        submitLabel("Alternative-Code-Review", "NEED", null)), recs.get(1));
  }

  @Test
  public void latestSubmitRecordsOnly() throws Exception {
    Change c = newChange();
    ChangeUpdate update = newUpdate(c, changeOwner);
    update.setSubject("Submit patch set 1");
    update.submit(ImmutableList.of(
        submitRecord("OK", null,
          submitLabel("Code-Review", "OK", otherUser.getAccountId()))));
    update.commit();

    incrementPatchSet(c);
    update = newUpdate(c, changeOwner);
    update.setSubject("Submit patch set 2");
    update.submit(ImmutableList.of(
        submitRecord("OK", null,
          submitLabel("Code-Review", "OK", changeOwner.getAccountId()))));
    update.commit();

    ChangeNotes notes = newNotes(c);
    assertEquals(submitRecord("OK", null,
          submitLabel("Code-Review", "OK", changeOwner.getAccountId())),
        Iterables.getOnlyElement(notes.getSubmitRecords()));
  }

  @Test
  public void emptyChangeUpdate() throws Exception {
    ChangeUpdate update = newUpdate(newChange(), changeOwner);
    update.commit();
    assertNull(update.getRevision());
  }

  @Test
  public void hashtagCommit() throws Exception {
    Change c = newChange();
    ChangeUpdate update = newUpdate(c, changeOwner);
    LinkedHashSet<String> hashtags = new LinkedHashSet<>();
    hashtags.add("tag1");
    hashtags.add("tag2");
    update.setHashtags(hashtags);
    update.commit();
    try (RevWalk walk = new RevWalk(repo)) {
      RevCommit commit = walk.parseCommit(update.getRevision());
      walk.parseBody(commit);
      assertTrue(commit.getFullMessage().endsWith("Hashtags: tag1,tag2\n"));
    }
  }

  @Test
  public void hashtagChangeNotes() throws Exception {
    Change c = newChange();
    ChangeUpdate update = newUpdate(c, changeOwner);
    LinkedHashSet<String> hashtags = new LinkedHashSet<>();
    hashtags.add("tag1");
    hashtags.add("tag2");
    update.setHashtags(hashtags);
    update.commit();

    ChangeNotes notes = newNotes(c);
    assertEquals(hashtags, notes.getHashtags());
  }

  @Test
  public void emptyExceptSubject() throws Exception {
    ChangeUpdate update = newUpdate(newChange(), changeOwner);
    update.setSubject("Create change");
    update.commit();
    assertNotNull(update.getRevision());
  }

  @Test
  public void multipleUpdatesInBatch() throws Exception {
    Change c = newChange();
    ChangeUpdate update1 = newUpdate(c, changeOwner);
    update1.putApproval("Verified", (short) 1);

    ChangeUpdate update2 = newUpdate(c, otherUser);
    update2.putApproval("Code-Review", (short) 2);

    BatchMetaDataUpdate batch = update1.openUpdate();
    try {
      batch.write(update1, new CommitBuilder());
      batch.write(update2, new CommitBuilder());
      batch.commit();
    } finally {
      batch.close();
    }

    ChangeNotes notes = newNotes(c);
    List<PatchSetApproval> psas =
        notes.getApprovals().get(c.currentPatchSetId());
    assertEquals(2, psas.size());

    assertEquals(changeOwner.getAccount().getId(), psas.get(0).getAccountId());
    assertEquals("Verified", psas.get(0).getLabel());
    assertEquals((short) 1, psas.get(0).getValue());

    assertEquals(otherUser.getAccount().getId(), psas.get(1).getAccountId());
    assertEquals("Code-Review", psas.get(1).getLabel());
    assertEquals((short) 2, psas.get(1).getValue());
  }

  @Test
  public void multipleUpdatesIncludingComments() throws Exception {
    Change c = newChange();
    ChangeUpdate update1 = newUpdate(c, otherUser);
    String uuid1 = "uuid1";
    String message1 = "comment 1";
    CommentRange range1 = new CommentRange(1, 1, 2, 1);
    Timestamp time1 = TimeUtil.nowTs();
    PatchSet.Id psId = c.currentPatchSetId();
    BatchRefUpdate bru = repo.getRefDatabase().newBatchUpdate();
    BatchMetaDataUpdate batch = update1.openUpdateInBatch(bru);
    PatchLineComment comment1 = newPublishedPatchLineComment(psId, "file1",
        uuid1, range1, range1.getEndLine(), otherUser, null, time1, message1,
        (short) 0, "abcd1234abcd1234abcd1234abcd1234abcd1234");
    update1.setPatchSetId(psId);
    update1.upsertComment(comment1);
    update1.writeCommit(batch);
    ChangeUpdate update2 = newUpdate(c, otherUser);
    update2.putApproval("Code-Review", (short) 2);
    update2.writeCommit(batch);

    try (RevWalk rw = new RevWalk(repo)) {
      batch.commit();
      bru.execute(rw, NullProgressMonitor.INSTANCE);

      ChangeNotes notes = newNotes(c);
      ObjectId tip = notes.getRevision();
      RevCommit commitWithApprovals = rw.parseCommit(tip);
      assertNotNull(commitWithApprovals);
      RevCommit commitWithComments = commitWithApprovals.getParent(0);
      assertNotNull(commitWithComments);

      ChangeNotesParser notesWithComments =
          new ChangeNotesParser(c, commitWithComments.copy(), rw, repoManager);
      notesWithComments.parseAll();
      ImmutableListMultimap<PatchSet.Id, PatchSetApproval> approvals1 =
          notesWithComments.buildApprovals();
      assertEquals(0, approvals1.size());
      assertEquals(1, notesWithComments.commentsForBase.size());
      notesWithComments.close();

      ChangeNotesParser notesWithApprovals =
          new ChangeNotesParser(c, commitWithApprovals.copy(), rw, repoManager);
      notesWithApprovals.parseAll();
      ImmutableListMultimap<PatchSet.Id, PatchSetApproval> approvals2 =
          notesWithApprovals.buildApprovals();
      assertEquals(1, approvals2.size());
      assertEquals(1, notesWithApprovals.commentsForBase.size());
      notesWithApprovals.close();
    } finally {
      batch.close();
    }
  }

  @Test
  public void multipleUpdatesAcrossRefs() throws Exception {
    Change c1 = newChange();
    ChangeUpdate update1 = newUpdate(c1, changeOwner);
    update1.putApproval("Verified", (short) 1);

    Change c2 = newChange();
    ChangeUpdate update2 = newUpdate(c2, otherUser);
    update2.putApproval("Code-Review", (short) 2);

    BatchMetaDataUpdate batch1 = null;
    BatchMetaDataUpdate batch2 = null;

    BatchRefUpdate bru = repo.getRefDatabase().newBatchUpdate();
    try {
      batch1 = update1.openUpdateInBatch(bru);
      batch1.write(update1, new CommitBuilder());
      batch1.commit();
      assertNull(repo.getRef(update1.getRefName()));

      batch2 = update2.openUpdateInBatch(bru);
      batch2.write(update2, new CommitBuilder());
      batch2.commit();
      assertNull(repo.getRef(update2.getRefName()));
    } finally {
      if (batch1 != null) {
        batch1.close();
      }
      if (batch2 != null) {
        batch2.close();
      }
    }

    List<ReceiveCommand> cmds = bru.getCommands();
    assertEquals(2, cmds.size());
    assertEquals(update1.getRefName(), cmds.get(0).getRefName());
    assertEquals(update2.getRefName(), cmds.get(1).getRefName());

    try (RevWalk rw = new RevWalk(repo)) {
      bru.execute(rw, NullProgressMonitor.INSTANCE);
    }

    assertEquals(ReceiveCommand.Result.OK, cmds.get(0).getResult());
    assertEquals(ReceiveCommand.Result.OK, cmds.get(1).getResult());

    assertNotNull(repo.getRef(update1.getRefName()));
    assertNotNull(repo.getRef(update2.getRefName()));
  }

  @Test
  public void changeMessageOnePatchSet() throws Exception {
    Change c = newChange();
    ChangeUpdate update = newUpdate(c, changeOwner);
    update.putReviewer(changeOwner.getAccount().getId(), REVIEWER);
    update.setChangeMessage("Just a little code change.\n");
    update.commit();
    PatchSet.Id ps1 = c.currentPatchSetId();

    ChangeNotes notes = newNotes(c);
    ListMultimap<PatchSet.Id, ChangeMessage> changeMessages =
        notes.getChangeMessages();
    assertEquals(1, changeMessages.keySet().size());

    ChangeMessage cm = Iterables.getOnlyElement(changeMessages.get(ps1));
    assertEquals("Just a little code change.\n",
        cm.getMessage());
    assertEquals(changeOwner.getAccount().getId(),
        cm.getAuthor());
    assertEquals(ps1, cm.getPatchSetId());
  }

  @Test
  public void noChangeMessage() throws Exception {
    Change c = newChange();
    ChangeUpdate update = newUpdate(c, changeOwner);
    update.putReviewer(changeOwner.getAccount().getId(), REVIEWER);
    update.commit();

    ChangeNotes notes = newNotes(c);
    ListMultimap<PatchSet.Id, ChangeMessage> changeMessages =
        notes.getChangeMessages();
    assertEquals(0, changeMessages.keySet().size());
  }

  @Test
  public void changeMessageWithTrailingDoubleNewline() throws Exception {
    Change c = newChange();
    ChangeUpdate update = newUpdate(c, changeOwner);
    update.setChangeMessage("Testing trailing double newline\n"
        + "\n");
    update.commit();
    PatchSet.Id ps1 = c.currentPatchSetId();

    ChangeNotes notes = newNotes(c);
    ListMultimap<PatchSet.Id, ChangeMessage> changeMessages =
        notes.getChangeMessages();
    assertEquals(1, changeMessages.keySet().size());

    ChangeMessage cm1 = Iterables.getOnlyElement(changeMessages.get(ps1));
    assertEquals("Testing trailing double newline\n" + "\n", cm1.getMessage());
    assertEquals(changeOwner.getAccount().getId(), cm1.getAuthor());
  }

  @Test
  public void changeMessageWithMultipleParagraphs() throws Exception {
    Change c = newChange();
    ChangeUpdate update = newUpdate(c, changeOwner);
    update.setChangeMessage("Testing paragraph 1\n"
        + "\n"
        + "Testing paragraph 2\n"
        + "\n"
        + "Testing paragraph 3");
    update.commit();
    PatchSet.Id ps1 = c.currentPatchSetId();

    ChangeNotes notes = newNotes(c);
    ListMultimap<PatchSet.Id, ChangeMessage> changeMessages =
        notes.getChangeMessages();
    assertEquals(1, changeMessages.keySet().size());

    ChangeMessage cm1 = Iterables.getOnlyElement(changeMessages.get(ps1));
    assertEquals("Testing paragraph 1\n"
        + "\n"
        + "Testing paragraph 2\n"
        + "\n"
        + "Testing paragraph 3", cm1.getMessage());
    assertEquals(changeOwner.getAccount().getId(), cm1.getAuthor());
  }

  @Test
  public void changeMessagesMultiplePatchSets() throws Exception {
    Change c = newChange();
    ChangeUpdate update = newUpdate(c, changeOwner);
    update.putReviewer(changeOwner.getAccount().getId(), REVIEWER);
    update.setChangeMessage("This is the change message for the first PS.");
    update.commit();
    PatchSet.Id ps1 = c.currentPatchSetId();

    incrementPatchSet(c);
    update = newUpdate(c, changeOwner);

    update.setChangeMessage("This is the change message for the second PS.");
    update.commit();
    PatchSet.Id ps2 = c.currentPatchSetId();

    ChangeNotes notes = newNotes(c);
    ListMultimap<PatchSet.Id, ChangeMessage> changeMessages =
        notes.getChangeMessages();
    assertEquals(2, changeMessages.keySet().size());

    ChangeMessage cm1 = Iterables.getOnlyElement(changeMessages.get(ps1));
    assertEquals("This is the change message for the first PS.",
        cm1.getMessage());
    assertEquals(changeOwner.getAccount().getId(),
        cm1.getAuthor());

    ChangeMessage cm2 = Iterables.getOnlyElement(changeMessages.get(ps2));
    assertEquals(ps1, cm1.getPatchSetId());
    assertEquals("This is the change message for the second PS.",
        cm2.getMessage());
    assertEquals(changeOwner.getAccount().getId(), cm2.getAuthor());
    assertEquals(ps2, cm2.getPatchSetId());
  }

  @Test
  public void changeMessageMultipleInOnePatchSet() throws Exception {
    Change c = newChange();
    ChangeUpdate update = newUpdate(c, changeOwner);
    update.putReviewer(changeOwner.getAccount().getId(), REVIEWER);
    update.setChangeMessage("First change message.\n");
    update.commit();

    PatchSet.Id ps1 = c.currentPatchSetId();

    update = newUpdate(c, changeOwner);
    update.putReviewer(changeOwner.getAccount().getId(), REVIEWER);
    update.setChangeMessage("Second change message.\n");
    update.commit();

    ChangeNotes notes = newNotes(c);
    ListMultimap<PatchSet.Id, ChangeMessage> changeMessages =
        notes.getChangeMessages();
    assertEquals(1, changeMessages.keySet().size());

    List<ChangeMessage> cm = changeMessages.get(ps1);
    assertEquals(2, cm.size());
    assertEquals("First change message.\n",
        cm.get(0).getMessage());
    assertEquals(changeOwner.getAccount().getId(),
        cm.get(0).getAuthor());
    assertEquals(ps1, cm.get(0).getPatchSetId());
    assertEquals("Second change message.\n",
        cm.get(1).getMessage());
    assertEquals(changeOwner.getAccount().getId(),
        cm.get(1).getAuthor());
    assertEquals(ps1, cm.get(1).getPatchSetId());
  }

  @Test
  public void patchLineCommentNotesFormatSide1() throws Exception {
    Change c = newChange();
    ChangeUpdate update = newUpdate(c, otherUser);
    String uuid1 = "uuid1";
    String uuid2 = "uuid2";
    String uuid3 = "uuid3";
    String message1 = "comment 1";
    String message2 = "comment 2";
    String message3 = "comment 3";
    CommentRange range1 = new CommentRange(1, 1, 2, 1);
    Timestamp time1 = TimeUtil.nowTs();
    Timestamp time2 = TimeUtil.nowTs();
    Timestamp time3 = TimeUtil.nowTs();
    PatchSet.Id psId = c.currentPatchSetId();

    PatchLineComment comment1 = newPublishedPatchLineComment(psId, "file1",
        uuid1, range1, range1.getEndLine(), otherUser, null, time1, message1,
        (short) 1, "abcd1234abcd1234abcd1234abcd1234abcd1234");
    update.setPatchSetId(psId);
    update.upsertComment(comment1);
    update.commit();

    update = newUpdate(c, otherUser);
    CommentRange range2 = new CommentRange(2, 1, 3, 1);
    PatchLineComment comment2 = newPublishedPatchLineComment(psId, "file1",
        uuid2, range2, range2.getEndLine(), otherUser, null, time2, message2,
        (short) 1, "abcd1234abcd1234abcd1234abcd1234abcd1234");
    update.setPatchSetId(psId);
    update.upsertComment(comment2);
    update.commit();

    update = newUpdate(c, otherUser);
    CommentRange range3 = new CommentRange(3, 1, 4, 1);
    PatchLineComment comment3 = newPublishedPatchLineComment(psId, "file2",
        uuid3, range3, range3.getEndLine(), otherUser, null, time3, message3,
        (short) 1, "abcd1234abcd1234abcd1234abcd1234abcd1234");
    update.setPatchSetId(psId);
    update.upsertComment(comment3);
    update.commit();

    ChangeNotes notes = newNotes(c);

    try (RevWalk walk = new RevWalk(repo)) {
      ArrayList<Note> notesInTree =
          Lists.newArrayList(notes.getNoteMap().iterator());
      Note note = Iterables.getOnlyElement(notesInTree);

      byte[] bytes =
          walk.getObjectReader().open(
              note.getData(), Constants.OBJ_BLOB).getBytes();
      String noteString = new String(bytes, UTF_8);
      assertEquals("Patch-set: 1\n"
          + "Revision: abcd1234abcd1234abcd1234abcd1234abcd1234\n"
          + "File: file1\n"
          + "\n"
          + "1:1-2:1\n"
          + CommentsInNotesUtil.formatTime(serverIdent, time1) + "\n"
          + "Author: Other Account <2@gerrit>\n"
          + "UUID: uuid1\n"
          + "Bytes: 9\n"
          + "comment 1\n"
          + "\n"
          + "2:1-3:1\n"
          + CommentsInNotesUtil.formatTime(serverIdent, time2) + "\n"
          + "Author: Other Account <2@gerrit>\n"
          + "UUID: uuid2\n"
          + "Bytes: 9\n"
          + "comment 2\n"
          + "\n"
          + "File: file2\n"
          + "\n"
          + "3:1-4:1\n"
          + CommentsInNotesUtil.formatTime(serverIdent, time3) + "\n"
          + "Author: Other Account <2@gerrit>\n"
          + "UUID: uuid3\n"
          + "Bytes: 9\n"
          + "comment 3\n"
          + "\n",
          noteString);
    }
  }

  @Test
  public void patchLineCommentNotesFormatSide0() throws Exception {
    Change c = newChange();
    ChangeUpdate update = newUpdate(c, otherUser);
    String uuid1 = "uuid1";
    String uuid2 = "uuid2";
    String message1 = "comment 1";
    String message2 = "comment 2";
    CommentRange range1 = new CommentRange(1, 1, 2, 1);
    Timestamp time1 = TimeUtil.nowTs();
    Timestamp time2 = TimeUtil.nowTs();
    PatchSet.Id psId = c.currentPatchSetId();

    PatchLineComment comment1 = newPublishedPatchLineComment(psId, "file1",
        uuid1, range1, range1.getEndLine(), otherUser, null, time1, message1,
        (short) 0, "abcd1234abcd1234abcd1234abcd1234abcd1234");
    update.setPatchSetId(psId);
    update.upsertComment(comment1);
    update.commit();

    update = newUpdate(c, otherUser);
    CommentRange range2 = new CommentRange(2, 1, 3, 1);
    PatchLineComment comment2 = newPublishedPatchLineComment(psId, "file1",
        uuid2, range2, range2.getEndLine(), otherUser, null, time2, message2,
        (short) 0, "abcd1234abcd1234abcd1234abcd1234abcd1234");
    update.setPatchSetId(psId);
    update.upsertComment(comment2);
    update.commit();

    ChangeNotes notes = newNotes(c);

    try (RevWalk walk = new RevWalk(repo)) {
      ArrayList<Note> notesInTree =
          Lists.newArrayList(notes.getNoteMap().iterator());
      Note note = Iterables.getOnlyElement(notesInTree);

      byte[] bytes =
          walk.getObjectReader().open(
              note.getData(), Constants.OBJ_BLOB).getBytes();
      String noteString = new String(bytes, UTF_8);
      assertEquals("Base-for-patch-set: 1\n"
          + "Revision: abcd1234abcd1234abcd1234abcd1234abcd1234\n"
          + "File: file1\n"
          + "\n"
          + "1:1-2:1\n"
          + CommentsInNotesUtil.formatTime(serverIdent, time1) + "\n"
          + "Author: Other Account <2@gerrit>\n"
          + "UUID: uuid1\n"
          + "Bytes: 9\n"
          + "comment 1\n"
          + "\n"
          + "2:1-3:1\n"
          + CommentsInNotesUtil.formatTime(serverIdent, time2) + "\n"
          + "Author: Other Account <2@gerrit>\n"
          + "UUID: uuid2\n"
          + "Bytes: 9\n"
          + "comment 2\n"
          + "\n",
          noteString);
    }
  }

  @Test
  public void patchLineCommentMultipleOnePatchsetOneFileBothSides()
      throws Exception {
    Change c = newChange();
    ChangeUpdate update = newUpdate(c, otherUser);
    String uuid1 = "uuid1";
    String uuid2 = "uuid2";
    String messageForBase = "comment for base";
    String messageForPS = "comment for ps";
    CommentRange range = new CommentRange(1, 1, 2, 1);
    Timestamp now = TimeUtil.nowTs();
    PatchSet.Id psId = c.currentPatchSetId();

    PatchLineComment commentForBase =
        newPublishedPatchLineComment(psId, "filename", uuid1,
        range, range.getEndLine(), otherUser, null, now, messageForBase,
        (short) 0, "abcd1234abcd1234abcd1234abcd1234abcd1234");
    update.setPatchSetId(psId);
    update.upsertComment(commentForBase);
    update.commit();

    update = newUpdate(c, otherUser);
    PatchLineComment commentForPS =
        newPublishedPatchLineComment(psId, "filename", uuid2,
        range, range.getEndLine(), otherUser, null, now, messageForPS,
        (short) 1, "abcd4567abcd4567abcd4567abcd4567abcd4567");
    update.setPatchSetId(psId);
    update.upsertComment(commentForPS);
    update.commit();

    ChangeNotes notes = newNotes(c);
    Multimap<PatchSet.Id, PatchLineComment> commentsForBase =
        notes.getBaseComments();
    Multimap<PatchSet.Id, PatchLineComment> commentsForPS =
        notes.getPatchSetComments();
    assertEquals(commentsForBase.size(), 1);
    assertEquals(commentsForPS.size(), 1);

    assertEquals(commentForBase,
        Iterables.getOnlyElement(commentsForBase.get(psId)));
    assertEquals(commentForPS,
        Iterables.getOnlyElement(commentsForPS.get(psId)));
  }

  @Test
  public void patchLineCommentMultipleOnePatchsetOneFile() throws Exception {
    Change c = newChange();
    String uuid1 = "uuid1";
    String uuid2 = "uuid2";
    CommentRange range = new CommentRange(1, 1, 2, 1);
    PatchSet.Id psId = c.currentPatchSetId();
    String filename = "filename";
    short side = (short) 1;

    ChangeUpdate update = newUpdate(c, otherUser);
    Timestamp timeForComment1 = TimeUtil.nowTs();
    Timestamp timeForComment2 = TimeUtil.nowTs();
    PatchLineComment comment1 = newPublishedPatchLineComment(psId, filename,
        uuid1, range, range.getEndLine(), otherUser, null, timeForComment1,
        "comment 1", side, "abcd1234abcd1234abcd1234abcd1234abcd1234");
    update.setPatchSetId(psId);
    update.upsertComment(comment1);
    update.commit();

    update = newUpdate(c, otherUser);
    PatchLineComment comment2 = newPublishedPatchLineComment(psId, filename,
        uuid2, range, range.getEndLine(), otherUser, null, timeForComment2,
        "comment 2", side, "abcd1234abcd1234abcd1234abcd1234abcd1234");
    update.setPatchSetId(psId);
    update.upsertComment(comment2);
    update.commit();

    ChangeNotes notes = newNotes(c);
    Multimap<PatchSet.Id, PatchLineComment> commentsForBase =
        notes.getBaseComments();
    Multimap<PatchSet.Id, PatchLineComment> commentsForPS =
        notes.getPatchSetComments();
    assertEquals(commentsForBase.size(), 0);
    assertEquals(commentsForPS.size(), 2);

    ImmutableList<PatchLineComment> commentsForThisPS =
        (ImmutableList<PatchLineComment>) commentsForPS.get(psId);
    assertEquals(commentsForThisPS.size(), 2);
    PatchLineComment commentFromNotes1 = commentsForThisPS.get(0);
    PatchLineComment commentFromNotes2 = commentsForThisPS.get(1);

    assertEquals(comment1, commentFromNotes1);
    assertEquals(comment2, commentFromNotes2);
  }

  @Test
  public void patchLineCommentMultipleOnePatchsetMultipleFiles()
      throws Exception {
    Change c = newChange();
    String uuid = "uuid";
    CommentRange range = new CommentRange(1, 1, 2, 1);
    PatchSet.Id psId = c.currentPatchSetId();
    String filename1 = "filename1";
    String filename2 = "filename2";
    short side = (short) 1;

    ChangeUpdate update = newUpdate(c, otherUser);
    Timestamp now = TimeUtil.nowTs();
    PatchLineComment comment1 = newPublishedPatchLineComment(psId, filename1,
        uuid, range, range.getEndLine(), otherUser, null, now, "comment 1",
        side, "abcd1234abcd1234abcd1234abcd1234abcd1234");
    update.setPatchSetId(psId);
    update.upsertComment(comment1);
    update.commit();

    update = newUpdate(c, otherUser);
    PatchLineComment comment2 = newPublishedPatchLineComment(psId, filename2,
        uuid, range, range.getEndLine(), otherUser, null, now, "comment 2",
        side, "abcd1234abcd1234abcd1234abcd1234abcd1234");
    update.setPatchSetId(psId);
    update.upsertComment(comment2);
    update.commit();

    ChangeNotes notes = newNotes(c);
    Multimap<PatchSet.Id, PatchLineComment> commentsForBase =
        notes.getBaseComments();
    Multimap<PatchSet.Id, PatchLineComment> commentsForPS =
        notes.getPatchSetComments();
    assertEquals(commentsForBase.size(), 0);
    assertEquals(commentsForPS.size(), 2);

    ImmutableList<PatchLineComment> commentsForThisPS =
        (ImmutableList<PatchLineComment>) commentsForPS.get(psId);
    assertEquals(commentsForThisPS.size(), 2);
    PatchLineComment commentFromNotes1 = commentsForThisPS.get(0);
    PatchLineComment commentFromNotes2 = commentsForThisPS.get(1);

    assertEquals(comment1, commentFromNotes1);
    assertEquals(comment2, commentFromNotes2);
  }

  @Test
  public void patchLineCommentMultiplePatchsets() throws Exception {
    Change c = newChange();
    String uuid = "uuid";
    CommentRange range = new CommentRange(1, 1, 2, 1);
    PatchSet.Id ps1 = c.currentPatchSetId();
    String filename = "filename1";
    short side = (short) 1;

    ChangeUpdate update = newUpdate(c, otherUser);
    Timestamp now = TimeUtil.nowTs();
    PatchLineComment comment1 = newPublishedPatchLineComment(ps1, filename,
        uuid, range, range.getEndLine(), otherUser, null, now, "comment on ps1",
        side, "abcd1234abcd1234abcd1234abcd1234abcd1234");
    update.setPatchSetId(ps1);
    update.upsertComment(comment1);
    update.commit();

    incrementPatchSet(c);
    PatchSet.Id ps2 = c.currentPatchSetId();

    update = newUpdate(c, otherUser);
    now = TimeUtil.nowTs();
    PatchLineComment comment2 = newPublishedPatchLineComment(ps2, filename,
        uuid, range, range.getEndLine(), otherUser, null, now, "comment on ps2",
        side, "abcd4567abcd4567abcd4567abcd4567abcd4567");
    update.setPatchSetId(ps2);
    update.upsertComment(comment2);
    update.commit();

    ChangeNotes notes = newNotes(c);
    LinkedListMultimap<PatchSet.Id, PatchLineComment> commentsForBase =
        LinkedListMultimap.create(notes.getBaseComments());
    LinkedListMultimap<PatchSet.Id, PatchLineComment> commentsForPS =
        LinkedListMultimap.create(notes.getPatchSetComments());
    assertEquals(commentsForBase.keys().size(), 0);
    assertEquals(commentsForPS.values().size(), 2);

    List<PatchLineComment> commentsForPS1 = commentsForPS.get(ps1);
    assertEquals(commentsForPS1.size(), 1);
    PatchLineComment commentFromPs1 = commentsForPS1.get(0);

    List<PatchLineComment> commentsForPS2 = commentsForPS.get(ps2);
    assertEquals(commentsForPS2.size(), 1);
    PatchLineComment commentFromPs2 = commentsForPS2.get(0);

    assertEquals(comment1, commentFromPs1);
    assertEquals(comment2, commentFromPs2);
  }

  @Test
  public void patchLineCommentSingleDraftToPublished() throws Exception {
    Change c = newChange();
    String uuid = "uuid";
    CommentRange range = new CommentRange(1, 1, 2, 1);
    PatchSet.Id ps1 = c.currentPatchSetId();
    String filename = "filename1";
    short side = (short) 1;

    ChangeUpdate update = newUpdate(c, otherUser);
    Timestamp now = TimeUtil.nowTs();
    PatchLineComment comment1 = newPatchLineComment(ps1, filename, uuid,
        range, range.getEndLine(), otherUser, null, now, "comment on ps1", side,
        "abcd4567abcd4567abcd4567abcd4567abcd4567", Status.DRAFT);
    update.setPatchSetId(ps1);
    update.insertComment(comment1);
    update.commit();

    ChangeNotes notes = newNotes(c);
    assertEquals(1, notes.getDraftPsComments(otherUserId).values().size());
    assertEquals(0, notes.getDraftBaseComments(otherUserId).values().size());

    comment1.setStatus(Status.PUBLISHED);
    update = newUpdate(c, otherUser);
    update.setPatchSetId(ps1);
    update.updateComment(comment1);
    update.commit();

    notes = newNotes(c);

    assertTrue(notes.getDraftPsComments(otherUserId).values().isEmpty());
    assertTrue(notes.getDraftBaseComments(otherUserId).values().isEmpty());

    assertTrue(notes.getBaseComments().values().isEmpty());
    PatchLineComment commentFromNotes =
        Iterables.getOnlyElement(notes.getPatchSetComments().values());
    assertEquals(comment1, commentFromNotes);
  }

  @Test
  public void patchLineCommentMultipleDraftsSameSidePublishOne()
      throws OrmException, IOException {
    Change c = newChange();
    String uuid1 = "uuid1";
    String uuid2 = "uuid2";
    CommentRange range1 = new CommentRange(1, 1, 2, 2);
    CommentRange range2 = new CommentRange(2, 2, 3, 3);
    String filename = "filename1";
    short side = (short) 1;
    Timestamp now = TimeUtil.nowTs();
    String commitSHA1 = "abcd4567abcd4567abcd4567abcd4567abcd4567";
    PatchSet.Id psId = c.currentPatchSetId();

    // Write two drafts on the same side of one patch set.
    ChangeUpdate update = newUpdate(c, otherUser);
    update.setPatchSetId(psId);
    PatchLineComment comment1 = newPatchLineComment(psId, filename, uuid1,
        range1, range1.getEndLine(), otherUser, null, now, "comment on ps1",
        side, commitSHA1, Status.DRAFT);
    PatchLineComment comment2 = newPatchLineComment(psId, filename, uuid2,
        range2, range2.getEndLine(), otherUser, null, now, "other on ps1",
        side, commitSHA1, Status.DRAFT);
    update.insertComment(comment1);
    update.insertComment(comment2);
    update.commit();

    ChangeNotes notes = newNotes(c);
    assertTrue(notes.getDraftBaseComments(otherUserId).values().isEmpty());
    assertEquals(2, notes.getDraftPsComments(otherUserId).values().size());

    assertTrue(notes.getDraftPsComments(otherUserId).containsValue(comment1));
    assertTrue(notes.getDraftPsComments(otherUserId).containsValue(comment2));

    // Publish first draft.
    update = newUpdate(c, otherUser);
    update.setPatchSetId(psId);
    comment1.setStatus(Status.PUBLISHED);
    update.updateComment(comment1);
    update.commit();

    notes = newNotes(c);
    assertEquals(comment1,
        Iterables.getOnlyElement(notes.getPatchSetComments().get(psId)));
    assertEquals(comment2,
        Iterables.getOnlyElement(
            notes.getDraftPsComments(otherUserId).values()));

    assertTrue(notes.getBaseComments().values().isEmpty());
    assertTrue(notes.getDraftBaseComments(otherUserId).values().isEmpty());
  }

  @Test
  public void patchLineCommentsMultipleDraftsBothSidesPublishAll()
      throws OrmException, IOException {
    Change c = newChange();
    String uuid1 = "uuid1";
    String uuid2 = "uuid2";
    CommentRange range1 = new CommentRange(1, 1, 2, 2);
    CommentRange range2 = new CommentRange(2, 2, 3, 3);
    String filename = "filename1";
    Timestamp now = TimeUtil.nowTs();
    String commitSHA1 = "abcd4567abcd4567abcd4567abcd4567abcd4567";
    String baseSHA1 = "abcd1234abcd1234abcd1234abcd1234abcd1234";
    PatchSet.Id psId = c.currentPatchSetId();

    // Write two drafts, one on each side of the patchset.
    ChangeUpdate update = newUpdate(c, otherUser);
    update.setPatchSetId(psId);
    PatchLineComment baseComment = newPatchLineComment(psId, filename, uuid1,
        range1, range1.getEndLine(), otherUser, null, now, "comment on base",
        (short) 0, baseSHA1, Status.DRAFT);
    PatchLineComment psComment = newPatchLineComment(psId, filename, uuid2,
        range2, range2.getEndLine(), otherUser, null, now, "comment on ps",
        (short) 1, commitSHA1, Status.DRAFT);

    update.insertComment(baseComment);
    update.insertComment(psComment);
    update.commit();

    ChangeNotes notes = newNotes(c);
    PatchLineComment baseDraftCommentFromNotes =
        Iterables.getOnlyElement(
            notes.getDraftBaseComments(otherUserId).values());
    PatchLineComment psDraftCommentFromNotes =
        Iterables.getOnlyElement(
            notes.getDraftPsComments(otherUserId).values());

    assertEquals(baseComment, baseDraftCommentFromNotes);
    assertEquals(psComment, psDraftCommentFromNotes);

    // Publish both comments.
    update = newUpdate(c, otherUser);
    update.setPatchSetId(psId);

    baseComment.setStatus(Status.PUBLISHED);
    psComment.setStatus(Status.PUBLISHED);
    update.updateComment(baseComment);
    update.updateComment(psComment);
    update.commit();

    notes = newNotes(c);

    PatchLineComment baseCommentFromNotes =
        Iterables.getOnlyElement(notes.getBaseComments().values());
    PatchLineComment psCommentFromNotes =
        Iterables.getOnlyElement(notes.getPatchSetComments().values());

    assertEquals(baseComment, baseCommentFromNotes);
    assertEquals(psComment, psCommentFromNotes);

    assertTrue(notes.getDraftBaseComments(otherUserId).values().isEmpty());
    assertTrue(notes.getDraftPsComments(otherUserId).values().isEmpty());
  }

  @Test
  public void fileComment() throws Exception {
    Change c = newChange();
    ChangeUpdate update = newUpdate(c, otherUser);
    String uuid = "uuid";
    String messageForBase = "comment for base";
    Timestamp now = TimeUtil.nowTs();
    PatchSet.Id psId = c.currentPatchSetId();

    PatchLineComment commentForBase =
        newPublishedPatchLineComment(psId, "filename", uuid,
        null, 0, otherUser, null, now, messageForBase,
        (short) 0, "abcd1234abcd1234abcd1234abcd1234abcd1234");
    update.setPatchSetId(psId);
    update.upsertComment(commentForBase);
    update.commit();

    ChangeNotes notes = newNotes(c);
    Multimap<PatchSet.Id, PatchLineComment> commentsForBase =
        notes.getBaseComments();
    Multimap<PatchSet.Id, PatchLineComment> commentsForPs =
        notes.getPatchSetComments();

    assertTrue(commentsForPs.isEmpty());
    assertEquals(commentForBase,
        Iterables.getOnlyElement(commentsForBase.get(psId)));
  }

  @Test
  public void patchLineCommentNoRange() throws Exception {
    Change c = newChange();
    ChangeUpdate update = newUpdate(c, otherUser);
    String uuid = "uuid";
    String messageForBase = "comment for base";
    Timestamp now = TimeUtil.nowTs();
    PatchSet.Id psId = c.currentPatchSetId();

    PatchLineComment commentForBase =
        newPublishedPatchLineComment(psId, "filename", uuid,
        null, 1, otherUser, null, now, messageForBase,
        (short) 0, "abcd1234abcd1234abcd1234abcd1234abcd1234");
    update.setPatchSetId(psId);
    update.upsertComment(commentForBase);
    update.commit();

    ChangeNotes notes = newNotes(c);
    Multimap<PatchSet.Id, PatchLineComment> commentsForBase =
        notes.getBaseComments();
    Multimap<PatchSet.Id, PatchLineComment> commentsForPs =
        notes.getPatchSetComments();

    assertTrue(commentsForPs.isEmpty());
    assertEquals(commentForBase,
        Iterables.getOnlyElement(commentsForBase.get(psId)));
  }
}