path: root/javatests/com/google/gerrit/server/schema/Schema_166_to_167_WithGroupsInReviewDbTest.java

// Copyright (C) 2018 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.schema;

import static com.google.common.collect.ImmutableList.toImmutableList;
import static com.google.common.truth.Truth.assertThat;
import static com.google.gerrit.extensions.common.testing.CommitInfoSubject.assertThat;
import static com.google.gerrit.server.notedb.NoteDbTable.GROUPS;
import static com.google.gerrit.server.notedb.NotesMigration.DISABLE_REVIEW_DB;
import static com.google.gerrit.server.notedb.NotesMigration.SECTION_NOTE_DB;
import static com.google.gerrit.truth.OptionalSubject.assertThat;

import com.google.common.collect.ImmutableList;
import com.google.gerrit.common.data.GroupReference;
import com.google.gerrit.extensions.api.GerritApi;
import com.google.gerrit.extensions.api.accounts.AccountInput;
import com.google.gerrit.extensions.api.config.ConsistencyCheckInfo;
import com.google.gerrit.extensions.api.groups.GroupInput;
import com.google.gerrit.extensions.common.AccountInfo;
import com.google.gerrit.extensions.common.CommitInfo;
import com.google.gerrit.extensions.common.GroupAuditEventInfo;
import com.google.gerrit.extensions.common.GroupAuditEventInfo.GroupMemberAuditEventInfo;
import com.google.gerrit.extensions.common.GroupAuditEventInfo.Type;
import com.google.gerrit.extensions.common.GroupAuditEventInfo.UserMemberAuditEventInfo;
import com.google.gerrit.extensions.common.GroupInfo;
import com.google.gerrit.extensions.common.GroupOptionsInfo;
import com.google.gerrit.extensions.registration.DynamicSet;
import com.google.gerrit.extensions.restapi.IdString;
import com.google.gerrit.extensions.restapi.RestApiException;
import com.google.gerrit.reviewdb.client.Account;
import com.google.gerrit.reviewdb.client.AccountGroup;
import com.google.gerrit.reviewdb.client.RefNames;
import com.google.gerrit.reviewdb.server.ReviewDb;
import com.google.gerrit.reviewdb.server.ReviewDbWrapper;
import com.google.gerrit.server.GerritPersonIdent;
import com.google.gerrit.server.IdentifiedUser;
import com.google.gerrit.server.Sequences;
import com.google.gerrit.server.account.GroupBackend;
import com.google.gerrit.server.account.GroupUUID;
import com.google.gerrit.server.config.AllUsersName;
import com.google.gerrit.server.config.GerritServerId;
import com.google.gerrit.server.config.GerritServerIdProvider;
import com.google.gerrit.server.git.CommitUtil;
import com.google.gerrit.server.git.GitRepositoryManager;
import com.google.gerrit.server.group.InternalGroup;
import com.google.gerrit.server.group.SystemGroupBackend;
import com.google.gerrit.server.group.db.GroupConfig;
import com.google.gerrit.server.group.db.GroupNameNotes;
import com.google.gerrit.server.group.db.GroupsConsistencyChecker;
import com.google.gerrit.server.group.testing.InternalGroupSubject;
import com.google.gerrit.server.group.testing.TestGroupBackend;
import com.google.gerrit.server.util.time.TimeUtil;
import com.google.gerrit.testing.InMemoryTestEnvironment;
import com.google.gerrit.testing.TestTimeUtil;
import com.google.gerrit.testing.TestTimeUtil.TempClockStep;
import com.google.gerrit.testing.TestUpdateUI;
import com.google.gerrit.truth.OptionalSubject;
import com.google.gwtorm.jdbc.JdbcSchema;
import com.google.gwtorm.server.OrmException;
import com.google.inject.Inject;
import java.io.IOException;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.Timestamp;
import java.time.LocalDate;
import java.time.Month;
import java.time.ZoneOffset;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
import org.eclipse.jgit.errors.ConfigInvalidException;
import org.eclipse.jgit.lib.Config;
import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevSort;
import org.eclipse.jgit.revwalk.RevWalk;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;

public class Schema_166_to_167_WithGroupsInReviewDbTest {
  private static Config createConfig() {
    Config config = new Config();
    config.setString(GerritServerIdProvider.SECTION, null, GerritServerIdProvider.KEY, "1234567");

    // Enable groups in ReviewDb. This means the primary storage for groups is ReviewDb.
    config.setBoolean(SECTION_NOTE_DB, GROUPS.key(), DISABLE_REVIEW_DB, false);

    return config;
  }

  @Rule
  public InMemoryTestEnvironment testEnv =
      new InMemoryTestEnvironment(Schema_166_to_167_WithGroupsInReviewDbTest::createConfig);

  @Inject private GerritApi gApi;
  @Inject private Schema_167 schema167;
  @Inject private ReviewDb db;
  @Inject private GitRepositoryManager gitRepoManager;
  @Inject private AllUsersName allUsersName;
  @Inject private GroupsConsistencyChecker consistencyChecker;
  @Inject private IdentifiedUser currentUser;
  @Inject private @GerritServerId String serverId;
  @Inject private @GerritPersonIdent PersonIdent serverIdent;
  @Inject private GroupBundle.Factory groupBundleFactory;
  @Inject private GroupBackend groupBackend;
  @Inject private DynamicSet<GroupBackend> backends;
  @Inject private Sequences seq;

  private JdbcSchema jdbcSchema;

