@@ -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 |
@@ -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()) |
@@ -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) | |||
} | |||
} |
@@ -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{}) | |||
} |