test: consolidate Go tests (#39962)

Consolidate all Go tests. Coverage is identical to before. Go tests are
around 5% faster while being 7% smaller. No non-test code is touched.

models/issues/comment_test.go

@@ -19,162 +19,177 @@ import (
 )
 
 func TestCreateComment(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
+	prepareErr := unittest.PrepareTestDatabase()
 
-	issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{})
-	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: issue.RepoID})
-	doer := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: repo.OwnerID})
+	t.Run("LoadAssigneeUserAndTeam_DeletedTeamBecomesGhostTeam", func(t *testing.T) {
+		assert.NoError(t, prepareErr)
 
-	now := time.Now().Unix()
-	comment, err := issues_model.CreateComment(t.Context(), &issues_model.CreateCommentOptions{
-		Type:    issues_model.CommentTypeComment,
-		Doer:    doer,
-		Repo:    repo,
-		Issue:   issue,
-		Content: "Hello",
-	})
-	assert.NoError(t, err)
-	then := time.Now().Unix()
-
-	assert.Equal(t, issues_model.CommentTypeComment, comment.Type)
-	assert.Equal(t, "Hello", comment.Content)
-	assert.Equal(t, issue.ID, comment.IssueID)
-	assert.Equal(t, doer.ID, comment.PosterID)
-	unittest.AssertInt64InRange(t, now, then, int64(comment.CreatedUnix))
-	unittest.AssertExistsAndLoadBean(t, comment) // assert actually added to DB
-
-	updatedIssue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: issue.ID})
-	unittest.AssertInt64InRange(t, now, then, int64(updatedIssue.UpdatedUnix))
-	assert.Nil(t, comment.CommentMetaData)
-
-	ctx := issues_model.WithProjectWorkflow(t.Context(), project_model.WorkflowEventItemClosed)
-	comment, err = issues_model.CreateComment(ctx, &issues_model.CreateCommentOptions{
-		Type:               issues_model.CommentTypeProjectColumn,
-		Doer:               doer,
-		Repo:               repo,
-		Issue:              issue,
-		ProjectColumnID:    5,
-		ProjectColumnTitle: "Done",
-		ProjectTitle:       "Board",
-	})
-	require.NoError(t, err)
-	assert.Equal(t, &issues_model.CommentMetaData{
-		ProjectColumnID:      5,
-		ProjectColumnTitle:   "Done",
-		ProjectTitle:         "Board",
-		ProjectWorkflowEvent: project_model.WorkflowEventItemClosed,
-		SpecialDoerName:      issues_model.SpecialDoerNameProjectWorkflow,
-	}, unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: comment.ID}).CommentMetaData)
-}
-
-func TestLoadAssigneeUserAndTeam_DeletedTeamBecomesGhostTeam(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 15})
-	comment := &issues_model.Comment{
-		Type:           issues_model.CommentTypeAssignees,
-		IssueID:        issue.ID,
-		AssigneeTeamID: 999999, // non-existing team ID
-	}
-	assert.NoError(t, comment.LoadAssigneeUserAndTeam(t.Context()))
-	assert.NotNil(t, comment.AssigneeTeam)
-	assert.EqualValues(t, -1, comment.AssigneeTeam.ID)
-}
-
-func TestCommentListLoadAttributesMixedAssignees(t *testing.T) {
-	require.NoError(t, unittest.PrepareTestDatabase())
-	first := &issues_model.Comment{
-		ID: 1, PosterID: 1, IssueID: 1, LabelID: 1, MilestoneID: 1, OldMilestoneID: 1, AssigneeID: 1, DependentIssueID: 2,
-	}
-	last := &issues_model.Comment{
-		ID: 2, PosterID: 2, IssueID: 4, LabelID: 2, MilestoneID: 3, OldMilestoneID: 3, AssigneeID: 2, DependentIssueID: 1,
-	}
-	comments := issues_model.CommentList{
-		{AssigneeTeamID: 8},
-		{AssigneeID: 999999},
-		first,
-	}
-	for i := range db.DefaultMaxInSize {
-		id := unittest.NonexistentID - int64(i)
-		comments = append(comments, &issues_model.Comment{
-			ID: id, PosterID: id, IssueID: id, LabelID: id, MilestoneID: id, OldMilestoneID: id, AssigneeID: id, DependentIssueID: id,
-		})
-	}
-	comments = append(comments, last)
-
-	require.NoError(t, comments.LoadAttributes(t.Context()))
-	assert.Nil(t, comments[0].Assignee)
-	assert.Zero(t, comments[0].AssigneeID)
-	assert.Equal(t, user_model.GhostUserID, comments[1].AssigneeID)
-	assert.Equal(t, user_model.GhostUserID, comments[1].Assignee.ID)
-	for _, comment := range []*issues_model.Comment{first, last} {
-		require.NotNil(t, comment.Poster)
-		assert.Equal(t, comment.PosterID, comment.Poster.ID)
-		require.NotNil(t, comment.Issue)
-		assert.Equal(t, comment.IssueID, comment.Issue.ID)
-		require.NotNil(t, comment.Label)
-		assert.Equal(t, comment.LabelID, comment.Label.ID)
-		require.NotNil(t, comment.Milestone)
-		assert.Equal(t, comment.MilestoneID, comment.Milestone.ID)
-		require.NotNil(t, comment.OldMilestone)
-		assert.Equal(t, comment.OldMilestoneID, comment.OldMilestone.ID)
-		require.NotNil(t, comment.Assignee)
-		assert.Equal(t, comment.AssigneeID, comment.Assignee.ID)
-		require.NotNil(t, comment.DependentIssue)
-		assert.Equal(t, comment.DependentIssueID, comment.DependentIssue.ID)
-		require.NotNil(t, comment.DependentIssue.Repo)
-		assert.Equal(t, comment.DependentIssue.RepoID, comment.DependentIssue.Repo.ID)
-		require.Len(t, comment.Attachments, 2)
-		for _, attachment := range comment.Attachments {
-			assert.Equal(t, comment.ID, attachment.CommentID)
+		issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 15})
+		comment := &issues_model.Comment{
+			Type:           issues_model.CommentTypeAssignees,
+			IssueID:        issue.ID,
+			AssigneeTeamID: 999999, // non-existing team ID
 		}
-	}
-	missing := comments[3]
-	assert.Equal(t, user_model.GhostUserID, missing.Poster.ID)
-	assert.Equal(t, user_model.GhostUserID, missing.Assignee.ID)
-	assert.Nil(t, missing.Issue)
-	assert.Nil(t, missing.Label)
-	assert.Nil(t, missing.Milestone)
-	assert.Nil(t, missing.OldMilestone)
-	assert.Nil(t, missing.DependentIssue)
-	assert.Empty(t, missing.Attachments)
-}
+		assert.NoError(t, comment.LoadAssigneeUserAndTeam(t.Context()))
+		assert.NotNil(t, comment.AssigneeTeam)
+		assert.EqualValues(t, -1, comment.AssigneeTeam.ID)
+	})
 
-func Test_UpdateCommentAttachment(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
+	t.Run("CommentListLoadAttributesMixedAssignees", func(t *testing.T) {
+		require.NoError(t, prepareErr)
 
-	comment := unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: 1})
-	issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: comment.IssueID})
-	attachment := repo_model.Attachment{
-		RepoID: issue.RepoID, // must match the comment's repo, else the cross-repo guard rejects it
-		Name:   "test.txt",
-	}
-	assert.NoError(t, db.Insert(t.Context(), &attachment))
+		first := &issues_model.Comment{
+			ID: 1, PosterID: 1, IssueID: 1, LabelID: 1, MilestoneID: 1, OldMilestoneID: 1, AssigneeID: 1, DependentIssueID: 2,
+		}
+		last := &issues_model.Comment{
+			ID: 2, PosterID: 2, IssueID: 4, LabelID: 2, MilestoneID: 3, OldMilestoneID: 3, AssigneeID: 2, DependentIssueID: 1,
+		}
+		comments := issues_model.CommentList{
+			{AssigneeTeamID: 8},
+			{AssigneeID: 999999},
+			first,
+		}
+		for i := range db.DefaultMaxInSize {
+			id := unittest.NonexistentID - int64(i)
+			comments = append(comments, &issues_model.Comment{
+				ID: id, PosterID: id, IssueID: id, LabelID: id, MilestoneID: id, OldMilestoneID: id, AssigneeID: id, DependentIssueID: id,
+			})
+		}
+		comments = append(comments, last)
 
-	err := issues_model.UpdateCommentAttachments(t.Context(), comment, []string{attachment.UUID})
-	assert.NoError(t, err)
+		require.NoError(t, comments.LoadAttributes(t.Context()))
+		assert.Nil(t, comments[0].Assignee)
+		assert.Zero(t, comments[0].AssigneeID)
+		assert.Equal(t, user_model.GhostUserID, comments[1].AssigneeID)
+		assert.Equal(t, user_model.GhostUserID, comments[1].Assignee.ID)
+		for _, comment := range []*issues_model.Comment{first, last} {
+			require.NotNil(t, comment.Poster)
+			assert.Equal(t, comment.PosterID, comment.Poster.ID)
+			require.NotNil(t, comment.Issue)
+			assert.Equal(t, comment.IssueID, comment.Issue.ID)
+			require.NotNil(t, comment.Label)
+			assert.Equal(t, comment.LabelID, comment.Label.ID)
+			require.NotNil(t, comment.Milestone)
+			assert.Equal(t, comment.MilestoneID, comment.Milestone.ID)
+			require.NotNil(t, comment.OldMilestone)
+			assert.Equal(t, comment.OldMilestoneID, comment.OldMilestone.ID)
+			require.NotNil(t, comment.Assignee)
+			assert.Equal(t, comment.AssigneeID, comment.Assignee.ID)
+			require.NotNil(t, comment.DependentIssue)
+			assert.Equal(t, comment.DependentIssueID, comment.DependentIssue.ID)
+			require.NotNil(t, comment.DependentIssue.Repo)
+			assert.Equal(t, comment.DependentIssue.RepoID, comment.DependentIssue.Repo.ID)
+			require.Len(t, comment.Attachments, 2)
+			for _, attachment := range comment.Attachments {
+				assert.Equal(t, comment.ID, attachment.CommentID)
+			}
+		}
+		missing := comments[3]
+		assert.Equal(t, user_model.GhostUserID, missing.Poster.ID)
+		assert.Equal(t, user_model.GhostUserID, missing.Assignee.ID)
+		assert.Nil(t, missing.Issue)
+		assert.Nil(t, missing.Label)
+		assert.Nil(t, missing.Milestone)
+		assert.Nil(t, missing.OldMilestone)
+		assert.Nil(t, missing.DependentIssue)
+		assert.Empty(t, missing.Attachments)
+	})
 
-	attachment2 := unittest.AssertExistsAndLoadBean(t, &repo_model.Attachment{ID: attachment.ID})
-	assert.Equal(t, attachment.Name, attachment2.Name)
-	assert.Equal(t, comment.ID, attachment2.CommentID)
-	assert.Equal(t, comment.IssueID, attachment2.IssueID)
-}
+	t.Run("FetchCodeComments", func(t *testing.T) {
+		assert.NoError(t, prepareErr)
 
-func TestFetchCodeComments(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
+		issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 2})
+		user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 1})
+		res, err := issues_model.FetchCodeComments(t.Context(), issue, user, false)
+		assert.NoError(t, err)
+		assert.Contains(t, res, "README.md")
+		assert.Contains(t, res["README.md"], int64(4))
+		assert.Len(t, res["README.md"][4], 1)
+		assert.Equal(t, int64(4), res["README.md"][4][0].ID)
 
