Rewrite the 'AutoDate' tests using subtests

Also add a test to check the permissions to set a date, and a test
to check update dates on milestones.

The tests related to 'AutoDate' are:
- TestAPIEditIssueAutoDate
- TestAPIAddIssueLabelsAutoDate
- TestAPIEditIssueMilestoneAutoDate
- TestAPICreateIssueAttachmentAutoDate
- TestAPICreateCommentAutoDate
- TestAPIEditCommentWithDate
- TestAPICreateCommentAttachmentAutoDate

tests/integration/api_comment_attachment_test.go

@@ -112,7 +112,7 @@ func TestAPICreateCommentAttachment(t *testing.T) {
 	unittest.AssertExistsAndLoadBean(t, &repo_model.Attachment{ID: apiAttachment.ID, CommentID: comment.ID})
 }
 
-func TestAPICreateCommentAttachmentWithAutoDate(t *testing.T) {
+func TestAPICreateCommentAttachmentAutoDate(t *testing.T) {
 	defer tests.PrepareTestEnv(t)()
 
 	comment := unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: 2})
@@ -129,73 +129,63 @@ func TestAPICreateCommentAttachmentWithAutoDate(t *testing.T) {
 	buff := generateImg()
 	body := &bytes.Buffer{}
 
-	// Setup multi-part
+	t.Run("WithAutoDate", func(t *testing.T) {
-	writer := multipart.NewWriter(body)
+		defer tests.PrintCurrentTest(t)()
-	part, err := writer.CreateFormFile("attachment", filename)
-	assert.NoError(t, err)
-	_, err = io.Copy(part, &buff)
-	assert.NoError(t, err)
-	err = writer.Close()
-	assert.NoError(t, err)
 
-	req := NewRequestWithBody(t, "POST", urlStr, body)
+		// Setup multi-part
-	req.Header.Add("Content-Type", writer.FormDataContentType())
+		writer := multipart.NewWriter(body)
-	resp := session.MakeRequest(t, req, http.StatusCreated)
+		part, err := writer.CreateFormFile("attachment", filename)
+		assert.NoError(t, err)
+		_, err = io.Copy(part, &buff)
+		assert.NoError(t, err)
+		err = writer.Close()
+		assert.NoError(t, err)
 
-	apiAttachment := new(api.Attachment)
+		req := NewRequestWithBody(t, "POST", urlStr, body)
-	DecodeJSON(t, resp, &apiAttachment)
+		req.Header.Add("Content-Type", writer.FormDataContentType())
+		resp := session.MakeRequest(t, req, http.StatusCreated)
+		apiAttachment := new(api.Attachment)
+		DecodeJSON(t, resp, &apiAttachment)
 
-	unittest.AssertExistsAndLoadBean(t, &repo_model.Attachment{ID: apiAttachment.ID})
+		unittest.AssertExistsAndLoadBean(t, &repo_model.Attachment{ID: apiAttachment.ID})
-	// the execution of the API call supposedly lasted less than one minute
+		// the execution of the API call supposedly lasted less than one minute
-	updatedSince := time.Since(apiAttachment.Created)
+		updatedSince := time.Since(apiAttachment.Created)
-	assert.LessOrEqual(t, updatedSince, time.Minute)
+		assert.LessOrEqual(t, updatedSince, time.Minute)
 
-	commentAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: comment.ID})
+		commentAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: comment.ID})
-	updatedSince = time.Since(commentAfter.UpdatedUnix.AsTime())
+		updatedSince = time.Since(commentAfter.UpdatedUnix.AsTime())
-	assert.LessOrEqual(t, updatedSince, time.Minute)
+		assert.LessOrEqual(t, updatedSince, time.Minute)
-}
+	})
 
-func TestAPICreateCommentAttachmentWithNoAutoDate(t *testing.T) {
+	t.Run("WithUpdateDate", func(t *testing.T) {
-	defer tests.PrepareTestEnv(t)()
+		defer tests.PrintCurrentTest(t)()
 
-	comment := unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: 2})
+		updatedAt := time.Now().Add(-time.Hour).Truncate(time.Second)
-	issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: comment.IssueID})
+		urlStr += fmt.Sprintf("&updated_at=%s", updatedAt.UTC().Format(time.RFC3339))
-	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: issue.RepoID})
-	repoOwner := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: repo.OwnerID})
 
-	session := loginUser(t, repoOwner.Name)
+		// Setup multi-part
-	token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteIssue)
+		writer := multipart.NewWriter(body)
-	updatedAt := time.Now().Add(-time.Hour).Truncate(time.Second)
+		part, err := writer.CreateFormFile("attachment", filename)
-	urlStr := fmt.Sprintf("/api/v1/repos/%s/%s/issues/comments/%d/assets?token=%s&updated_at=%s",
+		assert.NoError(t, err)
-		repoOwner.Name, repo.Name, comment.ID, token, updatedAt.UTC().Format(time.RFC3339))
+		_, err = io.Copy(part, &buff)
+		assert.NoError(t, err)
+		err = writer.Close()
+		assert.NoError(t, err)
 
