// Copyright (C) 2022 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.acceptance.api.change;

import static com.google.common.truth.Truth.assertThat;
import static com.google.common.truth.Truth.assertWithMessage;
import static com.google.gerrit.acceptance.testsuite.project.TestProjectUpdate.allowLabel;
import static com.google.gerrit.server.group.SystemGroupBackend.ANONYMOUS_USERS;
import static com.google.gerrit.server.group.SystemGroupBackend.REGISTERED_USERS;
import static com.google.gerrit.server.project.testing.TestLabels.codeReview;
import static com.google.gerrit.server.project.testing.TestLabels.label;
import static com.google.gerrit.server.project.testing.TestLabels.value;
import static org.eclipse.jgit.lib.Constants.HEAD;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Iterables;
import com.google.gerrit.acceptance.AbstractDaemonTest;
import com.google.gerrit.acceptance.NoHttpd;
import com.google.gerrit.acceptance.PushOneCommit;
import com.google.gerrit.acceptance.Sandboxed;
import com.google.gerrit.acceptance.TestAccount;
import com.google.gerrit.acceptance.UseTimezone;
import com.google.gerrit.acceptance.VerifyNoPiiInChangeNotes;
import com.google.gerrit.acceptance.testsuite.account.AccountOperations;
import com.google.gerrit.acceptance.testsuite.change.ChangeOperations;
import com.google.gerrit.acceptance.testsuite.change.TestChange;
import com.google.gerrit.acceptance.testsuite.project.ProjectOperations;
import com.google.gerrit.acceptance.testsuite.request.RequestScopeOperations;
import com.google.gerrit.common.Nullable;
import com.google.gerrit.entities.Account;
import com.google.gerrit.entities.AccountGroup;
import com.google.gerrit.entities.Change;
import com.google.gerrit.entities.LabelType;
import com.google.gerrit.entities.Patch;
import com.google.gerrit.entities.Project;
import com.google.gerrit.entities.RefNames;
import com.google.gerrit.entities.SubmitRequirementExpression;
import com.google.gerrit.entities.SubmitRequirementExpressionResult;
import com.google.gerrit.extensions.api.changes.PublishChangeEditInput;
import com.google.gerrit.extensions.api.changes.ReviewInput;
import com.google.gerrit.extensions.common.ChangeInfo;
import com.google.gerrit.extensions.common.CommentInfo;
import com.google.gerrit.extensions.common.FileInfo;
import com.google.gerrit.server.account.ServiceUserClassifier;
import com.google.gerrit.server.project.SubmitRequirementsEvaluatorImpl;
import com.google.gerrit.server.query.change.ChangeData;
import com.google.inject.Inject;
import java.util.Map;
import org.eclipse.jgit.internal.storage.dfs.InMemoryRepository;
import org.eclipse.jgit.junit.TestRepository;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.merge.MergeStrategy;
import org.eclipse.jgit.merge.ThreeWayMerger;
import org.eclipse.jgit.revwalk.RevCommit;
import org.junit.Before;
import org.junit.Test;

@NoHttpd
@UseTimezone(timezone = "US/Eastern")
@VerifyNoPiiInChangeNotes(true)
public class SubmitRequirementPredicateIT extends AbstractDaemonTest {

  @Inject private RequestScopeOperations requestScopeOperations;
  @Inject private SubmitRequirementsEvaluatorImpl submitRequirementsEvaluator;
  @Inject private ChangeOperations changeOperations;
  @Inject private ProjectOperations projectOperations;
  @Inject private AccountOperations accountOperations;

  private final LabelType label =
      label("Custom-Label", value(1, "Positive"), value(0, "No score"), value(-1, "Negative"));

  private final LabelType pLabel =
      label("Custom-Label2", value(1, "Positive"), value(0, "No score"));

  @Before
  public void setUp() throws Exception {
    projectOperations
        .project(project)
        .forUpdate()
        .add(allowLabel(label.getName()).ref("refs/heads/*").group(ANONYMOUS_USERS).range(-1, 1))
        .add(allowLabel(pLabel.getName()).ref("refs/heads/*").group(ANONYMOUS_USERS).range(0, 1))
        .update();
    try (ProjectConfigUpdate u = updateProject(project)) {
      u.getConfig().upsertLabelType(label);
      u.getConfig().upsertLabelType(pLabel);
      u.save();
    }
  }

  @Test
  public void labelVote_greaterThan_withManyMaxVotes() throws Exception {
    TestRepository<InMemoryRepository> clonedRepo = cloneProject(project, admin);
    PushOneCommit.Result r1 =
        pushFactory
            .create(user.newIdent(), clonedRepo, "Subject", "file.txt", "text")
            .to("refs/for/master");

    Account.Id user11 = accountCreator.create("user11").id();
    Account.Id user12 = accountCreator.create("user12").id();
    Account.Id user13 = accountCreator.create("user13").id();
    Account.Id user14 = accountCreator.create("user14").id();
    Account.Id user15 = accountCreator.create("user15").id();
    Account.Id user16 = accountCreator.create("user16").id();
    Account.Id user17 = accountCreator.create("user17").id();
    ImmutableList<Account.Id> allUsers =
        ImmutableList.of(user11, user12, user13, user14, user15, user16, user17);

    // Give voting permissions to all users
    requestScopeOperations.setApiUser(admin.id());
    allowLabelPermission(
        codeReview().getName(), RefNames.REFS_HEADS + "*", REGISTERED_USERS, -2, +2);

    // The predicate uses the MAX_COUNT_INTERNAL in label predicate, and the SR expression matches
    // even if the change has more than 5 votes.
    for (Account.Id aId : allUsers) {
      approveAsUser(r1.getChangeId(), aId);
      assertMatching("label:Code-Review=+2,count>=1", r1.getChange().getId());
    }
  }