-	issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 2})
-	user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 1})
-	res, err := issues_model.FetchCodeComments(t.Context(), issue, user, false)
-	assert.NoError(t, err)
-	assert.Contains(t, res, "README.md")
-	assert.Contains(t, res["README.md"], int64(4))
-	assert.Len(t, res["README.md"][4], 1)
-	assert.Equal(t, int64(4), res["README.md"][4][0].ID)
+		user2 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
+		res, err = issues_model.FetchCodeComments(t.Context(), issue, user2, false)
+		assert.NoError(t, err)
+		assert.Len(t, res, 1)
+	})
 
-	user2 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
-	res, err = issues_model.FetchCodeComments(t.Context(), issue, user2, false)
-	assert.NoError(t, err)
-	assert.Len(t, res, 1)
+	t.Run("UpdateCommentAttachment", func(t *testing.T) {
+		assert.NoError(t, prepareErr)
+
+		comment := unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: 1})
+		issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: comment.IssueID})
+		attachment := repo_model.Attachment{
+			RepoID: issue.RepoID, // must match the comment's repo, else the cross-repo guard rejects it
+			Name:   "test.txt",
+		}
+		assert.NoError(t, db.Insert(t.Context(), &attachment))
+
+		err := issues_model.UpdateCommentAttachments(t.Context(), comment, []string{attachment.UUID})
+		assert.NoError(t, err)
+
+		attachment2 := unittest.AssertExistsAndLoadBean(t, &repo_model.Attachment{ID: attachment.ID})
+		assert.Equal(t, attachment.Name, attachment2.Name)
+		assert.Equal(t, comment.ID, attachment2.CommentID)
+		assert.Equal(t, comment.IssueID, attachment2.IssueID)
+	})
+
+	t.Run("UpdateIssueNumComments", func(t *testing.T) {
+		assert.NoError(t, prepareErr)
+		issue2 := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 2})
+
+		assert.NoError(t, issues_model.UpdateIssueNumComments(t.Context(), issue2.ID))
+		issue2 = unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 2})
+		assert.Equal(t, 1, issue2.NumComments)
+	})
+
+	t.Run("CreateComment", func(t *testing.T) {
+		assert.NoError(t, prepareErr)
+
+		issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{})
+		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: issue.RepoID})
+		doer := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: repo.OwnerID})
+
+		now := time.Now().Unix()
+		comment, err := issues_model.CreateComment(t.Context(), &issues_model.CreateCommentOptions{
+			Type:    issues_model.CommentTypeComment,
+			Doer:    doer,
+			Repo:    repo,
+			Issue:   issue,
+			Content: "Hello",
+		})
+		assert.NoError(t, err)
+		then := time.Now().Unix()
+
+		assert.Equal(t, issues_model.CommentTypeComment, comment.Type)
+		assert.Equal(t, "Hello", comment.Content)
+		assert.Equal(t, issue.ID, comment.IssueID)
+		assert.Equal(t, doer.ID, comment.PosterID)
+		unittest.AssertInt64InRange(t, now, then, int64(comment.CreatedUnix))
+		unittest.AssertExistsAndLoadBean(t, comment) // assert actually added to DB
+
+		updatedIssue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: issue.ID})
+		unittest.AssertInt64InRange(t, now, then, int64(updatedIssue.UpdatedUnix))
+		assert.Nil(t, comment.CommentMetaData)
+
+		ctx := issues_model.WithProjectWorkflow(t.Context(), project_model.WorkflowEventItemClosed)
+		comment, err = issues_model.CreateComment(ctx, &issues_model.CreateCommentOptions{
+			Type:               issues_model.CommentTypeProjectColumn,
+			Doer:               doer,
+			Repo:               repo,
+			Issue:              issue,
+			ProjectColumnID:    5,
+			ProjectColumnTitle: "Done",
+			ProjectTitle:       "Board",
+		})
+		require.NoError(t, err)
+		assert.Equal(t, &issues_model.CommentMetaData{
+			ProjectColumnID:      5,
+			ProjectColumnTitle:   "Done",
+			ProjectTitle:         "Board",
+			ProjectWorkflowEvent: project_model.WorkflowEventItemClosed,
+			SpecialDoerName:      issues_model.SpecialDoerNameProjectWorkflow,
+		}, unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{ID: comment.ID}).CommentMetaData)
+	})
 }
 
 func TestAsCommentType(t *testing.T) {
@@ -211,12 +226,3 @@ func TestMigrate_InsertIssueComments(t *testing.T) {
 
 	unittest.CheckConsistencyFor(t, &issues_model.Issue{})
 }
-
-func Test_UpdateIssueNumComments(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	issue2 := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 2})
-
-	assert.NoError(t, issues_model.UpdateIssueNumComments(t.Context(), issue2.ID))
-	issue2 = unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 2})
-	assert.Equal(t, 1, issue2.NumComments)
-}

models/issues/issue_list_test.go

@@ -17,111 +17,117 @@ import (
 )
 
 func TestIssueList_LoadRepositories(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
+	prepareErr := unittest.PrepareTestDatabase()
 
-	issueList := issues_model.IssueList{
-		unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 1}),
-		unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 2}),
-		unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 4}),
-	}
+	t.Run("LoadRepositories", func(t *testing.T) {
+		assert.NoError(t, prepareErr)
 
-	repos, err := issueList.LoadRepositories(t.Context())
-	assert.NoError(t, err)
-	assert.Len(t, repos, 2)
-	for _, issue := range issueList {
-		assert.Equal(t, issue.RepoID, issue.Repo.ID)
-	}
-}
-
-func TestIssueList_LoadIsRead(t *testing.T) {
-	// Regression: In("issue_id") was missing the issueIDs argument, causing
-	// xorm to generate "0=1" and never mark any issue as read.
-	require.NoError(t, unittest.PrepareTestDatabase())
-
-	issue1 := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 1})
-	issue2 := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 2})
-
-	// Fixture: uid=1 has is_read=true on issue 1 only.
-	issueList := issues_model.IssueList{issue1, issue2}
-	require.NoError(t, issueList.LoadIsRead(t.Context(), 1))
-
-	assert.True(t, issue1.IsRead, "issue 1 should be marked read for user 1")
-	assert.False(t, issue2.IsRead, "issue 2 should not be marked read for user 1")
-}
-
-func TestIssueList_LoadAttributes(t *testing.T) {
-	require.NoError(t, unittest.PrepareTestDatabase())
-	defer test.MockVariableValue(&setting.Service.EnableTimetracking, true)()
-	fixtureIssues := issues_model.IssueList{
-		unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 1}),
-		unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 2}),
-		unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 4}),
-	}
-	issueList := issues_model.IssueList{fixtureIssues[0]}
-	for i := range db.DefaultMaxInSize {
-		issueList = append(issueList, &issues_model.Issue{ID: int64(1000 + i), RepoID: 1, IsPull: true})
-	}
-	issueList = append(issueList, fixtureIssues[1:]...)
-
-	require.NoError(t, issueList.LoadAttributes(t.Context()))
-	require.NoError(t, issueList.LoadAttachments(t.Context()))
-	require.NoError(t, issueList.LoadComments(t.Context()))
-	assert.Len(t, fixtureIssues[0].Labels, 1)
-	assert.Len(t, fixtureIssues[1].Labels, 2)
-	assert.Len(t, fixtureIssues[0].Assignees, 1)
-	assert.Empty(t, fixtureIssues[1].Assignees)
-	assert.Len(t, fixtureIssues[0].Attachments, 1)
-	assert.Len(t, fixtureIssues[1].Attachments, 1)
-	assert.Len(t, fixtureIssues[2].Attachments, 2)
-	assert.Len(t, fixtureIssues[0].Comments, 3)
-	assert.Len(t, fixtureIssues[1].Comments, 4)
-	assert.Len(t, fixtureIssues[2].Comments, 1)
-	for _, issue := range fixtureIssues {
-		assert.Equal(t, issue.RepoID, issue.Repo.ID)
-		for _, label := range issue.Labels {
-			assert.Equal(t, unittest.AssertExistsAndLoadBean(t, &issues_model.Label{ID: label.ID}), label)
-			unittest.AssertExistsAndLoadBean(t, &issues_model.IssueLabel{IssueID: issue.ID, LabelID: label.ID})
-		}
-		if issue.PosterID > 0 {
-			assert.Equal(t, issue.PosterID, issue.Poster.ID)
-		}
-		if issue.AssigneeID > 0 {
-			assert.Equal(t, issue.AssigneeID, issue.Assignee.ID)
-		}
-		if issue.MilestoneID > 0 {
-			assert.Equal(t, issue.MilestoneID, issue.Milestone.ID)
-		}
-		if issue.IsPull {
-			require.NotNil(t, issue.PullRequest)
-			assert.Equal(t, issue.ID, issue.PullRequest.IssueID)
-			assert.Same(t, issue, issue.PullRequest.Issue)
-		}
-		for _, attachment := range issue.Attachments {
-			assert.Equal(t, issue.ID, attachment.IssueID)
-		}
-		for _, comment := range issue.Comments {
-			assert.Equal(t, issue.ID, comment.IssueID)
-		}
-		if issue.ID == int64(1) {
-			assert.Equal(t, int64(400), issue.TotalTrackedTime)
-		}
-		if issue.ID == 1 || issue.ID == 2 {
-			require.Len(t, issue.Projects, 1)
-			assert.Equal(t, int64(1), issue.Projects[0].ID)
-		} else {
-			assert.Empty(t, issue.Projects)
-		}
-	}
-	assert.Equal(t, int64(3682), fixtureIssues[1].TotalTrackedTime)
-
-	require.NoError(t, issueList.LoadDiscussComments(t.Context()))
-	assert.Len(t, fixtureIssues[0].Comments, 2)
-	assert.Empty(t, fixtureIssues[1].Comments)
-	assert.Len(t, fixtureIssues[2].Comments, 1)
-	for _, issue := range fixtureIssues {
-		for _, comment := range issue.Comments {
-			assert.Equal(t, issue.ID, comment.IssueID)
-			assert.Equal(t, issues_model.CommentTypeComment, comment.Type)
-		}
-	}
+		issueList := issues_model.IssueList{
+			unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 1}),
+			unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 2}),
+			unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 4}),
+		}
+
+		repos, err := issueList.LoadRepositories(t.Context())
+		assert.NoError(t, err)
+		assert.Len(t, repos, 2)
+		for _, issue := range issueList {
+			assert.Equal(t, issue.RepoID, issue.Repo.ID)
+		}
+	})
+
+	t.Run("LoadIsRead", func(t *testing.T) {
+		require.NoError(t, prepareErr)
+
+		// Regression: In("issue_id") was missing the issueIDs argument, causing
+		// xorm to generate "0=1" and never mark any issue as read.
+
+		issue1 := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 1})
+		issue2 := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 2})
+
+		// Fixture: uid=1 has is_read=true on issue 1 only.
+		issueList := issues_model.IssueList{issue1, issue2}
+		require.NoError(t, issueList.LoadIsRead(t.Context(), 1))
+
+		assert.True(t, issue1.IsRead, "issue 1 should be marked read for user 1")
+		assert.False(t, issue2.IsRead, "issue 2 should not be marked read for user 1")
+	})
+
+	t.Run("LoadAttributes", func(t *testing.T) {
+		require.NoError(t, prepareErr)
+
+		defer test.MockVariableValue(&setting.Service.EnableTimetracking, true)()
+		fixtureIssues := issues_model.IssueList{
+			unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 1}),
+			unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 2}),
+			unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 4}),
+		}
+		issueList := issues_model.IssueList{fixtureIssues[0]}
+		for i := range db.DefaultMaxInSize {
+			issueList = append(issueList, &issues_model.Issue{ID: int64(1000 + i), RepoID: 1, IsPull: true})
+		}
+		issueList = append(issueList, fixtureIssues[1:]...)
+
+		require.NoError(t, issueList.LoadAttributes(t.Context()))
+		require.NoError(t, issueList.LoadAttachments(t.Context()))
+		require.NoError(t, issueList.LoadComments(t.Context()))
+		assert.Len(t, fixtureIssues[0].Labels, 1)
+		assert.Len(t, fixtureIssues[1].Labels, 2)
+		assert.Len(t, fixtureIssues[0].Assignees, 1)
+		assert.Empty(t, fixtureIssues[1].Assignees)
+		assert.Len(t, fixtureIssues[0].Attachments, 1)
+		assert.Len(t, fixtureIssues[1].Attachments, 1)
+		assert.Len(t, fixtureIssues[2].Attachments, 2)
+		assert.Len(t, fixtureIssues[0].Comments, 3)
+		assert.Len(t, fixtureIssues[1].Comments, 4)
+		assert.Len(t, fixtureIssues[2].Comments, 1)
+		for _, issue := range fixtureIssues {
+			assert.Equal(t, issue.RepoID, issue.Repo.ID)
+			for _, label := range issue.Labels {
+				assert.Equal(t, unittest.AssertExistsAndLoadBean(t, &issues_model.Label{ID: label.ID}), label)
+				unittest.AssertExistsAndLoadBean(t, &issues_model.IssueLabel{IssueID: issue.ID, LabelID: label.ID})
+			}
+			if issue.PosterID > 0 {
+				assert.Equal(t, issue.PosterID, issue.Poster.ID)
+			}
+			if issue.AssigneeID > 0 {
+				assert.Equal(t, issue.AssigneeID, issue.Assignee.ID)
+			}
+			if issue.MilestoneID > 0 {
+				assert.Equal(t, issue.MilestoneID, issue.Milestone.ID)
+			}
+			if issue.IsPull {
+				require.NotNil(t, issue.PullRequest)
+				assert.Equal(t, issue.ID, issue.PullRequest.IssueID)
+				assert.Same(t, issue, issue.PullRequest.Issue)
+			}
+			for _, attachment := range issue.Attachments {
+				assert.Equal(t, issue.ID, attachment.IssueID)
+			}
+			for _, comment := range issue.Comments {
+				assert.Equal(t, issue.ID, comment.IssueID)
+			}
+			if issue.ID == int64(1) {
+				assert.Equal(t, int64(400), issue.TotalTrackedTime)
+			}
+			if issue.ID == 1 || issue.ID == 2 {
+				require.Len(t, issue.Projects, 1)
+				assert.Equal(t, int64(1), issue.Projects[0].ID)
+			} else {
+				assert.Empty(t, issue.Projects)
+			}
+		}
+		assert.Equal(t, int64(3682), fixtureIssues[1].TotalTrackedTime)
+
+		require.NoError(t, issueList.LoadDiscussComments(t.Context()))
+		assert.Len(t, fixtureIssues[0].Comments, 2)
+		assert.Empty(t, fixtureIssues[1].Comments)
+		assert.Len(t, fixtureIssues[2].Comments, 1)
+		for _, issue := range fixtureIssues {
+			for _, comment := range issue.Comments {
+				assert.Equal(t, issue.ID, comment.IssueID)
+				assert.Equal(t, issues_model.CommentTypeComment, comment.Type)
+			}
+		}
+	})
 }