-	filename := "image.png"
+		req := NewRequestWithBody(t, "POST", urlStr, body)
-	buff := generateImg()
+		req.Header.Add("Content-Type", writer.FormDataContentType())
-	body := &bytes.Buffer{}
+		resp := session.MakeRequest(t, req, http.StatusCreated)
+		apiAttachment := new(api.Attachment)
+		DecodeJSON(t, resp, &apiAttachment)
 
-	// Setup multi-part
+		// dates will be converted into the same tz, in order to compare them
-	writer := multipart.NewWriter(body)
+		utcTZ, _ := time.LoadLocation("UTC")
-	part, err := writer.CreateFormFile("attachment", filename)
+		unittest.AssertExistsAndLoadBean(t, &repo_model.Attachment{ID: apiAttachment.ID})
-	assert.NoError(t, err)
+		assert.Equal(t, updatedAt.In(utcTZ), apiAttachment.Created.In(utcTZ))
-	_, err = io.Copy(part, &buff)
-	assert.NoError(t, err)
-	err = writer.Close()
-	assert.NoError(t, err)
 
-	req := NewRequestWithBody(t, "POST", urlStr, body)
+		commentAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: comment.ID})
-	req.Header.Add("Content-Type", writer.FormDataContentType())
+		assert.Equal(t, updatedAt.In(utcTZ), commentAfter.UpdatedUnix.AsTime().In(utcTZ))
-	resp := session.MakeRequest(t, req, http.StatusCreated)
+	})
-
-	apiAttachment := new(api.Attachment)
-	DecodeJSON(t, resp, &apiAttachment)
-
-	// dates will be converted into the same tz, in order to compare them
-	utcTZ, _ := time.LoadLocation("UTC")
-	unittest.AssertExistsAndLoadBean(t, &repo_model.Attachment{ID: apiAttachment.ID})
-	assert.Equal(t, updatedAt.In(utcTZ), apiAttachment.Created.In(utcTZ))
-
-	commentAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: comment.ID})
-	assert.Equal(t, updatedAt.In(utcTZ), commentAfter.UpdatedUnix.AsTime().In(utcTZ))
 }
 
 func TestAPIEditCommentAttachment(t *testing.T) {

tests/integration/api_comment_test.go

@@ -111,61 +111,56 @@ func TestAPICreateComment(t *testing.T) {
 	unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: updatedComment.ID, IssueID: issue.ID, Content: commentBody})
 }
 
-func TestAPICreateCommentWithAutoDate(t *testing.T) {
+func TestAPICreateCommentAutoDate(t *testing.T) {
 	defer tests.PrepareTestEnv(t)()
-	const commentBody = "Comment body"
 
 	issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{})
 	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: issue.RepoID})
 	repoOwner := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: repo.OwnerID})
-
 	token := getUserToken(t, repoOwner.Name, auth_model.AccessTokenScopeWriteIssue)
+
 	urlStr := fmt.Sprintf("/api/v1/repos/%s/%s/issues/%d/comments?token=%s",
 		repoOwner.Name, repo.Name, issue.Index, token)
-	req := NewRequestWithValues(t, "POST", urlStr, map[string]string{
-		"body": commentBody,
-	})
-	resp := MakeRequest(t, req, http.StatusCreated)
-
-	var updatedComment api.Comment
-	DecodeJSON(t, resp, &updatedComment)
-
-	// the execution of the API call supposedly lasted less than one minute
-	updatedSince := time.Since(updatedComment.Updated)
-	assert.LessOrEqual(t, updatedSince, time.Minute)
-
-	commentAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: updatedComment.ID, IssueID: issue.ID, Content: commentBody})
-	updatedSince = time.Since(commentAfter.UpdatedUnix.AsTime())
-	assert.LessOrEqual(t, updatedSince, time.Minute)
-}
-
-func TestAPICreateCommentWithNoAutoDate(t *testing.T) {
-	defer tests.PrepareTestEnv(t)()
 	const commentBody = "Comment body"
-	updatedAt := time.Now().Add(-time.Hour).Truncate(time.Second)
 
-	issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{})
+	t.Run("WithAutoDate", func(t *testing.T) {
-	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: issue.RepoID})
+		defer tests.PrintCurrentTest(t)()
-	repoOwner := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: repo.OwnerID})
 