  @Before
  public void initDb() throws Exception {
    jdbcSchema = ReviewDbWrapper.unwrapJbdcSchema(db);

    try (Statement stmt = jdbcSchema.getConnection().createStatement()) {
      stmt.execute(
          "CREATE TABLE account_groups ("
              + " group_uuid varchar(255) DEFAULT '' NOT NULL,"
              + " group_id INTEGER DEFAULT 0 NOT NULL,"
              + " name varchar(255) DEFAULT '' NOT NULL,"
              + " created_on TIMESTAMP,"
              + " description CLOB,"
              + " owner_group_uuid varchar(255) DEFAULT '' NOT NULL,"
              + " visible_to_all CHAR(1) DEFAULT 'N' NOT NULL"
              + ")");

      stmt.execute(
          "CREATE TABLE account_group_members ("
              + " group_id INTEGER DEFAULT 0 NOT NULL,"
              + " account_id INTEGER DEFAULT 0 NOT NULL"
              + ")");

      stmt.execute(
          "CREATE TABLE account_group_members_audit ("
              + " group_id INTEGER DEFAULT 0 NOT NULL,"
              + " account_id INTEGER DEFAULT 0 NOT NULL,"
              + " added_by INTEGER DEFAULT 0 NOT NULL,"
              + " added_on TIMESTAMP,"
              + " removed_by INTEGER,"
              + " removed_on TIMESTAMP"
              + ")");

      stmt.execute(
          "CREATE TABLE account_group_by_id ("
              + " group_id INTEGER DEFAULT 0 NOT NULL,"
              + " include_uuid VARCHAR(255) DEFAULT '' NOT NULL"
              + ")");

      stmt.execute(
          "CREATE TABLE account_group_by_id_aud ("
              + " group_id INTEGER DEFAULT 0 NOT NULL,"
              + " include_uuid VARCHAR(255) DEFAULT '' NOT NULL,"
              + " added_by INTEGER DEFAULT 0 NOT NULL,"
              + " added_on TIMESTAMP,"
              + " removed_by INTEGER,"
              + " removed_on TIMESTAMP"
              + ")");
    }
  }

  @Before
  public void setTimeForTesting() {
    TestTimeUtil.resetWithClockStep(1, TimeUnit.SECONDS);
  }

  @After
  public void resetTime() {
    TestTimeUtil.useSystemTime();
  }

  @Test
  public void reviewDbOnlyGroupsAreMigratedToNoteDb() throws Exception {
    // Create groups only in ReviewDb
    AccountGroup group1 = newGroup().setName("verifiers").build();
    AccountGroup group2 = newGroup().setName("contributors").build();
    storeInReviewDb(group1, group2);

    executeSchemaMigration(schema167, group1, group2);

    ImmutableList<GroupReference> groups = getAllGroupsFromNoteDb();
    ImmutableList<String> groupNames =
        groups.stream().map(GroupReference::getName).collect(toImmutableList());
    assertThat(groupNames).containsAllOf("verifiers", "contributors");
  }

  @Test
  public void alreadyExistingGroupsAreMigratedToNoteDb() throws Exception {
    // Create group in NoteDb and ReviewDb
    GroupInput groupInput = new GroupInput();
    groupInput.name = "verifiers";
    groupInput.description = "old";
    GroupInfo group1 = gApi.groups().create(groupInput).get();
    storeInReviewDb(group1);

    // Update group only in ReviewDb
    AccountGroup group1InReviewDb = getFromReviewDb(new AccountGroup.Id(group1.groupId));
    group1InReviewDb.setDescription("new");
    updateInReviewDb(group1InReviewDb);

    // Create a second group in NoteDb and ReviewDb
    GroupInfo group2 = gApi.groups().create("contributors").get();
    storeInReviewDb(group2);

    executeSchemaMigration(schema167, group1, group2);

    // Verify that both groups are present in NoteDb
    ImmutableList<GroupReference> groups = getAllGroupsFromNoteDb();
    ImmutableList<String> groupNames =
        groups.stream().map(GroupReference::getName).collect(toImmutableList());
    assertThat(groupNames).containsAllOf("verifiers", "contributors");

    // Verify that group1 has the description from ReviewDb
    Optional<InternalGroup> group1InNoteDb = getGroupFromNoteDb(new AccountGroup.UUID(group1.id));
    assertThatGroup(group1InNoteDb).value().description().isEqualTo("new");
  }

  @Test
  public void adminGroupIsMigratedToNoteDb() throws Exception {
    // Administrators group is automatically created for all Gerrit servers (NoteDb only).
    GroupInfo adminGroup = gApi.groups().id("Administrators").get();
    storeInReviewDb(adminGroup);

    executeSchemaMigration(schema167, adminGroup);

    ImmutableList<GroupReference> groups = getAllGroupsFromNoteDb();
    ImmutableList<String> groupNames =
        groups.stream().map(GroupReference::getName).collect(toImmutableList());
    assertThat(groupNames).contains("Administrators");
  }

  @Test
  public void nonInteractiveUsersGroupIsMigratedToNoteDb() throws Exception {
    // 'Non-Interactive Users' group is automatically created for all Gerrit servers (NoteDb only).
    GroupInfo nonInteractiveUsersGroup = gApi.groups().id("Non-Interactive Users").get();
    storeInReviewDb(nonInteractiveUsersGroup);

    executeSchemaMigration(schema167, nonInteractiveUsersGroup);

    ImmutableList<GroupReference> groups = getAllGroupsFromNoteDb();
    ImmutableList<String> groupNames =
        groups.stream().map(GroupReference::getName).collect(toImmutableList());
    assertThat(groupNames).contains("Non-Interactive Users");
  }

  @Test
  public void groupsAreConsistentAfterMigrationToNoteDb() throws Exception {
    // Administrators group are automatically created for all Gerrit servers (NoteDb only).
    GroupInfo adminGroup = gApi.groups().id("Administrators").get();
    GroupInfo nonInteractiveUsersGroup = gApi.groups().id("Non-Interactive Users").get();
    storeInReviewDb(adminGroup, nonInteractiveUsersGroup);

    AccountGroup group1 = newGroup().setName("verifiers").build();
    AccountGroup group2 = newGroup().setName("contributors").build();
    storeInReviewDb(group1, group2);

    executeSchemaMigration(schema167, group1, group2);

    List<ConsistencyCheckInfo.ConsistencyProblemInfo> consistencyProblems =
        consistencyChecker.check();
    assertThat(consistencyProblems).isEmpty();
  }

