osbzr
/
com
项目红包剩余8542，下一贡献奖励5%，即 427个红包
Watch 13
Star 6
Wiki 捐赠
本站源代码
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branch: gamification
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'gamification'
${ noResults }
com/models/action_test.go

494 lines
15KB
Raw Permalink Blame History 

  1. package models

  2. 

  3. import (

  4. 	"path"

  5. 	"strings"

  6. 	"testing"

  7. 

  8. 	"code.gitea.io/gitea/modules/setting"

  9. 

  10. 	"github.com/stretchr/testify/assert"

  11. )

  12. 

  13. func TestAction_GetRepoPath(t *testing.T) {

  14. 	assert.NoError(t, PrepareTestDatabase())

  15. 	repo := AssertExistsAndLoadBean(t, &Repository{}).(*Repository)

  16. 	owner := AssertExistsAndLoadBean(t, &User{ID: repo.OwnerID}).(*User)

  17. 	action := &Action{RepoID: repo.ID}

  18. 	assert.Equal(t, path.Join(owner.Name, repo.Name), action.GetRepoPath())

  19. }

  20. 

  21. func TestAction_GetRepoLink(t *testing.T) {

  22. 	assert.NoError(t, PrepareTestDatabase())

  23. 	repo := AssertExistsAndLoadBean(t, &Repository{}).(*Repository)

  24. 	owner := AssertExistsAndLoadBean(t, &User{ID: repo.OwnerID}).(*User)

  25. 	action := &Action{RepoID: repo.ID}

  26. 	setting.AppSubURL = "/suburl/"

  27. 	expected := path.Join(setting.AppSubURL, owner.Name, repo.Name)

  28. 	assert.Equal(t, expected, action.GetRepoLink())

  29. }

  30. 

  31. func TestNewRepoAction(t *testing.T) {

  32. 	assert.NoError(t, PrepareTestDatabase())

  33. 

  34. 	user := AssertExistsAndLoadBean(t, &User{ID: 2}).(*User)

  35. 	repo := AssertExistsAndLoadBean(t, &Repository{OwnerID: user.ID}).(*Repository)

  36. 	repo.Owner = user

  37. 

  38. 	actionBean := &Action{

  39. 		OpType:    ActionCreateRepo,

  40. 		ActUserID: user.ID,

  41. 		RepoID:    repo.ID,

  42. 		ActUser:   user,

  43. 		Repo:      repo,

  44. 		IsPrivate: repo.IsPrivate,

  45. 	}

  46. 

  47. 	AssertNotExistsBean(t, actionBean)

  48. 	assert.NoError(t, NewRepoAction(user, repo))

  49. 	AssertExistsAndLoadBean(t, actionBean)

  50. 	CheckConsistencyFor(t, &Action{})

  51. }

  52. 

  53. func TestRenameRepoAction(t *testing.T) {

  54. 	assert.NoError(t, PrepareTestDatabase())

  55. 

  56. 	user := AssertExistsAndLoadBean(t, &User{ID: 2}).(*User)

  57. 	repo := AssertExistsAndLoadBean(t, &Repository{OwnerID: user.ID}).(*Repository)

  58. 	repo.Owner = user

  59. 

  60. 	oldRepoName := repo.Name

  61. 	const newRepoName = "newRepoName"

  62. 	repo.Name = newRepoName

  63. 	repo.LowerName = strings.ToLower(newRepoName)

  64. 

  65. 	actionBean := &Action{

  66. 		OpType:    ActionRenameRepo,

  67. 		ActUserID: user.ID,

  68. 		ActUser:   user,

  69. 		RepoID:    repo.ID,

  70. 		Repo:      repo,

  71. 		IsPrivate: repo.IsPrivate,

  72. 		Content:   oldRepoName,

  73. 	}

  74. 	AssertNotExistsBean(t, actionBean)

  75. 	assert.NoError(t, RenameRepoAction(user, oldRepoName, repo))

  76. 	AssertExistsAndLoadBean(t, actionBean)

  77. 

  78. 	_, err := x.ID(repo.ID).Cols("name", "lower_name").Update(repo)

  79. 	assert.NoError(t, err)

  80. 	CheckConsistencyFor(t, &Action{})

  81. }

  82. 

  83. func TestPushCommits_ToAPIPayloadCommits(t *testing.T) {

  84. 	pushCommits := NewPushCommits()

  85. 	pushCommits.Commits = []*PushCommit{

  86. 		{

  87. 			Sha1:           "69554a6",

  88. 			CommitterEmail: "user2@example.com",

  89. 			CommitterName:  "User2",

  90. 			AuthorEmail:    "user2@example.com",

  91. 			AuthorName:     "User2",

  92. 			Message:        "not signed commit",

  93. 		},

  94. 		{

  95. 			Sha1:           "27566bd",

  96. 			CommitterEmail: "user2@example.com",

  97. 			CommitterName:  "User2",

  98. 			AuthorEmail:    "user2@example.com",

  99. 			AuthorName:     "User2",

  100. 			Message:        "good signed commit (with not yet validated email)",

  101. 		},

  102. 		{

  103. 			Sha1:           "5099b81",

  104. 			CommitterEmail: "user2@example.com",

  105. 			CommitterName:  "User2",

  106. 			AuthorEmail:    "user2@example.com",

  107. 			AuthorName:     "User2",

  108. 			Message:        "good signed commit",

  109. 		},

  110. 	}

  111. 	pushCommits.Len = len(pushCommits.Commits)

  112. 

  113. 	repo := AssertExistsAndLoadBean(t, &Repository{ID: 16}).(*Repository)

  114. 	payloadCommits, err := pushCommits.ToAPIPayloadCommits(repo.RepoPath(), "/user2/repo16")

  115. 	assert.NoError(t, err)

  116. 	assert.EqualValues(t, 3, len(payloadCommits))

  117. 

  118. 	assert.Equal(t, "69554a6", payloadCommits[0].ID)

  119. 	assert.Equal(t, "not signed commit", payloadCommits[0].Message)

  120. 	assert.Equal(t, "/user2/repo16/commit/69554a6", payloadCommits[0].URL)

  121. 	assert.Equal(t, "User2", payloadCommits[0].Committer.Name)

  122. 	assert.Equal(t, "user2", payloadCommits[0].Committer.UserName)

  123. 	assert.Equal(t, "User2", payloadCommits[0].Author.Name)

  124. 	assert.Equal(t, "user2", payloadCommits[0].Author.UserName)

  125. 	assert.EqualValues(t, []string{}, payloadCommits[0].Added)

  126. 	assert.EqualValues(t, []string{}, payloadCommits[0].Removed)

  127. 	assert.EqualValues(t, []string{"readme.md"}, payloadCommits[0].Modified)

  128. 

  129. 	assert.Equal(t, "27566bd", payloadCommits[1].ID)

  130. 	assert.Equal(t, "good signed commit (with not yet validated email)", payloadCommits[1].Message)

  131. 	assert.Equal(t, "/user2/repo16/commit/27566bd", payloadCommits[1].URL)

  132. 	assert.Equal(t, "User2", payloadCommits[1].Committer.Name)

  133. 	assert.Equal(t, "user2", payloadCommits[1].Committer.UserName)

  134. 	assert.Equal(t, "User2", payloadCommits[1].Author.Name)

  135. 	assert.Equal(t, "user2", payloadCommits[1].Author.UserName)

  136. 	assert.EqualValues(t, []string{}, payloadCommits[1].Added)

  137. 	assert.EqualValues(t, []string{}, payloadCommits[1].Removed)

  138. 	assert.EqualValues(t, []string{"readme.md"}, payloadCommits[1].Modified)

  139. 

  140. 	assert.Equal(t, "5099b81", payloadCommits[2].ID)

  141. 	assert.Equal(t, "good signed commit", payloadCommits[2].Message)

  142. 	assert.Equal(t, "/user2/repo16/commit/5099b81", payloadCommits[2].URL)

  143. 	assert.Equal(t, "User2", payloadCommits[2].Committer.Name)

  144. 	assert.Equal(t, "user2", payloadCommits[2].Committer.UserName)

  145. 	assert.Equal(t, "User2", payloadCommits[2].Author.Name)

  146. 	assert.Equal(t, "user2", payloadCommits[2].Author.UserName)

  147. 	assert.EqualValues(t, []string{"readme.md"}, payloadCommits[2].Added)

  148. 	assert.EqualValues(t, []string{}, payloadCommits[2].Removed)

  149. 	assert.EqualValues(t, []string{}, payloadCommits[2].Modified)

  150. }

  151. 

  152. func TestPushCommits_AvatarLink(t *testing.T) {

  153. 	pushCommits := NewPushCommits()

  154. 	pushCommits.Commits = []*PushCommit{

  155. 		{

  156. 			Sha1:           "abcdef1",

  157. 			CommitterEmail: "user2@example.com",

  158. 			CommitterName:  "User Two",

  159. 			AuthorEmail:    "user4@example.com",

  160. 			AuthorName:     "User Four",

  161. 			Message:        "message1",

  162. 		},

  163. 		{

  164. 			Sha1:           "abcdef2",

  165. 			CommitterEmail: "user2@example.com",

  166. 			CommitterName:  "User Two",

  167. 			AuthorEmail:    "user2@example.com",

  168. 			AuthorName:     "User Two",

  169. 			Message:        "message2",

  170. 		},

  171. 	}

  172. 	pushCommits.Len = len(pushCommits.Commits)

  173. 

  174. 	assert.Equal(t,

  175. 		"/suburl/user/avatar/user2/-1",

  176. 		pushCommits.AvatarLink("user2@example.com"))

  177. 

  178. 	assert.Equal(t,

  179. 		"https://secure.gravatar.com/avatar/19ade630b94e1e0535b3df7387434154?d=identicon",

  180. 		pushCommits.AvatarLink("nonexistent@example.com"))

  181. }

  182. 

  183. func TestUpdateIssuesCommit(t *testing.T) {

  184. 	assert.NoError(t, PrepareTestDatabase())

  185. 	pushCommits := []*PushCommit{

  186. 		{

  187. 			Sha1:           "abcdef1",

  188. 			CommitterEmail: "user2@example.com",

  189. 			CommitterName:  "User Two",

  190. 			AuthorEmail:    "user4@example.com",

  191. 			AuthorName:     "User Four",

  192. 			Message:        "start working on #FST-1, #1",

  193. 		},

  194. 		{

  195. 			Sha1:           "abcdef2",

  196. 			CommitterEmail: "user2@example.com",

  197. 			CommitterName:  "User Two",

  198. 			AuthorEmail:    "user2@example.com",

  199. 			AuthorName:     "User Two",

  200. 			Message:        "a plain message",

  201. 		},

  202. 		{

  203. 			Sha1:           "abcdef2",

  204. 			CommitterEmail: "user2@example.com",

  205. 			CommitterName:  "User Two",

  206. 			AuthorEmail:    "user2@example.com",

  207. 			AuthorName:     "User Two",

  208. 			Message:        "close #2",

  209. 		},

  210. 	}

  211. 

  212. 	user := AssertExistsAndLoadBean(t, &User{ID: 2}).(*User)

  213. 	repo := AssertExistsAndLoadBean(t, &Repository{ID: 1}).(*Repository)

  214. 	repo.Owner = user

  215. 

  216. 	commentBean := &Comment{

  217. 		Type:      CommentTypeCommitRef,

  218. 		CommitSHA: "abcdef1",

  219. 		PosterID:  user.ID,

  220. 		IssueID:   1,

  221. 	}

  222. 	issueBean := &Issue{RepoID: repo.ID, Index: 2}

  223. 

  224. 	AssertNotExistsBean(t, commentBean)

  225. 	AssertNotExistsBean(t, &Issue{RepoID: repo.ID, Index: 2}, "is_closed=1")

  226. 	assert.NoError(t, UpdateIssuesCommit(user, repo, pushCommits, repo.DefaultBranch))

  227. 	AssertExistsAndLoadBean(t, commentBean)

  228. 	AssertExistsAndLoadBean(t, issueBean, "is_closed=1")

  229. 	CheckConsistencyFor(t, &Action{})

  230. 

  231. 	// Test that push to a non-default branch closes no issue.

  232. 	pushCommits = []*PushCommit{

  233. 		{

  234. 			Sha1:           "abcdef1",

  235. 			CommitterEmail: "user2@example.com",

  236. 			CommitterName:  "User Two",

  237. 			AuthorEmail:    "user4@example.com",

  238. 			AuthorName:     "User Four",

  239. 			Message:        "close #1",

  240. 		},

  241. 	}

  242. 	repo = AssertExistsAndLoadBean(t, &Repository{ID: 3}).(*Repository)

  243. 	commentBean = &Comment{

  244. 		Type:      CommentTypeCommitRef,

  245. 		CommitSHA: "abcdef1",

  246. 		PosterID:  user.ID,

  247. 		IssueID:   6,

  248. 	}

  249. 	issueBean = &Issue{RepoID: repo.ID, Index: 1}

  250. 

  251. 	AssertNotExistsBean(t, commentBean)

  252. 	AssertNotExistsBean(t, &Issue{RepoID: repo.ID, Index: 1}, "is_closed=1")

  253. 	assert.NoError(t, UpdateIssuesCommit(user, repo, pushCommits, "non-existing-branch"))

  254. 	AssertExistsAndLoadBean(t, commentBean)

  255. 	AssertNotExistsBean(t, issueBean, "is_closed=1")

  256. 	CheckConsistencyFor(t, &Action{})

  257. }

  258. 

  259. func TestUpdateIssuesCommit_Colon(t *testing.T) {

  260. 	assert.NoError(t, PrepareTestDatabase())

  261. 	pushCommits := []*PushCommit{

  262. 		{

  263. 			Sha1:           "abcdef2",

  264. 			CommitterEmail: "user2@example.com",

  265. 			CommitterName:  "User Two",

  266. 			AuthorEmail:    "user2@example.com",

  267. 			AuthorName:     "User Two",

  268. 			Message:        "close: #2",

  269. 		},

  270. 	}

  271. 

  272. 	user := AssertExistsAndLoadBean(t, &User{ID: 2}).(*User)

  273. 	repo := AssertExistsAndLoadBean(t, &Repository{ID: 1}).(*Repository)

  274. 	repo.Owner = user

  275. 

  276. 	issueBean := &Issue{RepoID: repo.ID, Index: 2}

  277. 

  278. 	AssertNotExistsBean(t, &Issue{RepoID: repo.ID, Index: 2}, "is_closed=1")

  279. 	assert.NoError(t, UpdateIssuesCommit(user, repo, pushCommits, repo.DefaultBranch))

  280. 	AssertExistsAndLoadBean(t, issueBean, "is_closed=1")

  281. 	CheckConsistencyFor(t, &Action{})

  282. }

  283. 

  284. func TestUpdateIssuesCommit_Issue5957(t *testing.T) {

  285. 	assert.NoError(t, PrepareTestDatabase())

  286. 	user := AssertExistsAndLoadBean(t, &User{ID: 2}).(*User)

  287. 

  288. 	// Test that push to a non-default branch closes an issue.

  289. 	pushCommits := []*PushCommit{

  290. 		{

  291. 			Sha1:           "abcdef1",

  292. 			CommitterEmail: "user2@example.com",

  293. 			CommitterName:  "User Two",

  294. 			AuthorEmail:    "user4@example.com",

  295. 			AuthorName:     "User Four",

  296. 			Message:        "close #2",

  297. 		},

  298. 	}

  299. 

  300. 	repo := AssertExistsAndLoadBean(t, &Repository{ID: 2}).(*Repository)

  301. 	commentBean := &Comment{

  302. 		Type:      CommentTypeCommitRef,

  303. 		CommitSHA: "abcdef1",

  304. 		PosterID:  user.ID,

  305. 		IssueID:   7,

  306. 	}

  307. 

  308. 	issueBean := &Issue{RepoID: repo.ID, Index: 2, ID: 7}

  309. 

  310. 	AssertNotExistsBean(t, commentBean)

  311. 	AssertNotExistsBean(t, issueBean, "is_closed=1")

  312. 	assert.NoError(t, UpdateIssuesCommit(user, repo, pushCommits, "non-existing-branch"))

  313. 	AssertExistsAndLoadBean(t, commentBean)

  314. 	AssertExistsAndLoadBean(t, issueBean, "is_closed=1")

  315. 	CheckConsistencyFor(t, &Action{})

  316. }

  317. 

  318. func TestUpdateIssuesCommit_AnotherRepo(t *testing.T) {

  319. 	assert.NoError(t, PrepareTestDatabase())

  320. 	user := AssertExistsAndLoadBean(t, &User{ID: 2}).(*User)

  321. 

  322. 	// Test that a push to default branch closes issue in another repo

  323. 	// If the user also has push permissions to that repo

  324. 	pushCommits := []*PushCommit{

  325. 		{

  326. 			Sha1:           "abcdef1",

  327. 			CommitterEmail: "user2@example.com",

  328. 			CommitterName:  "User Two",

  329. 			AuthorEmail:    "user2@example.com",

  330. 			AuthorName:     "User Two",

  331. 			Message:        "close user2/repo1#1",

  332. 		},

  333. 	}

  334. 

  335. 	repo := AssertExistsAndLoadBean(t, &Repository{ID: 2}).(*Repository)

  336. 	commentBean := &Comment{

  337. 		Type:      CommentTypeCommitRef,

  338. 		CommitSHA: "abcdef1",

  339. 		PosterID:  user.ID,

  340. 		IssueID:   1,

  341. 	}

  342. 

  343. 	issueBean := &Issue{RepoID: 1, Index: 1, ID: 1}

  344. 

  345. 	AssertNotExistsBean(t, commentBean)

  346. 	AssertNotExistsBean(t, issueBean, "is_closed=1")

  347. 	assert.NoError(t, UpdateIssuesCommit(user, repo, pushCommits, repo.DefaultBranch))

  348. 	AssertExistsAndLoadBean(t, commentBean)

  349. 	AssertExistsAndLoadBean(t, issueBean, "is_closed=1")

  350. 	CheckConsistencyFor(t, &Action{})

  351. }

  352. 

  353. func TestUpdateIssuesCommit_AnotherRepoNoPermission(t *testing.T) {

  354. 	assert.NoError(t, PrepareTestDatabase())

  355. 	user := AssertExistsAndLoadBean(t, &User{ID: 10}).(*User)

  356. 

  357. 	// Test that a push with close reference *can not* close issue

  358. 	// If the commiter doesn't have push rights in that repo

  359. 	pushCommits := []*PushCommit{

  360. 		{

  361. 			Sha1:           "abcdef3",

  362. 			CommitterEmail: "user10@example.com",

  363. 			CommitterName:  "User Ten",

  364. 			AuthorEmail:    "user10@example.com",

  365. 			AuthorName:     "User Ten",

  366. 			Message:        "close user3/repo3#1",

  367. 		},

  368. 	}

  369. 

  370. 	repo := AssertExistsAndLoadBean(t, &Repository{ID: 6}).(*Repository)

  371. 	commentBean := &Comment{

  372. 		Type:      CommentTypeCommitRef,

  373. 		CommitSHA: "abcdef3",

  374. 		PosterID:  user.ID,

  375. 		IssueID:   6,

  376. 	}

  377. 

  378. 	issueBean := &Issue{RepoID: 3, Index: 1, ID: 6}

  379. 

  380. 	AssertNotExistsBean(t, commentBean)

  381. 	AssertNotExistsBean(t, issueBean, "is_closed=1")

  382. 	assert.NoError(t, UpdateIssuesCommit(user, repo, pushCommits, repo.DefaultBranch))

  383. 	AssertNotExistsBean(t, commentBean)

  384. 	AssertNotExistsBean(t, issueBean, "is_closed=1")

  385. 	CheckConsistencyFor(t, &Action{})

  386. }

  387. 

  388. func TestTransferRepoAction(t *testing.T) {

  389. 	assert.NoError(t, PrepareTestDatabase())

  390. 

  391. 	user2 := AssertExistsAndLoadBean(t, &User{ID: 2}).(*User)

  392. 	user4 := AssertExistsAndLoadBean(t, &User{ID: 4}).(*User)

  393. 	repo := AssertExistsAndLoadBean(t, &Repository{ID: 1, OwnerID: user2.ID}).(*Repository)

  394. 

  395. 	repo.OwnerID = user4.ID

  396. 	repo.Owner = user4

  397. 

  398. 	actionBean := &Action{

  399. 		OpType:    ActionTransferRepo,

  400. 		ActUserID: user2.ID,

  401. 		ActUser:   user2,

  402. 		RepoID:    repo.ID,

  403. 		Repo:      repo,

  404. 		IsPrivate: repo.IsPrivate,

  405. 	}

  406. 	AssertNotExistsBean(t, actionBean)

  407. 	assert.NoError(t, TransferRepoAction(user2, user2, repo))

  408. 	AssertExistsAndLoadBean(t, actionBean)

  409. 

  410. 	_, err := x.ID(repo.ID).Cols("owner_id").Update(repo)

  411. 	assert.NoError(t, err)

  412. 	CheckConsistencyFor(t, &Action{})

  413. }

  414. 

  415. func TestMergePullRequestAction(t *testing.T) {

  416. 	assert.NoError(t, PrepareTestDatabase())

  417. 	user := AssertExistsAndLoadBean(t, &User{ID: 2}).(*User)

  418. 	repo := AssertExistsAndLoadBean(t, &Repository{ID: 1, OwnerID: user.ID}).(*Repository)

  419. 	repo.Owner = user

  420. 	issue := AssertExistsAndLoadBean(t, &Issue{ID: 3, RepoID: repo.ID}).(*Issue)

  421. 

  422. 	actionBean := &Action{

  423. 		OpType:    ActionMergePullRequest,

  424. 		ActUserID: user.ID,

  425. 		ActUser:   user,

  426. 		RepoID:    repo.ID,

  427. 		Repo:      repo,

  428. 		IsPrivate: repo.IsPrivate,

  429. 	}

  430. 	AssertNotExistsBean(t, actionBean)

  431. 	assert.NoError(t, MergePullRequestAction(user, repo, issue))

  432. 	AssertExistsAndLoadBean(t, actionBean)

  433. 	CheckConsistencyFor(t, &Action{})

  434. }

  435. 

  436. func TestGetFeeds(t *testing.T) {

  437. 	// test with an individual user

  438. 	assert.NoError(t, PrepareTestDatabase())

  439. 	user := AssertExistsAndLoadBean(t, &User{ID: 2}).(*User)

  440. 

  441. 	actions, err := GetFeeds(GetFeedsOptions{

  442. 		RequestedUser:    user,

  443. 		RequestingUserID: user.ID,

  444. 		IncludePrivate:   true,

  445. 		OnlyPerformedBy:  false,

  446. 		IncludeDeleted:   true,

  447. 	})

  448. 	assert.NoError(t, err)

  449. 	if assert.Len(t, actions, 1) {

  450. 		assert.EqualValues(t, 1, actions[0].ID)

  451. 		assert.EqualValues(t, user.ID, actions[0].UserID)

  452. 	}

  453. 

  454. 	actions, err = GetFeeds(GetFeedsOptions{

  455. 		RequestedUser:    user,

  456. 		RequestingUserID: user.ID,

  457. 		IncludePrivate:   false,

  458. 		OnlyPerformedBy:  false,

  459. 	})

  460. 	assert.NoError(t, err)

  461. 	assert.Len(t, actions, 0)

  462. }

  463. 

  464. func TestGetFeeds2(t *testing.T) {

  465. 	// test with an organization user

  466. 	assert.NoError(t, PrepareTestDatabase())

  467. 	org := AssertExistsAndLoadBean(t, &User{ID: 3}).(*User)

  468. 	const userID = 2 // user2 is an owner of the organization

  469. 

  470. 	actions, err := GetFeeds(GetFeedsOptions{

  471. 		RequestedUser:    org,

  472. 		RequestingUserID: userID,

  473. 		IncludePrivate:   true,

  474. 		OnlyPerformedBy:  false,

  475. 		IncludeDeleted:   true,

  476. 	})

  477. 	assert.NoError(t, err)

  478. 	assert.Len(t, actions, 1)

  479. 	if assert.Len(t, actions, 1) {

  480. 		assert.EqualValues(t, 2, actions[0].ID)

  481. 		assert.EqualValues(t, org.ID, actions[0].UserID)

  482. 	}

  483. 

  484. 	actions, err = GetFeeds(GetFeedsOptions{

  485. 		RequestedUser:    org,

  486. 		RequestingUserID: userID,

  487. 		IncludePrivate:   false,

  488. 		OnlyPerformedBy:  false,

  489. 		IncludeDeleted:   true,

  490. 	})

  491. 	assert.NoError(t, err)

  492. 	assert.Len(t, actions, 0)

  493. }
上海开阖软件有限公司 沪ICP备12045867号-1