-	token := getUserToken(t, repoOwner.Name, auth_model.AccessTokenScopeWriteIssue)
+		req := NewRequestWithValues(t, "POST", urlStr, map[string]string{
-	urlStr := fmt.Sprintf("/api/v1/repos/%s/%s/issues/%d/comments?token=%s",
+			"body": commentBody,
-		repoOwner.Name, repo.Name, issue.Index, token)
+		})
-	req := NewRequestWithJSON(t, "POST", urlStr, &api.CreateIssueCommentOption{
+		resp := MakeRequest(t, req, http.StatusCreated)
-		Body:    commentBody,
+		var updatedComment api.Comment
-		Updated: &updatedAt,
+		DecodeJSON(t, resp, &updatedComment)
+
+		// the execution of the API call supposedly lasted less than one minute
+		updatedSince := time.Since(updatedComment.Updated)
+		assert.LessOrEqual(t, updatedSince, time.Minute)
+
+		commentAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: updatedComment.ID, IssueID: issue.ID, Content: commentBody})
+		updatedSince = time.Since(commentAfter.UpdatedUnix.AsTime())
+		assert.LessOrEqual(t, updatedSince, time.Minute)
 	})
 
-	resp := MakeRequest(t, req, http.StatusCreated)
+	t.Run("WithUpdateDate", func(t *testing.T) {
+		defer tests.PrintCurrentTest(t)()
 
-	var updatedComment api.Comment
+		updatedAt := time.Now().Add(-time.Hour).Truncate(time.Second)
-	DecodeJSON(t, resp, &updatedComment)
 
-	// dates will be converted into the same tz, in order to compare them
+		req := NewRequestWithJSON(t, "POST", urlStr, &api.CreateIssueCommentOption{
-	utcTZ, _ := time.LoadLocation("UTC")
+			Body:    commentBody,
-	assert.Equal(t, updatedAt.In(utcTZ), updatedComment.Updated.In(utcTZ))
+			Updated: &updatedAt,
-	commentAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: updatedComment.ID, IssueID: issue.ID, Content: commentBody})
+		})
-	assert.Equal(t, updatedAt.In(utcTZ), commentAfter.UpdatedUnix.AsTime().In(utcTZ))
+		resp := MakeRequest(t, req, http.StatusCreated)
+		var updatedComment api.Comment
+		DecodeJSON(t, resp, &updatedComment)
+
+		// dates will be converted into the same tz, in order to compare them
+		utcTZ, _ := time.LoadLocation("UTC")
+		assert.Equal(t, updatedAt.In(utcTZ), updatedComment.Updated.In(utcTZ))
+		commentAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: updatedComment.ID, IssueID: issue.ID, Content: commentBody})
+		assert.Equal(t, updatedAt.In(utcTZ), commentAfter.UpdatedUnix.AsTime().In(utcTZ))
+	})
 }
 
 func TestAPIGetComment(t *testing.T) {
@@ -219,64 +214,58 @@ func TestAPIEditComment(t *testing.T) {
 	unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: comment.ID, IssueID: issue.ID, Content: newCommentBody})
 }
 
-func TestAPIEditCommentWithAutoDate(t *testing.T) {
+func TestAPIEditCommentWithDate(t *testing.T) {
 	defer tests.PrepareTestEnv(t)()
-	const newCommentBody = "This is the new comment body"
 
 	comment := unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{},
 		unittest.Cond("type = ?", issues_model.CommentTypeComment))
 	issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: comment.IssueID})
 	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: issue.RepoID})
 	repoOwner := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: repo.OwnerID})
-
 	token := getUserToken(t, repoOwner.Name, auth_model.AccessTokenScopeWriteIssue)
+
 	urlStr := fmt.Sprintf("/api/v1/repos/%s/%s/issues/comments/%d?token=%s",
 		repoOwner.Name, repo.Name, comment.ID, token)
-	req := NewRequestWithValues(t, "PATCH", urlStr, map[string]string{
-		"body": newCommentBody,
-	})
-	resp := MakeRequest(t, req, http.StatusOK)
-
-	var updatedComment api.Comment
-	DecodeJSON(t, resp, &updatedComment)
-
-	// the execution of the API call supposedly lasted less than one minute
-	updatedSince := time.Since(updatedComment.Updated)
-	assert.LessOrEqual(t, updatedSince, time.Minute)
-
-	commentAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: comment.ID, IssueID: issue.ID, Content: newCommentBody})
-	updatedSince = time.Since(commentAfter.UpdatedUnix.AsTime())
-	assert.LessOrEqual(t, updatedSince, time.Minute)
-}
-
-func TestAPIEditCommentWithNoAutoDate(t *testing.T) {
-	defer tests.PrepareTestEnv(t)()
 	const newCommentBody = "This is the new comment body"
-	updatedAt := time.Now().Add(-time.Hour).Truncate(time.Second)
 
-	comment := unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{},
+	t.Run("WithAutoDate", func(t *testing.T) {
-		unittest.Cond("type = ?", issues_model.CommentTypeComment))
+		defer tests.PrintCurrentTest(t)()
-	issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: comment.IssueID})
-	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: issue.RepoID})
-	repoOwner := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: repo.OwnerID})
 