  @Test
  public void nameIsKeptDuringMigrationToNoteDb() throws Exception {
    AccountGroup group = newGroup().setName("verifiers").build();
    storeInReviewDb(group);

    executeSchemaMigration(schema167, group);

    Optional<InternalGroup> groupInNoteDb = getGroupFromNoteDb(group.getGroupUUID());
    assertThatGroup(groupInNoteDb).value().name().isEqualTo("verifiers");
  }

  @Test
  public void emptyNameIsKeptDuringMigrationToNoteDb() throws Exception {
    AccountGroup group = newGroup().setName("").build();
    storeInReviewDb(group);

    executeSchemaMigration(schema167, group);

    Optional<InternalGroup> groupInNoteDb = getGroupFromNoteDb(group.getGroupUUID());
    assertThatGroup(groupInNoteDb).value().name().isEqualTo("");
  }

  @Test
  public void uuidIsKeptDuringMigrationToNoteDb() throws Exception {
    AccountGroup.UUID groupUuid = new AccountGroup.UUID("ABCDEF");
    AccountGroup group = newGroup().setGroupUuid(groupUuid).build();
    storeInReviewDb(group);

    executeSchemaMigration(schema167, group);

    Optional<InternalGroup> groupInNoteDb = getGroupFromNoteDb(groupUuid);
    assertThatGroup(groupInNoteDb).value().groupUuid().isEqualTo(groupUuid);
  }

  @Test
  public void idIsKeptDuringMigrationToNoteDb() throws Exception {
    AccountGroup.Id id = new AccountGroup.Id(12345);
    AccountGroup group = newGroup().setId(id).build();
    storeInReviewDb(group);

    executeSchemaMigration(schema167, group);

    Optional<InternalGroup> groupInNoteDb = getGroupFromNoteDb(group.getGroupUUID());
    assertThatGroup(groupInNoteDb).value().id().isEqualTo(id);
  }

  @Test
  public void createdOnIsKeptDuringMigrationToNoteDb() throws Exception {
    Timestamp createdOn =
        Timestamp.from(
            LocalDate.of(2018, Month.FEBRUARY, 20)
                .atTime(18, 2, 56)
                .atZone(ZoneOffset.UTC)
                .toInstant());
    AccountGroup group = newGroup().setCreatedOn(createdOn).build();
    storeInReviewDb(group);

    executeSchemaMigration(schema167, group);

    Optional<InternalGroup> groupInNoteDb = getGroupFromNoteDb(group.getGroupUUID());
    assertThatGroup(groupInNoteDb).value().createdOn().isEqualTo(createdOn);
  }

  @Test
  public void ownerUuidIsKeptDuringMigrationToNoteDb() throws Exception {
    AccountGroup.UUID ownerGroupUuid = new AccountGroup.UUID("UVWXYZ");
    AccountGroup group = newGroup().setOwnerGroupUuid(ownerGroupUuid).build();
    storeInReviewDb(group);

    executeSchemaMigration(schema167, group);

    Optional<InternalGroup> groupInNoteDb = getGroupFromNoteDb(group.getGroupUUID());
    assertThatGroup(groupInNoteDb).value().ownerGroupUuid().isEqualTo(ownerGroupUuid);
  }

  @Test
  public void descriptionIsKeptDuringMigrationToNoteDb() throws Exception {
    AccountGroup group = newGroup().setDescription("A test group").build();
    storeInReviewDb(group);

    executeSchemaMigration(schema167, group);

    Optional<InternalGroup> groupInNoteDb = getGroupFromNoteDb(group.getGroupUUID());
    assertThatGroup(groupInNoteDb).value().description().isEqualTo("A test group");
  }

  @Test
  public void absentDescriptionIsKeptDuringMigrationToNoteDb() throws Exception {
    AccountGroup group = newGroup().build();
    storeInReviewDb(group);

    executeSchemaMigration(schema167, group);

    Optional<InternalGroup> groupInNoteDb = getGroupFromNoteDb(group.getGroupUUID());
    assertThatGroup(groupInNoteDb).value().description().isNull();
  }

  @Test
  public void visibleToAllIsKeptDuringMigrationToNoteDb() throws Exception {
    AccountGroup group = newGroup().setVisibleToAll(true).build();
    storeInReviewDb(group);

    executeSchemaMigration(schema167, group);

    Optional<InternalGroup> groupInNoteDb = getGroupFromNoteDb(group.getGroupUUID());
    assertThatGroup(groupInNoteDb).value().visibleToAll().isTrue();
  }

  @Test
  public void membersAreKeptDuringMigrationToNoteDb() throws Exception {
    AccountGroup group = newGroup().build();
    storeInReviewDb(group);
    Account.Id member1 = new Account.Id(23456);
    Account.Id member2 = new Account.Id(93483);
    addMembersInReviewDb(group.getId(), member1, member2);

    executeSchemaMigration(schema167, group);

    Optional<InternalGroup> groupInNoteDb = getGroupFromNoteDb(group.getGroupUUID());
    assertThatGroup(groupInNoteDb).value().members().containsExactly(member1, member2);
  }

  @Test
  public void subgroupsAreKeptDuringMigrationToNoteDb() throws Exception {
    AccountGroup group = newGroup().build();
    storeInReviewDb(group);
    AccountGroup.UUID subgroup1 = new AccountGroup.UUID("FGHIKL");
    AccountGroup.UUID subgroup2 = new AccountGroup.UUID("MNOPQR");
    addSubgroupsInReviewDb(group.getId(), subgroup1, subgroup2);

    executeSchemaMigration(schema167, group);

    Optional<InternalGroup> groupInNoteDb = getGroupFromNoteDb(group.getGroupUUID());
    assertThatGroup(groupInNoteDb).value().subgroups().containsExactly(subgroup1, subgroup2);
  }