  @Test
  public void messagePredicate_ignoresPunctuationPreservesOrder() throws Exception {
    Change.Id c1 =
        changeOperations
            .newChange()
            .commitMessage("Hello Earth, from planet Mars")
            .project(project)
            .createV1();
    // The punctuation and capitalisation is ignored.
    assertMatching("message:\"earth from planet\"", c1);
    // The punctuation and capitalisation is ignored.
    assertNotMatching("message:\"planet from earth\"", c1);
  }

  @Test
  public void distinctVoters_sameUserVotesOnDifferentLabels_fails() throws Exception {
    Change.Id c1 = changeOperations.newChange().project(project).createV1();
    requestScopeOperations.setApiUser(admin.id());
    approve(c1.toString());
    assertNotMatching("distinctvoters:\"[Code-Review,Custom-Label],value=MAX,count>1\"", c1);

    // Same user votes on both labels
    gApi.changes()
        .id(c1.toString())
        .current()
        .review(ReviewInput.create().label("Custom-Label", 1));
    assertNotMatching("distinctvoters:\"[Code-Review,Custom-Label],value=MAX,count>1\"", c1);
  }

  @Test
  public void distinctVoters_distinctUsersOnDifferentLabels_passes() throws Exception {
    Change.Id c1 = changeOperations.newChange().project(project).createV1();
    requestScopeOperations.setApiUser(admin.id());
    approve(c1.toString());
    requestScopeOperations.setApiUser(user.id());
    gApi.changes()
        .id(c1.toString())
        .current()
        .review(ReviewInput.create().label("Custom-Label", 1));
    assertMatching("distinctvoters:\"[Code-Review,Custom-Label],value=MAX,count>1\"", c1);
  }

  @Test
  public void distinctVoters_onlyMaxVotesRespected() throws Exception {
    Change.Id c1 = changeOperations.newChange().project(project).createV1();
    requestScopeOperations.setApiUser(user.id());
    gApi.changes()
        .id(c1.toString())
        .current()
        .review(ReviewInput.create().label("Custom-Label", 1));
    requestScopeOperations.setApiUser(admin.id());
    recommend(c1.toString());
    assertNotMatching("distinctvoters:\"[Code-Review,Custom-Label],value=MAX,count>1\"", c1);
    requestScopeOperations.setApiUser(admin.id());
    approve(c1.toString());
    assertMatching("distinctvoters:\"[Code-Review,Custom-Label],value=MAX,count>1\"", c1);
  }

  @Test
  public void distinctVoters_onlyMinVotesRespected() throws Exception {
    Change.Id c1 = changeOperations.newChange().project(project).createV1();
    requestScopeOperations.setApiUser(user.id());
    gApi.changes()
        .id(c1.toString())
        .current()
        .review(ReviewInput.create().label("Custom-Label", -1));
    requestScopeOperations.setApiUser(admin.id());
    recommend(c1.toString());
    assertNotMatching("distinctvoters:\"[Code-Review,Custom-Label],value=MIN,count>1\"", c1);
    requestScopeOperations.setApiUser(admin.id());
    gApi.changes().id(c1.toString()).current().review(ReviewInput.reject());
    assertMatching("distinctvoters:\"[Code-Review,Custom-Label],value=MIN,count>1\"", c1);
  }

  @Test
  public void distinctVoters_onlyExactValueRespected() throws Exception {
    Change.Id c1 = changeOperations.newChange().project(project).createV1();
    requestScopeOperations.setApiUser(user.id());
    gApi.changes()
        .id(c1.toString())
        .current()
        .review(ReviewInput.create().label("Custom-Label", 1));
    requestScopeOperations.setApiUser(admin.id());
    approve(c1.toString());
    assertNotMatching("distinctvoters:\"[Code-Review,Custom-Label],value=1,count>1\"", c1);
    requestScopeOperations.setApiUser(admin.id());
    recommend(c1.toString());
    assertMatching("distinctvoters:\"[Code-Review,Custom-Label],value=1,count>1\"", c1);
  }

  @Test
  public void distinctVoters_valueIsOptional() throws Exception {
    Change.Id c1 = changeOperations.newChange().project(project).createV1();
    requestScopeOperations.setApiUser(user.id());
    gApi.changes()
        .id(c1.toString())
        .current()
        .review(ReviewInput.create().label("Custom-Label", -1));
    requestScopeOperations.setApiUser(admin.id());
    assertNotMatching("distinctvoters:\"[Code-Review,Custom-Label],count>1\"", c1);
    recommend(c1.toString());
    assertMatching("distinctvoters:\"[Code-Review,Custom-Label],count>1\"", c1);
  }

  @Test
  public void distinctVoters_moreThanTwoLabels() throws Exception {
    Change.Id c1 = changeOperations.newChange().project(project).createV1();
    requestScopeOperations.setApiUser(user.id());
    gApi.changes()
        .id(c1.toString())
        .current()
        .review(ReviewInput.create().label("Custom-Label2", 1));
    requestScopeOperations.setApiUser(admin.id());
    recommend(c1.toString());
    assertMatching(
        "distinctvoters:\"[Code-Review,Custom-Label,Custom-Label2],value=1,count>1\"", c1);
  }

  @Test
  public void distinctVoters_moreThanTwoLabels_moreThanTwoUsers() throws Exception {
    Change.Id c1 = changeOperations.newChange().project(project).createV1();
    requestScopeOperations.setApiUser(user.id());
    gApi.changes()
        .id(c1.toString())
        .current()
        .review(ReviewInput.create().label("Custom-Label2", 1));
    requestScopeOperations.setApiUser(admin.id());
    recommend(c1.toString());
    assertNotMatching(
        "distinctvoters:\"[Code-Review,Custom-Label,Custom-Label2],value=1,count>2\"", c1);
    Account.Id tester = accountOperations.newAccount().create();
    requestScopeOperations.setApiUser(tester);
    gApi.changes()
        .id(c1.toString())
        .current()
        .review(ReviewInput.create().label("Custom-Label", 1));
    assertMatching(
        "distinctvoters:\"[Code-Review,Custom-Label,Custom-Label2],value=1,count>2\"", c1);
  }