-	token := getUserToken(t, repoOwner.Name, auth_model.AccessTokenScopeWriteIssue)
+		req := NewRequestWithValues(t, "PATCH", urlStr, map[string]string{
-	urlStr := fmt.Sprintf("/api/v1/repos/%s/%s/issues/comments/%d?token=%s",
+			"body": newCommentBody,
-		repoOwner.Name, repo.Name, comment.ID, token)
+		})
-	req := NewRequestWithJSON(t, "PATCH", urlStr, &api.EditIssueCommentOption{
+		resp := MakeRequest(t, req, http.StatusOK)
-		Body:    newCommentBody,
+		var updatedComment api.Comment
-		Updated: &updatedAt,
+		DecodeJSON(t, resp, &updatedComment)
+
+		// the execution of the API call supposedly lasted less than one minute
+		updatedSince := time.Since(updatedComment.Updated)
+		assert.LessOrEqual(t, updatedSince, time.Minute)
+
+		commentAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: comment.ID, IssueID: issue.ID, Content: newCommentBody})
+		updatedSince = time.Since(commentAfter.UpdatedUnix.AsTime())
+		assert.LessOrEqual(t, updatedSince, time.Minute)
 	})
-	resp := MakeRequest(t, req, http.StatusOK)
 
-	var updatedComment api.Comment
+	t.Run("WithUpdateDate", func(t *testing.T) {
-	DecodeJSON(t, resp, &updatedComment)
+		defer tests.PrintCurrentTest(t)()
 
-	// dates will be converted into the same tz, in order to compare them
+		updatedAt := time.Now().Add(-time.Hour).Truncate(time.Second)
-	utcTZ, _ := time.LoadLocation("UTC")
+
-	assert.Equal(t, updatedAt.In(utcTZ), updatedComment.Updated.In(utcTZ))
+		req := NewRequestWithJSON(t, "PATCH", urlStr, &api.EditIssueCommentOption{
-	commentAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: comment.ID, IssueID: issue.ID, Content: newCommentBody})
+			Body:    newCommentBody,
-	assert.Equal(t, updatedAt.In(utcTZ), commentAfter.UpdatedUnix.AsTime().In(utcTZ))
+			Updated: &updatedAt,
+		})
+		resp := MakeRequest(t, req, http.StatusOK)
+		var updatedComment api.Comment
+		DecodeJSON(t, resp, &updatedComment)
+
+		// dates will be converted into the same tz, in order to compare them
+		utcTZ, _ := time.LoadLocation("UTC")
+		assert.Equal(t, updatedAt.In(utcTZ), updatedComment.Updated.In(utcTZ))
+		commentAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: comment.ID, IssueID: issue.ID, Content: newCommentBody})
+		assert.Equal(t, updatedAt.In(utcTZ), commentAfter.UpdatedUnix.AsTime().In(utcTZ))
+	})
 }
 
 func TestAPIDeleteComment(t *testing.T) {

tests/integration/api_issue_attachment_test.go

@@ -101,7 +101,7 @@ func TestAPICreateIssueAttachment(t *testing.T) {
 	unittest.AssertExistsAndLoadBean(t, &repo_model.Attachment{ID: apiAttachment.ID, IssueID: issue.ID})
 }
 
-func TestAPICreateIssueAttachmentWithAutoDate(t *testing.T) {
+func TestAPICreateIssueAttachmentAutoDate(t *testing.T) {
 	defer tests.PrepareTestEnv(t)()
 
 	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
@@ -110,80 +110,71 @@ func TestAPICreateIssueAttachmentWithAutoDate(t *testing.T) {
 
 	session := loginUser(t, repoOwner.Name)
 	token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteIssue)
-
-	filename := "image.png"
-	buff := generateImg()
-	body := &bytes.Buffer{}
-
-	// Setup multi-part
-	writer := multipart.NewWriter(body)
-	part, err := writer.CreateFormFile("attachment", filename)
-	assert.NoError(t, err)
-	_, err = io.Copy(part, &buff)
-	assert.NoError(t, err)
-	err = writer.Close()
-	assert.NoError(t, err)
-
 	urlStr := fmt.Sprintf("/api/v1/repos/%s/%s/issues/%d/assets?token=%s",
 		repoOwner.Name, repo.Name, issue.Index, token)
 
-	req := NewRequestWithBody(t, "POST", urlStr, body)
-	req.Header.Add("Content-Type", writer.FormDataContentType())
-	resp := session.MakeRequest(t, req, http.StatusCreated)
-
-	apiAttachment := new(api.Attachment)
-	DecodeJSON(t, resp, &apiAttachment)
-
-	unittest.AssertExistsAndLoadBean(t, &repo_model.Attachment{ID: apiAttachment.ID, IssueID: issue.ID})
-	// the execution of the API call supposedly lasted less than one minute
-	updatedSince := time.Since(apiAttachment.Created)
-	assert.LessOrEqual(t, updatedSince, time.Minute)
-
-	issueAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: issue.Index})
-	updatedSince = time.Since(issueAfter.UpdatedUnix.AsTime())
-	assert.LessOrEqual(t, updatedSince, time.Minute)
-}
-
-func TestAPICreateIssueAttachmentWithNoAutoDate(t *testing.T) {
-	defer tests.PrepareTestEnv(t)()
-
-	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
-	issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{RepoID: repo.ID})
-	repoOwner := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: repo.OwnerID})
-
-	session := loginUser(t, repoOwner.Name)
-	token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteIssue)
-
 	filename := "image.png"
 	buff := generateImg()
 	body := &bytes.Buffer{}
 