  @Test
  public void logFormatWithAccountsAndGerritGroups() throws Exception {
    AccountInfo user1 = createAccount("user1");
    AccountInfo user2 = createAccount("user2");

    AccountGroup group1 = createInReviewDb("group1");
    AccountGroup group2 = createInReviewDb("group2");
    AccountGroup group3 = createInReviewDb("group3");

    // Add some accounts
    try (TempClockStep step = TestTimeUtil.freezeClock()) {
      addMembersInReviewDb(
          group1.getId(), new Account.Id(user1._accountId), new Account.Id(user2._accountId));
    }
    TimeUtil.nowTs();

    // Add some Gerrit groups
    try (TempClockStep step = TestTimeUtil.freezeClock()) {
      addSubgroupsInReviewDb(group1.getId(), group2.getGroupUUID(), group3.getGroupUUID());
    }

    executeSchemaMigration(schema167, group1, group2, group3);

    GroupBundle noteDbBundle = readGroupBundleFromNoteDb(group1.getGroupUUID());

    ImmutableList<CommitInfo> log = log(group1);
    assertThat(log).hasSize(4);

    // Verify commit that created the group
    assertThat(log.get(0)).message().isEqualTo("Create group");
    assertThat(log.get(0)).author().name().isEqualTo(serverIdent.getName());
    assertThat(log.get(0)).author().email().isEqualTo(serverIdent.getEmailAddress());
    assertThat(log.get(0)).author().date().isEqualTo(noteDbBundle.group().getCreatedOn());
    assertThat(log.get(0)).author().tz().isEqualTo(serverIdent.getTimeZoneOffset());
    assertThat(log.get(0)).committer().isEqualTo(log.get(0).author);

    // Verify commit that the group creator as member
    assertThat(log.get(1))
        .message()
        .isEqualTo(
            "Update group\n\nAdd: "
                + currentUser.getName()
                + " <"
                + currentUser.getAccountId()
                + "@"
                + serverId
                + ">");
    assertThat(log.get(1)).author().name().isEqualTo(currentUser.getName());
    assertThat(log.get(1)).author().email().isEqualTo(currentUser.getAccountId() + "@" + serverId);
    assertThat(log.get(1)).committer().hasSameDateAs(log.get(1).author);

    // Verify commit that added members
    assertThat(log.get(2))
        .message()
        .isEqualTo(
            "Update group\n"
                + "\n"
                + ("Add: user1 <" + user1._accountId + "@" + serverId + ">\n")
                + ("Add: user2 <" + user2._accountId + "@" + serverId + ">"));
    assertThat(log.get(2)).author().name().isEqualTo(currentUser.getName());
    assertThat(log.get(2)).author().email().isEqualTo(currentUser.getAccountId() + "@" + serverId);
    assertThat(log.get(2)).committer().hasSameDateAs(log.get(2).author);

    // Verify commit that added Gerrit groups
    assertThat(log.get(3))
        .message()
        .isEqualTo(
            "Update group\n"
                + "\n"
                + ("Add-group: " + group2.getName() + " <" + group2.getGroupUUID().get() + ">\n")
                + ("Add-group: " + group3.getName() + " <" + group3.getGroupUUID().get() + ">"));
    assertThat(log.get(3)).author().name().isEqualTo(currentUser.getName());
    assertThat(log.get(3)).author().email().isEqualTo(currentUser.getAccountId() + "@" + serverId);
    assertThat(log.get(3)).committer().hasSameDateAs(log.get(3).author);

    // Verify that audit log is correctly read by Gerrit
    List<? extends GroupAuditEventInfo> auditEvents =
        gApi.groups().id(group1.getGroupUUID().get()).auditLog();
    assertThat(auditEvents).hasSize(5);
    AccountInfo currentUserInfo = gApi.accounts().id(currentUser.getAccountId().get()).get();
    assertMemberAuditEvent(
        auditEvents.get(4), Type.ADD_USER, currentUser.getAccountId(), currentUserInfo);
    assertMemberAuditEvents(
        auditEvents.get(3),
        auditEvents.get(2),
        Type.ADD_USER,
        currentUser.getAccountId(),
        user1,
        user2);
    assertSubgroupAuditEvents(
        auditEvents.get(1),
        auditEvents.get(0),
        Type.ADD_GROUP,
        currentUser.getAccountId(),
        toGroupInfo(group2),
        toGroupInfo(group3));
  }

  @Test
  public void logFormatWithSystemGroups() throws Exception {
    AccountGroup group = createInReviewDb("group");

    try (TempClockStep step = TestTimeUtil.freezeClock()) {
      addSubgroupsInReviewDb(
          group.getId(), SystemGroupBackend.ANONYMOUS_USERS, SystemGroupBackend.REGISTERED_USERS);
    }

    executeSchemaMigration(schema167, group);

    GroupBundle noteDbBundle = readGroupBundleFromNoteDb(group.getGroupUUID());

    ImmutableList<CommitInfo> log = log(group);
    assertThat(log).hasSize(3);

    // Verify commit that created the group
    assertThat(log.get(0)).message().isEqualTo("Create group");
    assertThat(log.get(0)).author().name().isEqualTo(serverIdent.getName());
    assertThat(log.get(0)).author().email().isEqualTo(serverIdent.getEmailAddress());
    assertThat(log.get(0)).author().date().isEqualTo(noteDbBundle.group().getCreatedOn());
    assertThat(log.get(0)).author().tz().isEqualTo(serverIdent.getTimeZoneOffset());
    assertThat(log.get(0)).committer().isEqualTo(log.get(0).author);

    // Verify commit that the group creator as member
    assertThat(log.get(1))
        .message()
        .isEqualTo(
            "Update group\n\nAdd: "
                + currentUser.getName()
                + " <"
                + currentUser.getAccountId()
                + "@"
                + serverId
                + ">");
    assertThat(log.get(1)).author().name().isEqualTo(currentUser.getName());
    assertThat(log.get(1)).author().email().isEqualTo(currentUser.getAccountId() + "@" + serverId);
    assertThat(log.get(1)).committer().hasSameDateAs(log.get(1).author);

    // Verify commit that added system groups
    assertThat(log.get(2))
        .message()
        .isEqualTo(
            "Update group\n"
                + "\n"
                + "Add-group: Anonymous Users <global:Anonymous-Users>\n"
                + "Add-group: Registered Users <global:Registered-Users>");
    assertThat(log.get(2)).author().name().isEqualTo(currentUser.getName());
    assertThat(log.get(2)).author().email().isEqualTo(currentUser.getAccountId() + "@" + serverId);
    assertThat(log.get(2)).committer().hasSameDateAs(log.get(2).author);

    // Verify that audit log is correctly read by Gerrit
    List<? extends GroupAuditEventInfo> auditEvents =
        gApi.groups().id(group.getGroupUUID().get()).auditLog();
    assertThat(auditEvents).hasSize(3);
    AccountInfo currentUserInfo = gApi.accounts().id(currentUser.getAccountId().get()).get();
    assertMemberAuditEvent(
        auditEvents.get(2), Type.ADD_USER, currentUser.getAccountId(), currentUserInfo);
    assertSubgroupAuditEvents(
        auditEvents.get(1),
        auditEvents.get(0),
        Type.ADD_GROUP,
        currentUser.getAccountId(),
        groupInfoForExternalGroup(SystemGroupBackend.ANONYMOUS_USERS),
        groupInfoForExternalGroup(SystemGroupBackend.REGISTERED_USERS));
  }