models/issues/issue_project_multi_test.go

@@ -44,19 +44,14 @@ func TestIssueMultipleProjects(t *testing.T) {
 		require.Empty(t, issue1.Projects)
 
 		// assign issue to both projects (each project uses its own default column)
-		_, _, err = issues_model.IssueAssignOrRemoveProject(t.Context(), issue1, user2, []int64{project1.ID})
-		require.NoError(t, err)
-		assert.Nilf(t, issue1.Projects, "Issue's Projects should be nil after IssueAssignOrRemoveProject to ensure it reloads fresh data")
-		err = issue1.LoadProjects(t.Context())
-		require.NoError(t, err)
-		require.Len(t, issue1.Projects, 1)
-
-		_, _, err = issues_model.IssueAssignOrRemoveProject(t.Context(), issue1, user2, []int64{project1.ID, project2.ID})
-		require.NoError(t, err)
-		assert.Nilf(t, issue1.Projects, "Issue's Projects should be nil after IssueAssignOrRemoveProject to ensure it reloads fresh data")
-		err = issue1.LoadProjects(t.Context())
-		require.NoError(t, err)
-		require.Len(t, issue1.Projects, 2)
+		for _, projectIDs := range [][]int64{{project1.ID}, {project1.ID, project2.ID}} {
+			_, _, err = issues_model.IssueAssignOrRemoveProject(t.Context(), issue1, user2, projectIDs)
+			require.NoError(t, err)
+			assert.Nilf(t, issue1.Projects, "Issue's Projects should be nil after IssueAssignOrRemoveProject to ensure it reloads fresh data")
+			err = issue1.LoadProjects(t.Context())
+			require.NoError(t, err)
+			require.Len(t, issue1.Projects, len(projectIDs))
+		}
 		assert.ElementsMatch(t, []int64{project1.ID, project2.ID}, []int64{issue1.Projects[0].ID, issue1.Projects[1].ID}, "Issue should be in both projects")
 
 		// test issue's project column map

models/issues/issue_test.go

@@ -53,79 +53,211 @@ func TestIssue_ReplaceLabels(t *testing.T) {
 	testSuccess(18, []int64{6, 8, 7}, []int64{6, 7})
 }
 
-func Test_GetIssueIDsByRepoID(t *testing.T) {
+func TestIssueQueries(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 
-	ids, err := issues_model.GetIssueIDsByRepoID(t.Context(), 1)
-	assert.NoError(t, err)
-	assert.Len(t, ids, 5)
-}
-
-func TestIssueAPIURL(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 1})
-	err := issue.LoadAttributes(t.Context())
-
-	assert.NoError(t, err)
-	assert.Equal(t, "https://try.gitea.io/api/v1/repos/user2/repo1/issues/1", issue.APIURL(t.Context()))
-}
-
-func TestGetIssuesByIDs(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	testSuccess := func(expectedIssueIDs, nonExistentIssueIDs []int64) {
-		issues, err := issues_model.GetIssuesByIDs(t.Context(), append(expectedIssueIDs, nonExistentIssueIDs...), true)
+	t.Run("GetIssueIDsByRepoID", func(t *testing.T) {
+		ids, err := issues_model.GetIssueIDsByRepoID(t.Context(), 1)
 		assert.NoError(t, err)
-		actualIssueIDs := make([]int64, len(issues))
-		for i, issue := range issues {
-			actualIssueIDs[i] = issue.ID
-		}
-		assert.Equal(t, expectedIssueIDs, actualIssueIDs)
-	}
-	testSuccess([]int64{1, 2, 3}, []int64{})
-	testSuccess([]int64{1, 2, 3}, []int64{unittest.NonexistentID})
-	testSuccess([]int64{3, 2, 1}, []int64{})
-}
+		assert.Len(t, ids, 5)
+	})
 
-func TestGetParticipantIDsByIssue(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
+	t.Run("IssueAPIURL", func(t *testing.T) {
+		issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 1})
+		err := issue.LoadAttributes(t.Context())
 
-	checkParticipants := func(issueID int64, userIDs []int) {
-		issue, err := issues_model.GetIssueByID(t.Context(), issueID)
 		assert.NoError(t, err)
-		participants, err := issue.GetParticipantIDsByIssue(t.Context())
-		if assert.NoError(t, err) {
-			participantsIDs := make([]int, len(participants))
-			for i, uid := range participants {
-				participantsIDs[i] = int(uid)
+		assert.Equal(t, "https://try.gitea.io/api/v1/repos/user2/repo1/issues/1", issue.APIURL(t.Context()))
+	})
+
+	t.Run("GetIssuesByIDs", func(t *testing.T) {
+		testSuccess := func(expectedIssueIDs, nonExistentIssueIDs []int64) {
+			issues, err := issues_model.GetIssuesByIDs(t.Context(), append(expectedIssueIDs, nonExistentIssueIDs...), true)
+			assert.NoError(t, err)
+			actualIssueIDs := make([]int64, len(issues))
+			for i, issue := range issues {
+				actualIssueIDs[i] = issue.ID
 			}
-			sort.Ints(participantsIDs)
-			sort.Ints(userIDs)
-			assert.Equal(t, userIDs, participantsIDs)
+			assert.Equal(t, expectedIssueIDs, actualIssueIDs)
 		}
-	}
+		testSuccess([]int64{1, 2, 3}, []int64{})
+		testSuccess([]int64{1, 2, 3}, []int64{unittest.NonexistentID})
+		testSuccess([]int64{3, 2, 1}, []int64{})
+	})
 
-	// User 1 is issue1 poster (see fixtures/issue.yml)
-	// User 2 only labeled issue1 (see fixtures/comment.yml)
-	// Users 3 and 5 made actual comments (see fixtures/comment.yml)
-	// User 3 is inactive, thus not active participant
-	checkParticipants(1, []int{1, 5})
+	t.Run("GetParticipantIDsByIssue", func(t *testing.T) {
+		checkParticipants := func(issueID int64, userIDs []int) {
+			issue, err := issues_model.GetIssueByID(t.Context(), issueID)
+			assert.NoError(t, err)
+			participants, err := issue.GetParticipantIDsByIssue(t.Context())
+			if assert.NoError(t, err) {
+				participantsIDs := make([]int, len(participants))
+				for i, uid := range participants {
+					participantsIDs[i] = int(uid)
+				}
+				sort.Ints(participantsIDs)
+				sort.Ints(userIDs)
+				assert.Equal(t, userIDs, participantsIDs)
+			}
+		}
+
+		// User 1 is issue1 poster (see fixtures/issue.yml)
+		// User 2 only labeled issue1 (see fixtures/comment.yml)
+		// Users 3 and 5 made actual comments (see fixtures/comment.yml)
+		// User 3 is inactive, thus not active participant
+		checkParticipants(1, []int{1, 5})
+	})
+
+	t.Run("Issues", func(t *testing.T) {
+		publicOnlyUser2 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
+		publicOnlyUser2.ExtDoerData = user_model.NewTokenExtDoerData(user_model.CredentialAccessToken, 1, "public-only,read:issue")
+		for _, test := range []struct {
+			Opts             issues_model.IssuesOptions
+			ExpectedIssueIDs []int64
+		}{
+			{
+				issues_model.IssuesOptions{
+					AssigneeID: "1",
+					SortType:   "oldest",
+				},
+				[]int64{1, 6},
+			},
+			{
+				issues_model.IssuesOptions{
+					RepoCond: builder.In("repo_id", 1, 3),
+					SortType: "oldest",
+					Paginator: &db.ListOptions{
+						Page:     1,
+						PageSize: 4,
+					},
+				},
+				[]int64{1, 2, 3, 5},
+			},
+			{
+				issues_model.IssuesOptions{
+					LabelIDs: []int64{1},
+					Paginator: &db.ListOptions{
+						Page:     1,
+						PageSize: 4,
+					},
+				},
+				[]int64{2, 1},
+			},
+			{
+				issues_model.IssuesOptions{
+					LabelIDs: []int64{1, 2},
+					Paginator: &db.ListOptions{
+						Page:     1,
+						PageSize: 4,
+					},
+				},
+				[]int64{}, // issues with **both** label 1 and 2, none of these issues matches, TODO: add more tests
+			},
+			{
+				issues_model.IssuesOptions{
+					MilestoneIDs: []int64{1},
+				},
+				[]int64{2},
+			},
+			{
+				issues_model.IssuesOptions{
+					SubscriberID: 11,
+				},
+				[]int64{11, 5, 9, 8, 3, 2, 1},
+			},
+			{
+				issues_model.IssuesOptions{
+					RepoCond: builder.In("repo_id", 1, 2),
+					Doer:     publicOnlyUser2,
+					IsPull:   optional.Some(false),
+					SortType: "oldest",
+				},
+				[]int64{1, 5},
+			},
+		} {
+			issues, err := issues_model.Issues(t.Context(), &test.Opts)
+			assert.NoError(t, err)
+			if assert.Len(t, issues, len(test.ExpectedIssueIDs)) {
+				for i, issue := range issues {
+					assert.Equal(t, test.ExpectedIssueIDs[i], issue.ID)
+				}
+			}
+		}
+	})
+
+	t.Run("Issue_loadTotalTimes", func(t *testing.T) {
+		ms, err := issues_model.GetIssueByID(t.Context(), 2)
+		assert.NoError(t, err)
+		assert.NoError(t, ms.LoadTotalTimes(t.Context()))
+		assert.Equal(t, int64(3682), ms.TotalTrackedTime)
+	})
+
+	t.Run("Issue_ResolveMentions", func(t *testing.T) {
+		testSuccess := func(owner, repo, doer string, mentions []string, expected []int64) {
+			o := unittest.AssertExistsAndLoadBean(t, &user_model.User{LowerName: owner})
+			r := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{OwnerID: o.ID, LowerName: repo})
+			issue := &issues_model.Issue{RepoID: r.ID}
+			d := unittest.AssertExistsAndLoadBean(t, &user_model.User{LowerName: doer})
+			resolved, err := issues_model.ResolveIssueMentionsByVisibility(t.Context(), issue, d, mentions)
+			assert.NoError(t, err)
+			ids := make([]int64, len(resolved))
+			for i, user := range resolved {
+				ids[i] = user.ID
+			}
+			slices.Sort(ids)
+			assert.Equal(t, expected, ids)
+		}
+
+		// Public repo, existing user
+		testSuccess("user2", "repo1", "user1", []string{"user5"}, []int64{5})
+		// Public repo, non-existing user
+		testSuccess("user2", "repo1", "user1", []string{"nonexisting"}, []int64{})
+		// Public repo, doer
+		testSuccess("user2", "repo1", "user1", []string{"user1"}, []int64{})
+		// Private repo, team member
+		testSuccess("org17", "big_test_private_4", "user20", []string{"user2"}, []int64{2})
+		// Private repo, not a team member
+		testSuccess("org17", "big_test_private_4", "user20", []string{"user5"}, []int64{})
+		// Private repo, whole team
+		testSuccess("org17", "big_test_private_4", "user15", []string{"org17/owners"}, []int64{18})
+	})
+
+	t.Run("MilestoneList_LoadTotalTrackedTimes", func(t *testing.T) {
+		miles := issues_model.MilestoneList{
+			unittest.AssertExistsAndLoadBean(t, &issues_model.Milestone{ID: 1}),
+		}
+
+		assert.NoError(t, miles.LoadTotalTrackedTimes(t.Context()))
+
+		assert.Equal(t, int64(3682), miles[0].TotalTrackedTime)
+	})
+
+	t.Run("LoadTotalTrackedTime", func(t *testing.T) {
+		milestone := unittest.AssertExistsAndLoadBean(t, &issues_model.Milestone{ID: 1})
+
+		assert.NoError(t, milestone.LoadTotalTrackedTime(t.Context()))
+
+		assert.Equal(t, int64(3682), milestone.TotalTrackedTime)
+	})
+
+	t.Run("CountIssues", func(t *testing.T) {
+		count, err := issues_model.CountIssues(t.Context(), &issues_model.IssuesOptions{})
+		assert.NoError(t, err)
+		assert.EqualValues(t, 22, count)
+	})
 }
 
 func TestIssue_ClearLabels(t *testing.T) {
-	tests := []struct {
-		issueID int64
-		doerID  int64
-	}{
-		{1, 2}, // non-pull-request, has labels
-		{2, 2}, // pull-request, has labels
-		{3, 2}, // pull-request, has no labels
-	}
-	for _, test := range tests {
+	for _, issueID := range []int64{
+		1, // non-pull-request, has labels
+		2, // pull-request, has labels
+		3, // pull-request, has no labels
+	} {
 		assert.NoError(t, unittest.PrepareTestDatabase())
-		issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: test.issueID})
-		doer := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: test.doerID})
+		issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: issueID})
+		doer := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
 		assert.NoError(t, issues_model.ClearIssueLabels(t.Context(), issue, doer))
