Auto merge pull requests when all checks succeeded via API

integrations/api_helper_for_declarative_test.go

@@ -311,6 +311,24 @@ func doAPIManuallyMergePullRequest(ctx APITestContext, owner, repo, commitID str
 	}
 }
 
+func doAPIAutoMergePullRequest(ctx APITestContext, owner, repo string, index int64) func(*testing.T) {
+	return func(t *testing.T) {
+		urlStr := fmt.Sprintf("/api/v1/repos/%s/%s/pulls/%d/merge?token=%s",
+			owner, repo, index, ctx.Token)
+		req := NewRequestWithJSON(t, http.MethodPost, urlStr, &forms.MergePullRequestForm{
+			MergeMessageField:      "doAPIMergePullRequest Merge",
+			Do:                     string(models.MergeStyleMerge),
+			MergeWhenChecksSucceed: true,
+		})
+
+		if ctx.ExpectedCode != 0 {
+			ctx.Session.MakeRequest(t, req, ctx.ExpectedCode)
+			return
+		}
+		ctx.Session.MakeRequest(t, req, 200)
+	}
+}
+
 func doAPIGetBranch(ctx APITestContext, branch string, callback ...func(*testing.T, api.Branch)) func(*testing.T) {
 	return func(t *testing.T) {
 		req := NewRequestf(t, "GET", "/api/v1/repos/%s/%s/branches/%s?token=%s", ctx.Username, ctx.Reponame, branch, ctx.Token)

integrations/git_test.go

@@ -71,6 +71,7 @@ func testGit(t *testing.T, u *url.URL) {
 		mediaTest(t, &httpContext, little, big, littleLFS, bigLFS)
 
 		t.Run("BranchProtectMerge", doBranchProtectPRMerge(&httpContext, dstPath))
+		t.Run("AutoMerge", doAutoPRMerge(&httpContext, dstPath))
 		t.Run("CreatePRAndSetManuallyMerged", doCreatePRAndSetManuallyMerged(httpContext, httpContext, dstPath, "master", "test-manually-merge"))
 		t.Run("MergeFork", func(t *testing.T) {
 			defer PrintCurrentTest(t)()
@@ -593,3 +594,98 @@ func doBranchDelete(ctx APITestContext, owner, repo, branch string) func(*testin
 		ctx.Session.MakeRequest(t, req, http.StatusOK)
 	}
 }
+
+func doAutoPRMerge(baseCtx *APITestContext, dstPath string) func(t *testing.T) {
+	return func(t *testing.T) {
+		defer PrintCurrentTest(t)()
+
+		ctx := NewAPITestContext(t, baseCtx.Username, baseCtx.Reponame)
+
+		t.Run("CheckoutProtected", doGitCheckoutBranch(dstPath, "protected"))
+		t.Run("PullProtected", doGitPull(dstPath, "origin", "protected"))
+		t.Run("GenerateCommit", func(t *testing.T) {
+			_, err := generateCommitWithNewData(littleSize, dstPath, "[email protected]", "User Two", "branch-data-file-")
+			assert.NoError(t, err)
+		})
+		t.Run("PushToUnprotectedBranch", doGitPushTestRepository(dstPath, "origin", "protected:unprotected3"))
+		var pr api.PullRequest
+		var err error
+		t.Run("CreatePullRequest", func(t *testing.T) {
+			pr, err = doAPICreatePullRequest(ctx, baseCtx.Username, baseCtx.Reponame, "protected", "unprotected3")(t)
+			assert.NoError(t, err)
+		})
+
+		// Request repository commits page
+		req := NewRequest(t, "GET", fmt.Sprintf("/%s/%s/pulls/%d/commits", baseCtx.Username, baseCtx.Reponame, pr.Index))
+		resp := ctx.Session.MakeRequest(t, req, http.StatusOK)
+		doc := NewHTMLParser(t, resp.Body)
+
+		// Get first commit URL
+		commitURL, exists := doc.doc.Find("#commits-table tbody tr td.sha a").Last().Attr("href")
+		assert.True(t, exists)
+		assert.NotEmpty(t, commitURL)
+
+		commitID := path.Base(commitURL)
+
+		// Call API to add Pending status for commit
+		req = NewRequestWithJSON(t, "POST", fmt.Sprintf("/api/v1/repos/%s/%s/statuses/%s?token=%s", baseCtx.Username, baseCtx.Reponame, commitID, ctx.Token),
+			api.CreateStatusOption{
+				State:       api.CommitStatusPending,
+				TargetURL:   "http://test.ci/",
+				Description: "",
+				Context:     "testci",
+			},
+		)
+		ctx.Session.MakeRequest(t, req, http.StatusCreated)
+
+		// Add auto merge request
+		ctx.ExpectedCode = http.StatusCreated
+		t.Run("AutoMergePR", doAPIAutoMergePullRequest(ctx, baseCtx.Username, baseCtx.Reponame, pr.Index))
+		// Can not create schedule twice
+		ctx.ExpectedCode = http.StatusConflict
+		t.Run("AutoMergePR", doAPIAutoMergePullRequest(ctx, baseCtx.Username, baseCtx.Reponame, pr.Index))
+
+		// Check pr status
+		ctx.ExpectedCode = 0
+		pr, err = doAPIGetPullRequest(ctx, baseCtx.Username, baseCtx.Reponame, pr.Index)(t)
+		assert.NoError(t, err)
+		assert.Equal(t, false, pr.HasMerged)
+
+		// Call API to add Success status for commit
+		req = NewRequestWithJSON(t, "POST", fmt.Sprintf("/api/v1/repos/%s/%s/statuses/%s?token=%s", baseCtx.Username, baseCtx.Reponame, commitID, ctx.Token),
+			api.CreateStatusOption{
+				State:       api.CommitStatusFailure,
+				TargetURL:   "http://test.ci/",
+				Description: "",
+				Context:     "testci",
+			},
+		)
+		ctx.Session.MakeRequest(t, req, http.StatusCreated)
+
+		// Check pr status
+		pr, err = doAPIGetPullRequest(ctx, baseCtx.Username, baseCtx.Reponame, pr.Index)(t)
+		assert.NoError(t, err)
+		assert.Equal(t, false, pr.HasMerged)
+
+		// Call API to add Success statu for commit
+		req = NewRequestWithJSON(t, "POST", fmt.Sprintf("/api/v1/repos/%s/%s/statuses/%s?token=%s", baseCtx.Username, baseCtx.Reponame, commitID, ctx.Token),
+			api.CreateStatusOption{
+				State:       api.CommitStatusSuccess,
+				TargetURL:   "http://test.ci/",
+				Description: "",
+				Context:     "testci",
+			},
+		)
+		ctx.Session.MakeRequest(t, req, http.StatusCreated)
+
+		// wait to let gitea merge stuff
+		time.Sleep(time.Second)
+
+		// test pr status
+		pr, err = doAPIGetPullRequest(ctx, baseCtx.Username, baseCtx.Reponame, pr.Index)(t)
+		assert.NoError(t, err)
+		assert.Equal(t, true, pr.HasMerged)
+
+		t.Run("CheckoutMasterAgain", doGitCheckoutBranch(dstPath, "master"))
+	}
+}

models/error.go

@@ -1580,6 +1580,22 @@ func (err ErrPullRequestHasMerged) Error() string {
 		err.ID, err.IssueID, err.HeadRepoID, err.BaseRepoID, err.HeadBranch, err.BaseBranch)
 }
 
+// Error is the error implementation
+func (err ErrPullRequestAlreadyScheduledToAutoMerge) Error() string {
+	return fmt.Sprintf("pull request is already scheduled to auto merge when checks succeed [pull_id: %d]", err.PullID)
+}
+
+// ErrPullRequestAlreadyScheduledToAutoMerge represents a "PullRequestHasMerged"-error
+type ErrPullRequestAlreadyScheduledToAutoMerge struct {
+	PullID int64
+}
+
+// IsErrPullRequestAlreadyScheduledToAutoMerge checks if an error is a ErrPullRequestAlreadyScheduledToAutoMerge.
+func IsErrPullRequestAlreadyScheduledToAutoMerge(err error) bool {
+	_, ok := err.(ErrPullRequestAlreadyScheduledToAutoMerge)
+	return ok
+}
+
 // _________                                       __
 // \_   ___ \  ____   _____   _____   ____   _____/  |_
 // /    \  \/ /  _ \ /     \ /     \_/ __ \ /    \   __\

models/issue_comment.go

@@ -100,8 +100,12 @@ const (
 	CommentTypeProject
 	// 31 Project board changed
 	CommentTypeProjectBoard
-	// Dismiss Review
+	// 32 Dismiss Review
 	CommentTypeDismissReview
+	// 33 pr was scheduled to auto merge when checks succeed
+	CommentTypePRScheduledToAutoMerge
+	// 34 pr was un scheduled to auto merge when checks succeed
+	CommentTypePRUnScheduledToAutoMerge
 )
 
 // CommentTag defines comment tag type
@@ -1392,3 +1396,21 @@ func commitBranchCheck(gitRepo *git.Repository, startCommit *git.Commit, endComm
 	}
 	return nil
 }
+
+func createAutoMergeComment(sess *xorm.Session, typ CommentType, pr *PullRequest, doer *User) (comment *Comment, err error) {
+	if err = pr.loadIssue(sess); err != nil {
+		return
+	}
+
+	if err = pr.loadBaseRepo(sess); err != nil {
+		return
+	}
+
+	comment, err = createComment(sess, &CreateCommentOptions{
+		Type:  typ,
+		Doer:  doer,
+		Repo:  pr.BaseRepo,
+		Issue: pr.Issue,
+	})
+	return
+}

models/migrations/migrations.go

@@ -309,6 +309,8 @@ var migrations = []Migration{
 	NewMigration("Add LFS columns to Mirror", addLFSMirrorColumns),
 	// v179 -> v180
 	NewMigration("Convert avatar url to text", convertAvatarURLToText),
+	// v180 -> v181
+	NewMigration("Add auto merge table", addAutoMergeTable),
 }
 
 // GetCurrentDBVersion returns the current db version

models/migrations/v180.go

@@ -0,0 +1,23 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package migrations
+
+import (
+	"xorm.io/xorm"
+)
+
+func addAutoMergeTable(x *xorm.Engine) error {
+	type MergeStyle string
+	type ScheduledPullRequestMerge struct {
+		ID          int64      `xorm:"pk autoincr"`
+		PullID      int64      `xorm:"BIGINT"`
+		DoerID      int64      `xorm:"BIGINT"`
+		MergeStyle  MergeStyle `xorm:"varchar(50)"`
+		Message     string     `xorm:"TEXT"`
+		CreatedUnix int64      `xorm:"created"`
+	}
+
+	return x.Sync2(&ScheduledPullRequestMerge{})
+}

models/models.go

@@ -134,6 +134,7 @@ func init() {
 		new(ProjectIssue),
 		new(Session),
 		new(RepoTransfer),
+		new(ScheduledPullRequestMerge),
 	)
 
 	gonicNames := []string{"SSL", "UID"}

models/pull.go

@@ -657,6 +657,24 @@ func (pr *PullRequest) IsSameRepo() bool {
 	return pr.BaseRepoID == pr.HeadRepoID
 }
 
+// GetPullRequestsByHeadBranch returns all prs by head branch
+// Since there could be multiple prs to the same head branch, this function returns a slice of prs
+func GetPullRequestsByHeadBranch(headBranch string, headRepo *Repository, status PullRequestStatus) ([]*PullRequest, error) {
+	prs := make([]*PullRequest, 0, 2)
+	if err := x.Where("head_branch = ? AND head_repo_id = ? AND status = ?", headBranch, headRepo.ID, status).
+		Desc("id").
+		Find(prs); err != nil {
+		return nil, err
+	}
+	if len(prs) == 0 {
+		return nil, ErrPullRequestNotExist{
+			HeadBranch: headBranch,
+			HeadRepoID: headRepo.ID,
+		}
+	}
+	return prs, nil
+}
+
 // GetBaseBranchHTMLURL returns the HTML URL of the base branch
 func (pr *PullRequest) GetBaseBranchHTMLURL() string {
 	if err := pr.LoadBaseRepo(); err != nil {

models/scheduled_pull_request_merge.go

@@ -0,0 +1,113 @@
+// Copyright 2021 Gitea. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package models
+
+import (
+	"code.gitea.io/gitea/modules/timeutil"
+)
+
+// ScheduledPullRequestMerge represents a pull request scheduled for merging when checks succeed
+type ScheduledPullRequestMerge struct {
+	ID          int64              `xorm:"pk autoincr"`
+	PullID      int64              `xorm:"BIGINT"`
+	DoerID      int64              `xorm:"BIGINT"`
+	Doer        *User              `xorm:"-"`
+	MergeStyle  MergeStyle         `xorm:"varchar(50)"`
+	Message     string             `xorm:"TEXT"`
+	CreatedUnix timeutil.TimeStamp `xorm:"created"`
+}
+
+// ScheduleAutoMerge schedules a pull request to be merged when all checks succeed
+func ScheduleAutoMerge(doer *User, pullID int64, style MergeStyle, message string) error {
+	sess := x.NewSession()
+	if err := sess.Begin(); err != nil {
+		return err
+	}
+	defer sess.Close()
+
+	// Check if we already have a merge scheduled for that pull request
+	if exists, _, err := getScheduledPullRequestMergeByPullID(sess, pullID); err != nil {
+		return err
+	} else if exists {
+		return ErrPullRequestAlreadyScheduledToAutoMerge{PullID: pullID}
+	}
+
+	if _, err := sess.Insert(&ScheduledPullRequestMerge{
+		DoerID:     doer.ID,
+		PullID:     pullID,
+		MergeStyle: style,
+		Message:    message,
+	}); err != nil {
+		return err
+	}
+
+	pr, err := getPullRequestByID(sess, pullID)
+	if err != nil {
+		return err
+	}
+
+	if _, err := createAutoMergeComment(sess, CommentTypePRScheduledToAutoMerge, pr, doer); err != nil {
+		return err
+	}
+
+	return sess.Commit()
+}
+
+// GetScheduledPullRequestMergeByPullID gets a scheduled pull request merge by pull request id
+func GetScheduledPullRequestMergeByPullID(pullID int64) (bool, *ScheduledPullRequestMerge, error) {
+	return getScheduledPullRequestMergeByPullID(x, pullID)
+}
+
+func getScheduledPullRequestMergeByPullID(e Engine, pullID int64) (bool, *ScheduledPullRequestMerge, error) {
+	scheduledPRM := &ScheduledPullRequestMerge{}
+	exists, err := e.Where("pull_id = ?", pullID).Get(scheduledPRM)
+	if err != nil || !exists {
+		return false, nil, err
+	}
+
+	doer, err := getUserByID(e, scheduledPRM.DoerID)
+	if err != nil {
+		return false, nil, err
+	}
+
+	scheduledPRM.Doer = doer
+	return true, scheduledPRM, nil
+}
+
+// RemoveScheduledPullRequestMerge cancels a previously scheduled pull request
+func RemoveScheduledPullRequestMerge(doer *User, pullID int64, comment bool) error {
+	sess := x.NewSession()
+	if err := sess.Begin(); err != nil {
+		return err
+	}
+	defer sess.Close()
+
+	exist, scheduledPRM, err := getScheduledPullRequestMergeByPullID(sess, pullID)
+	if err != nil {
+		return err
+	} else if !exist {
+		return ErrNotExist{ID: pullID}
+	}
+
+	if _, err := sess.ID(scheduledPRM.ID).Delete(&ScheduledPullRequestMerge{}); err != nil {
+		return err
+	}
+
+	// if pull got merged we dont need to add a "auto-merge canceled comment"
+	if !comment || doer == nil {
+		return sess.Commit()
+	}
+
+	pr, err := getPullRequestByID(sess, pullID)
+	if err != nil {
+		return err
+	}
+
+	if _, err := createAutoMergeComment(sess, CommentTypePRUnScheduledToAutoMerge, pr, doer); err != nil {
+		return err
+	}
+
+	return sess.Commit()
+}