  @Test
  public void logFormatWithExternalGroup() throws Exception {
    AccountGroup group = createInReviewDb("group");

    TestGroupBackend testGroupBackend = new TestGroupBackend();
    backends.add("gerrit", testGroupBackend);
    AccountGroup.UUID subgroupUuid = testGroupBackend.create("test").getGroupUUID();
    assertThat(groupBackend.handles(subgroupUuid)).isTrue();
    addSubgroupsInReviewDb(group.getId(), subgroupUuid);

    executeSchemaMigration(schema167, group);

    GroupBundle noteDbBundle = readGroupBundleFromNoteDb(group.getGroupUUID());

    ImmutableList<CommitInfo> log = log(group);
    assertThat(log).hasSize(3);

    // Verify commit that created the group
    assertThat(log.get(0)).message().isEqualTo("Create group");
    assertThat(log.get(0)).author().name().isEqualTo(serverIdent.getName());
    assertThat(log.get(0)).author().email().isEqualTo(serverIdent.getEmailAddress());
    assertThat(log.get(0)).author().date().isEqualTo(noteDbBundle.group().getCreatedOn());
    assertThat(log.get(0)).author().tz().isEqualTo(serverIdent.getTimeZoneOffset());
    assertThat(log.get(0)).committer().isEqualTo(log.get(0).author);

    // Verify commit that the group creator as member
    assertThat(log.get(1))
        .message()
        .isEqualTo(
            "Update group\n\nAdd: "
                + currentUser.getName()
                + " <"
                + currentUser.getAccountId()
                + "@"
                + serverId
                + ">");
    assertThat(log.get(1)).author().name().isEqualTo(currentUser.getName());
    assertThat(log.get(1)).author().email().isEqualTo(currentUser.getAccountId() + "@" + serverId);
    assertThat(log.get(1)).committer().hasSameDateAs(log.get(1).author);

    // Verify commit that added system groups
    // Note: The schema migration can only resolve names of Gerrit groups, not of external groups
    // and system groups, hence the UUID shows up in commit messages where we would otherwise
    // expect the group name.
    assertThat(log.get(2))
        .message()
        .isEqualTo(
            "Update group\n"
                + "\n"
                + "Add-group: "
                + subgroupUuid.get()
                + " <"
                + subgroupUuid.get()
                + ">");
    assertThat(log.get(2)).author().name().isEqualTo(currentUser.getName());
    assertThat(log.get(2)).author().email().isEqualTo(currentUser.getAccountId() + "@" + serverId);
    assertThat(log.get(2)).committer().hasSameDateAs(log.get(2).author);

    // Verify that audit log is correctly read by Gerrit
    List<? extends GroupAuditEventInfo> auditEvents =
        gApi.groups().id(group.getGroupUUID().get()).auditLog();
    assertThat(auditEvents).hasSize(2);
    AccountInfo currentUserInfo = gApi.accounts().id(currentUser.getAccountId().get()).get();
    assertMemberAuditEvent(
        auditEvents.get(1), Type.ADD_USER, currentUser.getAccountId(), currentUserInfo);
    assertSubgroupAuditEvent(
        auditEvents.get(0),
        Type.ADD_GROUP,
        currentUser.getAccountId(),
        groupInfoForExternalGroup(subgroupUuid));
  }

  @Test
  public void logFormatWithNonExistingExternalGroup() throws Exception {
    AccountGroup group = createInReviewDb("group");

    AccountGroup.UUID subgroupUuid = new AccountGroup.UUID("notExisting:foo");

    assertThat(groupBackend.handles(subgroupUuid)).isFalse();
    addSubgroupsInReviewDb(group.getId(), subgroupUuid);

    executeSchemaMigration(schema167, group);

    GroupBundle noteDbBundle = readGroupBundleFromNoteDb(group.getGroupUUID());

    ImmutableList<CommitInfo> log = log(group);
    assertThat(log).hasSize(3);

    // Verify commit that created the group
    assertThat(log.get(0)).message().isEqualTo("Create group");
    assertThat(log.get(0)).author().name().isEqualTo(serverIdent.getName());
    assertThat(log.get(0)).author().email().isEqualTo(serverIdent.getEmailAddress());
    assertThat(log.get(0)).author().date().isEqualTo(noteDbBundle.group().getCreatedOn());
    assertThat(log.get(0)).author().tz().isEqualTo(serverIdent.getTimeZoneOffset());
    assertThat(log.get(0)).committer().isEqualTo(log.get(0).author);

    // Verify commit that the group creator as member
    assertThat(log.get(1))
        .message()
        .isEqualTo(
            "Update group\n\nAdd: "
                + currentUser.getName()
                + " <"
                + currentUser.getAccountId()
                + "@"
                + serverId
                + ">");
    assertThat(log.get(1)).author().name().isEqualTo(currentUser.getName());
    assertThat(log.get(1)).author().email().isEqualTo(currentUser.getAccountId() + "@" + serverId);
    assertThat(log.get(1)).committer().hasSameDateAs(log.get(1).author);

    // Verify commit that added system groups
    // Note: The schema migration can only resolve names of Gerrit groups, not of external groups
    // and system groups, hence the UUID shows up in commit messages where we would otherwise
    // expect the group name.
    assertThat(log.get(2))
        .message()
        .isEqualTo("Update group\n" + "\n" + "Add-group: notExisting:foo <notExisting:foo>");
    assertThat(log.get(2)).author().name().isEqualTo(currentUser.getName());
    assertThat(log.get(2)).author().email().isEqualTo(currentUser.getAccountId() + "@" + serverId);
    assertThat(log.get(2)).committer().hasSameDateAs(log.get(2).author);

    // Verify that audit log is correctly read by Gerrit
    List<? extends GroupAuditEventInfo> auditEvents =
        gApi.groups().id(group.getGroupUUID().get()).auditLog();
    assertThat(auditEvents).hasSize(2);
    AccountInfo currentUserInfo = gApi.accounts().id(currentUser.getAccountId().get()).get();
    assertMemberAuditEvent(
        auditEvents.get(1), Type.ADD_USER, currentUser.getAccountId(), currentUserInfo);
    assertSubgroupAuditEvent(
        auditEvents.get(0),
        Type.ADD_GROUP,
        currentUser.getAccountId(),
        groupInfoForExternalGroup(subgroupUuid));
  }