-		unittest.AssertNotExistsBean(t, &issues_model.IssueLabel{IssueID: test.issueID})
+		unittest.AssertNotExistsBean(t, &issues_model.IssueLabel{IssueID: issueID})
 	}
 }
 
@@ -149,92 +281,6 @@ func TestUpdateIssueCols(t *testing.T) {
 	unittest.AssertInt64InRange(t, now, then, int64(updatedIssue.UpdatedUnix))
 }
 
-func TestIssues(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	publicOnlyUser2 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
-	publicOnlyUser2.ExtDoerData = user_model.NewTokenExtDoerData(user_model.CredentialAccessToken, 1, "public-only,read:issue")
-	for _, test := range []struct {
-		Opts             issues_model.IssuesOptions
-		ExpectedIssueIDs []int64
-	}{
-		{
-			issues_model.IssuesOptions{
-				AssigneeID: "1",
-				SortType:   "oldest",
-			},
-			[]int64{1, 6},
-		},
-		{
-			issues_model.IssuesOptions{
-				RepoCond: builder.In("repo_id", 1, 3),
-				SortType: "oldest",
-				Paginator: &db.ListOptions{
-					Page:     1,
-					PageSize: 4,
-				},
-			},
-			[]int64{1, 2, 3, 5},
-		},
-		{
-			issues_model.IssuesOptions{
-				LabelIDs: []int64{1},
-				Paginator: &db.ListOptions{
-					Page:     1,
-					PageSize: 4,
-				},
-			},
-			[]int64{2, 1},
-		},
-		{
-			issues_model.IssuesOptions{
-				LabelIDs: []int64{1, 2},
-				Paginator: &db.ListOptions{
-					Page:     1,
-					PageSize: 4,
-				},
-			},
-			[]int64{}, // issues with **both** label 1 and 2, none of these issues matches, TODO: add more tests
-		},
-		{
-			issues_model.IssuesOptions{
-				MilestoneIDs: []int64{1},
-			},
-			[]int64{2},
-		},
-		{
-			issues_model.IssuesOptions{
-				SubscriberID: 11,
-			},
-			[]int64{11, 5, 9, 8, 3, 2, 1},
-		},
-		{
-			issues_model.IssuesOptions{
-				RepoCond: builder.In("repo_id", 1, 2),
-				Doer:     publicOnlyUser2,
-				IsPull:   optional.Some(false),
-				SortType: "oldest",
-			},
-			[]int64{1, 5},
-		},
-	} {
-		issues, err := issues_model.Issues(t.Context(), &test.Opts)
-		assert.NoError(t, err)
-		if assert.Len(t, issues, len(test.ExpectedIssueIDs)) {
-			for i, issue := range issues {
-				assert.Equal(t, test.ExpectedIssueIDs[i], issue.ID)
-			}
-		}
-	}
-}
-
-func TestIssue_loadTotalTimes(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	ms, err := issues_model.GetIssueByID(t.Context(), 2)
-	assert.NoError(t, err)
-	assert.NoError(t, ms.LoadTotalTimes(t.Context()))
-	assert.Equal(t, int64(3682), ms.TotalTrackedTime)
-}
-
 func testInsertIssue(t *testing.T, title, content string, expectIndex int64) *issues_model.Issue {
 	var newIssue issues_model.Issue
 	t.Run(title, func(t *testing.T) {
@@ -276,38 +322,6 @@ func TestIssue_InsertIssue(t *testing.T) {
 	assert.NoError(t, err)
 }
 
-func TestIssue_ResolveMentions(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-
-	testSuccess := func(owner, repo, doer string, mentions []string, expected []int64) {
-		o := unittest.AssertExistsAndLoadBean(t, &user_model.User{LowerName: owner})
-		r := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{OwnerID: o.ID, LowerName: repo})
-		issue := &issues_model.Issue{RepoID: r.ID}
-		d := unittest.AssertExistsAndLoadBean(t, &user_model.User{LowerName: doer})
-		resolved, err := issues_model.ResolveIssueMentionsByVisibility(t.Context(), issue, d, mentions)
-		assert.NoError(t, err)
-		ids := make([]int64, len(resolved))
-		for i, user := range resolved {
-			ids[i] = user.ID
-		}
-		slices.Sort(ids)
-		assert.Equal(t, expected, ids)
-	}
-
-	// Public repo, existing user
-	testSuccess("user2", "repo1", "user1", []string{"user5"}, []int64{5})
-	// Public repo, non-existing user
-	testSuccess("user2", "repo1", "user1", []string{"nonexisting"}, []int64{})
-	// Public repo, doer
-	testSuccess("user2", "repo1", "user1", []string{"user1"}, []int64{})
-	// Private repo, team member
-	testSuccess("org17", "big_test_private_4", "user20", []string{"user2"}, []int64{2})
-	// Private repo, not a team member
-	testSuccess("org17", "big_test_private_4", "user20", []string{"user5"}, []int64{})
-	// Private repo, whole team
-	testSuccess("org17", "big_test_private_4", "user15", []string{"org17/owners"}, []int64{18})
-}
-
 func TestResourceIndex(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 	var wg sync.WaitGroup
@@ -365,33 +379,6 @@ func TestCorrectIssueStats(t *testing.T) {
 	assert.EqualValues(t, issueStats.OpenCount, issueAmount)
 }
 
-func TestMilestoneList_LoadTotalTrackedTimes(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	miles := issues_model.MilestoneList{
-		unittest.AssertExistsAndLoadBean(t, &issues_model.Milestone{ID: 1}),
-	}
-
-	assert.NoError(t, miles.LoadTotalTrackedTimes(t.Context()))
-
-	assert.Equal(t, int64(3682), miles[0].TotalTrackedTime)
-}
-
-func TestLoadTotalTrackedTime(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	milestone := unittest.AssertExistsAndLoadBean(t, &issues_model.Milestone{ID: 1})
-
-	assert.NoError(t, milestone.LoadTotalTrackedTime(t.Context()))
-
-	assert.Equal(t, int64(3682), milestone.TotalTrackedTime)
-}
-
-func TestCountIssues(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	count, err := issues_model.CountIssues(t.Context(), &issues_model.IssuesOptions{})
-	assert.NoError(t, err)
-	assert.EqualValues(t, 22, count)
-}
-
 func TestIssueLoadAttributes(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 	setting.Service.EnableTimetracking = true

models/issues/issue_user_test.go

@@ -15,47 +15,47 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func Test_NewIssueUsers(t *testing.T) {
+func TestIssueUsers(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 
-	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
-	newIssue := &issues_model.Issue{
-		RepoID:   repo.ID,
-		PosterID: 4,
-		Index:    6,
-		Title:    "newTestIssueTitle",
-		Content:  "newTestIssueContent",
-	}
+	t.Run("NewIssueUsers", func(t *testing.T) {
+		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
+		newIssue := &issues_model.Issue{
+			RepoID:   repo.ID,
+			PosterID: 4,
+			Index:    6,
+			Title:    "newTestIssueTitle",
+			Content:  "newTestIssueContent",
+		}
 
-	// artificially insert new issue
-	require.NoError(t, db.Insert(t.Context(), newIssue))
-	require.NoError(t, issues_model.NewIssueUsers(t.Context(), repo, newIssue))
+		// artificially insert new issue
+		require.NoError(t, db.Insert(t.Context(), newIssue))
+		require.NoError(t, issues_model.NewIssueUsers(t.Context(), repo, newIssue))
 
-	// issue_user table should now have entries for new issue
-	unittest.AssertExistsAndLoadBean(t, &issues_model.IssueUser{IssueID: newIssue.ID, UID: newIssue.PosterID})
-	unittest.AssertExistsAndLoadBean(t, &issues_model.IssueUser{IssueID: newIssue.ID, UID: repo.OwnerID})
-}
-
-func TestUpdateIssueUserByRead(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 1})
-
-	assert.NoError(t, issues_model.UpdateIssueUserByRead(t.Context(), 4, issue.ID))
-	unittest.AssertExistsAndLoadBean(t, &issues_model.IssueUser{IssueID: issue.ID, UID: 4}, "is_read=1")
-
-	assert.NoError(t, issues_model.UpdateIssueUserByRead(t.Context(), 4, issue.ID))
-	unittest.AssertExistsAndLoadBean(t, &issues_model.IssueUser{IssueID: issue.ID, UID: 4}, "is_read=1")
-
-	assert.NoError(t, issues_model.UpdateIssueUserByRead(t.Context(), unittest.NonexistentID, unittest.NonexistentID))
-}
-
-func TestUpdateIssueUsersByMentions(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 1})
-
-	uids := []int64{2, 5}
-	assert.NoError(t, issues_model.UpdateIssueUsersByMentions(t.Context(), issue.ID, uids))
-	for _, uid := range uids {
-		unittest.AssertExistsAndLoadBean(t, &issues_model.IssueUser{IssueID: issue.ID, UID: uid}, "is_mentioned=1")
-	}
+		// issue_user table should now have entries for new issue
+		unittest.AssertExistsAndLoadBean(t, &issues_model.IssueUser{IssueID: newIssue.ID, UID: newIssue.PosterID})
+		unittest.AssertExistsAndLoadBean(t, &issues_model.IssueUser{IssueID: newIssue.ID, UID: repo.OwnerID})
+	})
+
+	t.Run("UpdateIssueUserByRead", func(t *testing.T) {
+		issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 1})
+
+		assert.NoError(t, issues_model.UpdateIssueUserByRead(t.Context(), 4, issue.ID))
+		unittest.AssertExistsAndLoadBean(t, &issues_model.IssueUser{IssueID: issue.ID, UID: 4}, "is_read=1")
+
+		assert.NoError(t, issues_model.UpdateIssueUserByRead(t.Context(), 4, issue.ID))
+		unittest.AssertExistsAndLoadBean(t, &issues_model.IssueUser{IssueID: issue.ID, UID: 4}, "is_read=1")
+
+		assert.NoError(t, issues_model.UpdateIssueUserByRead(t.Context(), unittest.NonexistentID, unittest.NonexistentID))
+	})
+
+	t.Run("UpdateIssueUsersByMentions", func(t *testing.T) {
+		issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 1})
+
+		uids := []int64{2, 5}
+		assert.NoError(t, issues_model.UpdateIssueUsersByMentions(t.Context(), issue.ID, uids))
+		for _, uid := range uids {
+			unittest.AssertExistsAndLoadBean(t, &issues_model.IssueUser{IssueID: issue.ID, UID: uid}, "is_mentioned=1")
+		}
+	})
 }