  @Test
  public void hasSubmoduleUpdate_withSubmoduleChangeInParent1() throws Exception {
    ObjectId initial = repo().exactRef(HEAD).getLeaf().getObjectId();
    PushOneCommit.Result r1 = createGitSubmoduleCommit("refs/for/master");
    testRepo.reset(initial);
    PushOneCommit.Result r2 = createNormalCommit("refs/for/master", "file1");
    PushOneCommit.Result merge =
        createMergeCommitChange(
            "refs/for/master",
            r1.getCommit(),
            r2.getCommit(),
            mergeAndGetTreeId(r1.getCommit(), r2.getCommit()));

    assertNotMatching("has:submodule-update,base=1", merge.getChange().getId());
    assertMatching("has:submodule-update,base=2", merge.getChange().getId());
    assertNotMatching("has:submodule-update", merge.getChange().getId());
  }

  @Test
  public void hasSubmoduleUpdate_withSubmoduleChangeInParent2() throws Exception {
    ObjectId initial = repo().exactRef(HEAD).getLeaf().getObjectId();
    PushOneCommit.Result r1 = createNormalCommit("refs/for/master", "file1");
    testRepo.reset(initial);
    PushOneCommit.Result r2 = createGitSubmoduleCommit("refs/for/master");
    PushOneCommit.Result merge =
        createMergeCommitChange(
            "refs/for/master",
            r1.getCommit(),
            r2.getCommit(),
            mergeAndGetTreeId(r1.getCommit(), r2.getCommit()));

    assertMatching("has:submodule-update,base=1", merge.getChange().getId());
    assertNotMatching("has:submodule-update,base=2", merge.getChange().getId());
    assertNotMatching("has:submodule-update", merge.getChange().getId());
  }

  @Test
  public void hasSubmoduleUpdate_withoutSubmoduleChange_doesNotMatch() throws Exception {
    ObjectId initial = repo().exactRef(HEAD).getLeaf().getObjectId();
    PushOneCommit.Result r1 = createNormalCommit("refs/for/master", "file1");
    testRepo.reset(initial);
    PushOneCommit.Result r2 = createNormalCommit("refs/for/master", "file2");
    PushOneCommit.Result merge =
        createMergeCommitChange(
            "refs/for/master",
            r1.getCommit(),
            r2.getCommit(),
            mergeAndGetTreeId(r1.getCommit(), r2.getCommit()));

    assertNotMatching("has:submodule-update,base=1", merge.getChange().getId());
    assertNotMatching("has:submodule-update,base=2", merge.getChange().getId());
    assertNotMatching("has:submodule-update", merge.getChange().getId());
  }

  @Test
  public void hasSubmoduleUpdate_withBaseParamGreaterThanParentCount_doesNotMatch()
      throws Exception {
    ObjectId initial = repo().exactRef(HEAD).getLeaf().getObjectId();
    PushOneCommit.Result r1 = createNormalCommit("refs/for/master", "file1");
    testRepo.reset(initial);
    PushOneCommit.Result r2 = createGitSubmoduleCommit("refs/for/master");
    PushOneCommit.Result merge =
        createMergeCommitChange(
            "refs/for/master",
            r1.getCommit(),
            r2.getCommit(),
            mergeAndGetTreeId(r1.getCommit(), r2.getCommit()));

    assertNotMatching("has:submodule-update,base=3", merge.getChange().getId());
  }

  @Test
  public void hasSubmoduleUpdate_withWrongArgs_throws() {
    assertError(
        "has:submodule-update,base=xyz",
        changeOperations.newChange().project(project).createV1(),
        "failed to parse the parent number xyz: For input string: \"xyz\"");
    assertError(
        "has:submodule-update,base=1,arg=foo",
        changeOperations.newChange().project(project).createV1(),
        "wrong number of arguments for the has:submodule-update operator");
    assertError(
        "has:submodule-update,base",
        changeOperations.newChange().project(project).createV1(),
        "unexpected base value format");
  }

  @Test
  public void nonContributorLabelVote_match() throws Exception {
    requestScopeOperations.setApiUser(user.id());
    TestRepository<InMemoryRepository> clonedRepo = cloneProject(project, user);
    PushOneCommit.Result r1 =
        pushFactory
            .create(user.newIdent(), clonedRepo, "Subject", "file.txt", "text")
            .to("refs/for/master");

    Change.Id cId = r1.getChange().getId();

    ChangeInfo changeInfo = gApi.changes().id(r1.getChangeId()).get();

    // Assert on uploader, committer and author
    assertUploader(changeInfo, user.email());
    assertCommitter(changeInfo, user.email());
    assertAuthor(changeInfo, user.email());

    // Vote from admin (a.k.a. non uploader/committer/author) matches
    requestScopeOperations.setApiUser(admin.id());
    approve(cId.toString());
    assertMatching("label:Code-Review=+2,user=non_contributor", cId);
    // Also make sure magic label votes and > operator work
    assertMatching("label:Code-Review=MAX,user=non_contributor", cId);
    assertMatching("label:Code-Review>+1,user=non_contributor", cId);
  }

  @Test
  public void nonContributorLabelVote_voteFromUploader_doesNotMatch() throws Exception {
    PushOneCommit.Result r1 = createNormalCommit(user.newIdent(), "refs/for/master", "file1");

    ChangeInfo changeInfo = gApi.changes().id(r1.getChangeId()).get();
    assertUploader(changeInfo, admin.email());

    // Vote from admin (a.k.a. uploader) does not match
    requestScopeOperations.setApiUser(admin.id());
    approve(r1.getChangeId());
    assertNotMatching("label:Code-Review=+2,user=non_contributor", r1.getChange().getId());
  }