  private static TestGroup.Builder newGroup() {
    return TestGroup.builder();
  }

  private AccountGroup createInReviewDb(String groupName) throws Exception {
    AccountGroup group =
        new AccountGroup(
            new AccountGroup.NameKey(groupName),
            new AccountGroup.Id(seq.nextGroupId()),
            GroupUUID.make(groupName, serverIdent),
            TimeUtil.nowTs());
    storeInReviewDb(group);
    addMembersInReviewDb(group.getId(), currentUser.getAccountId());
    return group;
  }

  private void storeInReviewDb(GroupInfo... groups) throws Exception {
    storeInReviewDb(
        Arrays.stream(groups)
            .map(Schema_166_to_167_WithGroupsInReviewDbTest::toAccountGroup)
            .toArray(AccountGroup[]::new));
  }

  private void storeInReviewDb(AccountGroup... groups) throws Exception {
    try (PreparedStatement stmt =
        jdbcSchema
            .getConnection()
            .prepareStatement(
                "INSERT INTO account_groups"
                    + " (group_uuid,"
                    + " group_id,"
                    + " name,"
                    + " description,"
                    + " created_on,"
                    + " owner_group_uuid,"
                    + " visible_to_all) VALUES (?, ?, ?, ?, ?, ?, ?)")) {
      for (AccountGroup group : groups) {
        stmt.setString(1, group.getGroupUUID().get());
        stmt.setInt(2, group.getId().get());
        stmt.setString(3, group.getName());
        stmt.setString(4, group.getDescription());
        stmt.setTimestamp(5, group.getCreatedOn());
        stmt.setString(6, group.getOwnerGroupUUID().get());
        stmt.setString(7, group.isVisibleToAll() ? "Y" : "N");
        stmt.addBatch();
      }
      stmt.executeBatch();
    }
  }

  private void updateInReviewDb(AccountGroup... groups) throws Exception {
    try (PreparedStatement stmt =
        jdbcSchema
            .getConnection()
            .prepareStatement(
                "UPDATE account_groups SET"
                    + " group_uuid = ?,"
                    + " name = ?,"
                    + " description = ?,"
                    + " created_on = ?,"
                    + " owner_group_uuid = ?,"
                    + " visible_to_all = ?"
                    + " WHERE group_id = ?")) {
      for (AccountGroup group : groups) {
        stmt.setString(1, group.getGroupUUID().get());
        stmt.setString(2, group.getName());
        stmt.setString(3, group.getDescription());
        stmt.setTimestamp(4, group.getCreatedOn());
        stmt.setString(5, group.getOwnerGroupUUID().get());
        stmt.setString(6, group.isVisibleToAll() ? "Y" : "N");
        stmt.setInt(7, group.getId().get());
        stmt.addBatch();
      }
      stmt.executeBatch();
    }
  }

  private AccountGroup getFromReviewDb(AccountGroup.Id groupId) throws Exception {
    try (Statement stmt = jdbcSchema.getConnection().createStatement();
        ResultSet rs =
            stmt.executeQuery(
                "SELECT group_uuid,"
                    + " name,"
                    + " description,"
                    + " created_on,"
                    + " owner_group_uuid,"
                    + " visible_to_all"
                    + " FROM account_groups"
                    + " WHERE group_id = "
                    + groupId.get())) {
      if (!rs.next()) {
        throw new OrmException(String.format("Group %s not found", groupId.get()));
      }

      AccountGroup.UUID groupUuid = new AccountGroup.UUID(rs.getString(1));
      AccountGroup.NameKey groupName = new AccountGroup.NameKey(rs.getString(2));
      String description = rs.getString(3);
      Timestamp createdOn = rs.getTimestamp(4);
      AccountGroup.UUID ownerGroupUuid = new AccountGroup.UUID(rs.getString(5));
      boolean visibleToAll = "Y".equals(rs.getString(6));

      AccountGroup group = new AccountGroup(groupName, groupId, groupUuid, createdOn);
      group.setDescription(description);
      group.setOwnerGroupUUID(ownerGroupUuid);
      group.setVisibleToAll(visibleToAll);

      if (rs.next()) {
        throw new OrmException(String.format("Group ID %s is ambiguous", groupId.get()));
      }

      return group;
    }
  }