models/issues/issue_watch_test.go

@@ -13,55 +13,48 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestCreateOrUpdateIssueWatch(t *testing.T) {
+func TestIssueWatch(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 
-	assert.NoError(t, issues_model.CreateOrUpdateIssueWatch(t.Context(), 3, 1, true))
-	iw := unittest.AssertExistsAndLoadBean(t, &issues_model.IssueWatch{UserID: 3, IssueID: 1})
-	assert.True(t, iw.IsWatching)
+	t.Run("GetIssueWatch", func(t *testing.T) {
+		_, exists, err := issues_model.GetIssueWatch(t.Context(), 9, 1)
+		assert.True(t, exists)
+		assert.NoError(t, err)
 
-	assert.NoError(t, issues_model.CreateOrUpdateIssueWatch(t.Context(), 1, 1, false))
-	iw = unittest.AssertExistsAndLoadBean(t, &issues_model.IssueWatch{UserID: 1, IssueID: 1})
-	assert.False(t, iw.IsWatching)
-}
-
-func TestGetIssueWatch(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-
-	_, exists, err := issues_model.GetIssueWatch(t.Context(), 9, 1)
-	assert.True(t, exists)
-	assert.NoError(t, err)
-
-	iw, exists, err := issues_model.GetIssueWatch(t.Context(), 2, 2)
-	assert.True(t, exists)
-	assert.NoError(t, err)
-	assert.False(t, iw.IsWatching)
-
-	_, exists, err = issues_model.GetIssueWatch(t.Context(), 3, 1)
-	assert.False(t, exists)
-	assert.NoError(t, err)
-}
-
-func TestGetIssueWatchers(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-
-	iws, err := issues_model.GetIssueWatchers(t.Context(), 1, db.ListOptions{})
-	assert.NoError(t, err)
-	// Watcher is inactive, thus 0
-	assert.Empty(t, iws)
-
-	iws, err = issues_model.GetIssueWatchers(t.Context(), 2, db.ListOptions{})
-	assert.NoError(t, err)
-	// Watcher is explicit not watching
-	assert.Empty(t, iws)
-
-	iws, err = issues_model.GetIssueWatchers(t.Context(), 5, db.ListOptions{})
-	assert.NoError(t, err)
-	// Issue has no Watchers
-	assert.Empty(t, iws)
-
-	iws, err = issues_model.GetIssueWatchers(t.Context(), 7, db.ListOptions{})
-	assert.NoError(t, err)
-	// Issue has one watcher
-	assert.Len(t, iws, 1)
+		iw, exists, err := issues_model.GetIssueWatch(t.Context(), 2, 2)
+		assert.True(t, exists)
+		assert.NoError(t, err)
+		assert.False(t, iw.IsWatching)
+
+		_, exists, err = issues_model.GetIssueWatch(t.Context(), 3, 1)
+		assert.False(t, exists)
+		assert.NoError(t, err)
+	})
+
+	t.Run("GetIssueWatchers", func(t *testing.T) {
+		for _, issueID := range []int64{
+			1, // Watcher is inactive, thus 0
+			2, // Watcher is explicit not watching
+			5, // Issue has no Watchers
+		} {
+			iws, err := issues_model.GetIssueWatchers(t.Context(), issueID, db.ListOptions{})
+			assert.NoError(t, err)
+			assert.Empty(t, iws)
+		}
+
+		iws, err := issues_model.GetIssueWatchers(t.Context(), 7, db.ListOptions{})
+		assert.NoError(t, err)
+		// Issue has one watcher
+		assert.Len(t, iws, 1)
+	})
+
+	t.Run("CreateOrUpdateIssueWatch", func(t *testing.T) {
+		assert.NoError(t, issues_model.CreateOrUpdateIssueWatch(t.Context(), 3, 1, true))
+		iw := unittest.AssertExistsAndLoadBean(t, &issues_model.IssueWatch{UserID: 3, IssueID: 1})
+		assert.True(t, iw.IsWatching)
+
+		assert.NoError(t, issues_model.CreateOrUpdateIssueWatch(t.Context(), 1, 1, false))
+		iw = unittest.AssertExistsAndLoadBean(t, &issues_model.IssueWatch{UserID: 1, IssueID: 1})
+		assert.False(t, iw.IsWatching)
+	})
 }

models/issues/label_test.go

@@ -17,41 +17,190 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestLabel_CalOpenIssues(t *testing.T) {
+func TestLabelQueries(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
-	label := unittest.AssertExistsAndLoadBean(t, &issues_model.Label{ID: 1})
-	label.CalOpenIssues()
-	assert.Equal(t, 2, label.NumOpenIssues)
-}
+	t.Run("Label_CalOpenIssues", func(t *testing.T) {
+		label := unittest.AssertExistsAndLoadBean(t, &issues_model.Label{ID: 1})
+		label.CalOpenIssues()
+		assert.Equal(t, 2, label.NumOpenIssues)
+	})
+	t.Run("Label_LoadSelectedLabelsAfterClick", func(t *testing.T) {
+		// Loading the label id:8 which have a scope and an exclusivity
+		label := unittest.AssertExistsAndLoadBean(t, &issues_model.Label{ID: 8})
 
-func TestLabel_LoadSelectedLabelsAfterClick(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	// Loading the label id:8 which have a scope and an exclusivity
-	label := unittest.AssertExistsAndLoadBean(t, &issues_model.Label{ID: 8})
+		// First test : with negative and scope
+		label.LoadSelectedLabelsAfterClick([]int64{1, -8}, []string{"", "scope"})
+		assert.Equal(t, "1", label.QueryString)
+		assert.True(t, label.IsSelected)
 
-	// First test : with negative and scope
-	label.LoadSelectedLabelsAfterClick([]int64{1, -8}, []string{"", "scope"})
-	assert.Equal(t, "1", label.QueryString)
-	assert.True(t, label.IsSelected)
+		// Second test : with duplicates
+		label.LoadSelectedLabelsAfterClick([]int64{1, 7, 1, 7, 7}, []string{"", "scope", "", "scope", "scope"})
+		assert.Equal(t, "1,8", label.QueryString)
+		assert.False(t, label.IsSelected)
 
-	// Second test : with duplicates
-	label.LoadSelectedLabelsAfterClick([]int64{1, 7, 1, 7, 7}, []string{"", "scope", "", "scope", "scope"})
-	assert.Equal(t, "1,8", label.QueryString)
-	assert.False(t, label.IsSelected)
+		// Third test : empty set
+		label.LoadSelectedLabelsAfterClick([]int64{}, []string{})
+		assert.False(t, label.IsSelected)
+		assert.Equal(t, "8", label.QueryString)
+	})
+	t.Run("Label_ExclusiveScope", func(t *testing.T) {
+		label := unittest.AssertExistsAndLoadBean(t, &issues_model.Label{ID: 7})
+		assert.Equal(t, "scope", label.ExclusiveScope())
 
-	// Third test : empty set
-	label.LoadSelectedLabelsAfterClick([]int64{}, []string{})
-	assert.False(t, label.IsSelected)
-	assert.Equal(t, "8", label.QueryString)
-}
+		label = unittest.AssertExistsAndLoadBean(t, &issues_model.Label{ID: 9})
+		assert.Equal(t, "scope/subscope", label.ExclusiveScope())
+	})
+	t.Run("GetLabelByID", func(t *testing.T) {
+		label, err := issues_model.GetLabelByID(t.Context(), 1)
+		assert.NoError(t, err)
+		assert.EqualValues(t, 1, label.ID)
 
-func TestLabel_ExclusiveScope(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	label := unittest.AssertExistsAndLoadBean(t, &issues_model.Label{ID: 7})
-	assert.Equal(t, "scope", label.ExclusiveScope())
+		_, err = issues_model.GetLabelByID(t.Context(), unittest.NonexistentID)
+		assert.True(t, issues_model.IsErrLabelNotExist(err))
+	})
+	t.Run("GetLabelInRepoByName", func(t *testing.T) {
+		label, err := issues_model.GetLabelInRepoByName(t.Context(), 1, "label1")
+		assert.NoError(t, err)
+		assert.EqualValues(t, 1, label.ID)
+		assert.Equal(t, "label1", label.Name)
 
-	label = unittest.AssertExistsAndLoadBean(t, &issues_model.Label{ID: 9})
-	assert.Equal(t, "scope/subscope", label.ExclusiveScope())
+		_, err = issues_model.GetLabelInRepoByName(t.Context(), 1, "")
+		assert.ErrorIs(t, err, util.ErrNotExist)
+
+		_, err = issues_model.GetLabelInRepoByName(t.Context(), unittest.NonexistentID, "nonexistent")
+		assert.ErrorIs(t, err, util.ErrNotExist)
+	})
+	t.Run("GetLabelInRepoByNames", func(t *testing.T) {
+		for _, names := range [][]string{
+			{"label1", "label2"},
+			// label3 doesn't exists.. See labels.yml
+			{"label1", "label2", "label3"},
+		} {
+			labelIDs, err := issues_model.GetLabelIDsInRepoByNames(t.Context(), 1, names)
+			assert.NoError(t, err)
+			assert.Len(t, labelIDs, 2)
+			assert.Equal(t, int64(1), labelIDs[0])
+			assert.Equal(t, int64(2), labelIDs[1])
+		}
+	})
+	t.Run("GetLabelInRepoByID", func(t *testing.T) {
+		label, err := issues_model.GetLabelInRepoByID(t.Context(), 1, 1)
+		assert.NoError(t, err)
+		assert.EqualValues(t, 1, label.ID)
+
+		_, err = issues_model.GetLabelInRepoByID(t.Context(), 1, -1)
+		assert.ErrorIs(t, err, util.ErrNotExist)
+
+		_, err = issues_model.GetLabelInRepoByID(t.Context(), unittest.NonexistentID, unittest.NonexistentID)
+		assert.ErrorIs(t, err, util.ErrNotExist)
+	})
+	t.Run("GetLabelsInRepoByIDs", func(t *testing.T) {
+		labels, err := issues_model.GetLabelsInRepoByIDs(t.Context(), 1, []int64{1, 2, unittest.NonexistentID})
+		assert.NoError(t, err)
+		if assert.Len(t, labels, 2) {
+			assert.EqualValues(t, 1, labels[0].ID)
+			assert.EqualValues(t, 2, labels[1].ID)
+		}
+	})
+
+	// Org versions
+	t.Run("GetLabelInOrgByName", func(t *testing.T) {
+		label, err := issues_model.GetLabelInOrgByName(t.Context(), 3, "orglabel3")
+		assert.NoError(t, err)
+		assert.EqualValues(t, 3, label.ID)
+		assert.Equal(t, "orglabel3", label.Name)
+
+		_, err = issues_model.GetLabelInOrgByName(t.Context(), 3, "")
+		assert.True(t, issues_model.IsErrOrgLabelNotExist(err))
+
+		_, err = issues_model.GetLabelInOrgByName(t.Context(), 0, "orglabel3")
+		assert.True(t, issues_model.IsErrOrgLabelNotExist(err))
+
+		_, err = issues_model.GetLabelInOrgByName(t.Context(), -1, "orglabel3")
+		assert.True(t, issues_model.IsErrOrgLabelNotExist(err))
+
+		_, err = issues_model.GetLabelInOrgByName(t.Context(), unittest.NonexistentID, "nonexistent")
+		assert.True(t, issues_model.IsErrOrgLabelNotExist(err))
+	})
+	t.Run("GetLabelInOrgByID", func(t *testing.T) {
+		label, err := issues_model.GetLabelInOrgByID(t.Context(), 3, 3)
+		assert.NoError(t, err)
+		assert.EqualValues(t, 3, label.ID)
+
+		_, err = issues_model.GetLabelInOrgByID(t.Context(), 3, -1)
+		assert.True(t, issues_model.IsErrOrgLabelNotExist(err))
+
+		_, err = issues_model.GetLabelInOrgByID(t.Context(), 0, 3)
+		assert.True(t, issues_model.IsErrOrgLabelNotExist(err))
+
+		_, err = issues_model.GetLabelInOrgByID(t.Context(), -1, 3)
+		assert.True(t, issues_model.IsErrOrgLabelNotExist(err))
+
+		_, err = issues_model.GetLabelInOrgByID(t.Context(), unittest.NonexistentID, unittest.NonexistentID)
+		assert.True(t, issues_model.IsErrOrgLabelNotExist(err))
+	})
+	t.Run("GetLabelsInOrgByIDs", func(t *testing.T) {
+		labels, err := issues_model.GetLabelsInOrgByIDs(t.Context(), 3, []int64{3, 4, unittest.NonexistentID})
+		assert.NoError(t, err)
+		if assert.Len(t, labels, 2) {
+			assert.EqualValues(t, 3, labels[0].ID)
+			assert.EqualValues(t, 4, labels[1].ID)
+		}
+	})
+	t.Run("GetLabelsByIssueID", func(t *testing.T) {
+		labels, err := issues_model.GetLabelsByIssueID(t.Context(), 1)
+		assert.NoError(t, err)
+		if assert.Len(t, labels, 1) {
+			assert.EqualValues(t, 1, labels[0].ID)
+		}
+
+		labels, err = issues_model.GetLabelsByIssueID(t.Context(), unittest.NonexistentID)
+		assert.NoError(t, err)
+		assert.Empty(t, labels)
+	})
+	t.Run("HasIssueLabel", func(t *testing.T) {
+		assert.True(t, issues_model.HasIssueLabel(t.Context(), 1, 1))
+		assert.False(t, issues_model.HasIssueLabel(t.Context(), 1, 2))
+		assert.False(t, issues_model.HasIssueLabel(t.Context(), unittest.NonexistentID, unittest.NonexistentID))
+	})
+	t.Run("GetLabelsByRepoID", func(t *testing.T) {
+		_, err := db.GetEngine(t.Context()).ID(2).Cols("num_issues", "num_closed_issues").Update(&issues_model.Label{NumIssues: 3, NumClosedIssues: 3})
+		assert.NoError(t, err)
+		testSuccess := func(repoID int64, sortType string, expectedIssueIDs []int64) {
+			labels, err := issues_model.GetLabelsByRepoID(t.Context(), repoID, sortType, db.ListOptions{})
+			assert.NoError(t, err)
+			assert.Len(t, labels, len(expectedIssueIDs))
+			for i, label := range labels {
+				assert.Equal(t, expectedIssueIDs[i], label.ID)
+			}
+		}
+		testSuccess(1, "leastissues", []int64{2, 1})
+		testSuccess(1, "mostissues", []int64{1, 2})
+		testSuccess(1, "reversealphabetically", []int64{2, 1})
+		testSuccess(1, "default", []int64{1, 2})
+	})
+	t.Run("GetLabelsByOrgID", func(t *testing.T) {
+		_, err := db.GetEngine(t.Context()).ID(3).Cols("num_issues", "num_closed_issues").Update(&issues_model.Label{NumIssues: 3, NumClosedIssues: 3})
+		assert.NoError(t, err)
+		testSuccess := func(orgID int64, sortType string, expectedIssueIDs []int64) {
+			labels, err := issues_model.GetLabelsByOrgID(t.Context(), orgID, sortType, db.ListOptions{})
+			assert.NoError(t, err)
+			assert.Len(t, labels, len(expectedIssueIDs))
+			for i, label := range labels {
+				assert.Equal(t, expectedIssueIDs[i], label.ID)
+			}
+		}
+		testSuccess(3, "leastissues", []int64{3, 4})
+		testSuccess(3, "mostissues", []int64{4, 3})
+		testSuccess(3, "reversealphabetically", []int64{4, 3})
+		testSuccess(3, "default", []int64{3, 4})
+
+		_, err = issues_model.GetLabelsByOrgID(t.Context(), 0, "leastissues", db.ListOptions{})
+		assert.True(t, issues_model.IsErrOrgLabelNotExist(err))
+
+		_, err = issues_model.GetLabelsByOrgID(t.Context(), -1, "leastissues", db.ListOptions{})
+		assert.True(t, issues_model.IsErrOrgLabelNotExist(err))
+	})
 }
 
 func TestSortLabelsForDisplay(t *testing.T) {
@@ -118,185 +267,6 @@ func TestNewLabels(t *testing.T) {
 	unittest.CheckConsistencyFor(t, &issues_model.Label{}, &repo_model.Repository{})
 }
 
-func TestGetLabelByID(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	label, err := issues_model.GetLabelByID(t.Context(), 1)
-	assert.NoError(t, err)
-	assert.EqualValues(t, 1, label.ID)
-
-	_, err = issues_model.GetLabelByID(t.Context(), unittest.NonexistentID)
-	assert.True(t, issues_model.IsErrLabelNotExist(err))
-}
-
-func TestGetLabelInRepoByName(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	label, err := issues_model.GetLabelInRepoByName(t.Context(), 1, "label1")
-	assert.NoError(t, err)
-	assert.EqualValues(t, 1, label.ID)
-	assert.Equal(t, "label1", label.Name)
-
-	_, err = issues_model.GetLabelInRepoByName(t.Context(), 1, "")
-	assert.ErrorIs(t, err, util.ErrNotExist)
-
-	_, err = issues_model.GetLabelInRepoByName(t.Context(), unittest.NonexistentID, "nonexistent")
-	assert.ErrorIs(t, err, util.ErrNotExist)
-}
-
-func TestGetLabelInRepoByNames(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	labelIDs, err := issues_model.GetLabelIDsInRepoByNames(t.Context(), 1, []string{"label1", "label2"})
-	assert.NoError(t, err)
-
-	assert.Len(t, labelIDs, 2)
-
-	assert.Equal(t, int64(1), labelIDs[0])
-	assert.Equal(t, int64(2), labelIDs[1])
-}
-
-func TestGetLabelInRepoByNamesDiscardsNonExistentLabels(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	// label3 doesn't exists.. See labels.yml
-	labelIDs, err := issues_model.GetLabelIDsInRepoByNames(t.Context(), 1, []string{"label1", "label2", "label3"})
-	assert.NoError(t, err)
-
-	assert.Len(t, labelIDs, 2)
-
-	assert.Equal(t, int64(1), labelIDs[0])
-	assert.Equal(t, int64(2), labelIDs[1])
-	assert.NoError(t, err)
-}
-
-func TestGetLabelInRepoByID(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	label, err := issues_model.GetLabelInRepoByID(t.Context(), 1, 1)
-	assert.NoError(t, err)
-	assert.EqualValues(t, 1, label.ID)
-
-	_, err = issues_model.GetLabelInRepoByID(t.Context(), 1, -1)
-	assert.ErrorIs(t, err, util.ErrNotExist)
-
-	_, err = issues_model.GetLabelInRepoByID(t.Context(), unittest.NonexistentID, unittest.NonexistentID)
-	assert.ErrorIs(t, err, util.ErrNotExist)
-}
-
-func TestGetLabelsInRepoByIDs(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	labels, err := issues_model.GetLabelsInRepoByIDs(t.Context(), 1, []int64{1, 2, unittest.NonexistentID})
-	assert.NoError(t, err)
-	if assert.Len(t, labels, 2) {
-		assert.EqualValues(t, 1, labels[0].ID)
-		assert.EqualValues(t, 2, labels[1].ID)
-	}
-}
-
-func TestGetLabelsByRepoID(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	_, err := db.GetEngine(t.Context()).ID(2).Cols("num_issues", "num_closed_issues").Update(&issues_model.Label{NumIssues: 3, NumClosedIssues: 3})
-	assert.NoError(t, err)
-	testSuccess := func(repoID int64, sortType string, expectedIssueIDs []int64) {
-		labels, err := issues_model.GetLabelsByRepoID(t.Context(), repoID, sortType, db.ListOptions{})
-		assert.NoError(t, err)
-		assert.Len(t, labels, len(expectedIssueIDs))
-		for i, label := range labels {
-			assert.Equal(t, expectedIssueIDs[i], label.ID)
-		}
-	}
-	testSuccess(1, "leastissues", []int64{2, 1})
-	testSuccess(1, "mostissues", []int64{1, 2})
-	testSuccess(1, "reversealphabetically", []int64{2, 1})
-	testSuccess(1, "default", []int64{1, 2})
-}
-
-// Org versions
-
-func TestGetLabelInOrgByName(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	label, err := issues_model.GetLabelInOrgByName(t.Context(), 3, "orglabel3")
-	assert.NoError(t, err)
-	assert.EqualValues(t, 3, label.ID)
-	assert.Equal(t, "orglabel3", label.Name)
-
-	_, err = issues_model.GetLabelInOrgByName(t.Context(), 3, "")
-	assert.True(t, issues_model.IsErrOrgLabelNotExist(err))
-
-	_, err = issues_model.GetLabelInOrgByName(t.Context(), 0, "orglabel3")
-	assert.True(t, issues_model.IsErrOrgLabelNotExist(err))
-
-	_, err = issues_model.GetLabelInOrgByName(t.Context(), -1, "orglabel3")
-	assert.True(t, issues_model.IsErrOrgLabelNotExist(err))
-
-	_, err = issues_model.GetLabelInOrgByName(t.Context(), unittest.NonexistentID, "nonexistent")
-	assert.True(t, issues_model.IsErrOrgLabelNotExist(err))
-}
-
-func TestGetLabelInOrgByID(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	label, err := issues_model.GetLabelInOrgByID(t.Context(), 3, 3)
-	assert.NoError(t, err)
-	assert.EqualValues(t, 3, label.ID)
-
-	_, err = issues_model.GetLabelInOrgByID(t.Context(), 3, -1)
-	assert.True(t, issues_model.IsErrOrgLabelNotExist(err))
-
-	_, err = issues_model.GetLabelInOrgByID(t.Context(), 0, 3)
-	assert.True(t, issues_model.IsErrOrgLabelNotExist(err))
-
-	_, err = issues_model.GetLabelInOrgByID(t.Context(), -1, 3)
-	assert.True(t, issues_model.IsErrOrgLabelNotExist(err))
-
-	_, err = issues_model.GetLabelInOrgByID(t.Context(), unittest.NonexistentID, unittest.NonexistentID)
-	assert.True(t, issues_model.IsErrOrgLabelNotExist(err))
-}
-
-func TestGetLabelsInOrgByIDs(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	labels, err := issues_model.GetLabelsInOrgByIDs(t.Context(), 3, []int64{3, 4, unittest.NonexistentID})
-	assert.NoError(t, err)
-	if assert.Len(t, labels, 2) {
-		assert.EqualValues(t, 3, labels[0].ID)
-		assert.EqualValues(t, 4, labels[1].ID)
-	}
-}
-
-func TestGetLabelsByOrgID(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	_, err := db.GetEngine(t.Context()).ID(3).Cols("num_issues", "num_closed_issues").Update(&issues_model.Label{NumIssues: 3, NumClosedIssues: 3})
-	assert.NoError(t, err)
-	testSuccess := func(orgID int64, sortType string, expectedIssueIDs []int64) {
-		labels, err := issues_model.GetLabelsByOrgID(t.Context(), orgID, sortType, db.ListOptions{})
-		assert.NoError(t, err)
-		assert.Len(t, labels, len(expectedIssueIDs))
-		for i, label := range labels {
-			assert.Equal(t, expectedIssueIDs[i], label.ID)
-		}
-	}
-	testSuccess(3, "leastissues", []int64{3, 4})
-	testSuccess(3, "mostissues", []int64{4, 3})
-	testSuccess(3, "reversealphabetically", []int64{4, 3})
-	testSuccess(3, "default", []int64{3, 4})
-
-	_, err = issues_model.GetLabelsByOrgID(t.Context(), 0, "leastissues", db.ListOptions{})
-	assert.True(t, issues_model.IsErrOrgLabelNotExist(err))
-
-	_, err = issues_model.GetLabelsByOrgID(t.Context(), -1, "leastissues", db.ListOptions{})
-	assert.True(t, issues_model.IsErrOrgLabelNotExist(err))
-}
-
-//
-
-func TestGetLabelsByIssueID(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	labels, err := issues_model.GetLabelsByIssueID(t.Context(), 1)
-	assert.NoError(t, err)
-	if assert.Len(t, labels, 1) {
-		assert.EqualValues(t, 1, labels[0].ID)
-	}
-
-	labels, err = issues_model.GetLabelsByIssueID(t.Context(), unittest.NonexistentID)
-	assert.NoError(t, err)
-	assert.Empty(t, labels)
-}
-
 func TestUpdateLabel(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 	label := unittest.AssertExistsAndLoadBean(t, &issues_model.Label{ID: 1})
@@ -350,13 +320,6 @@ func TestDeleteLabel(t *testing.T) {
 	unittest.CheckConsistencyFor(t, &issues_model.Label{}, &repo_model.Repository{})
 }
 
-func TestHasIssueLabel(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	assert.True(t, issues_model.HasIssueLabel(t.Context(), 1, 1))
-	assert.False(t, issues_model.HasIssueLabel(t.Context(), 1, 2))
-	assert.False(t, issues_model.HasIssueLabel(t.Context(), unittest.NonexistentID, unittest.NonexistentID))
-}
-
 func TestNewIssueLabel(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 	label := unittest.AssertExistsAndLoadBean(t, &issues_model.Label{ID: 2})

models/issues/milestone_test.go

@@ -24,263 +24,189 @@ func TestMilestone_State(t *testing.T) {
 	assert.Equal(t, api.StateClosed, (&issues_model.Milestone{IsClosed: true}).State())
 }
 
-func TestGetMilestoneByRepoID(t *testing.T) {
+func TestMilestoneQueries(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
-
-	milestone, err := issues_model.GetMilestoneByRepoID(t.Context(), 1, 1)
-	assert.NoError(t, err)
-	assert.EqualValues(t, 1, milestone.ID)
-	assert.EqualValues(t, 1, milestone.RepoID)
-
-	_, err = issues_model.GetMilestoneByRepoID(t.Context(), unittest.NonexistentID, unittest.NonexistentID)
-	assert.True(t, issues_model.IsErrMilestoneNotExist(err))
-}
-
-func TestGetMilestonesByRepoID(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	test := func(repoID int64, state api.StateType) {
-		var isClosed optional.Option[bool]
-		switch state {
-		case api.StateClosed, api.StateOpen:
-			isClosed = optional.Some(state == api.StateClosed)
-		}
-		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: repoID})
-		milestones, err := db.Find[issues_model.Milestone](t.Context(), issues_model.FindMilestoneOptions{
-			RepoID:   repo.ID,
-			IsClosed: isClosed,
-		})
+	t.Run("GetMilestoneByRepoID", func(t *testing.T) {
+		milestone, err := issues_model.GetMilestoneByRepoID(t.Context(), 1, 1)
 		assert.NoError(t, err)
+		assert.EqualValues(t, 1, milestone.ID)
+		assert.EqualValues(t, 1, milestone.RepoID)
 
-		var n int
-
-		switch state {
-		case api.StateClosed:
-			n = repo.NumClosedMilestones
-
-		case api.StateAll:
-			n = repo.NumMilestones
-
-		case api.StateOpen:
-			fallthrough
-
-		default:
-			n = repo.NumOpenMilestones
-		}
-
-		assert.Len(t, milestones, n)
-		for _, milestone := range milestones {
-			assert.Equal(t, repoID, milestone.RepoID)
-		}
-	}
-	test(1, api.StateOpen)
-	test(1, api.StateAll)
-	test(1, api.StateClosed)
-	test(2, api.StateOpen)
-	test(2, api.StateAll)
-	test(2, api.StateClosed)
-	test(3, api.StateOpen)
-	test(3, api.StateClosed)
-	test(3, api.StateAll)
-
-	milestones, err := db.Find[issues_model.Milestone](t.Context(), issues_model.FindMilestoneOptions{
-		RepoID:   unittest.NonexistentID,
-		IsClosed: optional.Some(false),
+		_, err = issues_model.GetMilestoneByRepoID(t.Context(), unittest.NonexistentID, unittest.NonexistentID)
+		assert.True(t, issues_model.IsErrMilestoneNotExist(err))
 	})
-	assert.NoError(t, err)
-	assert.Empty(t, milestones)
-}
-
-func TestGetMilestones(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
-	test := func(sortType string, sortCond func(*issues_model.Milestone) int) {
-		for _, page := range []int{0, 1} {
+	t.Run("GetMilestonesByRepoID", func(t *testing.T) {
+		test := func(repoID int64, state api.StateType) {
+			var isClosed optional.Option[bool]
+			switch state {
+			case api.StateClosed, api.StateOpen:
+				isClosed = optional.Some(state == api.StateClosed)
+			}
+			repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: repoID})
 			milestones, err := db.Find[issues_model.Milestone](t.Context(), issues_model.FindMilestoneOptions{
-				ListOptions: db.ListOptions{
-					Page:     page,
-					PageSize: setting.UI.IssuePagingNum,
-				},
 				RepoID:   repo.ID,
-				IsClosed: optional.Some(false),
-				SortType: sortType,
+				IsClosed: isClosed,
 			})
 			assert.NoError(t, err)
-			assert.Len(t, milestones, repo.NumMilestones-repo.NumClosedMilestones)
-			values := make([]int, len(milestones))
-			for i, milestone := range milestones {
-				values[i] = sortCond(milestone)
-			}
-			assert.True(t, sort.IntsAreSorted(values))
 
-			milestones, err = db.Find[issues_model.Milestone](t.Context(), issues_model.FindMilestoneOptions{
-				ListOptions: db.ListOptions{
-					Page:     page,
-					PageSize: setting.UI.IssuePagingNum,
-				},
-				RepoID:   repo.ID,
+			var n int
+
+			switch state {
+			case api.StateClosed:
+				n = repo.NumClosedMilestones
+
+			case api.StateAll:
+				n = repo.NumMilestones
+
+			case api.StateOpen:
+				fallthrough
+
+			default:
+				n = repo.NumOpenMilestones
+			}
+
+			assert.Len(t, milestones, n)
+			for _, milestone := range milestones {
+				assert.Equal(t, repoID, milestone.RepoID)
+			}
+		}
+		test(1, api.StateOpen)
+		test(1, api.StateAll)
+		test(1, api.StateClosed)
+		test(2, api.StateOpen)
+		test(2, api.StateAll)
+		test(2, api.StateClosed)
+		test(3, api.StateOpen)
+		test(3, api.StateClosed)
+		test(3, api.StateAll)
+
+		milestones, err := db.Find[issues_model.Milestone](t.Context(), issues_model.FindMilestoneOptions{
+			RepoID:   unittest.NonexistentID,
+			IsClosed: optional.Some(false),
+		})
+		assert.NoError(t, err)
+		assert.Empty(t, milestones)
+	})
+	t.Run("GetMilestones", func(t *testing.T) {
+		test := func(t *testing.T, options issues_model.FindMilestoneOptions, numOpen, numClosed int) {
+			testSort := func(sortType string, sortCond func(*issues_model.Milestone) int) {
+				for _, page := range []int{0, 1} {
+					for _, isClosed := range []bool{false, true} {
+						options.ListOptions = db.ListOptions{
+							Page:     page,
+							PageSize: setting.UI.IssuePagingNum,
+						}
+						options.IsClosed = optional.Some(isClosed)
+						options.SortType = sortType
+						milestones, err := db.Find[issues_model.Milestone](t.Context(), options)
+						assert.NoError(t, err)
+						expectedCount := numOpen
+						if isClosed {
+							expectedCount = numClosed
+						}
+						assert.Len(t, milestones, expectedCount)
+						values := make([]int, len(milestones))
+						for i, milestone := range milestones {
+							values[i] = sortCond(milestone)
+						}
+						assert.True(t, sort.IntsAreSorted(values))
+					}
+				}
+			}
+			testSort("furthestduedate", func(milestone *issues_model.Milestone) int {
+				return -int(milestone.DeadlineUnix)
+			})
+			testSort("leastcomplete", func(milestone *issues_model.Milestone) int {
+				return milestone.Completeness
+			})
+			testSort("mostcomplete", func(milestone *issues_model.Milestone) int {
+				return -milestone.Completeness
+			})
+			testSort("leastissues", func(milestone *issues_model.Milestone) int {
+				return milestone.NumIssues
+			})
+			testSort("mostissues", func(milestone *issues_model.Milestone) int {
+				return -milestone.NumIssues
+			})
+			testSort("soonestduedate", func(milestone *issues_model.Milestone) int {
+				return int(milestone.DeadlineUnix)
+			})
+		}
+		t.Run("repo", func(t *testing.T) {
+			repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
+			test(t, issues_model.FindMilestoneOptions{RepoID: repo.ID}, repo.NumMilestones-repo.NumClosedMilestones, repo.NumClosedMilestones)
+		})
+		t.Run("repos", func(t *testing.T) {
+			repo1 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
+			repo2 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 2})
+			test(t, issues_model.FindMilestoneOptions{RepoIDs: []int64{repo1.ID, repo2.ID}},
+				repo1.NumOpenMilestones+repo2.NumOpenMilestones, repo1.NumClosedMilestones+repo2.NumClosedMilestones)
+		})
+	})
+	t.Run("CountRepoMilestones", func(t *testing.T) {
+		test := func(repoID int64) {
+			repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: repoID})
+			count, err := db.Count[issues_model.Milestone](t.Context(), issues_model.FindMilestoneOptions{
+				RepoID: repoID,
+			})
+			assert.NoError(t, err)
+			assert.EqualValues(t, repo.NumMilestones, count)
+		}
+		test(1)
+		test(2)
+		test(3)
+
+		count, err := db.Count[issues_model.Milestone](t.Context(), issues_model.FindMilestoneOptions{
+			RepoID: unittest.NonexistentID,
+		})
+		assert.NoError(t, err)
+		assert.EqualValues(t, 0, count)
+	})
+	t.Run("CountRepoClosedMilestones", func(t *testing.T) {
+		test := func(repoID int64) {
+			repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: repoID})
+			count, err := db.Count[issues_model.Milestone](t.Context(), issues_model.FindMilestoneOptions{
+				RepoID:   repoID,
 				IsClosed: optional.Some(true),
-				Name:     "",
-				SortType: sortType,
 			})
 			assert.NoError(t, err)
-			assert.Len(t, milestones, repo.NumClosedMilestones)
-			values = make([]int, len(milestones))
-			for i, milestone := range milestones {
-				values[i] = sortCond(milestone)
-			}
-			assert.True(t, sort.IntsAreSorted(values))
+			assert.EqualValues(t, repo.NumClosedMilestones, count)
 		}
-	}
-	test("furthestduedate", func(milestone *issues_model.Milestone) int {
-		return -int(milestone.DeadlineUnix)
-	})
-	test("leastcomplete", func(milestone *issues_model.Milestone) int {
-		return milestone.Completeness
-	})
-	test("mostcomplete", func(milestone *issues_model.Milestone) int {
-		return -milestone.Completeness
-	})
-	test("leastissues", func(milestone *issues_model.Milestone) int {
-		return milestone.NumIssues
-	})
-	test("mostissues", func(milestone *issues_model.Milestone) int {
-		return -milestone.NumIssues
-	})
-	test("soonestduedate", func(milestone *issues_model.Milestone) int {
-		return int(milestone.DeadlineUnix)
-	})
-}
+		test(1)
+		test(2)
+		test(3)
 
-func TestCountRepoMilestones(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	test := func(repoID int64) {
-		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: repoID})
 		count, err := db.Count[issues_model.Milestone](t.Context(), issues_model.FindMilestoneOptions{
-			RepoID: repoID,
-		})
-		assert.NoError(t, err)
-		assert.EqualValues(t, repo.NumMilestones, count)
-	}
-	test(1)
-	test(2)
-	test(3)
-
-	count, err := db.Count[issues_model.Milestone](t.Context(), issues_model.FindMilestoneOptions{
-		RepoID: unittest.NonexistentID,
-	})
-	assert.NoError(t, err)
-	assert.EqualValues(t, 0, count)
-}
-
-func TestCountRepoClosedMilestones(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	test := func(repoID int64) {
-		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: repoID})
-		count, err := db.Count[issues_model.Milestone](t.Context(), issues_model.FindMilestoneOptions{
-			RepoID:   repoID,
+			RepoID:   unittest.NonexistentID,
 			IsClosed: optional.Some(true),
 		})
 		assert.NoError(t, err)
-		assert.EqualValues(t, repo.NumClosedMilestones, count)
-	}
-	test(1)
-	test(2)
-	test(3)
-
-	count, err := db.Count[issues_model.Milestone](t.Context(), issues_model.FindMilestoneOptions{
-		RepoID:   unittest.NonexistentID,
-		IsClosed: optional.Some(true),
+		assert.EqualValues(t, 0, count)
 	})
