Add check for incorrect rebase by checking for duplicate commits and skip PR rules check(mentions, reviewers) if any appears.

Author: xjusko

src/main/java/org/wildfly/bot/PullRequestRuleProcessor.java

@@ -46,6 +46,10 @@ void pullRequestRuleCheck(
             return;
         }
 
+        if (githubProcessor.hasDuplicateCommitInBase(pullRequest, pullRequestPayload.getRepository())) {
+            return;
+        }
+
         GHRepository repository = pullRequest.getRepository();
         SequencedMap<String, List<String>> ccMentionsWithRules = new LinkedHashMap<>();
         Set<String> reviewers = new HashSet<>();

src/main/java/org/wildfly/bot/util/GithubProcessor.java

@@ -7,11 +7,14 @@
 import jakarta.inject.Inject;
 import org.eclipse.microprofile.config.inject.ConfigProperty;
 import org.jboss.logging.Logger;
+import org.kohsuke.github.GHCommit;
+import org.kohsuke.github.GHCommitQueryBuilder;
 import org.kohsuke.github.GHCommitState;
 import org.kohsuke.github.GHIssueComment;
 import org.kohsuke.github.GHLabel;
 import org.kohsuke.github.GHPerson;
 import org.kohsuke.github.GHPullRequest;
+import org.kohsuke.github.GHPullRequestCommitDetail;
 import org.kohsuke.github.GHRepository;
 import org.kohsuke.github.GHUser;
 import org.kohsuke.github.GitHub;
@@ -389,4 +392,33 @@ private String createCCMentionComment(SequencedMap<String, List<String>> ccMenti
                 )
                 .toList());
     }
+
+    public boolean hasDuplicateCommitInBase(GHPullRequest pullRequest, GHRepository repository)
+            throws IOException {
+        String baseBranch = pullRequest.getBase().getRef();
+        GHCommitQueryBuilder commitQuery = repository.queryCommits();
+        if (commitQuery == null) {
+            return false;
+        }
+
+        Set<String> baseCommitSHAs = commitQuery
+                .from(baseBranch)
+                .pageSize(100)
+                .list()
+                .toSet()
+                .stream()
+                .map(GHCommit::getSHA1)
+                .collect(Collectors.toSet());
+
+        for (GHPullRequestCommitDetail prCommit : pullRequest.listCommits()) {
+            String prSha = prCommit.getSha();
+            if (baseCommitSHAs.contains(prSha)) {
+                LOG.infof("Skipping rules due to incorrect rebase detected: commit %s is already in the base branch %s",
+                        prSha,
+                        baseBranch);
+                return true;
+            }
+        }
+        return false;
+    }
 }

src/test/java/org/wildfly/bot/PRSkipPullRequestTest.java

@@ -4,16 +4,30 @@
 import io.quarkus.test.junit.QuarkusTest;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
+import org.kohsuke.github.GHCommit;
+import org.kohsuke.github.GHCommitQueryBuilder;
+import org.kohsuke.github.GHPullRequestCommitDetail;
+import org.kohsuke.github.PagedIterable;
+import org.kohsuke.github.PagedIterator;
 import org.wildfly.bot.utils.TestConstants;
 import org.wildfly.bot.utils.WildflyGitHubBotTesting;
 import org.wildfly.bot.utils.mocking.Mockable;
 import org.wildfly.bot.utils.mocking.MockedGHPullRequest;
 import org.wildfly.bot.utils.testing.PullRequestJson;
 import org.wildfly.bot.utils.testing.internal.TestModel;
 
+import java.util.Set;
+
+import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.anyInt;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
 
 @QuarkusTest
 @GitHubAppTest
@@ -81,4 +95,49 @@ void testSkippingFormatCheckOnDraft() throws Throwable {
                     verifyNoMoreInteractions(mocks.pullRequest(pullRequestJson.id()));
                 });
     }
-}
+
+    @Test
+    void testSkippingRulesOnIncorrectRebase() throws Throwable {
+        final String duplicateSHA = "sha1";
+        final String baseBranch = "main";
+        pullRequestJson = TestModel.setPullRequestJsonBuilder(pullRequestJsonBuilder -> pullRequestJsonBuilder);
+        mockedContext = MockedGHPullRequest.builder(pullRequestJson.id());
+        TestModel.given(
+                mocks -> {
+                    WildflyGitHubBotTesting.mockRepo(mocks, wildflyConfigFile, pullRequestJson, mockedContext);
+                    GHCommit commit1 = mock(GHCommit.class);
+                    GHCommit commit2 = mock(GHCommit.class);
+
+                    when(commit1.getSHA1()).thenReturn(duplicateSHA);
+                    when(commit2.getSHA1()).thenReturn("sha2");
+
+                    // Create a fake PagedIterable for repository commits.
+                    Set<GHCommit> fakeRepoCommitSet = Set.of(commit1, commit2);
+                    PagedIterable<GHCommit> fakeRepoCommits = mock(PagedIterable.class);
+                    GHCommitQueryBuilder mockedQueryBuilder = mock(GHCommitQueryBuilder.class);
+
+                    when(mocks.repository(TestConstants.TEST_REPO).queryCommits()).thenReturn(mockedQueryBuilder);
+                    when(mockedQueryBuilder.from(eq(baseBranch))).thenReturn(mockedQueryBuilder);
+                    when(mockedQueryBuilder.pageSize(anyInt())).thenReturn(mockedQueryBuilder);
+                    when(mockedQueryBuilder.list()).thenReturn(fakeRepoCommits);
+                    when(fakeRepoCommits.toSet()).thenReturn(fakeRepoCommitSet);
+
+                    GHPullRequestCommitDetail fakePRCommit = mock(GHPullRequestCommitDetail.class);
+                    PagedIterator<GHPullRequestCommitDetail> mockIterator = mock(PagedIterator.class);
+                    PagedIterable<GHPullRequestCommitDetail> fakePRCommits = mock(PagedIterable.class);
+
+                    when(fakePRCommit.getSha()).thenReturn(duplicateSHA);
+                    when(mockIterator.hasNext()).thenReturn(true, false);
+                    when(mockIterator.next()).thenReturn(fakePRCommit);
+                    when(mocks.pullRequest(pullRequestJson.id()).listCommits()).thenReturn(fakePRCommits);
+                    when(fakePRCommits._iterator(anyInt())).thenReturn(mockIterator);
+                })
+                .pullRequestEvent(pullRequestJson)
+                .then(mocks -> {
+                    verify(mocks.pullRequest(pullRequestJson.id())).getBase();
+                    verify(mocks.repository(TestConstants.TEST_REPO)).queryCommits();
+                    verify(mocks.pullRequest(pullRequestJson.id()), never()).addLabels(nullable(String[].class));
+                    verify(mocks.pullRequest(pullRequestJson.id()), never()).requestReviewers(any());
+                });
+    }
+}

src/test/java/org/wildfly/bot/PRTriggerTest.java

@@ -185,6 +185,7 @@ private void checkValidRun(SsePullRequestPayload ssePullRequestPayload, Action a
                     Mockito.verify(repo, Mockito.atMostOnce()).listLabels();
                     Mockito.verify(repo, Mockito.atMostOnce()).createLabel(ArgumentMatchers.anyString(),
                             ArgumentMatchers.anyString());
+                    Mockito.verify(repo, Mockito.atMostOnce()).queryCommits();
                     Mockito.verifyNoMoreInteractions(repo);
                 });
     }