  private void addMembersInReviewDb(AccountGroup.Id groupId, Account.Id... memberIds)
      throws Exception {
    try (PreparedStatement addMemberStmt =
            jdbcSchema
                .getConnection()
                .prepareStatement(
                    "INSERT INTO account_group_members"
                        + " (group_id,"
                        + " account_id) VALUES ("
                        + groupId.get()
                        + ", ?)");
        PreparedStatement addMemberAuditStmt =
            jdbcSchema
                .getConnection()
                .prepareStatement(
                    "INSERT INTO account_group_members_audit"
                        + " (group_id,"
                        + " account_id,"
                        + " added_by,"
                        + " added_on) VALUES ("
                        + groupId.get()
                        + ", ?, "
                        + currentUser.getAccountId().get()
                        + ", ?)")) {
      Timestamp addedOn = TimeUtil.nowTs();
      for (Account.Id memberId : memberIds) {
        addMemberStmt.setInt(1, memberId.get());
        addMemberStmt.addBatch();

        addMemberAuditStmt.setInt(1, memberId.get());
        addMemberAuditStmt.setTimestamp(2, addedOn);
        addMemberAuditStmt.addBatch();
      }
      addMemberStmt.executeBatch();
      addMemberAuditStmt.executeBatch();
    }
  }

  private void addSubgroupsInReviewDb(AccountGroup.Id groupId, AccountGroup.UUID... subgroupUuids)
      throws Exception {
    try (PreparedStatement addSubGroupStmt =
            jdbcSchema
                .getConnection()
                .prepareStatement(
                    "INSERT INTO account_group_by_id"
                        + " (group_id,"
                        + " include_uuid) VALUES ("
                        + groupId.get()
                        + ", ?)");
        PreparedStatement addSubGroupAuditStmt =
            jdbcSchema
                .getConnection()
                .prepareStatement(
                    "INSERT INTO account_group_by_id_aud"
                        + " (group_id,"
                        + " include_uuid,"
                        + " added_by,"
                        + " added_on) VALUES ("
                        + groupId.get()
                        + ", ?, "
                        + currentUser.getAccountId().get()
                        + ", ?)")) {
      Timestamp addedOn = TimeUtil.nowTs();
      for (AccountGroup.UUID subgroupUuid : subgroupUuids) {
        addSubGroupStmt.setString(1, subgroupUuid.get());
        addSubGroupStmt.addBatch();

        addSubGroupAuditStmt.setString(1, subgroupUuid.get());
        addSubGroupAuditStmt.setTimestamp(2, addedOn);
        addSubGroupAuditStmt.addBatch();
      }
      addSubGroupStmt.executeBatch();
      addSubGroupAuditStmt.executeBatch();
    }
  }

  private AccountInfo createAccount(String name) throws RestApiException {
    AccountInput accountInput = new AccountInput();
    accountInput.username = name;
    accountInput.name = name;
    return gApi.accounts().create(accountInput).get();
  }

  private GroupBundle readGroupBundleFromNoteDb(AccountGroup.UUID groupUuid) throws Exception {
    try (Repository allUsersRepo = gitRepoManager.openRepository(allUsersName)) {
      return groupBundleFactory.fromNoteDb(allUsersName, allUsersRepo, groupUuid);
    }
  }

  private void executeSchemaMigration(SchemaVersion schema, AccountGroup... groupsToVerify)
      throws Exception {
    executeSchemaMigration(
        schema,
        Arrays.stream(groupsToVerify)
            .map(AccountGroup::getGroupUUID)
            .toArray(AccountGroup.UUID[]::new));
  }

  private void executeSchemaMigration(SchemaVersion schema, GroupInfo... groupsToVerify)
      throws Exception {
    executeSchemaMigration(
        schema,
        Arrays.stream(groupsToVerify)
            .map(i -> new AccountGroup.UUID(i.id))
            .toArray(AccountGroup.UUID[]::new));
  }

  private void executeSchemaMigration(SchemaVersion schema, AccountGroup.UUID... groupsToVerify)
      throws Exception {
    List<GroupBundle> reviewDbBundles = new ArrayList<>();
    for (AccountGroup.UUID groupUuid : groupsToVerify) {
      reviewDbBundles.add(GroupBundle.Factory.fromReviewDb(db, groupUuid));
    }

    schema.migrateData(db, new TestUpdateUI());

    for (GroupBundle reviewDbBundle : reviewDbBundles) {
      assertMigratedCleanly(readGroupBundleFromNoteDb(reviewDbBundle.uuid()), reviewDbBundle);
    }
  }

  private void assertMigratedCleanly(GroupBundle noteDbBundle, GroupBundle expectedReviewDbBundle) {
    assertThat(GroupBundle.compareWithAudits(expectedReviewDbBundle, noteDbBundle)).isEmpty();
  }

  private ImmutableList<CommitInfo> log(AccountGroup group) throws Exception {
    ImmutableList.Builder<CommitInfo> result = ImmutableList.builder();
    List<Date> commitDates = new ArrayList<>();
    try (Repository allUsersRepo = gitRepoManager.openRepository(allUsersName);
        RevWalk rw = new RevWalk(allUsersRepo)) {
      Ref ref = allUsersRepo.exactRef(RefNames.refsGroups(group.getGroupUUID()));
      if (ref != null) {
        rw.sort(RevSort.REVERSE);
        rw.setRetainBody(true);
        rw.markStart(rw.parseCommit(ref.getObjectId()));
        for (RevCommit c : rw) {
          result.add(CommitUtil.toCommitInfo(c));
          commitDates.add(c.getCommitterIdent().getWhen());
        }
      }
    }
    assertThat(commitDates).named("commit timestamps for %s", result).isOrdered();
    return result.build();
  }

  private ImmutableList<GroupReference> getAllGroupsFromNoteDb()
      throws IOException, ConfigInvalidException {
    try (Repository allUsersRepo = gitRepoManager.openRepository(allUsersName)) {
      return GroupNameNotes.loadAllGroups(allUsersRepo);
    }
  }

  private Optional<InternalGroup> getGroupFromNoteDb(AccountGroup.UUID groupUuid) throws Exception {
    try (Repository allUsersRepo = gitRepoManager.openRepository(allUsersName)) {
      return GroupConfig.loadForGroup(allUsersName, allUsersRepo, groupUuid).getLoadedGroup();
    }
  }

  private static OptionalSubject<InternalGroupSubject, InternalGroup> assertThatGroup(
      Optional<InternalGroup> group) {
    return assertThat(group, InternalGroupSubject::assertThat).named("group");
  }