  @Test
  @Sandboxed
  public void nonContributorLabelVote_voteFromAuthor_doesNotMatch() throws Exception {
    Account.Id authorId =
        accountOperations
            .newAccount()
            .fullname("author")
            .preferredEmail("authoremail@example.com")
            .create();
    Account.Id committerId =
        accountOperations
            .newAccount()
            .fullname("committer")
            .preferredEmail("committeremail@example.com")
            .create();

    Change.Id changeId =
        changeOperations
            .newChange()
            .project(project)
            .author(authorId)
            .committer(committerId)
            .createV1();
    ChangeInfo changeInfo = gApi.changes().id(changeId.get()).get();
    assertAuthor(changeInfo, "authoremail@example.com");

    allowLabelPermission(
        codeReview().getName(), RefNames.REFS_HEADS + "*", REGISTERED_USERS, -2, +2);

    // Vote from author does not match
    requestScopeOperations.setApiUser(authorId);
    approve(changeId.toString());
    assertNotMatching("label:Code-Review=+2,user=non_contributor", changeId);
  }

  @Test
  public void nonContributorLabelVote_voteFromCommitter_doesNotMatch() throws Exception {
    Account.Id authorId =
        accountOperations
            .newAccount()
            .fullname("author")
            .preferredEmail("authoremail@example.com")
            .create();
    Account.Id committerId =
        accountOperations
            .newAccount()
            .fullname("committer")
            .preferredEmail("committeremail@example.com")
            .create();

    Change.Id changeId =
        changeOperations
            .newChange()
            .project(project)
            .author(authorId)
            .committer(committerId)
            .createV1();
    ChangeInfo changeInfo = gApi.changes().id(changeId.get()).get();
    assertCommitter(changeInfo, "committeremail@example.com");

    allowLabelPermission(
        codeReview().getName(), RefNames.REFS_HEADS + "*", REGISTERED_USERS, -2, +2);

    // Vote from committer does not match
    requestScopeOperations.setApiUser(committerId);
    approve(changeId.toString());
    assertNotMatching("label:Code-Review=+2,user=non_contributor", changeId);
  }

  @Test
  public void nonContributorLabelVote_uploaderAndAuthorDifferent() throws Exception {
    TestRepository<InMemoryRepository> clonedRepo = cloneProject(project, admin);
    PushOneCommit.Result r1 =
        pushFactory
            .create(user.newIdent(), clonedRepo, "Subject", "file.txt", "text")
            .to("refs/for/master");

    requestScopeOperations.setApiUser(admin.id());
    ChangeInfo changeInfo = gApi.changes().id(r1.getChangeId()).get();
    assertUploader(changeInfo, admin.email());
    assertAuthor(changeInfo, user.email());

    allowLabelPermission(
        codeReview().getName(), RefNames.REFS_HEADS + "*", REGISTERED_USERS, -2, +2);

    // Vote from admin (a.k.a. uploader) does not match
    requestScopeOperations.setApiUser(user.id());
    approve(r1.getChangeId());
    assertNotMatching("label:Code-Review=+2,user=non_contributor", r1.getChange().getId());

    // Vote from user (a.k.a. author) does not match
    requestScopeOperations.setApiUser(admin.id());
    approve(r1.getChangeId());
    assertNotMatching("label:Code-Review=+2,user=non_contributor", r1.getChange().getId());

    // Vote from user2 (a.k.a. non-author and non-uploader) matches
    TestAccount user2 = accountCreator.create();
    requestScopeOperations.setApiUser(user2.id());
    approve(r1.getChangeId());
    assertMatching("label:Code-Review=+2,user=non_contributor", r1.getChange().getId());
  }

  @Test
  public void nonAuthorLabelVote_match() throws Exception {
    requestScopeOperations.setApiUser(user.id());
    TestRepository<InMemoryRepository> clonedRepo = cloneProject(project, user);
    PushOneCommit.Result r1 =
        pushFactory
            .create(user.newIdent(), clonedRepo, "Subject", "file.txt", "text")
            .to("refs/for/master");

    Change.Id cId = r1.getChange().getId();

    ChangeInfo changeInfo = gApi.changes().id(r1.getChangeId()).get();

    // Assert on author
    assertAuthor(changeInfo, user.email());

    // Vote from admin (a.k.a. non author) matches
    requestScopeOperations.setApiUser(admin.id());
    approve(cId.toString());
    assertMatching("label:Code-Review=+2,user=non_author", cId);
    // Also make sure magic label votes and > operator work
    assertMatching("label:Code-Review=MAX,user=non_author", cId);
    assertMatching("label:Code-Review>+1,user=non_author", cId);
  }

  @Test
  @Sandboxed
  public void nonAuthorLabelVote_voteFromAuthor_doesNotMatch() throws Exception {
    Account.Id authorId =
        accountOperations
            .newAccount()
            .fullname("author")
            .preferredEmail("authoremail@example.com")
            .create();
    Account.Id committerId =
        accountOperations
            .newAccount()
            .fullname("committer")
            .preferredEmail("committeremail@example.com")
            .create();

    TestChange change =
        changeOperations
            .newChange()
            .project(project)
            .author(authorId)
            .committer(committerId)
            .createAndGet();
    ChangeInfo changeInfo = gApi.changes().id(change.id()).get();
    assertAuthor(changeInfo, "authoremail@example.com");

    allowLabelPermission(
        codeReview().getName(), RefNames.REFS_HEADS + "*", REGISTERED_USERS, -2, +2);

    // Vote from author does not match
    requestScopeOperations.setApiUser(authorId);
    approve(change.id().id());
    assertNotMatching("label:Code-Review=+2,user=non_author", change.numericChangeId());
  }

  @Test
  public void nonCommitterLabelVote_voteFromCommitter_doesNotMatch() throws Exception {
    Account.Id authorId =
        accountOperations
            .newAccount()
            .fullname("author")
            .preferredEmail("authoremail@example.com")
            .create();
    Account.Id committerId =
        accountOperations
            .newAccount()
            .fullname("committer")
            .preferredEmail("committeremail@example.com")
            .create();

    TestChange change =
        changeOperations
            .newChange()
            .project(project)
            .author(authorId)
            .committer(committerId)
            .createAndGet();
    ChangeInfo changeInfo = gApi.changes().id(change.id()).get();
    assertCommitter(changeInfo, "committeremail@example.com");

    allowLabelPermission(
        codeReview().getName(), RefNames.REFS_HEADS + "*", REGISTERED_USERS, -2, +2);

    // Vote from committer does not match
    requestScopeOperations.setApiUser(committerId);
    approve(change.id().id());
    assertNotMatching("label:Code-Review=+2,user=non_committer", change.numericChangeId());
  }