-	assert.NoError(t, err)
-	assert.EqualValues(t, 0, count)
-}
+	t.Run("CountMilestonesByRepoIDs", func(t *testing.T) {
+		milestonesCount := func(repoID int64) (int, int) {
+			repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: repoID})
+			return repo.NumOpenMilestones, repo.NumClosedMilestones
+		}
+		repo1OpenCount, repo1ClosedCount := milestonesCount(1)
+		repo2OpenCount, repo2ClosedCount := milestonesCount(2)
 
-func TestCountMilestonesByRepoIDs(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	milestonesCount := func(repoID int64) (int, int) {
-		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: repoID})
-		return repo.NumOpenMilestones, repo.NumClosedMilestones
-	}
-	repo1OpenCount, repo1ClosedCount := milestonesCount(1)
-	repo2OpenCount, repo2ClosedCount := milestonesCount(2)
-
-	openCounts, err := issues_model.CountMilestonesMap(t.Context(), issues_model.FindMilestoneOptions{
-		RepoIDs:  []int64{1, 2},
-		IsClosed: optional.Some(false),
-	})
-	assert.NoError(t, err)
-	assert.EqualValues(t, repo1OpenCount, openCounts[1])
-	assert.EqualValues(t, repo2OpenCount, openCounts[2])
-
-	closedCounts, err := issues_model.CountMilestonesMap(t.Context(),
-		issues_model.FindMilestoneOptions{
+		openCounts, err := issues_model.CountMilestonesMap(t.Context(), issues_model.FindMilestoneOptions{
 			RepoIDs:  []int64{1, 2},
-			IsClosed: optional.Some(true),
+			IsClosed: optional.Some(false),
 		})
-	assert.NoError(t, err)
-	assert.EqualValues(t, repo1ClosedCount, closedCounts[1])
-	assert.EqualValues(t, repo2ClosedCount, closedCounts[2])
-}
+		assert.NoError(t, err)
+		assert.EqualValues(t, repo1OpenCount, openCounts[1])
+		assert.EqualValues(t, repo2OpenCount, openCounts[2])
 
-func TestGetMilestonesByRepoIDs(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	repo1 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
-	repo2 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 2})
-	test := func(sortType string, sortCond func(*issues_model.Milestone) int) {
-		for _, page := range []int{0, 1} {
-			openMilestones, err := db.Find[issues_model.Milestone](t.Context(), issues_model.FindMilestoneOptions{
-				ListOptions: db.ListOptions{
-					Page:     page,
-					PageSize: setting.UI.IssuePagingNum,
-				},
-				RepoIDs:  []int64{repo1.ID, repo2.ID},
-				IsClosed: optional.Some(false),
-				SortType: sortType,
+		closedCounts, err := issues_model.CountMilestonesMap(t.Context(),
+			issues_model.FindMilestoneOptions{
+				RepoIDs:  []int64{1, 2},
+				IsClosed: optional.Some(true),
 			})
-			assert.NoError(t, err)
-			assert.Len(t, openMilestones, repo1.NumOpenMilestones+repo2.NumOpenMilestones)
-			values := make([]int, len(openMilestones))
-			for i, milestone := range openMilestones {
-				values[i] = sortCond(milestone)
-			}
-			assert.True(t, sort.IntsAreSorted(values))
-
-			closedMilestones, err := db.Find[issues_model.Milestone](t.Context(),
-				issues_model.FindMilestoneOptions{
-					ListOptions: db.ListOptions{
-						Page:     page,
-						PageSize: setting.UI.IssuePagingNum,
-					},
-					RepoIDs:  []int64{repo1.ID, repo2.ID},
-					IsClosed: optional.Some(true),
-					SortType: sortType,
-				})
-			assert.NoError(t, err)
-			assert.Len(t, closedMilestones, repo1.NumClosedMilestones+repo2.NumClosedMilestones)
-			values = make([]int, len(closedMilestones))
-			for i, milestone := range closedMilestones {
-				values[i] = sortCond(milestone)
-			}
-			assert.True(t, sort.IntsAreSorted(values))
-		}
-	}
-	test("furthestduedate", func(milestone *issues_model.Milestone) int {
-		return -int(milestone.DeadlineUnix)
-	})
-	test("leastcomplete", func(milestone *issues_model.Milestone) int {
-		return milestone.Completeness
-	})
-	test("mostcomplete", func(milestone *issues_model.Milestone) int {
-		return -milestone.Completeness
-	})
-	test("leastissues", func(milestone *issues_model.Milestone) int {
-		return milestone.NumIssues
-	})
-	test("mostissues", func(milestone *issues_model.Milestone) int {
-		return -milestone.NumIssues
-	})
-	test("soonestduedate", func(milestone *issues_model.Milestone) int {
-		return int(milestone.DeadlineUnix)
+		assert.NoError(t, err)
+		assert.EqualValues(t, repo1ClosedCount, closedCounts[1])
+		assert.EqualValues(t, repo2ClosedCount, closedCounts[2])
 	})
 }
 

models/issues/review_test.go

@@ -225,33 +225,14 @@ func TestDismissReview(t *testing.T) {
 	assert.True(t, rejectReviewExample.Dismissed)
 	assert.False(t, requestReviewExample.Dismissed)
 
-	assert.NoError(t, issues_model.DismissReview(t.Context(), requestReviewExample, true))
-	rejectReviewExample = unittest.AssertExistsAndLoadBean(t, &issues_model.Review{ID: 9})
-	requestReviewExample = unittest.AssertExistsAndLoadBean(t, &issues_model.Review{ID: 11})
-	assert.True(t, rejectReviewExample.Dismissed)
-	assert.False(t, requestReviewExample.Dismissed)
-	assert.False(t, approveReviewExample.Dismissed)
-
-	assert.NoError(t, issues_model.DismissReview(t.Context(), requestReviewExample, true))
-	rejectReviewExample = unittest.AssertExistsAndLoadBean(t, &issues_model.Review{ID: 9})
-	requestReviewExample = unittest.AssertExistsAndLoadBean(t, &issues_model.Review{ID: 11})
-	assert.True(t, rejectReviewExample.Dismissed)
-	assert.False(t, requestReviewExample.Dismissed)
-	assert.False(t, approveReviewExample.Dismissed)
-
-	assert.NoError(t, issues_model.DismissReview(t.Context(), requestReviewExample, false))
-	rejectReviewExample = unittest.AssertExistsAndLoadBean(t, &issues_model.Review{ID: 9})
-	requestReviewExample = unittest.AssertExistsAndLoadBean(t, &issues_model.Review{ID: 11})
-	assert.True(t, rejectReviewExample.Dismissed)
-	assert.False(t, requestReviewExample.Dismissed)
-	assert.False(t, approveReviewExample.Dismissed)
-
-	assert.NoError(t, issues_model.DismissReview(t.Context(), requestReviewExample, false))
-	rejectReviewExample = unittest.AssertExistsAndLoadBean(t, &issues_model.Review{ID: 9})
-	requestReviewExample = unittest.AssertExistsAndLoadBean(t, &issues_model.Review{ID: 11})
-	assert.True(t, rejectReviewExample.Dismissed)
-	assert.False(t, requestReviewExample.Dismissed)
-	assert.False(t, approveReviewExample.Dismissed)
+	for _, dismissed := range []bool{true, true, false, false} {
+		assert.NoError(t, issues_model.DismissReview(t.Context(), requestReviewExample, dismissed))
+		rejectReviewExample = unittest.AssertExistsAndLoadBean(t, &issues_model.Review{ID: 9})
+		requestReviewExample = unittest.AssertExistsAndLoadBean(t, &issues_model.Review{ID: 11})
+		assert.True(t, rejectReviewExample.Dismissed)
+		assert.False(t, requestReviewExample.Dismissed)
+		assert.False(t, approveReviewExample.Dismissed)
+	}
 
 	assert.NoError(t, issues_model.DismissReview(t.Context(), rejectReviewExample, false))
 	assert.False(t, rejectReviewExample.Dismissed)