  private void assertMemberAuditEvent(
      GroupAuditEventInfo info,
      Type expectedType,
      Account.Id expectedUser,
      AccountInfo expectedMember) {
    assertThat(info.user._accountId).isEqualTo(expectedUser.get());
    assertThat(info.type).isEqualTo(expectedType);
    assertThat(info).isInstanceOf(UserMemberAuditEventInfo.class);
    assertAccount(((UserMemberAuditEventInfo) info).member, expectedMember);
  }

  private void assertMemberAuditEvents(
      GroupAuditEventInfo info1,
      GroupAuditEventInfo info2,
      Type expectedType,
      Account.Id expectedUser,
      AccountInfo expectedMember1,
      AccountInfo expectedMember2) {
    assertThat(info1).isInstanceOf(UserMemberAuditEventInfo.class);
    assertThat(info2).isInstanceOf(UserMemberAuditEventInfo.class);

    UserMemberAuditEventInfo event1 = (UserMemberAuditEventInfo) info1;
    UserMemberAuditEventInfo event2 = (UserMemberAuditEventInfo) info2;

    assertThat(event1.member._accountId)
        .isAnyOf(expectedMember1._accountId, expectedMember2._accountId);
    assertThat(event2.member._accountId)
        .isAnyOf(expectedMember1._accountId, expectedMember2._accountId);
    assertThat(event1.member._accountId).isNotEqualTo(event2.member._accountId);

    if (event1.member._accountId == expectedMember1._accountId) {
      assertMemberAuditEvent(info1, expectedType, expectedUser, expectedMember1);
      assertMemberAuditEvent(info2, expectedType, expectedUser, expectedMember2);
    } else {
      assertMemberAuditEvent(info1, expectedType, expectedUser, expectedMember2);
      assertMemberAuditEvent(info2, expectedType, expectedUser, expectedMember1);
    }
  }

  private void assertSubgroupAuditEvent(
      GroupAuditEventInfo info,
      Type expectedType,
      Account.Id expectedUser,
      GroupInfo expectedSubGroup) {
    assertThat(info.user._accountId).isEqualTo(expectedUser.get());
    assertThat(info.type).isEqualTo(expectedType);
    assertThat(info).isInstanceOf(GroupMemberAuditEventInfo.class);
    assertGroup(((GroupMemberAuditEventInfo) info).member, expectedSubGroup);
  }

  private void assertSubgroupAuditEvents(
      GroupAuditEventInfo info1,
      GroupAuditEventInfo info2,
      Type expectedType,
      Account.Id expectedUser,
      GroupInfo expectedSubGroup1,
      GroupInfo expectedSubGroup2) {
    assertThat(info1).isInstanceOf(GroupMemberAuditEventInfo.class);
    assertThat(info2).isInstanceOf(GroupMemberAuditEventInfo.class);

    GroupMemberAuditEventInfo event1 = (GroupMemberAuditEventInfo) info1;
    GroupMemberAuditEventInfo event2 = (GroupMemberAuditEventInfo) info2;

    assertThat(event1.member.id).isAnyOf(expectedSubGroup1.id, expectedSubGroup2.id);
    assertThat(event2.member.id).isAnyOf(expectedSubGroup1.id, expectedSubGroup2.id);
    assertThat(event1.member.id).isNotEqualTo(event2.member.id);

    if (event1.member.id.equals(expectedSubGroup1.id)) {
      assertSubgroupAuditEvent(info1, expectedType, expectedUser, expectedSubGroup1);
      assertSubgroupAuditEvent(info2, expectedType, expectedUser, expectedSubGroup2);
    } else {
      assertSubgroupAuditEvent(info1, expectedType, expectedUser, expectedSubGroup2);
      assertSubgroupAuditEvent(info2, expectedType, expectedUser, expectedSubGroup1);
    }
  }

  private void assertAccount(AccountInfo actual, AccountInfo expected) {
    assertThat(actual._accountId).isEqualTo(expected._accountId);
    assertThat(actual.name).isEqualTo(expected.name);
    assertThat(actual.email).isEqualTo(expected.email);
    assertThat(actual.username).isEqualTo(expected.username);
  }

  private void assertGroup(GroupInfo actual, GroupInfo expected) {
    assertThat(actual.id).isEqualTo(expected.id);
    assertThat(actual.name).isEqualTo(expected.name);
    assertThat(actual.groupId).isEqualTo(expected.groupId);
  }

  private GroupInfo groupInfoForExternalGroup(AccountGroup.UUID groupUuid) {
    GroupInfo groupInfo = new GroupInfo();
    groupInfo.id = IdString.fromDecoded(groupUuid.get()).encoded();

    if (groupBackend.handles(groupUuid)) {
      groupInfo.name = groupBackend.get(groupUuid).getName();
    }

    return groupInfo;
  }

  private static AccountGroup toAccountGroup(GroupInfo info) {
    AccountGroup group =
        new AccountGroup(
            new AccountGroup.NameKey(info.name),
            new AccountGroup.Id(info.groupId),
            new AccountGroup.UUID(info.id),
            info.createdOn);
    group.setDescription(info.description);
    if (info.ownerId != null) {
      group.setOwnerGroupUUID(new AccountGroup.UUID(info.ownerId));
    }
    group.setVisibleToAll(
        info.options != null && info.options.visibleToAll != null && info.options.visibleToAll);
    return group;
  }

  private static GroupInfo toGroupInfo(AccountGroup group) {
    GroupInfo groupInfo = new GroupInfo();
    groupInfo.id = group.getGroupUUID().get();
    groupInfo.groupId = group.getId().get();
    groupInfo.name = group.getName();
    groupInfo.createdOn = group.getCreatedOn();
    groupInfo.description = group.getDescription();
    groupInfo.owner = group.getOwnerGroupUUID().get();
    groupInfo.options = new GroupOptionsInfo();
    groupInfo.options.visibleToAll = group.isVisibleToAll() ? true : null;
    return groupInfo;
  }
}