Move UpdateIssuesCommit from models to repofiles (#9276)

models/action.go

@@ -7,7 +7,6 @@ package models
 
 import (
 	"fmt"
-	"html"
 	"path"
 	"strconv"
 	"strings"
@@ -16,7 +15,6 @@ import (
 	"code.gitea.io/gitea/modules/base"
 	"code.gitea.io/gitea/modules/git"
 	"code.gitea.io/gitea/modules/log"
-	"code.gitea.io/gitea/modules/references"
 	"code.gitea.io/gitea/modules/setting"
 	api "code.gitea.io/gitea/modules/structs"
 	"code.gitea.io/gitea/modules/timeutil"
@@ -409,132 +407,6 @@ func (pc *PushCommits) AvatarLink(email string) string {
 	return pc.avatars[email]
 }
 
-// getIssueFromRef returns the issue referenced by a ref. Returns a nil *Issue
-// if the provided ref references a non-existent issue.
-func getIssueFromRef(repo *Repository, index int64) (*Issue, error) {
-	issue, err := GetIssueByIndex(repo.ID, index)
-	if err != nil {
-		if IsErrIssueNotExist(err) {
-			return nil, nil
-		}
-		return nil, err
-	}
-	return issue, nil
-}
-
-func changeIssueStatus(repo *Repository, issue *Issue, doer *User, status bool) error {
-
-	stopTimerIfAvailable := func(doer *User, issue *Issue) error {
-
-		if StopwatchExists(doer.ID, issue.ID) {
-			if err := CreateOrStopIssueStopwatch(doer, issue); err != nil {
-				return err
-			}
-		}
-
-		return nil
-	}
-
-	issue.Repo = repo
-	if err := issue.ChangeStatus(doer, status); err != nil {
-		// Don't return an error when dependencies are open as this would let the push fail
-		if IsErrDependenciesLeft(err) {
-			return stopTimerIfAvailable(doer, issue)
-		}
-		return err
-	}
-
-	return stopTimerIfAvailable(doer, issue)
-}
-
-// UpdateIssuesCommit checks if issues are manipulated by commit message.
-func UpdateIssuesCommit(doer *User, repo *Repository, commits []*PushCommit, branchName string) error {
-	// Commits are appended in the reverse order.
-	for i := len(commits) - 1; i >= 0; i-- {
-		c := commits[i]
-
-		type markKey struct {
-			ID     int64
-			Action references.XRefAction
-		}
-
-		refMarked := make(map[markKey]bool)
-		var refRepo *Repository
-		var refIssue *Issue
-		var err error
-		for _, ref := range references.FindAllIssueReferences(c.Message) {
-
-			// issue is from another repo
-			if len(ref.Owner) > 0 && len(ref.Name) > 0 {
-				refRepo, err = GetRepositoryFromMatch(ref.Owner, ref.Name)
-				if err != nil {
-					continue
-				}
-			} else {
-				refRepo = repo
-			}
-			if refIssue, err = getIssueFromRef(refRepo, ref.Index); err != nil {
-				return err
-			}
-			if refIssue == nil {
-				continue
-			}
-
-			perm, err := GetUserRepoPermission(refRepo, doer)
-			if err != nil {
-				return err
-			}
-
-			key := markKey{ID: refIssue.ID, Action: ref.Action}
-			if refMarked[key] {
-				continue
-			}
-			refMarked[key] = true
-
-			// FIXME: this kind of condition is all over the code, it should be consolidated in a single place
-			canclose := perm.IsAdmin() || perm.IsOwner() || perm.CanWrite(UnitTypeIssues) || refIssue.PosterID == doer.ID
-			cancomment := canclose || perm.CanRead(UnitTypeIssues)
-
-			// Don't proceed if the user can't comment
-			if !cancomment {
-				continue
-			}
-
-			message := fmt.Sprintf(`<a href="%s/commit/%s">%s</a>`, repo.Link(), c.Sha1, html.EscapeString(c.Message))
-			if err = CreateRefComment(doer, refRepo, refIssue, message, c.Sha1); err != nil {
-				return err
-			}
-
-			// Only issues can be closed/reopened this way, and user needs the correct permissions
-			if refIssue.IsPull || !canclose {
-				continue
-			}
-
-			// Only process closing/reopening keywords
-			if ref.Action != references.XRefActionCloses && ref.Action != references.XRefActionReopens {
-				continue
-			}
-
-			if !repo.CloseIssuesViaCommitInAnyBranch {
-				// If the issue was specified to be in a particular branch, don't allow commits in other branches to close it
-				if refIssue.Ref != "" {
-					if branchName != refIssue.Ref {
-						continue
-					}
-					// Otherwise, only process commits to the default branch
-				} else if branchName != repo.DefaultBranch {
-					continue
-				}
-			}
-
-			if err := changeIssueStatus(refRepo, refIssue, doer, ref.Action == references.XRefActionCloses); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
 // GetFeedsOptions options for retrieving feeds
 type GetFeedsOptions struct {
 	RequestedUser    *User

models/action_test.go

@@ -127,211 +127,6 @@ func TestPushCommits_AvatarLink(t *testing.T) {
 		pushCommits.AvatarLink("nonexistent@example.com"))
 }
 
-func TestUpdateIssuesCommit(t *testing.T) {
-	assert.NoError(t, PrepareTestDatabase())
-	pushCommits := []*PushCommit{
-		{
-			Sha1:           "abcdef1",
-			CommitterEmail: "user2@example.com",
-			CommitterName:  "User Two",
-			AuthorEmail:    "user4@example.com",
-			AuthorName:     "User Four",
-			Message:        "start working on #FST-1, #1",
-		},
-		{
-			Sha1:           "abcdef2",
-			CommitterEmail: "user2@example.com",
-			CommitterName:  "User Two",
-			AuthorEmail:    "user2@example.com",
-			AuthorName:     "User Two",
-			Message:        "a plain message",
-		},
-		{
-			Sha1:           "abcdef2",
-			CommitterEmail: "user2@example.com",
-			CommitterName:  "User Two",
-			AuthorEmail:    "user2@example.com",
-			AuthorName:     "User Two",
-			Message:        "close #2",
-		},
-	}
-
-	user := AssertExistsAndLoadBean(t, &User{ID: 2}).(*User)
-	repo := AssertExistsAndLoadBean(t, &Repository{ID: 1}).(*Repository)
-	repo.Owner = user
-
-	commentBean := &Comment{
-		Type:      CommentTypeCommitRef,
-		CommitSHA: "abcdef1",
-		PosterID:  user.ID,
-		IssueID:   1,
-	}
-	issueBean := &Issue{RepoID: repo.ID, Index: 4}
-
-	AssertNotExistsBean(t, commentBean)
-	AssertNotExistsBean(t, &Issue{RepoID: repo.ID, Index: 2}, "is_closed=1")
-	assert.NoError(t, UpdateIssuesCommit(user, repo, pushCommits, repo.DefaultBranch))
-	AssertExistsAndLoadBean(t, commentBean)
-	AssertExistsAndLoadBean(t, issueBean, "is_closed=1")
-	CheckConsistencyFor(t, &Action{})
-
-	// Test that push to a non-default branch closes no issue.
-	pushCommits = []*PushCommit{
-		{
-			Sha1:           "abcdef1",
-			CommitterEmail: "user2@example.com",
-			CommitterName:  "User Two",
-			AuthorEmail:    "user4@example.com",
-			AuthorName:     "User Four",
-			Message:        "close #1",
-		},
-	}
-	repo = AssertExistsAndLoadBean(t, &Repository{ID: 3}).(*Repository)
-	commentBean = &Comment{
-		Type:      CommentTypeCommitRef,
-		CommitSHA: "abcdef1",
-		PosterID:  user.ID,
-		IssueID:   6,
-	}
-	issueBean = &Issue{RepoID: repo.ID, Index: 1}
-
-	AssertNotExistsBean(t, commentBean)
-	AssertNotExistsBean(t, &Issue{RepoID: repo.ID, Index: 1}, "is_closed=1")
-	assert.NoError(t, UpdateIssuesCommit(user, repo, pushCommits, "non-existing-branch"))
-	AssertExistsAndLoadBean(t, commentBean)
-	AssertNotExistsBean(t, issueBean, "is_closed=1")
-	CheckConsistencyFor(t, &Action{})
-}
-
-func TestUpdateIssuesCommit_Colon(t *testing.T) {
-	assert.NoError(t, PrepareTestDatabase())
-	pushCommits := []*PushCommit{
-		{
-			Sha1:           "abcdef2",
-			CommitterEmail: "user2@example.com",
-			CommitterName:  "User Two",
-			AuthorEmail:    "user2@example.com",
-			AuthorName:     "User Two",
-			Message:        "close: #2",
-		},
-	}
-
-	user := AssertExistsAndLoadBean(t, &User{ID: 2}).(*User)
-	repo := AssertExistsAndLoadBean(t, &Repository{ID: 1}).(*Repository)
-	repo.Owner = user
-
-	issueBean := &Issue{RepoID: repo.ID, Index: 4}
-
-	AssertNotExistsBean(t, &Issue{RepoID: repo.ID, Index: 2}, "is_closed=1")
-	assert.NoError(t, UpdateIssuesCommit(user, repo, pushCommits, repo.DefaultBranch))
-	AssertExistsAndLoadBean(t, issueBean, "is_closed=1")
-	CheckConsistencyFor(t, &Action{})
-}
-
-func TestUpdateIssuesCommit_Issue5957(t *testing.T) {
-	assert.NoError(t, PrepareTestDatabase())
-	user := AssertExistsAndLoadBean(t, &User{ID: 2}).(*User)
-
-	// Test that push to a non-default branch closes an issue.
-	pushCommits := []*PushCommit{
-		{
-			Sha1:           "abcdef1",
-			CommitterEmail: "user2@example.com",
-			CommitterName:  "User Two",
-			AuthorEmail:    "user4@example.com",
-			AuthorName:     "User Four",
-			Message:        "close #2",
-		},
-	}
-
-	repo := AssertExistsAndLoadBean(t, &Repository{ID: 2}).(*Repository)
-	commentBean := &Comment{
-		Type:      CommentTypeCommitRef,
-		CommitSHA: "abcdef1",
-		PosterID:  user.ID,
-		IssueID:   7,
-	}
-
-	issueBean := &Issue{RepoID: repo.ID, Index: 2, ID: 7}
-
-	AssertNotExistsBean(t, commentBean)
-	AssertNotExistsBean(t, issueBean, "is_closed=1")
-	assert.NoError(t, UpdateIssuesCommit(user, repo, pushCommits, "non-existing-branch"))
-	AssertExistsAndLoadBean(t, commentBean)
-	AssertExistsAndLoadBean(t, issueBean, "is_closed=1")
-	CheckConsistencyFor(t, &Action{})
-}
-
-func TestUpdateIssuesCommit_AnotherRepo(t *testing.T) {
-	assert.NoError(t, PrepareTestDatabase())
-	user := AssertExistsAndLoadBean(t, &User{ID: 2}).(*User)
-
-	// Test that a push to default branch closes issue in another repo
-	// If the user also has push permissions to that repo
-	pushCommits := []*PushCommit{
-		{
-			Sha1:           "abcdef1",
-			CommitterEmail: "user2@example.com",
-			CommitterName:  "User Two",
-			AuthorEmail:    "user2@example.com",
-			AuthorName:     "User Two",
-			Message:        "close user2/repo1#1",
-		},
-	}
-
-	repo := AssertExistsAndLoadBean(t, &Repository{ID: 2}).(*Repository)
-	commentBean := &Comment{
-		Type:      CommentTypeCommitRef,
-		CommitSHA: "abcdef1",
-		PosterID:  user.ID,
-		IssueID:   1,
-	}
-
-	issueBean := &Issue{RepoID: 1, Index: 1, ID: 1}
-
-	AssertNotExistsBean(t, commentBean)
-	AssertNotExistsBean(t, issueBean, "is_closed=1")
-	assert.NoError(t, UpdateIssuesCommit(user, repo, pushCommits, repo.DefaultBranch))
-	AssertExistsAndLoadBean(t, commentBean)
-	AssertExistsAndLoadBean(t, issueBean, "is_closed=1")
-	CheckConsistencyFor(t, &Action{})
-}
-
-func TestUpdateIssuesCommit_AnotherRepoNoPermission(t *testing.T) {
-	assert.NoError(t, PrepareTestDatabase())
-	user := AssertExistsAndLoadBean(t, &User{ID: 10}).(*User)
-
-	// Test that a push with close reference *can not* close issue
-	// If the commiter doesn't have push rights in that repo
-	pushCommits := []*PushCommit{
-		{
-			Sha1:           "abcdef3",
-			CommitterEmail: "user10@example.com",
-			CommitterName:  "User Ten",
-			AuthorEmail:    "user10@example.com",
-			AuthorName:     "User Ten",
-			Message:        "close user3/repo3#1",
-		},
-	}
-
-	repo := AssertExistsAndLoadBean(t, &Repository{ID: 6}).(*Repository)
-	commentBean := &Comment{
-		Type:      CommentTypeCommitRef,
-		CommitSHA: "abcdef3",
-		PosterID:  user.ID,
-		IssueID:   6,
-	}
-
-	issueBean := &Issue{RepoID: 3, Index: 1, ID: 6}
-
-	AssertNotExistsBean(t, commentBean)
-	AssertNotExistsBean(t, issueBean, "is_closed=1")
-	assert.NoError(t, UpdateIssuesCommit(user, repo, pushCommits, repo.DefaultBranch))
-	AssertNotExistsBean(t, commentBean)
-	AssertNotExistsBean(t, issueBean, "is_closed=1")
-	CheckConsistencyFor(t, &Action{})
-}
-
 func TestGetFeeds(t *testing.T) {
 	// test with an individual user
 	assert.NoError(t, PrepareTestDatabase())

modules/repofiles/action.go

@@ -7,15 +7,142 @@ package repofiles
 import (
 	"encoding/json"
 	"fmt"
+	"html"
 	"strings"
 
 	"code.gitea.io/gitea/models"
 	"code.gitea.io/gitea/modules/git"
 	"code.gitea.io/gitea/modules/log"
 	"code.gitea.io/gitea/modules/notification"
+	"code.gitea.io/gitea/modules/references"
 	"code.gitea.io/gitea/modules/setting"
 )
 
+// getIssueFromRef returns the issue referenced by a ref. Returns a nil *Issue
+// if the provided ref references a non-existent issue.
+func getIssueFromRef(repo *models.Repository, index int64) (*models.Issue, error) {
+	issue, err := models.GetIssueByIndex(repo.ID, index)
+	if err != nil {
+		if models.IsErrIssueNotExist(err) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	return issue, nil
+}
+
+func changeIssueStatus(repo *models.Repository, issue *models.Issue, doer *models.User, status bool) error {
+	stopTimerIfAvailable := func(doer *models.User, issue *models.Issue) error {
+
+		if models.StopwatchExists(doer.ID, issue.ID) {
+			if err := models.CreateOrStopIssueStopwatch(doer, issue); err != nil {
+				return err
+			}
+		}
+
+		return nil
+	}
+
+	issue.Repo = repo
+	if err := issue.ChangeStatus(doer, status); err != nil {
+		// Don't return an error when dependencies are open as this would let the push fail
+		if models.IsErrDependenciesLeft(err) {
+			return stopTimerIfAvailable(doer, issue)
+		}
+		return err
+	}
+
+	return stopTimerIfAvailable(doer, issue)
+}
+
+// UpdateIssuesCommit checks if issues are manipulated by commit message.
+func UpdateIssuesCommit(doer *models.User, repo *models.Repository, commits []*models.PushCommit, branchName string) error {
+	// Commits are appended in the reverse order.
+	for i := len(commits) - 1; i >= 0; i-- {
+		c := commits[i]
+
+		type markKey struct {
+			ID     int64
+			Action references.XRefAction
+		}
+
+		refMarked := make(map[markKey]bool)
+		var refRepo *models.Repository
+		var refIssue *models.Issue
+		var err error
+		for _, ref := range references.FindAllIssueReferences(c.Message) {
+
+			// issue is from another repo
+			if len(ref.Owner) > 0 && len(ref.Name) > 0 {
+				refRepo, err = models.GetRepositoryFromMatch(ref.Owner, ref.Name)
+				if err != nil {
+					continue
+				}
+			} else {
+				refRepo = repo
+			}
+			if refIssue, err = getIssueFromRef(refRepo, ref.Index); err != nil {
+				return err
+			}
+			if refIssue == nil {
+				continue
+			}
+
+			perm, err := models.GetUserRepoPermission(refRepo, doer)
+			if err != nil {
+				return err
+			}
+
+			key := markKey{ID: refIssue.ID, Action: ref.Action}
+			if refMarked[key] {
+				continue
+			}
+			refMarked[key] = true
+
+			// FIXME: this kind of condition is all over the code, it should be consolidated in a single place
+			canclose := perm.IsAdmin() || perm.IsOwner() || perm.CanWrite(models.UnitTypeIssues) || refIssue.PosterID == doer.ID
+			cancomment := canclose || perm.CanRead(models.UnitTypeIssues)
+
+			// Don't proceed if the user can't comment
+			if !cancomment {
+				continue
+			}
+
+			message := fmt.Sprintf(`<a href="%s/commit/%s">%s</a>`, repo.Link(), c.Sha1, html.EscapeString(c.Message))
+			if err = models.CreateRefComment(doer, refRepo, refIssue, message, c.Sha1); err != nil {
+				return err
+			}
+
+			// Only issues can be closed/reopened this way, and user needs the correct permissions
+			if refIssue.IsPull || !canclose {
+				continue
+			}
+
+			// Only process closing/reopening keywords
+			if ref.Action != references.XRefActionCloses && ref.Action != references.XRefActionReopens {
+				continue
+			}
+
+			if !repo.CloseIssuesViaCommitInAnyBranch {
+				// If the issue was specified to be in a particular branch, don't allow commits in other branches to close it
+				if refIssue.Ref != "" {
+					if branchName != refIssue.Ref {
+						continue
+					}
+					// Otherwise, only process commits to the default branch
+				} else if branchName != repo.DefaultBranch {
+					continue
+				}
+			}
+
+			if err := changeIssueStatus(refRepo, refIssue, doer, ref.Action == references.XRefActionCloses); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
 // CommitRepoActionOptions represent options of a new commit action.
 type CommitRepoActionOptions struct {
 	PusherName  string
@@ -86,7 +213,7 @@ func CommitRepoAction(opts CommitRepoActionOptions) error {
 			opts.Commits.CompareURL = repo.ComposeCompareURL(opts.OldCommitID, opts.NewCommitID)
 		}
 
-		if err = models.UpdateIssuesCommit(pusher, repo, opts.Commits.Commits, refName); err != nil {
+		if err = UpdateIssuesCommit(pusher, repo, opts.Commits.Commits, refName); err != nil {
 			log.Error("updateIssuesCommit: %v", err)
 		}
 	}

modules/repofiles/action_test.go

@@ -124,3 +124,208 @@ func TestCommitRepoAction(t *testing.T) {
 		testCorrectRepoAction(t, s.commitRepoActionOptions, &s.action)
 	}
 }
+
+func TestUpdateIssuesCommit(t *testing.T) {
+	assert.NoError(t, models.PrepareTestDatabase())
+	pushCommits := []*models.PushCommit{
+		{
+			Sha1:           "abcdef1",
+			CommitterEmail: "user2@example.com",
+			CommitterName:  "User Two",
+			AuthorEmail:    "user4@example.com",
+			AuthorName:     "User Four",
+			Message:        "start working on #FST-1, #1",
+		},
+		{
+			Sha1:           "abcdef2",
+			CommitterEmail: "user2@example.com",
+			CommitterName:  "User Two",
+			AuthorEmail:    "user2@example.com",
+			AuthorName:     "User Two",
+			Message:        "a plain message",
+		},
+		{
+			Sha1:           "abcdef2",
+			CommitterEmail: "user2@example.com",
+			CommitterName:  "User Two",
+			AuthorEmail:    "user2@example.com",
+			AuthorName:     "User Two",
+			Message:        "close #2",
+		},
+	}
+
+	user := models.AssertExistsAndLoadBean(t, &models.User{ID: 2}).(*models.User)
+	repo := models.AssertExistsAndLoadBean(t, &models.Repository{ID: 1}).(*models.Repository)
+	repo.Owner = user
+
+	commentBean := &models.Comment{
+		Type:      models.CommentTypeCommitRef,
+		CommitSHA: "abcdef1",
+		PosterID:  user.ID,
+		IssueID:   1,
+	}
+	issueBean := &models.Issue{RepoID: repo.ID, Index: 4}
+
+	models.AssertNotExistsBean(t, commentBean)
+	models.AssertNotExistsBean(t, &models.Issue{RepoID: repo.ID, Index: 2}, "is_closed=1")
+	assert.NoError(t, UpdateIssuesCommit(user, repo, pushCommits, repo.DefaultBranch))
+	models.AssertExistsAndLoadBean(t, commentBean)
+	models.AssertExistsAndLoadBean(t, issueBean, "is_closed=1")
+	models.CheckConsistencyFor(t, &models.Action{})
+
+	// Test that push to a non-default branch closes no issue.
+	pushCommits = []*models.PushCommit{
+		{
+			Sha1:           "abcdef1",
+			CommitterEmail: "user2@example.com",
+			CommitterName:  "User Two",
+			AuthorEmail:    "user4@example.com",
+			AuthorName:     "User Four",
+			Message:        "close #1",
+		},
+	}
+	repo = models.AssertExistsAndLoadBean(t, &models.Repository{ID: 3}).(*models.Repository)
+	commentBean = &models.Comment{
+		Type:      models.CommentTypeCommitRef,
+		CommitSHA: "abcdef1",
+		PosterID:  user.ID,
+		IssueID:   6,
+	}
+	issueBean = &models.Issue{RepoID: repo.ID, Index: 1}
+
+	models.AssertNotExistsBean(t, commentBean)
+	models.AssertNotExistsBean(t, &models.Issue{RepoID: repo.ID, Index: 1}, "is_closed=1")
+	assert.NoError(t, UpdateIssuesCommit(user, repo, pushCommits, "non-existing-branch"))
+	models.AssertExistsAndLoadBean(t, commentBean)
+	models.AssertNotExistsBean(t, issueBean, "is_closed=1")
+	models.CheckConsistencyFor(t, &models.Action{})
+}
+
+func TestUpdateIssuesCommit_Colon(t *testing.T) {
+	assert.NoError(t, models.PrepareTestDatabase())
+	pushCommits := []*models.PushCommit{
+		{
+			Sha1:           "abcdef2",
+			CommitterEmail: "user2@example.com",
+			CommitterName:  "User Two",
+			AuthorEmail:    "user2@example.com",
+			AuthorName:     "User Two",
+			Message:        "close: #2",
+		},
+	}
+
+	user := models.AssertExistsAndLoadBean(t, &models.User{ID: 2}).(*models.User)
+	repo := models.AssertExistsAndLoadBean(t, &models.Repository{ID: 1}).(*models.Repository)
+	repo.Owner = user
+
+	issueBean := &models.Issue{RepoID: repo.ID, Index: 4}
+
+	models.AssertNotExistsBean(t, &models.Issue{RepoID: repo.ID, Index: 2}, "is_closed=1")
+	assert.NoError(t, UpdateIssuesCommit(user, repo, pushCommits, repo.DefaultBranch))
+	models.AssertExistsAndLoadBean(t, issueBean, "is_closed=1")
+	models.CheckConsistencyFor(t, &models.Action{})
+}
+
+func TestUpdateIssuesCommit_Issue5957(t *testing.T) {
+	assert.NoError(t, models.PrepareTestDatabase())
+	user := models.AssertExistsAndLoadBean(t, &models.User{ID: 2}).(*models.User)
+
+	// Test that push to a non-default branch closes an issue.
+	pushCommits := []*models.PushCommit{
+		{
+			Sha1:           "abcdef1",
+			CommitterEmail: "user2@example.com",
+			CommitterName:  "User Two",
+			AuthorEmail:    "user4@example.com",
+			AuthorName:     "User Four",
+			Message:        "close #2",
+		},
+	}
+
+	repo := models.AssertExistsAndLoadBean(t, &models.Repository{ID: 2}).(*models.Repository)
+	commentBean := &models.Comment{
+		Type:      models.CommentTypeCommitRef,
+		CommitSHA: "abcdef1",
+		PosterID:  user.ID,
+		IssueID:   7,
+	}
+
+	issueBean := &models.Issue{RepoID: repo.ID, Index: 2, ID: 7}
+
+	models.AssertNotExistsBean(t, commentBean)
+	models.AssertNotExistsBean(t, issueBean, "is_closed=1")
+	assert.NoError(t, UpdateIssuesCommit(user, repo, pushCommits, "non-existing-branch"))
+	models.AssertExistsAndLoadBean(t, commentBean)
+	models.AssertExistsAndLoadBean(t, issueBean, "is_closed=1")
+	models.CheckConsistencyFor(t, &models.Action{})
+}
+
+func TestUpdateIssuesCommit_AnotherRepo(t *testing.T) {
+	assert.NoError(t, models.PrepareTestDatabase())
+	user := models.AssertExistsAndLoadBean(t, &models.User{ID: 2}).(*models.User)
+
+	// Test that a push to default branch closes issue in another repo
+	// If the user also has push permissions to that repo
+	pushCommits := []*models.PushCommit{
+		{
+			Sha1:           "abcdef1",
+			CommitterEmail: "user2@example.com",
+			CommitterName:  "User Two",
+			AuthorEmail:    "user2@example.com",
+			AuthorName:     "User Two",
+			Message:        "close user2/repo1#1",
+		},
+	}
+
+	repo := models.AssertExistsAndLoadBean(t, &models.Repository{ID: 2}).(*models.Repository)
+	commentBean := &models.Comment{
+		Type:      models.CommentTypeCommitRef,
+		CommitSHA: "abcdef1",
+		PosterID:  user.ID,
+		IssueID:   1,
+	}
+
+	issueBean := &models.Issue{RepoID: 1, Index: 1, ID: 1}
+
+	models.AssertNotExistsBean(t, commentBean)
+	models.AssertNotExistsBean(t, issueBean, "is_closed=1")
+	assert.NoError(t, UpdateIssuesCommit(user, repo, pushCommits, repo.DefaultBranch))
+	models.AssertExistsAndLoadBean(t, commentBean)
+	models.AssertExistsAndLoadBean(t, issueBean, "is_closed=1")
+	models.CheckConsistencyFor(t, &models.Action{})
+}
+
+func TestUpdateIssuesCommit_AnotherRepoNoPermission(t *testing.T) {
+	assert.NoError(t, models.PrepareTestDatabase())
+	user := models.AssertExistsAndLoadBean(t, &models.User{ID: 10}).(*models.User)
+
+	// Test that a push with close reference *can not* close issue
+	// If the commiter doesn't have push rights in that repo
+	pushCommits := []*models.PushCommit{
+		{
+			Sha1:           "abcdef3",
+			CommitterEmail: "user10@example.com",
+			CommitterName:  "User Ten",
+			AuthorEmail:    "user10@example.com",
+			AuthorName:     "User Ten",
+			Message:        "close user3/repo3#1",
+		},
+	}
+
+	repo := models.AssertExistsAndLoadBean(t, &models.Repository{ID: 6}).(*models.Repository)
+	commentBean := &models.Comment{
+		Type:      models.CommentTypeCommitRef,
+		CommitSHA: "abcdef3",
+		PosterID:  user.ID,
+		IssueID:   6,
+	}
+
+	issueBean := &models.Issue{RepoID: 3, Index: 1, ID: 6}
+
+	models.AssertNotExistsBean(t, commentBean)
+	models.AssertNotExistsBean(t, issueBean, "is_closed=1")
+	assert.NoError(t, UpdateIssuesCommit(user, repo, pushCommits, repo.DefaultBranch))
+	models.AssertNotExistsBean(t, commentBean)
+	models.AssertNotExistsBean(t, issueBean, "is_closed=1")
+	models.CheckConsistencyFor(t, &models.Action{})
+}