  @Test
  public void nonCommitterLabelVote_match() throws Exception {
    requestScopeOperations.setApiUser(user.id());
    TestRepository<InMemoryRepository> clonedRepo = cloneProject(project, user);
    PushOneCommit.Result r1 =
        pushFactory
            .create(user.newIdent(), clonedRepo, "Subject", "file.txt", "text")
            .to("refs/for/master");

    Change.Id cId = r1.getChange().getId();

    ChangeInfo changeInfo = gApi.changes().id(r1.getChangeId()).get();

    // Assert on committer
    assertAuthor(changeInfo, user.email());

    // Vote from admin (a.k.a. non committer) matches
    requestScopeOperations.setApiUser(admin.id());
    approve(cId.toString());
    assertMatching("label:Code-Review=+2,user=non_committer", cId);
    // Also make sure magic label votes and > operator work
    assertMatching("label:Code-Review=MAX,user=non_committer", cId);
    assertMatching("label:Code-Review>+1,user=non_committer", cId);
  }

  @Test
  public void label_requireVoteFromHumanReviewers() throws Exception {
    projectOperations
        .project(project)
        .forUpdate()
        .add(allowLabel("Code-Review").ref("refs/*").group(REGISTERED_USERS).range(-2, 2))
        .update();

    Account.Id owner = accountCreator.create("owner").id();
    Account.Id reviewer1 = accountCreator.create("reviewer1").id();
    Account.Id reviewer2 = accountCreator.create("reviewer2").id();
    Account.Id reviewer3 = accountCreator.create("reviewer3").id();

    Account.Id serviceUser = accountCreator.create("serviceUser").id();
    gApi.groups().id(ServiceUserClassifier.SERVICE_USERS).addMembers(serviceUser.toString());

    Change.Id changeApprovedByAllReviewers =
        changeOperations.newChange().project(project).owner(owner).createV1();
    addReviewers(project, changeApprovedByAllReviewers, reviewer1, reviewer2, reviewer3);
    addReviews(
        project,
        changeApprovedByAllReviewers,
        ReviewInput.approve(),
        reviewer1,
        reviewer2,
        reviewer3);

    Change.Id changeApprovedBySomeReviewers =
        changeOperations.newChange().project(project).owner(owner).createV1();
    addReviewers(project, changeApprovedBySomeReviewers, reviewer1, reviewer2, reviewer3);
    addReviews(project, changeApprovedBySomeReviewers, ReviewInput.approve(), reviewer1, reviewer2);

    Change.Id changeRecommendedByAllReviewers =
        changeOperations.newChange().project(project).owner(owner).createV1();
    addReviewers(project, changeRecommendedByAllReviewers, reviewer1, reviewer2, reviewer3);
    addReviews(
        project,
        changeRecommendedByAllReviewers,
        ReviewInput.recommend(),
        reviewer1,
        reviewer2,
        reviewer3);

    Change.Id changeRecommendedBySomeReviewers =
        changeOperations.newChange().project(project).owner(owner).createV1();
    addReviewers(project, changeRecommendedBySomeReviewers, reviewer1, reviewer2, reviewer3);
    addReviews(
        project, changeRecommendedBySomeReviewers, ReviewInput.recommend(), reviewer1, reviewer2);

    Change.Id changeNoVotesByReviewers =
        changeOperations.newChange().project(project).owner(owner).createV1();
    addReviewers(project, changeNoVotesByReviewers, reviewer1, reviewer2, reviewer3);

    Change.Id changeWithoutReviewers =
        changeOperations.newChange().project(project).owner(owner).createV1();

    requestScopeOperations.setApiUser(user.id());

    // change without reviewers doesn't match
    assertNotMatching("label:Code-Review=MAX,users=human_reviewers", changeWithoutReviewers);

    // match changes where all reviewers have the same vote
    assertRequirement(
        "label:Code-Review=MAX,users=human_reviewers",
        ImmutableList.of(changeApprovedByAllReviewers),
        ImmutableList.of(
            changeApprovedBySomeReviewers,
            changeRecommendedByAllReviewers,
            changeRecommendedBySomeReviewers,
            changeNoVotesByReviewers));
    assertRequirement(
        "label:Code-Review=2,users=human_reviewers",
        ImmutableList.of(changeApprovedByAllReviewers),
        ImmutableList.of(
            changeApprovedBySomeReviewers,
            changeRecommendedByAllReviewers,
            changeRecommendedBySomeReviewers,
            changeNoVotesByReviewers));
    assertRequirement(
        "label:Code-Review=1,users=human_reviewers",
        ImmutableList.of(changeRecommendedByAllReviewers),
        ImmutableList.of(
            changeApprovedBySomeReviewers,
            changeApprovedByAllReviewers,
            changeRecommendedBySomeReviewers,
            changeNoVotesByReviewers));

    // match changes where no reviewer voted (same as "label:Code-Review=0")
    assertRequirement(
        "label:Code-Review=0,users=human_reviewers",
        ImmutableList.of(changeNoVotesByReviewers),
        ImmutableList.of(
            changeApprovedByAllReviewers,
            changeApprovedBySomeReviewers,
            changeRecommendedByAllReviewers,
            changeRecommendedBySomeReviewers));

    // match changes where all reviewers have a vote <=, >=, < or >
    assertRequirement(
        "label:Code-Review<=2,users=human_reviewers",
        ImmutableList.of(
            changeApprovedByAllReviewers,
            changeApprovedBySomeReviewers,
            changeRecommendedByAllReviewers,
            changeRecommendedBySomeReviewers,
            changeNoVotesByReviewers),
        ImmutableList.of());
    assertRequirement(
        "label:Code-Review<=1,users=human_reviewers",
        ImmutableList.of(
            changeRecommendedByAllReviewers,
            changeRecommendedByAllReviewers,
            changeRecommendedBySomeReviewers,
            changeNoVotesByReviewers),
        ImmutableList.of(changeApprovedByAllReviewers));
    assertRequirement(
        "label:Code-Review>=1,users=human_reviewers",
        ImmutableList.of(changeApprovedByAllReviewers, changeRecommendedByAllReviewers),
        ImmutableList.of(
            changeApprovedBySomeReviewers,
            changeRecommendedBySomeReviewers,
            changeNoVotesByReviewers));
    assertRequirement(
        "label:Code-Review<1,users=human_reviewers",
        ImmutableList.of(changeNoVotesByReviewers),
        ImmutableList.of(
            changeApprovedByAllReviewers,
            changeApprovedBySomeReviewers,
            changeRecommendedByAllReviewers,
            changeRecommendedBySomeReviewers));
    assertRequirement(
        "label:Code-Review>1,users=human_reviewers",
        ImmutableList.of(changeApprovedByAllReviewers),
        ImmutableList.of(
            changeApprovedBySomeReviewers,
            changeRecommendedByAllReviewers,
            changeRecommendedBySomeReviewers,
            changeNoVotesByReviewers));

    // match changes where all reviewers have any (non-zero) vote
    assertRequirement(
        "label:Code-Review=ANY,users=human_reviewers",
        ImmutableList.of(changeApprovedByAllReviewers, changeRecommendedByAllReviewers),
        ImmutableList.of(
            changeApprovedBySomeReviewers,
            changeRecommendedBySomeReviewers,
            changeNoVotesByReviewers));

    // votes of the change owners are ignored (as the change owner is not considered as a reviewer)
    addReviews(project, changeApprovedByAllReviewers, ReviewInput.dislike(), owner);
    assertRequirement(
        "label:Code-Review=MAX,users=human_reviewers",
        ImmutableList.of(changeApprovedByAllReviewers),
        ImmutableList.of(
            changeApprovedBySomeReviewers,
            changeRecommendedByAllReviewers,
            changeRecommendedBySomeReviewers,
            changeNoVotesByReviewers));

    // missing votes from service users are fine
    addReviewers(project, changeApprovedByAllReviewers, serviceUser);
    assertRequirement(
        "label:Code-Review=MAX,users=human_reviewers",
        ImmutableList.of(changeApprovedByAllReviewers),
        ImmutableList.of(
            changeApprovedBySomeReviewers,
            changeRecommendedByAllReviewers,
            changeRecommendedBySomeReviewers,
            changeNoVotesByReviewers));

    // votes from service users are ignored
    addReviews(project, changeApprovedByAllReviewers, ReviewInput.dislike(), serviceUser);
    assertRequirement(
        "label:Code-Review=MAX,users=human_reviewers",
        ImmutableList.of(changeApprovedByAllReviewers),
        ImmutableList.of(
            changeApprovedBySomeReviewers,
            changeRecommendedByAllReviewers,
            changeRecommendedBySomeReviewers,
            changeNoVotesByReviewers));

    // when reviewers by email are present changes do not match, unless the expected value is 0
    projectOperations.project(project).forUpdate().enableReviewerByEmail().update();
    Change.Id changeRecommendedByAllReviewersWithReviewersByEmail =
        changeOperations.newChange().project(project).owner(owner).createV1();
    addReviewers(
        project,
        changeRecommendedByAllReviewersWithReviewersByEmail,
        reviewer1,
        reviewer2,
        reviewer3);
    addReviews(
        project,
        changeRecommendedByAllReviewersWithReviewersByEmail,
        ReviewInput.recommend(),
        reviewer1,
        reviewer2,
        reviewer3);
    addReviewer(
        project,
        changeRecommendedByAllReviewersWithReviewersByEmail,
        "email-without-account@example.com");
    Change.Id changeNoVotesByReviewersWithReviewersByEmail =
        changeOperations.newChange().project(project).owner(owner).createV1();
    addReviewers(
        project, changeNoVotesByReviewersWithReviewersByEmail, reviewer1, reviewer2, reviewer3);
    addReviewer(
        project, changeNoVotesByReviewersWithReviewersByEmail, "email-without-account@example.com");
    assertRequirement(
        "label:Code-Review=MAX,users=human_reviewers",
        ImmutableList.of(),
        ImmutableList.of(
            changeRecommendedByAllReviewersWithReviewersByEmail,
            changeNoVotesByReviewersWithReviewersByEmail));
    assertRequirement(
        "label:Code-Review=2,users=human_reviewers",
        ImmutableList.of(),
        ImmutableList.of(
            changeRecommendedByAllReviewersWithReviewersByEmail,
            changeNoVotesByReviewersWithReviewersByEmail));
    assertRequirement(
        "label:Code-Review=ANY,users=human_reviewers",
        ImmutableList.of(),
        ImmutableList.of(
            changeRecommendedByAllReviewersWithReviewersByEmail,
            changeNoVotesByReviewersWithReviewersByEmail));
    assertRequirement(
        "label:Code-Review=0,users=human_reviewers",
        ImmutableList.of(changeNoVotesByReviewersWithReviewersByEmail),
        ImmutableList.of(changeRecommendedByAllReviewersWithReviewersByEmail));
    assertRequirement(
        "label:Code-Review<=2,users=human_reviewers",
        ImmutableList.of(
            changeRecommendedByAllReviewersWithReviewersByEmail,
            changeNoVotesByReviewersWithReviewersByEmail),
        ImmutableList.of());
    assertRequirement(
        "label:Code-Review<=0,users=human_reviewers",
        ImmutableList.of(changeNoVotesByReviewersWithReviewersByEmail),
        ImmutableList.of(changeRecommendedByAllReviewersWithReviewersByEmail));
    assertRequirement(
        "label:Code-Review<=-1,users=human_reviewers",
        ImmutableList.of(),
        ImmutableList.of(
            changeRecommendedByAllReviewersWithReviewersByEmail,
            changeNoVotesByReviewersWithReviewersByEmail));
    assertRequirement(
        "label:Code-Review<2,users=human_reviewers",
        ImmutableList.of(
            changeRecommendedByAllReviewersWithReviewersByEmail,
            changeNoVotesByReviewersWithReviewersByEmail),
        ImmutableList.of());
    assertRequirement(
        "label:Code-Review<1,users=human_reviewers",
        ImmutableList.of(changeNoVotesByReviewersWithReviewersByEmail),
        ImmutableList.of(changeRecommendedByAllReviewersWithReviewersByEmail));
    assertRequirement(
        "label:Code-Review<0,users=human_reviewers",
        ImmutableList.of(),
        ImmutableList.of(
            changeRecommendedByAllReviewersWithReviewersByEmail,
            changeNoVotesByReviewersWithReviewersByEmail));
    assertRequirement(
        "label:Code-Review>=0,users=human_reviewers",
        ImmutableList.of(
            changeRecommendedByAllReviewersWithReviewersByEmail,
            changeNoVotesByReviewersWithReviewersByEmail),
        ImmutableList.of());
    assertRequirement(
        "label:Code-Review>=1,users=human_reviewers",
        ImmutableList.of(),
        ImmutableList.of(
            changeRecommendedByAllReviewersWithReviewersByEmail,
            changeNoVotesByReviewersWithReviewersByEmail));
    assertRequirement(
        "label:Code-Review>-1,users=human_reviewers",
        ImmutableList.of(
            changeRecommendedByAllReviewersWithReviewersByEmail,
            changeNoVotesByReviewersWithReviewersByEmail),
        ImmutableList.of());
    assertRequirement(
        "label:Code-Review>0,users=human_reviewers",
        ImmutableList.of(),
        ImmutableList.of(
            changeRecommendedByAllReviewersWithReviewersByEmail,
            changeNoVotesByReviewersWithReviewersByEmail));

    // cannot combine users=human_reviewers" with submit record status
    assertError(
        "label:Code-Review=ok,users=human_reviewers",
        changeApprovedByAllReviewers,
        "Cannot use the 'users=human_reviewers' argument in conjunction with a submit record label"
            + " status");

    // cannot combine "users" arg with a "user" arg
    assertError(
        "label:Code-Review=MAX,users=human_reviewers,user=reviewer1",
        changeApprovedByAllReviewers,
        "Cannot use the 'users' argument in conjunction with other arguments ('count', 'user',"
            + " group')");

    // cannot combine "users" arg with a "group" arg
    assertError(
        "label:Code-Review=MAX,users=human_reviewers,group=foo",
        changeApprovedByAllReviewers,
        "Cannot use the 'users' argument in conjunction with other arguments ('count', 'user',"
            + " group')");

    // cannot combine "users" arg with a positional arg
    assertError(
        "label:Code-Review=MAX,users=human_reviewers,reviewer1",
        changeApprovedByAllReviewers,
        "Cannot use the 'users' argument in conjunction with other arguments ('count', 'user',"
            + " group')");
    assertError(
        "label:Code-Review=MAX,reviewer1,users=human_reviewers",
        changeApprovedByAllReviewers,
        "Cannot use the 'users' argument in conjunction with other arguments ('count', 'user',"
            + " group')");

    // label without "users=human_reviewers" still works
    assertRequirement(
        "label:Code-Review=MAX,user=reviewer1",
        ImmutableList.of(changeApprovedByAllReviewers, changeApprovedBySomeReviewers),
        ImmutableList.of(
            changeRecommendedByAllReviewers,
            changeRecommendedBySomeReviewers,
            changeNoVotesByReviewers));
    assertRequirement(
        "label:Code-Review=MAX,reviewer1",
        ImmutableList.of(changeApprovedByAllReviewers, changeApprovedBySomeReviewers),
        ImmutableList.of(
            changeRecommendedByAllReviewers,
            changeRecommendedBySomeReviewers,
            changeNoVotesByReviewers));
  }