-	// Setup multi-part
+	t.Run("WithAutoDate", func(t *testing.T) {
-	writer := multipart.NewWriter(body)
+		defer tests.PrintCurrentTest(t)()
-	part, err := writer.CreateFormFile("attachment", filename)
-	assert.NoError(t, err)
-	_, err = io.Copy(part, &buff)
-	assert.NoError(t, err)
-	err = writer.Close()
-	assert.NoError(t, err)
 
-	updatedAt := time.Now().Add(-time.Hour).Truncate(time.Second)
+		// Setup multi-part
-	urlStr := fmt.Sprintf("/api/v1/repos/%s/%s/issues/%d/assets?token=%s&updated_at=%s",
+		writer := multipart.NewWriter(body)
-		repoOwner.Name, repo.Name, issue.Index, token, updatedAt.UTC().Format(time.RFC3339))
+		part, err := writer.CreateFormFile("attachment", filename)
+		assert.NoError(t, err)
+		_, err = io.Copy(part, &buff)
+		assert.NoError(t, err)
+		err = writer.Close()
+		assert.NoError(t, err)
 
-	req := NewRequestWithBody(t, "POST", urlStr, body)
+		req := NewRequestWithBody(t, "POST", urlStr, body)
-	req.Header.Add("Content-Type", writer.FormDataContentType())
+		req.Header.Add("Content-Type", writer.FormDataContentType())
-	resp := session.MakeRequest(t, req, http.StatusCreated)
+		resp := session.MakeRequest(t, req, http.StatusCreated)
 
-	apiAttachment := new(api.Attachment)
+		apiAttachment := new(api.Attachment)
-	DecodeJSON(t, resp, &apiAttachment)
+		DecodeJSON(t, resp, &apiAttachment)
 
-	// dates will be converted into the same tz, in order to compare them
+		unittest.AssertExistsAndLoadBean(t, &repo_model.Attachment{ID: apiAttachment.ID, IssueID: issue.ID})
-	utcTZ, _ := time.LoadLocation("UTC")
+		// the execution of the API call supposedly lasted less than one minute
-	unittest.AssertExistsAndLoadBean(t, &repo_model.Attachment{ID: apiAttachment.ID, IssueID: issue.ID})
+		updatedSince := time.Since(apiAttachment.Created)
-	assert.Equal(t, updatedAt.In(utcTZ), apiAttachment.Created.In(utcTZ))
+		assert.LessOrEqual(t, updatedSince, time.Minute)
-	issueAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: issue.ID})
+
-	assert.Equal(t, updatedAt.In(utcTZ), issueAfter.UpdatedUnix.AsTime().In(utcTZ))
+		issueAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: issue.Index})
+		updatedSince = time.Since(issueAfter.UpdatedUnix.AsTime())
+		assert.LessOrEqual(t, updatedSince, time.Minute)
+	})
+
+	t.Run("WithUpdateDate", func(t *testing.T) {
+		defer tests.PrintCurrentTest(t)()
+
+		updatedAt := time.Now().Add(-time.Hour).Truncate(time.Second)
+		urlStr += fmt.Sprintf("&updated_at=%s", updatedAt.UTC().Format(time.RFC3339))
+
+		// Setup multi-part
+		writer := multipart.NewWriter(body)
+		part, err := writer.CreateFormFile("attachment", filename)
+		assert.NoError(t, err)
+		_, err = io.Copy(part, &buff)
+		assert.NoError(t, err)
+		err = writer.Close()
+		assert.NoError(t, err)
+
+		req := NewRequestWithBody(t, "POST", urlStr, body)
+		req.Header.Add("Content-Type", writer.FormDataContentType())
+		resp := session.MakeRequest(t, req, http.StatusCreated)
+
+		apiAttachment := new(api.Attachment)
+		DecodeJSON(t, resp, &apiAttachment)
+
+		// dates will be converted into the same tz, in order to compare them
+		utcTZ, _ := time.LoadLocation("UTC")
+		unittest.AssertExistsAndLoadBean(t, &repo_model.Attachment{ID: apiAttachment.ID, IssueID: issue.ID})
+		assert.Equal(t, updatedAt.In(utcTZ), apiAttachment.Created.In(utcTZ))
+		issueAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: issue.ID})
+		assert.Equal(t, updatedAt.In(utcTZ), issueAfter.UpdatedUnix.AsTime().In(utcTZ))
+	})
 }
 
 func TestAPIEditIssueAttachment(t *testing.T) {

tests/integration/api_issue_label_test.go

@@ -16,6 +16,7 @@ import (
 	"code.gitea.io/gitea/models/unittest"
 	user_model "code.gitea.io/gitea/models/user"
 	api "code.gitea.io/gitea/modules/structs"
+	"code.gitea.io/gitea/tests"
 
 	"github.com/stretchr/testify/assert"
 )
@@ -112,57 +113,47 @@ func TestAPIAddIssueLabels(t *testing.T) {
 	unittest.AssertExistsAndLoadBean(t, &issues_model.IssueLabel{IssueID: issue.ID, LabelID: 2})
 }
 
-func TestAPIAddIssueLabelsWithAutoDate(t *testing.T) {
+func TestAPIAddIssueLabelsAutoDate(t *testing.T) {
-	assert.NoError(t, unittest.LoadFixtures())
+	defer tests.PrepareTestEnv(t)()
 
-	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
+	issueBefore := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 3})
-	issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{RepoID: repo.ID})
+	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: issueBefore.RepoID})
-	_ = unittest.AssertExistsAndLoadBean(t, &issues_model.Label{RepoID: repo.ID, ID: 2})
 	owner := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: repo.OwnerID})
 
 	session := loginUser(t, owner.Name)
 	token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteIssue)
