afan
/
gitea
Tarkkaile 1
Äänestä 0
Fork 0
Koodi Ongelmat 0 Pull-pyynnöt 0 Julkaisut 0 Wiki Activity
gitea源码
3 Commitit
2 Branchit
Haara: master
Branchit Tagit
${ item.name }
Create branch ${ searchTerm }
from 'master'
${ noResults }
gitea/services/mailer/mail_test.go

mail_test.go 21KB
Pysyvä linkki Historia Raaka

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568 
  1. // Copyright 2019 The Gitea Authors. All rights reserved.

  2. // SPDX-License-Identifier: MIT

  3. 

  4. package mailer

  5. 

  6. import (

  7. 	"bytes"

  8. 	"context"

  9. 	"encoding/base64"

  10. 	"fmt"

  11. 	"html/template"

  12. 	"io"

  13. 	"mime/quotedprintable"

  14. 	"regexp"

  15. 	"strings"

  16. 	"testing"

  17. 	texttmpl "text/template"

  18. 

  19. 	actions_model "code.gitea.io/gitea/models/actions"

  20. 	activities_model "code.gitea.io/gitea/models/activities"

  21. 	issues_model "code.gitea.io/gitea/models/issues"

  22. 	repo_model "code.gitea.io/gitea/models/repo"

  23. 	"code.gitea.io/gitea/models/unittest"

  24. 	user_model "code.gitea.io/gitea/models/user"

  25. 	"code.gitea.io/gitea/modules/markup"

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

  27. 	"code.gitea.io/gitea/modules/storage"

  28. 	"code.gitea.io/gitea/modules/templates"

  29. 	"code.gitea.io/gitea/modules/test"

  30. 	"code.gitea.io/gitea/services/attachment"

  31. 	sender_service "code.gitea.io/gitea/services/mailer/sender"

  32. 

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

  34. 	"github.com/stretchr/testify/require"

  35. )

  36. 

  37. const subjectTpl = `

  38. {{.SubjectPrefix}}[{{.Repo}}] @{{.Doer.Name}} #{{.Issue.Index}} - {{.Issue.Title}}

  39. `

  40. 

  41. const bodyTpl = `

  42. <!DOCTYPE html>

  43. <html>

  44. <head>

  45. 	<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />

  46. 	<title>{{.Subject}}</title>

  47. </head>

  48. 

  49. <body>

  50. 	<p>{{.Body}}</p>

  51. 	<p>

  52. 		---

  53. 		<br>

  54. 		<a href="{{.Link}}">View it on Gitea</a>.

  55. 	</p>

  56. </body>

  57. </html>

  58. `

  59. 

  60. func prepareMailerTest(t *testing.T) (doer *user_model.User, repo *repo_model.Repository, issue *issues_model.Issue, comment *issues_model.Comment) {

  61. 	assert.NoError(t, unittest.PrepareTestDatabase())

  62. 	setting.MailService = &setting.Mailer{From: "test@gitea.com"}

  63. 	setting.Domain = "localhost"

  64. 	setting.AppURL = "https://try.gitea.io/"

  65. 

  66. 	doer = unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})

  67. 	repo = unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1, Owner: doer})

  68. 	issue = unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 1, Repo: repo, Poster: doer})

  69. 	comment = unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: 2, Issue: issue})

  70. 	require.NoError(t, issue.LoadRepo(t.Context()))

  71. 	return doer, repo, issue, comment

  72. }

  73. 

  74. func prepareMailerBase64Test(t *testing.T) (doer *user_model.User, repo *repo_model.Repository, issue *issues_model.Issue, att1, att2 *repo_model.Attachment) {

  75. 	user, repo, issue, comment := prepareMailerTest(t)

  76. 	setting.MailService.EmbedAttachmentImages = true

  77. 

  78. 	att1, err := attachment.NewAttachment(t.Context(), &repo_model.Attachment{

  79. 		RepoID:     repo.ID,

  80. 		IssueID:    issue.ID,

  81. 		UploaderID: user.ID,

  82. 		CommentID:  comment.ID,

  83. 		Name:       "test.png",

  84. 	}, bytes.NewReader([]byte("\x89\x50\x4e\x47\x0d\x0a\x1a\x0a")), 8)

  85. 	require.NoError(t, err)

  86. 

  87. 	att2, err = attachment.NewAttachment(t.Context(), &repo_model.Attachment{

  88. 		RepoID:     repo.ID,

  89. 		IssueID:    issue.ID,

  90. 		UploaderID: user.ID,

  91. 		CommentID:  comment.ID,

  92. 		Name:       "test.png",

  93. 	}, bytes.NewReader([]byte("\x89\x50\x4e\x47\x0d\x0a\x1a\x0a"+strings.Repeat("\x00", 1024))), 8+1024)

  94. 	require.NoError(t, err)

  95. 

  96. 	return user, repo, issue, att1, att2

  97. }

  98. 

  99. func prepareMailTemplates(name, subjectTmpl, bodyTmpl string) {

  100. 	loadedTemplates.Store(&templates.MailTemplates{

  101. 		SubjectTemplates: texttmpl.Must(texttmpl.New(name).Parse(subjectTmpl)),

  102. 		BodyTemplates:    template.Must(template.New(name).Parse(bodyTmpl)),

  103. 	})

  104. }

  105. 

  106. func TestComposeIssueComment(t *testing.T) {

  107. 	doer, _, issue, comment := prepareMailerTest(t)

  108. 

  109. 	markup.Init(&markup.RenderHelperFuncs{

  110. 		IsUsernameMentionable: func(ctx context.Context, username string) bool {

  111. 			return username == doer.Name

  112. 		},

  113. 	})

  114. 

  115. 	setting.IncomingEmail.Enabled = true

  116. 	defer func() { setting.IncomingEmail.Enabled = false }()

  117. 

  118. 	prepareMailTemplates("repo/issue/comment", subjectTpl, bodyTpl)

  119. 

  120. 	recipients := []*user_model.User{{Name: "Test", Email: "test@gitea.com"}, {Name: "Test2", Email: "test2@gitea.com"}}

  121. 	msgs, err := composeIssueCommentMessages(t.Context(), &mailComment{

  122. 		Issue: issue, Doer: doer, ActionType: activities_model.ActionCommentIssue,

  123. 		Content: fmt.Sprintf("test @%s %s#%d body", doer.Name, issue.Repo.FullName(), issue.Index),

  124. 		Comment: comment,

  125. 	}, "en-US", recipients, false, "issue comment")

  126. 	assert.NoError(t, err)

  127. 	assert.Len(t, msgs, 2)

  128. 	gomailMsg := msgs[0].ToMessage()

  129. 	replyTo := gomailMsg.GetGenHeader("Reply-To")[0]

  130. 	subject := gomailMsg.GetGenHeader("Subject")[0]

  131. 

  132. 	assert.Len(t, gomailMsg.GetAddrHeader("To"), 1, "exactly one recipient is expected in the To field")

  133. 	tokenRegex := regexp.MustCompile(`\Aincoming\+(.+)@localhost\z`)

  134. 	assert.Regexp(t, tokenRegex, replyTo)

  135. 	token := tokenRegex.FindAllStringSubmatch(replyTo, 1)[0][1]

  136. 	assert.Equal(t, "Re: ", subject[:4], "Comment reply subject should contain Re:")

  137. 	assert.Equal(t, "Re: [user2/repo1] @user2 #1 - issue1", subject)

  138. 	assert.Equal(t, "<user2/repo1/issues/1@localhost>", gomailMsg.GetGenHeader("In-Reply-To")[0], "In-Reply-To header doesn't match")

  139. 	assert.ElementsMatch(t, []string{"<user2/repo1/issues/1@localhost>", "<reply-" + token + "@localhost>"}, gomailMsg.GetGenHeader("References"), "References header doesn't match")

  140. 	assert.Equal(t, "<user2/repo1/issues/1/comment/2@localhost>", gomailMsg.GetGenHeader("Message-ID")[0], "Message-ID header doesn't match")

  141. 	assert.Equal(t, "<mailto:"+replyTo+">", gomailMsg.GetGenHeader("List-Post")[0])

  142. 	assert.Len(t, gomailMsg.GetGenHeader("List-Unsubscribe"), 2) // url + mailto

  143. 

  144. 	var buf bytes.Buffer

  145. 	_, err = gomailMsg.WriteTo(&buf)

  146. 	require.NoError(t, err)

  147. 

  148. 	b, err := io.ReadAll(quotedprintable.NewReader(&buf))

  149. 	assert.NoError(t, err)

  150. 

  151. 	// text/plain

  152. 	assert.Contains(t, string(b), fmt.Sprintf(`( %s )`, doer.HTMLURL(t.Context())))

  153. 	assert.Contains(t, string(b), fmt.Sprintf(`( %s )`, issue.HTMLURL(t.Context())))

  154. 

  155. 	// text/html

  156. 	assert.Contains(t, string(b), fmt.Sprintf(`href="%s"`, doer.HTMLURL(t.Context())))

  157. 	assert.Contains(t, string(b), fmt.Sprintf(`href="%s"`, issue.HTMLURL(t.Context())))

  158. }

  159. 

  160. func TestMailMentionsComment(t *testing.T) {

  161. 	doer, _, issue, comment := prepareMailerTest(t)

  162. 	comment.Poster = doer

  163. 	prepareMailTemplates("repo/issue/comment", subjectTpl, bodyTpl)

  164. 	mails := 0

  165. 

  166. 	defer test.MockVariableValue(&SendAsync, func(msgs ...*sender_service.Message) {

  167. 		mails = len(msgs)

  168. 	})()

  169. 

  170. 	err := MailParticipantsComment(t.Context(), comment, activities_model.ActionCommentIssue, issue, []*user_model.User{})

  171. 	require.NoError(t, err)

  172. 	assert.Equal(t, 3, mails)

  173. }

  174. 

  175. func TestComposeIssueMessage(t *testing.T) {

  176. 	doer, _, issue, _ := prepareMailerTest(t)

  177. 

  178. 	prepareMailTemplates("repo/issue/new", subjectTpl, bodyTpl)

  179. 	recipients := []*user_model.User{{Name: "Test", Email: "test@gitea.com"}, {Name: "Test2", Email: "test2@gitea.com"}}

  180. 	msgs, err := composeIssueCommentMessages(t.Context(), &mailComment{

  181. 		Issue: issue, Doer: doer, ActionType: activities_model.ActionCreateIssue,

  182. 		Content: "test body",

  183. 	}, "en-US", recipients, false, "issue create")

  184. 	assert.NoError(t, err)

  185. 	assert.Len(t, msgs, 2)

  186. 

  187. 	gomailMsg := msgs[0].ToMessage()

  188. 	mailto := gomailMsg.GetAddrHeader("To")

  189. 	subject := gomailMsg.GetGenHeader("Subject")

  190. 	messageID := gomailMsg.GetGenHeader("Message-ID")

  191. 	inReplyTo := gomailMsg.GetGenHeader("In-Reply-To")

  192. 	references := gomailMsg.GetGenHeader("References")

  193. 

  194. 	assert.Len(t, mailto, 1, "exactly one recipient is expected in the To field")

  195. 	assert.Equal(t, "[user2/repo1] @user2 #1 - issue1", subject[0])

  196. 	assert.Equal(t, "<user2/repo1/issues/1@localhost>", inReplyTo[0], "In-Reply-To header doesn't match")

  197. 	assert.Equal(t, "<user2/repo1/issues/1@localhost>", references[0], "References header doesn't match")

  198. 	assert.Equal(t, "<user2/repo1/issues/1@localhost>", messageID[0], "Message-ID header doesn't match")

  199. 	assert.Empty(t, gomailMsg.GetGenHeader("List-Post"))         // incoming mail feature disabled

  200. 	assert.Len(t, gomailMsg.GetGenHeader("List-Unsubscribe"), 1) // url without mailto

  201. }

  202. 

  203. func TestTemplateSelection(t *testing.T) {

  204. 	doer, repo, issue, comment := prepareMailerTest(t)

  205. 	recipients := []*user_model.User{{Name: "Test", Email: "test@gitea.com"}}

  206. 

  207. 	prepareMailTemplates("repo/issue/default", "repo/issue/default/subject", "repo/issue/default/body")

  208. 

  209. 	texttmpl.Must(LoadedTemplates().SubjectTemplates.New("repo/issue/new").Parse("repo/issue/new/subject"))

  210. 	texttmpl.Must(LoadedTemplates().SubjectTemplates.New("repo/pull/comment").Parse("repo/pull/comment/subject"))

  211. 	texttmpl.Must(LoadedTemplates().SubjectTemplates.New("repo/issue/close").Parse("")) // Must default to a fallback subject

  212. 	template.Must(LoadedTemplates().BodyTemplates.New("repo/issue/new").Parse("repo/issue/new/body"))

  213. 	template.Must(LoadedTemplates().BodyTemplates.New("repo/pull/comment").Parse("repo/pull/comment/body"))

  214. 	template.Must(LoadedTemplates().BodyTemplates.New("repo/issue/close").Parse("repo/issue/close/body"))

  215. 

  216. 	expect := func(t *testing.T, msg *sender_service.Message, expSubject, expBody string) {

  217. 		subject := msg.ToMessage().GetGenHeader("Subject")

  218. 		msgbuf := new(bytes.Buffer)

  219. 		_, _ = msg.ToMessage().WriteTo(msgbuf)

  220. 		wholemsg := msgbuf.String()

  221. 		assert.Equal(t, []string{expSubject}, subject)

  222. 		assert.Contains(t, wholemsg, expBody)

  223. 	}

  224. 

  225. 	msg := testComposeIssueCommentMessage(t, &mailComment{

  226. 		Issue: issue, Doer: doer, ActionType: activities_model.ActionCreateIssue,

  227. 		Content: "test body",

  228. 	}, recipients, false, "TestTemplateSelection")

  229. 	expect(t, msg, "repo/issue/new/subject", "repo/issue/new/body")

  230. 

  231. 	msg = testComposeIssueCommentMessage(t, &mailComment{

  232. 		Issue: issue, Doer: doer, ActionType: activities_model.ActionCommentIssue,

  233. 		Content: "test body", Comment: comment,

  234. 	}, recipients, false, "TestTemplateSelection")

  235. 	expect(t, msg, "repo/issue/default/subject", "repo/issue/default/body")

  236. 

  237. 	pull := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 2, Repo: repo, Poster: doer})

  238. 	comment = unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: 4, Issue: pull})

  239. 	msg = testComposeIssueCommentMessage(t, &mailComment{

  240. 		Issue: pull, Doer: doer, ActionType: activities_model.ActionCommentPull,

  241. 		Content: "test body", Comment: comment,

  242. 	}, recipients, false, "TestTemplateSelection")

  243. 	expect(t, msg, "repo/pull/comment/subject", "repo/pull/comment/body")

  244. 

  245. 	msg = testComposeIssueCommentMessage(t, &mailComment{

  246. 		Issue: issue, Doer: doer, ActionType: activities_model.ActionCloseIssue,

  247. 		Content: "test body", Comment: comment,

  248. 	}, recipients, false, "TestTemplateSelection")

  249. 	expect(t, msg, "Re: [user2/repo1] issue1 (#1)", "repo/issue/close/body")

  250. }

  251. 

  252. func TestTemplateServices(t *testing.T) {

  253. 	doer, _, issue, comment := prepareMailerTest(t)

  254. 	assert.NoError(t, issue.LoadRepo(t.Context()))

  255. 

  256. 	expect := func(t *testing.T, issue *issues_model.Issue, comment *issues_model.Comment, doer *user_model.User,

  257. 		actionType activities_model.ActionType, fromMention bool, tplSubject, tplBody, expSubject, expBody string,

  258. 	) {

  259. 		prepareMailTemplates("repo/issue/default", tplSubject, tplBody)

  260. 		recipients := []*user_model.User{{Name: "Test", Email: "test@gitea.com"}}

  261. 		msg := testComposeIssueCommentMessage(t, &mailComment{

  262. 			Issue: issue, Doer: doer, ActionType: actionType,

  263. 			Content: "test body", Comment: comment,

  264. 		}, recipients, fromMention, "TestTemplateServices")

  265. 

  266. 		subject := msg.ToMessage().GetGenHeader("Subject")

  267. 		msgbuf := new(bytes.Buffer)

  268. 		_, _ = msg.ToMessage().WriteTo(msgbuf)

  269. 		wholemsg := msgbuf.String()

  270. 

  271. 		assert.Equal(t, []string{expSubject}, subject)

  272. 		assert.Contains(t, wholemsg, "\r\n"+expBody+"\r\n")

  273. 	}

  274. 

  275. 	expect(t, issue, comment, doer, activities_model.ActionCommentIssue, false,

  276. 		"{{.SubjectPrefix}}[{{.Repo}}]: @{{.Doer.Name}} commented on #{{.Issue.Index}} - {{.Issue.Title}}",

  277. 		"//{{.ActionType}},{{.ActionName}},{{if .IsMention}}norender{{end}}//",

  278. 		"Re: [user2/repo1]: @user2 commented on #1 - issue1",

  279. 		"//issue,comment,//")

  280. 

  281. 	expect(t, issue, comment, doer, activities_model.ActionCommentIssue, true,

  282. 		"{{if .IsMention}}must render{{end}}",

  283. 		"//subject is: {{.Subject}}//",

  284. 		"must render",

  285. 		"//subject is: must render//")

  286. 

  287. 	expect(t, issue, comment, doer, activities_model.ActionCommentIssue, true,

  288. 		"{{.FallbackSubject}}",

  289. 		"//{{.SubjectPrefix}}//",

  290. 		"Re: [user2/repo1] issue1 (#1)",

  291. 		"//Re: //")

  292. }

  293. 

  294. func testComposeIssueCommentMessage(t *testing.T, ctx *mailComment, recipients []*user_model.User, fromMention bool, info string) *sender_service.Message {

  295. 	msgs, err := composeIssueCommentMessages(t.Context(), ctx, "en-US", recipients, fromMention, info)

  296. 	assert.NoError(t, err)

  297. 	assert.Len(t, msgs, 1)

  298. 	return msgs[0]

  299. }

  300. 

  301. func TestGenerateAdditionalHeadersForIssue(t *testing.T) {

  302. 	doer, _, issue, _ := prepareMailerTest(t)

  303. 

  304. 	comment := &mailComment{Issue: issue, Doer: doer}

  305. 	recipient := &user_model.User{Name: "test", Email: "test@gitea.com"}

  306. 

  307. 	headers := generateAdditionalHeadersForIssue(comment, "dummy-reason", recipient)

  308. 

  309. 	expected := map[string]string{

  310. 		"List-ID":                   "user2/repo1 <repo1.user2.localhost>",

  311. 		"List-Archive":              "<https://try.gitea.io/user2/repo1>",

  312. 		"X-Gitea-Reason":            "dummy-reason",

  313. 		"X-Gitea-Sender":            "user2",

  314. 		"X-Gitea-Recipient":         "test",

  315. 		"X-Gitea-Recipient-Address": "test@gitea.com",

  316. 		"X-Gitea-Repository":        "repo1",

  317. 		"X-Gitea-Repository-Path":   "user2/repo1",

  318. 		"X-Gitea-Repository-Link":   "https://try.gitea.io/user2/repo1",

  319. 		"X-Gitea-Issue-ID":          "1",

  320. 		"X-Gitea-Issue-Link":        "https://try.gitea.io/user2/repo1/issues/1",

  321. 	}

  322. 

  323. 	for key, value := range expected {

  324. 		if assert.Contains(t, headers, key) {

  325. 			assert.Equal(t, value, headers[key])

  326. 		}

  327. 	}

  328. }

  329. 

  330. func TestGenerateMessageIDForIssue(t *testing.T) {

  331. 	_, _, issue, comment := prepareMailerTest(t)

  332. 	_, _, pullIssue, _ := prepareMailerTest(t)

  333. 	pullIssue.IsPull = true

  334. 

  335. 	type args struct {

  336. 		issue      *issues_model.Issue

  337. 		comment    *issues_model.Comment

  338. 		actionType activities_model.ActionType

  339. 	}

  340. 	tests := []struct {

  341. 		name   string

  342. 		args   args

  343. 		prefix string

  344. 	}{

  345. 		{

  346. 			name: "Open Issue",

  347. 			args: args{

  348. 				issue:      issue,

  349. 				actionType: activities_model.ActionCreateIssue,

  350. 			},

  351. 			prefix: fmt.Sprintf("<%s/issues/%d@%s>", issue.Repo.FullName(), issue.Index, setting.Domain),

  352. 		},

  353. 		{

  354. 			name: "Open Pull",

  355. 			args: args{

  356. 				issue:      pullIssue,

  357. 				actionType: activities_model.ActionCreatePullRequest,

  358. 			},

  359. 			prefix: fmt.Sprintf("<%s/pulls/%d@%s>", issue.Repo.FullName(), issue.Index, setting.Domain),

  360. 		},

  361. 		{

  362. 			name: "Comment Issue",

  363. 			args: args{

  364. 				issue:      issue,

  365. 				comment:    comment,

  366. 				actionType: activities_model.ActionCommentIssue,

  367. 			},

  368. 			prefix: fmt.Sprintf("<%s/issues/%d/comment/%d@%s>", issue.Repo.FullName(), issue.Index, comment.ID, setting.Domain),

  369. 		},

  370. 		{

  371. 			name: "Comment Pull",

  372. 			args: args{

  373. 				issue:      pullIssue,

  374. 				comment:    comment,

  375. 				actionType: activities_model.ActionCommentPull,

  376. 			},

  377. 			prefix: fmt.Sprintf("<%s/pulls/%d/comment/%d@%s>", issue.Repo.FullName(), issue.Index, comment.ID, setting.Domain),

  378. 		},

  379. 		{

  380. 			name: "Close Issue",

  381. 			args: args{

  382. 				issue:      issue,

  383. 				actionType: activities_model.ActionCloseIssue,

  384. 			},

  385. 			prefix: fmt.Sprintf("<%s/issues/%d/close/", issue.Repo.FullName(), issue.Index),

  386. 		},

  387. 		{

  388. 			name: "Close Pull",

  389. 			args: args{

  390. 				issue:      pullIssue,

  391. 				actionType: activities_model.ActionClosePullRequest,

  392. 			},

  393. 			prefix: fmt.Sprintf("<%s/pulls/%d/close/", issue.Repo.FullName(), issue.Index),

  394. 		},

  395. 		{

  396. 			name: "Reopen Issue",

  397. 			args: args{

  398. 				issue:      issue,

  399. 				actionType: activities_model.ActionReopenIssue,

  400. 			},

  401. 			prefix: fmt.Sprintf("<%s/issues/%d/reopen/", issue.Repo.FullName(), issue.Index),

  402. 		},

  403. 		{

  404. 			name: "Reopen Pull",

  405. 			args: args{

  406. 				issue:      pullIssue,

  407. 				actionType: activities_model.ActionReopenPullRequest,

  408. 			},

  409. 			prefix: fmt.Sprintf("<%s/pulls/%d/reopen/", issue.Repo.FullName(), issue.Index),

  410. 		},

  411. 		{

  412. 			name: "Merge Pull",

  413. 			args: args{

  414. 				issue:      pullIssue,

  415. 				actionType: activities_model.ActionMergePullRequest,

  416. 			},

  417. 			prefix: fmt.Sprintf("<%s/pulls/%d/merge/", issue.Repo.FullName(), issue.Index),

  418. 		},

  419. 		{

  420. 			name: "Ready Pull",

  421. 			args: args{

  422. 				issue:      pullIssue,

  423. 				actionType: activities_model.ActionPullRequestReadyForReview,

  424. 			},

  425. 			prefix: fmt.Sprintf("<%s/pulls/%d/ready/", issue.Repo.FullName(), issue.Index),

  426. 		},

  427. 	}

  428. 	for _, tt := range tests {

  429. 		t.Run(tt.name, func(t *testing.T) {

  430. 			got := generateMessageIDForIssue(tt.args.issue, tt.args.comment, tt.args.actionType)

  431. 			assert.True(t, strings.HasPrefix(got, tt.prefix), "%v, want %v", got, tt.prefix)

  432. 		})

  433. 	}

  434. }

  435. 

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

  437. 	msgID := generateMessageIDForRelease(&repo_model.Release{

  438. 		ID:   1,

  439. 		Repo: &repo_model.Repository{OwnerName: "owner", Name: "repo"},

  440. 	})

  441. 	assert.Equal(t, "<owner/repo/releases/1@localhost>", msgID)

  442. }

  443. 

  444. func TestGenerateMessageIDForActionsWorkflowRunStatusEmail(t *testing.T) {

  445. 	assert.NoError(t, unittest.PrepareTestDatabase())

  446. 

  447. 	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 2})

  448. 	run := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionRun{ID: 795, RepoID: repo.ID})

  449. 	assert.NoError(t, run.LoadAttributes(t.Context()))

  450. 	msgID := generateMessageIDForActionsWorkflowRunStatusEmail(repo, run)

  451. 	assert.Equal(t, "<user2/repo2/actions/runs/191@localhost>", msgID)

  452. }

  453. 

  454. func TestFromDisplayName(t *testing.T) {

  455. 	tmpl, err := texttmpl.New("mailFrom").Parse("{{ .DisplayName }}")

  456. 	assert.NoError(t, err)

  457. 	setting.MailService = &setting.Mailer{FromDisplayNameFormatTemplate: tmpl}

  458. 	defer func() { setting.MailService = nil }()

  459. 

  460. 	tests := []struct {

  461. 		userDisplayName string

  462. 		fromDisplayName string

  463. 	}{{

  464. 		userDisplayName: "test",

  465. 		fromDisplayName: "test",

  466. 	}, {

  467. 		userDisplayName: "Hi Its <Mee>",

  468. 		fromDisplayName: "Hi Its <Mee>",

  469. 	}, {

  470. 		userDisplayName: "Æsir",

  471. 		fromDisplayName: "=?utf-8?q?=C3=86sir?=",

  472. 	}, {

  473. 		userDisplayName: "new😀user",

  474. 		fromDisplayName: "=?utf-8?q?new=F0=9F=98=80user?=",

  475. 	}}

  476. 

  477. 	for _, tc := range tests {

  478. 		t.Run(tc.userDisplayName, func(t *testing.T) {

  479. 			user := &user_model.User{FullName: tc.userDisplayName, Name: "tmp"}

  480. 			got := fromDisplayName(user)

  481. 			assert.Equal(t, tc.fromDisplayName, got)

  482. 		})

  483. 	}

  484. 

  485. 	t.Run("template with all available vars", func(t *testing.T) {

  486. 		tmpl, err = texttmpl.New("mailFrom").Parse("{{ .DisplayName }} (by {{ .AppName }} on [{{ .Domain }}])")

  487. 		assert.NoError(t, err)

  488. 		setting.MailService = &setting.Mailer{FromDisplayNameFormatTemplate: tmpl}

  489. 		oldAppName := setting.AppName

  490. 		setting.AppName = "Code IT"

  491. 		oldDomain := setting.Domain

  492. 		setting.Domain = "code.it"

  493. 		defer func() {

  494. 			setting.AppName = oldAppName

  495. 			setting.Domain = oldDomain

  496. 		}()

  497. 

  498. 		assert.Equal(t, "Mister X (by Code IT on [code.it])", fromDisplayName(&user_model.User{FullName: "Mister X", Name: "tmp"}))

  499. 	})

  500. }

  501. 

  502. func TestEmbedBase64Images(t *testing.T) {

  503. 	user, repo, issue, att1, att2 := prepareMailerBase64Test(t)

  504. 	// comment := &mailComment{Issue: issue, Doer: user}

  505. 

  506. 	imgExternalURL := "https://via.placeholder.com/10"

  507. 	imgExternalImg := fmt.Sprintf(`<img src="%s"/>`, imgExternalURL)

  508. 

  509. 	att1URL := setting.AppURL + repo.Owner.Name + "/" + repo.Name + "/attachments/" + att1.UUID

  510. 	att1Img := fmt.Sprintf(`<img src="%s"/>`, att1URL)

  511. 	att1Base64 := "data:image/png;base64,iVBORw0KGgo="

  512. 	att1ImgBase64 := fmt.Sprintf(`<img src="%s"/>`, att1Base64)

  513. 

  514. 	att2URL := setting.AppURL + repo.Owner.Name + "/" + repo.Name + "/attachments/" + att2.UUID

  515. 	att2Img := fmt.Sprintf(`<img src="%s"/>`, att2URL)

  516. 	att2File, err := storage.Attachments.Open(att2.RelativePath())

  517. 	require.NoError(t, err)

  518. 	defer att2File.Close()

  519. 	att2Bytes, err := io.ReadAll(att2File)

  520. 	require.NoError(t, err)

  521. 	require.Greater(t, len(att2Bytes), 1024)

  522. 	att2Base64 := "data:image/png;base64," + base64.StdEncoding.EncodeToString(att2Bytes)

  523. 	att2ImgBase64 := fmt.Sprintf(`<img src="%s"/>`, att2Base64)

  524. 

  525. 	t.Run("ComposeMessage", func(t *testing.T) {

  526. 		prepareMailTemplates("repo/issue/new", subjectTpl, bodyTpl)

  527. 

  528. 		issue.Content = fmt.Sprintf(`MSG-BEFORE <image src="attachments/%s"> MSG-AFTER`, att1.UUID)

  529. 		require.NoError(t, issues_model.UpdateIssueCols(t.Context(), issue, "content"))

  530. 

  531. 		recipients := []*user_model.User{{Name: "Test", Email: "test@gitea.com"}}

  532. 		msgs, err := composeIssueCommentMessages(t.Context(), &mailComment{

  533. 			Issue:      issue,

  534. 			Doer:       user,

  535. 			ActionType: activities_model.ActionCreateIssue,

  536. 			Content:    issue.Content,

  537. 		}, "en-US", recipients, false, "issue create")

  538. 		require.NoError(t, err)

  539. 

  540. 		mailBody := msgs[0].Body

  541. 		assert.Regexp(t, `MSG-BEFORE <a[^>]+><img src="data:image/png;base64,iVBORw0KGgo=".*/></a> MSG-AFTER`, mailBody)

  542. 	})

  543. 

  544. 	t.Run("EmbedInstanceImageSkipExternalImage", func(t *testing.T) {

  545. 		mailBody := "<html><head></head><body><p>Test1</p>" + imgExternalImg + "<p>Test2</p>" + att1Img + "<p>Test3</p></body></html>"

  546. 		expectedMailBody := "<html><head></head><body><p>Test1</p>" + imgExternalImg + "<p>Test2</p>" + att1ImgBase64 + "<p>Test3</p></body></html>"

  547. 		b64embedder := newMailAttachmentBase64Embedder(user, repo, 1024)

  548. 		resultMailBody, err := b64embedder.Base64InlineImages(t.Context(), template.HTML(mailBody))

  549. 		require.NoError(t, err)

  550. 		assert.Equal(t, expectedMailBody, string(resultMailBody))

  551. 	})

  552. 

  553. 	t.Run("LimitedEmailBodySize", func(t *testing.T) {

  554. 		mailBody := fmt.Sprintf("<html><head></head><body>%s%s</body></html>", att1Img, att2Img)

  555. 		b64embedder := newMailAttachmentBase64Embedder(user, repo, 1024)

  556. 		resultMailBody, err := b64embedder.Base64InlineImages(t.Context(), template.HTML(mailBody))

  557. 		require.NoError(t, err)

  558. 		expected := fmt.Sprintf("<html><head></head><body>%s%s</body></html>", att1ImgBase64, att2Img)

  559. 		assert.Equal(t, expected, string(resultMailBody))

  560. 

  561. 		b64embedder = newMailAttachmentBase64Embedder(user, repo, 4096)

  562. 		resultMailBody, err = b64embedder.Base64InlineImages(t.Context(), template.HTML(mailBody))

  563. 		require.NoError(t, err)

  564. 		expected = fmt.Sprintf("<html><head></head><body>%s%s</body></html>", att1ImgBase64, att2ImgBase64)

  565. 		assert.Equal(t, expected, string(resultMailBody))

  566. 	})

  567. }