  @Test
  public void hasUnresolvedComments() throws Exception {
    TestRepository<InMemoryRepository> clonedRepo = cloneProject(project, admin);
    PushOneCommit.Result r =
        pushFactory
            .create(user.newIdent(), clonedRepo, "Subject", "file.txt", "text")
            .to("refs/for/master");

    assertNotMatching("has:unresolved", r.getChange().getId());
    assertMatching("-has:unresolved", r.getChange().getId());

    ReviewInput reviewInput = new ReviewInput();
    ReviewInput.CommentInput commentInput = new ReviewInput.CommentInput();
    commentInput.line = 1;
    commentInput.message = "inline";
    commentInput.unresolved = true;
    reviewInput.comments = ImmutableMap.of(Patch.COMMIT_MSG, ImmutableList.of(commentInput));
    gApi.changes().id(project.get(), r.getChange().getId().get()).current().review(reviewInput);
    CommentInfo commentInfo =
        Iterables.getOnlyElement(
            gApi.changes()
                .id(project.get(), r.getChange().getId().get())
                .current()
                .commentsAsList());

    assertMatching("has:unresolved", r.getChange().getId());
    assertNotMatching("-has:unresolved", r.getChange().getId());

    // Rename the file in the change to check that the change still matches if the commented file
    // path is no longer present in the current patch set.
    gApi.changes().id(project.get(), r.getChange().getId().get()).edit().create();
    gApi.changes()
        .id(project.get(), r.getChange().getId().get())
        .edit()
        .renameFile("file.txt", "renamed-file.txt");
    gApi.changes()
        .id(project.get(), r.getChange().getId().get())
        .edit()
        .publish(new PublishChangeEditInput());
    Map<String, FileInfo> files =
        gApi.changes().id(project.get(), r.getChange().getId().get()).current().files("1");
    assertThat(files.keySet()).containsExactly(Patch.COMMIT_MSG, "renamed-file.txt");
    assertThat(files.get("renamed-file.txt").oldPath).isEqualTo("file.txt");
    assertMatching("has:unresolved", r.getChange().getId());
    assertNotMatching("-has:unresolved", r.getChange().getId());

    // Resolve the comment.
    reviewInput = new ReviewInput();
    commentInput = new ReviewInput.CommentInput();
    commentInput.inReplyTo = commentInfo.id;
    commentInput.message = "done";
    commentInput.unresolved = false;
    reviewInput.comments = ImmutableMap.of(Patch.COMMIT_MSG, ImmutableList.of(commentInput));
    gApi.changes().id(project.get(), r.getChange().getId().get()).current().review(reviewInput);
    assertNotMatching("has:unresolved", r.getChange().getId());
    assertMatching("-has:unresolved", r.getChange().getId());
  }