-
 	urlStr := fmt.Sprintf("/api/v1/repos/%s/%s/issues/%d/labels?token=%s",
-		repo.OwnerName, repo.Name, issue.Index, token)
+		owner.Name, repo.Name, issueBefore.Index, token)
-	req := NewRequestWithJSON(t, "POST", urlStr, &api.IssueLabelsOption{
+
-		Labels: []int64{1, 2},
+	t.Run("WithAutoDate", func(t *testing.T) {
+		defer tests.PrintCurrentTest(t)()
+
+		req := NewRequestWithJSON(t, "POST", urlStr, &api.IssueLabelsOption{
+			Labels: []int64{1},
+		})
+		MakeRequest(t, req, http.StatusOK)
+
+		issueAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: issueBefore.ID})
+		// the execution of the API call supposedly lasted less than one minute
+		updatedSince := time.Since(issueAfter.UpdatedUnix.AsTime())
+		assert.LessOrEqual(t, updatedSince, time.Minute)
 	})
-	resp := MakeRequest(t, req, http.StatusOK)
-	var apiLabels []*api.Label
-	DecodeJSON(t, resp, &apiLabels)
 
-	issueAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: issue.Index})
+	t.Run("WithUpdatedDate", func(t *testing.T) {
-	// the execution of the API call supposedly lasted less than one minute
+		defer tests.PrintCurrentTest(t)()
-	updatedSince := time.Since(issueAfter.UpdatedUnix.AsTime())
-	assert.LessOrEqual(t, updatedSince, time.Minute)
-}
 
-func TestAPIAddIssueLabelsWithNoAutoDate(t *testing.T) {
+		updatedAt := time.Now().Add(-time.Hour).Truncate(time.Second)
-	assert.NoError(t, unittest.LoadFixtures())
+		req := NewRequestWithJSON(t, "POST", urlStr, &api.IssueLabelsOption{
+			Labels:  []int64{2},
+			Updated: &updatedAt,
+		})
+		MakeRequest(t, req, http.StatusOK)
 
-	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
+		// dates will be converted into the same tz, in order to compare them
-	issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{RepoID: repo.ID})
+		utcTZ, _ := time.LoadLocation("UTC")
-	_ = unittest.AssertExistsAndLoadBean(t, &issues_model.Label{RepoID: repo.ID, ID: 2})
+		issueAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: issueBefore.ID})
-	owner := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: repo.OwnerID})
+		assert.Equal(t, updatedAt.In(utcTZ), issueAfter.UpdatedUnix.AsTime().In(utcTZ))
-
-	session := loginUser(t, owner.Name)
-	token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteIssue)
-	updatedAt := time.Now().Add(-time.Hour).Truncate(time.Second)
-
-	urlStr := fmt.Sprintf("/api/v1/repos/%s/%s/issues/%d/labels?token=%s",
-		repo.OwnerName, repo.Name, issue.Index, token)
-	req := NewRequestWithJSON(t, "POST", urlStr, &api.IssueLabelsOption{
-		Labels:  []int64{1, 2},
-		Updated: &updatedAt,
 	})
-	resp := MakeRequest(t, req, http.StatusOK)
-	var apiLabels []*api.Label
-	DecodeJSON(t, resp, &apiLabels)
-	// dates will be converted into the same tz, in order to compare them
-	utcTZ, _ := time.LoadLocation("UTC")
-	issueAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: issue.Index})
-	assert.Equal(t, updatedAt.In(utcTZ), issueAfter.UpdatedUnix.AsTime().In(utcTZ))
 }
 
 func TestAPIReplaceIssueLabels(t *testing.T) {

tests/integration/api_issue_test.go

@@ -213,61 +213,155 @@ func TestAPIEditIssue(t *testing.T) {
 	assert.Equal(t, title, issueAfter.Title)
 }
 
-func TestAPIEditIssueWithAutoDate(t *testing.T) {
+func TestAPIEditIssueAutoDate(t *testing.T) {
 	defer tests.PrepareTestEnv(t)()
 
-	issueBefore := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 10})
+	issueBefore := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 13})
 	repoBefore := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: issueBefore.RepoID})
 	owner := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: repoBefore.OwnerID})
 	assert.NoError(t, issueBefore.LoadAttributes(db.DefaultContext))
 
-	session := loginUser(t, owner.Name)
+	t.Run("WithAutoDate", func(t *testing.T) {
-	token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteIssue)
+		defer tests.PrintCurrentTest(t)()
 
-	body := "new content!"
+		// User2 is not owner, but can update the 'public' issue with auto date
-	urlStr := fmt.Sprintf("/api/v1/repos/%s/%s/issues/%d?token=%s", owner.Name, repoBefore.Name, issueBefore.Index, token)
+		session := loginUser(t, "user2")
-	req := NewRequestWithJSON(t, "PATCH", urlStr, api.EditIssueOption{
+		token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteIssue)
-		Body: &body,
+		urlStr := fmt.Sprintf("/api/v1/repos/%s/%s/issues/%d?token=%s", owner.Name, repoBefore.Name, issueBefore.Index, token)
+
+		body := "new content!"
+		req := NewRequestWithJSON(t, "PATCH", urlStr, api.EditIssueOption{
+			Body: &body,
+		})
+		resp := MakeRequest(t, req, http.StatusCreated)
+		var apiIssue api.Issue
+		DecodeJSON(t, resp, &apiIssue)
+
+		// the execution of the API call supposedly lasted less than one minute
+		updatedSince := time.Since(apiIssue.Updated)
+		assert.LessOrEqual(t, updatedSince, time.Minute)
+
+		issueAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: issueBefore.ID})
+		updatedSince = time.Since(issueAfter.UpdatedUnix.AsTime())
+		assert.LessOrEqual(t, updatedSince, time.Minute)
 	})
-	resp := MakeRequest(t, req, http.StatusCreated)
-	var apiIssue api.Issue
-	DecodeJSON(t, resp, &apiIssue)
 
-	// the execution of the API call supposedly lasted less than one minute
+	t.Run("WithUpdateDate", func(t *testing.T) {
-	updatedSince := time.Since(apiIssue.Updated)
+		defer tests.PrintCurrentTest(t)()
-	assert.LessOrEqual(t, updatedSince, time.Minute)
 
-	issueAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 10})
+		// User1 is admin, and so can update the issue without auto date
-	updatedSince = time.Since(issueAfter.UpdatedUnix.AsTime())
+		session := loginUser(t, "user1")
-	assert.LessOrEqual(t, updatedSince, time.Minute)
+		token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteIssue)
+		urlStr := fmt.Sprintf("/api/v1/repos/%s/%s/issues/%d?token=%s", owner.Name, repoBefore.Name, issueBefore.Index, token)
+
+		body := "new content, with updated time"
+		updatedAt := time.Now().Add(-time.Hour).Truncate(time.Second)
+		req := NewRequestWithJSON(t, "PATCH", urlStr, api.EditIssueOption{
+			Body:    &body,
+			Updated: &updatedAt,
+		})
+		resp := MakeRequest(t, req, http.StatusCreated)
+		var apiIssue api.Issue
+		DecodeJSON(t, resp, &apiIssue)
+
+		// dates are converted into the same tz, in order to compare them
+		utcTZ, _ := time.LoadLocation("UTC")
+		assert.Equal(t, updatedAt.In(utcTZ), apiIssue.Updated.In(utcTZ))
+
+		issueAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: issueBefore.ID})
+		assert.Equal(t, updatedAt.In(utcTZ), issueAfter.UpdatedUnix.AsTime().In(utcTZ))
+	})
+
+	t.Run("WithoutPermission", func(t *testing.T) {
+		defer tests.PrintCurrentTest(t)()
+
+		// User2 is not owner nor admin, and so can't update the issue without auto date
+		session := loginUser(t, "user2")
+		token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteIssue)
+		urlStr := fmt.Sprintf("/api/v1/repos/%s/%s/issues/%d?token=%s", owner.Name, repoBefore.Name, issueBefore.Index, token)
+
+		body := "new content, with updated time"
+		updatedAt := time.Now().Add(-time.Hour).Truncate(time.Second)
+		req := NewRequestWithJSON(t, "PATCH", urlStr, api.EditIssueOption{
+			Body:    &body,
+			Updated: &updatedAt,
+		})
+		resp := MakeRequest(t, req, http.StatusForbidden)
+		var apiError api.APIError
+		DecodeJSON(t, resp, &apiError)
+
+		assert.Equal(t, "user needs to have admin or owner right", apiError.Message)
+	})
 }
 