  private void addReviewers(Project.NameKey project, Change.Id changeId, Account.Id... reviewers)
      throws Exception {
    for (Account.Id reviewer : reviewers) {
      addReviewer(project, changeId, reviewer.toString());
    }
  }

  private void addReviewer(Project.NameKey project, Change.Id changeId, String reviewer)
      throws Exception {
    gApi.changes().id(project.get(), changeId.get()).addReviewer(reviewer);
  }

  private void addReviews(
      Project.NameKey project, Change.Id changeId, ReviewInput reviewInput, Account.Id... reviewers)
      throws Exception {
    for (Account.Id reviewer : reviewers) {
      requestScopeOperations.setApiUser(reviewer);
      gApi.changes().id(project.get(), changeId.get()).current().review(reviewInput);
    }
  }

  private void approveAsUser(String changeId, Account.Id userId) throws Exception {
    requestScopeOperations.setApiUser(userId);
    approve(changeId);
  }

  private static void assertUploader(ChangeInfo changeInfo, String email) {
    assertThat(changeInfo.revisions.get(changeInfo.currentRevision).uploader.email)
        .isEqualTo(email);
  }

  private static void assertCommitter(ChangeInfo changeInfo, String email) {
    assertThat(changeInfo.revisions.get(changeInfo.currentRevision).commit.committer.email)
        .isEqualTo(email);
  }

  private static void assertAuthor(ChangeInfo changeInfo, String email) {
    assertThat(changeInfo.revisions.get(changeInfo.currentRevision).commit.author.email)
        .isEqualTo(email);
  }

  private void allowLabelPermission(
      String labelName, String refPattern, AccountGroup.UUID group, int minVote, int maxVote) {
    projectOperations
        .project(project)
        .forUpdate()
        .add(allowLabel(labelName).ref(refPattern).group(group).range(minVote, maxVote))
        .update();
  }

  private PushOneCommit.Result createGitSubmoduleCommit(String ref) throws Exception {
    return pushFactory
        .create(admin.newIdent(), testRepo, "subject", ImmutableMap.of())
        .addGitSubmodule(
            "modules/module-a", ObjectId.fromString("19f1787342cb15d7e82a762f6b494e91ccb4dd34"))
        .to(ref);
  }

  private PushOneCommit.Result createNormalCommit(
      PersonIdent personIdent, String ref, String fileName) throws Exception {
    return pushFactory
        .create(personIdent, testRepo, "subject", ImmutableMap.of(fileName, fileName))
        .to(ref);
  }

  private PushOneCommit.Result createNormalCommit(String ref, String fileName) throws Exception {
    return pushFactory
        .create(admin.newIdent(), testRepo, "subject", ImmutableMap.of(fileName, fileName))
        .to(ref);
  }

  private PushOneCommit.Result createMergeCommitChange(
      String ref, RevCommit parent1, RevCommit parent2, @Nullable ObjectId treeId)
      throws Exception {
    PushOneCommit m =
        pushFactory
            .create(admin.newIdent(), testRepo)
            .setParents(ImmutableList.of(parent1, parent2));
    if (treeId != null) {
      m.setTopLevelTreeId(treeId);
    }
    PushOneCommit.Result result = m.to(ref);
    result.assertOkStatus();
    return result;
  }

  private ObjectId mergeAndGetTreeId(RevCommit c1, RevCommit c2) throws Exception {
    ThreeWayMerger threeWayMerger = MergeStrategy.RESOLVE.newMerger(repo(), true);
    threeWayMerger.setBase(c1.getParent(0));
    boolean mergeResult = threeWayMerger.merge(c1, c2);
    assertThat(mergeResult).isTrue();
    return threeWayMerger.getResultTreeId();
  }

  private void assertRequirement(
      String requirement,
      ImmutableList<Change.Id> matchingChanges,
      ImmutableList<Change.Id> nonMatchingChanges) {
    for (Change.Id matchingChange : matchingChanges) {
      assertMatching(requirement, matchingChange);
    }

    for (Change.Id nonMatchingChange : nonMatchingChanges) {
      assertNotMatching(requirement, nonMatchingChange);
    }
  }

  private void assertMatching(String requirement, Change.Id change) {
    assertWithMessage("requirement \"%s\" doesn't match change %s", requirement, change)
        .that(evaluate(requirement, change).status())
        .isEqualTo(SubmitRequirementExpressionResult.Status.PASS);
  }

  private void assertNotMatching(String requirement, Change.Id change) {
    assertWithMessage("requirement \"%s\" matches change %s", requirement, change)
        .that(evaluate(requirement, change).status())
        .isEqualTo(SubmitRequirementExpressionResult.Status.FAIL);
  }

  private void assertError(String requirement, Change.Id change, String errorMessage) {
    SubmitRequirementExpressionResult result = evaluate(requirement, change);
    assertThat(result.status()).isEqualTo(SubmitRequirementExpressionResult.Status.ERROR);
    assertThat(result.errorMessage().get()).isEqualTo(errorMessage);
  }

  private SubmitRequirementExpressionResult evaluate(String requirement, Change.Id change) {
    ChangeData cd = changeDataFactory.create(project, change);
    return submitRequirementsEvaluator.evaluateExpression(
        SubmitRequirementExpression.create(requirement), cd);
  }
}