-func TestAPIEditIssueWithNoAutoDate(t *testing.T) {
+func TestAPIEditIssueMilestoneAutoDate(t *testing.T) {
 	defer tests.PrepareTestEnv(t)()
 
-	issueBefore := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 10})
+	issueBefore := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 1})
 	repoBefore := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: issueBefore.RepoID})
+
 	owner := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: repoBefore.OwnerID})
 	assert.NoError(t, issueBefore.LoadAttributes(db.DefaultContext))
 
 	session := loginUser(t, owner.Name)
 	token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteIssue)
-
-	body := "new content, with updated time"
-	updatedAt := time.Now().Add(-time.Hour).Truncate(time.Second)
 	urlStr := fmt.Sprintf("/api/v1/repos/%s/%s/issues/%d?token=%s", owner.Name, repoBefore.Name, issueBefore.Index, token)
-	req := NewRequestWithJSON(t, "PATCH", urlStr, api.EditIssueOption{
+
-		Body:    &body,
+	t.Run("WithAutoDate", func(t *testing.T) {
-		Updated: &updatedAt,
+		defer tests.PrintCurrentTest(t)()
+
+		milestone := int64(1)
+		req := NewRequestWithJSON(t, "PATCH", urlStr, api.EditIssueOption{
+			Milestone: &milestone,
+		})
+		MakeRequest(t, req, http.StatusCreated)
+
+		// the execution of the API call supposedly lasted less than one minute
+		milestoneAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Milestone{ID: milestone})
+		updatedSince := time.Since(milestoneAfter.UpdatedUnix.AsTime())
+		assert.LessOrEqual(t, updatedSince, time.Minute)
+	})
+
+	t.Run("WithPostUpdateDate", func(t *testing.T) {
+		defer tests.PrintCurrentTest(t)()
+
+		// Note: the updated_unix field of the test Milestones is set to NULL
+		// Hence, any date is higher than the Milestone's updated date
+		updatedAt := time.Now().Add(-time.Hour).Truncate(time.Second)
+		milestone := int64(2)
+		req := NewRequestWithJSON(t, "PATCH", urlStr, api.EditIssueOption{
+			Milestone: &milestone,
+			Updated:   &updatedAt,
+		})
+		MakeRequest(t, req, http.StatusCreated)
+
+		// the milestone date should be set to 'updatedAt'
+		// dates are converted into the same tz, in order to compare them
+		utcTZ, _ := time.LoadLocation("UTC")
+		milestoneAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Milestone{ID: milestone})
+		assert.Equal(t, updatedAt.In(utcTZ), milestoneAfter.UpdatedUnix.AsTime().In(utcTZ))
+	})
+
+	t.Run("WithPastUpdateDate", func(t *testing.T) {
+		defer tests.PrintCurrentTest(t)()
+
+		// Note: This Milestone's updated_unix has been set to Now() by the first subtest
+		milestone := int64(1)
+		milestoneBefore := unittest.AssertExistsAndLoadBean(t, &issues_model.Milestone{ID: milestone})
+
+		updatedAt := time.Now().Add(-time.Hour).Truncate(time.Second)
+		req := NewRequestWithJSON(t, "PATCH", urlStr, api.EditIssueOption{
+			Milestone: &milestone,
+			Updated:   &updatedAt,
+		})
+		MakeRequest(t, req, http.StatusCreated)
+
+		// the milestone date should not change
+		// dates are converted into the same tz, in order to compare them
+		utcTZ, _ := time.LoadLocation("UTC")
+		milestoneAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Milestone{ID: milestone})
+		assert.Equal(t, milestoneAfter.UpdatedUnix.AsTime().In(utcTZ), milestoneBefore.UpdatedUnix.AsTime().In(utcTZ))
 	})
-	resp := MakeRequest(t, req, http.StatusCreated)
-	var apiIssue api.Issue
-	DecodeJSON(t, resp, &apiIssue)
-	// dates will be converted into the same tz, in order to compare them
-	utcTZ, _ := time.LoadLocation("UTC")
-	assert.Equal(t, updatedAt.In(utcTZ), apiIssue.Updated.In(utcTZ))
-	issueAfter := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 10})
-	assert.Equal(t, updatedAt.In(utcTZ), issueAfter.UpdatedUnix.AsTime().In(utcTZ))
 }
 
 func TestAPISearchIssues(t *testing.T) {