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/repo/archive_test.go

@@ -1,32 +0,0 @@
-// Copyright 2025 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package repo
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestArchiveType(t *testing.T) {
-	name, archiveType := SplitArchiveNameType("test.tar.gz")
-	assert.Equal(t, "test", name)
-	assert.Equal(t, "tar.gz", archiveType.String())
-
-	name, archiveType = SplitArchiveNameType("a/b/test.zip")
-	assert.Equal(t, "a/b/test", name)
-	assert.Equal(t, "zip", archiveType.String())
-
-	name, archiveType = SplitArchiveNameType("1234.bundle")
-	assert.Equal(t, "1234", name)
-	assert.Equal(t, "bundle", archiveType.String())
-
-	name, archiveType = SplitArchiveNameType("test")
-	assert.Equal(t, "test", name)
-	assert.Equal(t, "unknown", archiveType.String())
-
-	name, archiveType = SplitArchiveNameType("test.xz")
-	assert.Equal(t, "test.xz", name)
-	assert.Equal(t, "unknown", archiveType.String())
-}

models/repo/attachment_test.go

@@ -34,46 +34,73 @@ func TestIncreaseDownloadCount(t *testing.T) {
 func TestGetByCommentOrIssueID(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 
-	// count of attachments from issue ID
-	attachments, err := repo_model.GetAttachmentsByIssueID(t.Context(), 1)
-	assert.NoError(t, err)
-	assert.Len(t, attachments, 1)
+	t.Run("GetByCommentOrIssueID", func(t *testing.T) {
+		// count of attachments from issue ID
+		attachments, err := repo_model.GetAttachmentsByIssueID(t.Context(), 1)
+		assert.NoError(t, err)
+		assert.Len(t, attachments, 1)
 
-	attachments, err = repo_model.GetAttachmentsByIssueID(t.Context(), 0)
-	assert.NoError(t, err)
-	assert.Empty(t, attachments)
+		attachments, err = repo_model.GetAttachmentsByIssueID(t.Context(), 0)
+		assert.NoError(t, err)
+		assert.Empty(t, attachments)
 
-	attachments, err = repo_model.GetAttachmentsByCommentID(t.Context(), 1)
-	assert.NoError(t, err)
-	assert.Len(t, attachments, 2)
-}
+		attachments, err = repo_model.GetAttachmentsByCommentID(t.Context(), 1)
+		assert.NoError(t, err)
+		assert.Len(t, attachments, 2)
+	})
 
-func TestDeleteAttachments(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
+	t.Run("GetAttachmentsByUUIDs", func(t *testing.T) {
+		attachList, err := repo_model.GetAttachmentsByUUIDs(t.Context(), []string{"a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11", "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a17", "not-existing-uuid"})
+		assert.NoError(t, err)
+		assert.Len(t, attachList, 2)
+		assert.Equal(t, "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11", attachList[0].UUID)
+		assert.Equal(t, "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a17", attachList[1].UUID)
+		assert.Equal(t, int64(1), attachList[0].IssueID)
+		assert.Equal(t, int64(5), attachList[1].IssueID)
+	})
 
-	count, err := repo_model.DeleteAttachmentsByIssue(t.Context(), 4, false)
-	assert.NoError(t, err)
-	assert.Equal(t, 2, count)
+	t.Run("GetUnlinkedAttachmentsByUserID", func(t *testing.T) {
+		attachments, err := repo_model.GetUnlinkedAttachmentsByUserID(t.Context(), 8)
+		assert.NoError(t, err)
+		assert.Len(t, attachments, 1)
+		assert.Equal(t, int64(10), attachments[0].ID)
+		assert.Zero(t, attachments[0].IssueID)
+		assert.Zero(t, attachments[0].ReleaseID)
+		assert.Zero(t, attachments[0].CommentID)
 
-	count, err = repo_model.DeleteAttachmentsByComment(t.Context(), 2, false)
-	assert.NoError(t, err)
-	assert.Equal(t, 2, count)
+		attachments, err = repo_model.GetUnlinkedAttachmentsByUserID(t.Context(), 1)
+		assert.NoError(t, err)
+		assert.Empty(t, attachments)
+	})
 
-	err = repo_model.DeleteAttachment(t.Context(), &repo_model.Attachment{ID: 8}, false)
-	assert.NoError(t, err)
+	t.Run("DeleteAttachments", func(t *testing.T) {
+		count, err := repo_model.DeleteAttachmentsByIssue(t.Context(), 4, false)
+		assert.NoError(t, err)
+		assert.Equal(t, 2, count)
 
-	attachment, err := repo_model.GetAttachmentByUUID(t.Context(), "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a18")
-	assert.Error(t, err)
-	assert.True(t, repo_model.IsErrAttachmentNotExist(err))
-	assert.Nil(t, attachment)
-}
+		count, err = repo_model.DeleteAttachmentsByComment(t.Context(), 2, false)
+		assert.NoError(t, err)
+		assert.Equal(t, 2, count)
 
-func TestGetAttachmentByID(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
+		err = repo_model.DeleteAttachment(t.Context(), &repo_model.Attachment{ID: 8}, false)
+		assert.NoError(t, err)
 
-	attach, err := repo_model.GetAttachmentByID(t.Context(), 1)
-	assert.NoError(t, err)
-	assert.Equal(t, "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11", attach.UUID)
+		attachment, err := repo_model.GetAttachmentByUUID(t.Context(), "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a18")
+		assert.Error(t, err)
+		assert.True(t, repo_model.IsErrAttachmentNotExist(err))
+		assert.Nil(t, attachment)
+	})
+
+	t.Run("UpdateAttachment", func(t *testing.T) {
+		attach, err := repo_model.GetAttachmentByID(t.Context(), 1)
+		assert.NoError(t, err)
+		assert.Equal(t, "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11", attach.UUID)
+
+		attach.Name = "new_name"
+		assert.NoError(t, repo_model.UpdateAttachment(t.Context(), attach))
+
+		unittest.AssertExistsAndLoadBean(t, &repo_model.Attachment{Name: "new_name"})
+	})
 }
 
 func TestDeleteOrphanedAttachments(t *testing.T) {
@@ -111,44 +138,3 @@ func TestAttachment_DownloadURL(t *testing.T) {
 	}
 	assert.Equal(t, "https://try.gitea.io/attachments/a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11", attach.DownloadURL(t.Context()))
 }
-
-func TestUpdateAttachment(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-
-	attach, err := repo_model.GetAttachmentByID(t.Context(), 1)
-	assert.NoError(t, err)
-	assert.Equal(t, "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11", attach.UUID)
-
-	attach.Name = "new_name"
-	assert.NoError(t, repo_model.UpdateAttachment(t.Context(), attach))
-
-	unittest.AssertExistsAndLoadBean(t, &repo_model.Attachment{Name: "new_name"})
-}
-
-func TestGetAttachmentsByUUIDs(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-
-	attachList, err := repo_model.GetAttachmentsByUUIDs(t.Context(), []string{"a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11", "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a17", "not-existing-uuid"})
-	assert.NoError(t, err)
-	assert.Len(t, attachList, 2)
-	assert.Equal(t, "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11", attachList[0].UUID)
-	assert.Equal(t, "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a17", attachList[1].UUID)
-	assert.Equal(t, int64(1), attachList[0].IssueID)
-	assert.Equal(t, int64(5), attachList[1].IssueID)
-}
-
-func TestGetUnlinkedAttachmentsByUserID(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-
-	attachments, err := repo_model.GetUnlinkedAttachmentsByUserID(t.Context(), 8)
-	assert.NoError(t, err)
-	assert.Len(t, attachments, 1)
-	assert.Equal(t, int64(10), attachments[0].ID)
-	assert.Zero(t, attachments[0].IssueID)
-	assert.Zero(t, attachments[0].ReleaseID)
-	assert.Zero(t, attachments[0].CommentID)
-
-	attachments, err = repo_model.GetUnlinkedAttachmentsByUserID(t.Context(), 1)
-	assert.NoError(t, err)
-	assert.Empty(t, attachments)
-}

models/repo/avatar_test.go

@@ -25,3 +25,19 @@ func TestRepoAvatarLink(t *testing.T) {
 	link = repo.AvatarLink(t.Context())
 	assert.Equal(t, "https://localhost/sub-path/repo-avatars/avatar.png", link)
 }
+
+func TestArchiveType(t *testing.T) {
+	for _, tc := range []struct {
+		input, name, archiveType string
+	}{
+		{"test.tar.gz", "test", "tar.gz"},
+		{"a/b/test.zip", "a/b/test", "zip"},
+		{"1234.bundle", "1234", "bundle"},
+		{"test", "test", "unknown"},
+		{"test.xz", "test.xz", "unknown"},
+	} {
+		name, archiveType := SplitArchiveNameType(tc.input)
+		assert.Equal(t, tc.name, name)
+		assert.Equal(t, tc.archiveType, archiveType.String())
+	}
+}

models/repo/collaboration_test.go

@@ -15,107 +15,100 @@ import (
 
 func TestRepository_GetCollaborators(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
-	test := func(repoID int64) {
-		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: repoID})
-		collaborators, _, err := repo_model.GetCollaborators(t.Context(), &repo_model.FindCollaborationOptions{RepoID: repo.ID})
-		assert.NoError(t, err)
-		expectedLen, err := db.GetEngine(t.Context()).Count(&repo_model.Collaboration{RepoID: repoID})
-		assert.NoError(t, err)
-		assert.Len(t, collaborators, int(expectedLen))
-		for _, collaborator := range collaborators {
-			assert.Equal(t, collaborator.User.ID, collaborator.Collaboration.UserID)
-			assert.Equal(t, repoID, collaborator.Collaboration.RepoID)
+
+	t.Run("Repository_GetCollaborators", func(t *testing.T) {
+		for _, repoID := range []int64{1, 2, 3, 4} {
+			repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: repoID})
+			collaborators, _, err := repo_model.GetCollaborators(t.Context(), &repo_model.FindCollaborationOptions{RepoID: repo.ID})
+			assert.NoError(t, err)
+			expectedLen, err := db.GetEngine(t.Context()).Count(&repo_model.Collaboration{RepoID: repoID})
+			assert.NoError(t, err)
+			assert.Len(t, collaborators, int(expectedLen))
+			for _, collaborator := range collaborators {
+				assert.Equal(t, collaborator.User.ID, collaborator.Collaboration.UserID)
+				assert.Equal(t, repoID, collaborator.Collaboration.RepoID)
+			}
 		}
-	}
-	test(1)
-	test(2)
-	test(3)
-	test(4)
 
-	// Test db.ListOptions
-	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 22})
+		// Test db.ListOptions
+		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 22})
 
-	collaborators1, _, err := repo_model.GetCollaborators(t.Context(), &repo_model.FindCollaborationOptions{
-		ListOptions: db.ListOptions{PageSize: 1, Page: 1},
-		RepoID:      repo.ID,
-	})
-	assert.NoError(t, err)
-	assert.Len(t, collaborators1, 1)
-
-	collaborators2, _, err := repo_model.GetCollaborators(t.Context(), &repo_model.FindCollaborationOptions{
-		ListOptions: db.ListOptions{PageSize: 1, Page: 2},
-		RepoID:      repo.ID,
-	})
-	assert.NoError(t, err)
-	assert.Len(t, collaborators2, 1)
-
-	assert.NotEqual(t, collaborators1[0].ID, collaborators2[0].ID)
-}
-
-func TestRepository_IsCollaborator(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-
-	test := func(repoID, userID int64, expected bool) {
-		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: repoID})
-		actual, err := repo_model.IsCollaborator(t.Context(), repo.ID, userID)
+		collaborators1, _, err := repo_model.GetCollaborators(t.Context(), &repo_model.FindCollaborationOptions{
+			ListOptions: db.ListOptions{PageSize: 1, Page: 1},
+			RepoID:      repo.ID,
+		})
 		assert.NoError(t, err)
-		assert.Equal(t, expected, actual)
-	}
-	test(3, 2, true)
-	test(3, unittest.NonexistentID, false)
-	test(4, 2, false)
-	test(4, 4, true)
-}
-
-func TestRepository_IsOwnerMemberCollaborator(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-
-	repo1 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 3})
-
-	// Organisation owner.
-	actual, err := repo_model.HasAccessToRepoCodeUnit(t.Context(), repo1, 2)
-	assert.NoError(t, err)
-	assert.True(t, actual)
-
-	// Team member.
-	actual, err = repo_model.HasAccessToRepoCodeUnit(t.Context(), repo1, 4)
-	assert.NoError(t, err)
-	assert.True(t, actual)
-
-	// Normal user.
-	actual, err = repo_model.HasAccessToRepoCodeUnit(t.Context(), repo1, 1)
-	assert.NoError(t, err)
-	assert.False(t, actual)
-
-	repo2 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 4})
-
-	// Collaborator.
-	actual, err = repo_model.HasAccessToRepoCodeUnit(t.Context(), repo2, 4)
-	assert.NoError(t, err)
-	assert.True(t, actual)
-
-	repo3 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 15})
-
-	// Repository owner.
-	actual, err = repo_model.HasAccessToRepoCodeUnit(t.Context(), repo3, 2)
-	assert.NoError(t, err)
-	assert.True(t, actual)
-}
-
-func TestRepo_GetCollaboration(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-
-	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 4})
-
-	// Existing collaboration.
-	collab, err := repo_model.GetCollaboration(t.Context(), repo.ID, 4)
-	assert.NoError(t, err)
-	assert.NotNil(t, collab)
-	assert.EqualValues(t, 4, collab.UserID)
-	assert.EqualValues(t, 4, collab.RepoID)
-
-	// Non-existing collaboration.
-	collab, err = repo_model.GetCollaboration(t.Context(), repo.ID, 1)
-	assert.NoError(t, err)
-	assert.Nil(t, collab)
+		assert.Len(t, collaborators1, 1)
+
+		collaborators2, _, err := repo_model.GetCollaborators(t.Context(), &repo_model.FindCollaborationOptions{
+			ListOptions: db.ListOptions{PageSize: 1, Page: 2},
+			RepoID:      repo.ID,
+		})
+		assert.NoError(t, err)
+		assert.Len(t, collaborators2, 1)
+
+		assert.NotEqual(t, collaborators1[0].ID, collaborators2[0].ID)
+	})
+
+	t.Run("Repository_IsCollaborator", func(t *testing.T) {
+		test := func(repoID, userID int64, expected bool) {
+			repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: repoID})
+			actual, err := repo_model.IsCollaborator(t.Context(), repo.ID, userID)
+			assert.NoError(t, err)
+			assert.Equal(t, expected, actual)
+		}
+		test(3, 2, true)
+		test(3, unittest.NonexistentID, false)
+		test(4, 2, false)
+		test(4, 4, true)
+	})
+
+	t.Run("Repository_IsOwnerMemberCollaborator", func(t *testing.T) {
+		repo1 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 3})
+
+		// Organisation owner.
+		actual, err := repo_model.HasAccessToRepoCodeUnit(t.Context(), repo1, 2)
+		assert.NoError(t, err)
+		assert.True(t, actual)
+
+		// Team member.
+		actual, err = repo_model.HasAccessToRepoCodeUnit(t.Context(), repo1, 4)
+		assert.NoError(t, err)
+		assert.True(t, actual)
+
+		// Normal user.
+		actual, err = repo_model.HasAccessToRepoCodeUnit(t.Context(), repo1, 1)
+		assert.NoError(t, err)
+		assert.False(t, actual)
+
+		repo2 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 4})
+
+		// Collaborator.
+		actual, err = repo_model.HasAccessToRepoCodeUnit(t.Context(), repo2, 4)
+		assert.NoError(t, err)
+		assert.True(t, actual)
+
+		repo3 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 15})
+
+		// Repository owner.
+		actual, err = repo_model.HasAccessToRepoCodeUnit(t.Context(), repo3, 2)
+		assert.NoError(t, err)
+		assert.True(t, actual)
+	})
+
+	t.Run("Repo_GetCollaboration", func(t *testing.T) {
+		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 4})
+
+		// Existing collaboration.
+		collab, err := repo_model.GetCollaboration(t.Context(), repo.ID, 4)
+		assert.NoError(t, err)
+		assert.NotNil(t, collab)
+		assert.EqualValues(t, 4, collab.UserID)
+		assert.EqualValues(t, 4, collab.RepoID)
+
+		// Non-existing collaboration.
+		collab, err = repo_model.GetCollaboration(t.Context(), repo.ID, 1)
+		assert.NoError(t, err)
+		assert.Nil(t, collab)
+	})
 }

models/repo/pull_request_default_test.go

@@ -33,46 +33,37 @@ func TestDefaultTargetBranchSelection(t *testing.T) {
 }
 
 func TestPullRequestConfigFromDB(t *testing.T) {
-	cases := []struct {
+	for _, tc := range []struct {
 		// name describes the row shape under test; the comments capture why each row matters.
-		name              string
-		json              string
-		wantMergeUpdate   bool
-		wantRebaseUpdate  bool
-		wantDefaultStyle  UpdateStyle
-		wantValidatesPass bool
+		name             string
+		json             string
+		wantRebaseUpdate bool
 	}{
 		{
 			// Empty object exercises the all-defaults path (e.g. fresh repos created via low-level paths).
 			name: "defaults", json: "{}",
-			wantMergeUpdate: true, wantRebaseUpdate: true,
-			wantDefaultStyle: UpdateStyleMerge, wantValidatesPass: true,
+			wantRebaseUpdate: true,
 		},
 		{
 			// Realistic upgrade case: pre-PR JSON lacks the new fields and has AllowRebaseUpdate=false.
 			// Historical setting must be preserved while new fields take safe defaults.
-			name:            "legacy without new fields",
-			json:            `{"AllowMerge":true,"AllowRebase":true,"AllowRebaseMerge":true,"AllowSquash":true,"AllowRebaseUpdate":false}`,
-			wantMergeUpdate: true, wantRebaseUpdate: false,
-			wantDefaultStyle: UpdateStyleMerge, wantValidatesPass: true,
+			name:             "legacy without new fields",
+			json:             `{"AllowMerge":true,"AllowRebase":true,"AllowRebaseMerge":true,"AllowSquash":true,"AllowRebaseUpdate":false}`,
+			wantRebaseUpdate: false,
 		},
 		{
 			// Partially-migrated row with explicit empty string must normalize so ValidateUpdateSettings passes.
 			name: "empty default style", json: `{"DefaultUpdateStyle":""}`,
-			wantMergeUpdate: true, wantRebaseUpdate: true,
-			wantDefaultStyle: UpdateStyleMerge, wantValidatesPass: true,
+			wantRebaseUpdate: true,
 		},
-	}
-	for _, tc := range cases {
+	} {
 		t.Run(tc.name, func(t *testing.T) {
 			cfg := new(PullRequestsConfig)
 			assert.NoError(t, cfg.FromDB([]byte(tc.json)))
-			assert.Equal(t, tc.wantMergeUpdate, cfg.AllowMergeUpdate)
+			assert.True(t, cfg.AllowMergeUpdate)
 			assert.Equal(t, tc.wantRebaseUpdate, cfg.AllowRebaseUpdate)
-			assert.Equal(t, tc.wantDefaultStyle, cfg.DefaultUpdateStyle)
-			if tc.wantValidatesPass {
-				assert.NoError(t, cfg.ValidateUpdateSettings())
-			}
+			assert.Equal(t, UpdateStyleMerge, cfg.DefaultUpdateStyle)
+			assert.NoError(t, cfg.ValidateUpdateSettings())
 		})
 	}
 }

models/repo/pushmirror_test.go

@@ -27,17 +27,12 @@ func TestPushMirrorsIterate(t *testing.T) {
 	})
 
 	long, _ := time.ParseDuration("24h")
-	db.Insert(t.Context(), &repo_model.PushMirror{
-		RemoteName:     "test-2",
-		LastUpdateUnix: now,
-		Interval:       long,
-	})
-
-	db.Insert(t.Context(), &repo_model.PushMirror{
-		RemoteName:     "test-3",
-		LastUpdateUnix: now,
-		Interval:       0,
-	})
+	for _, mirror := range []*repo_model.PushMirror{
+		{RemoteName: "test-2", LastUpdateUnix: now, Interval: long},
+		{RemoteName: "test-3", LastUpdateUnix: now, Interval: 0},
+	} {
+		db.Insert(t.Context(), mirror)
+	}
 
 	repo_model.PushMirrorsIterate(t.Context(), 1, func(idx int, bean any) error {
 		m, ok := bean.(*repo_model.PushMirror)

models/repo/redirect_test.go

@@ -24,53 +24,37 @@ func TestLookupRedirect(t *testing.T) {
 }
 
 func TestNewRedirect(t *testing.T) {
-	// redirect to a completely new name
-	assert.NoError(t, unittest.PrepareTestDatabase())
+	for _, tc := range []struct {
+		repoID  int64
+		newName string
+	}{
+		{1, "newreponame"}, // redirect to a completely new name
+		{1, "oldrepo1"},    // redirect to previously used name
+		{2, "newreponame"}, // redirect for a previously-unredirected repo
+	} {
+		t.Run(tc.newName, func(t *testing.T) {
+			assert.NoError(t, unittest.PrepareTestDatabase())
 
-	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
-	assert.NoError(t, repo_model.NewRedirect(t.Context(), repo.OwnerID, repo.ID, repo.Name, "newreponame"))
+			repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: tc.repoID})
+			assert.NoError(t, repo_model.NewRedirect(t.Context(), repo.OwnerID, repo.ID, repo.Name, tc.newName))
 
-	unittest.AssertExistsAndLoadBean(t, &repo_model.Redirect{
-		OwnerID:        repo.OwnerID,
-		LowerName:      repo.LowerName,
-		RedirectRepoID: repo.ID,
-	})
-	unittest.AssertExistsAndLoadBean(t, &repo_model.Redirect{
-		OwnerID:        repo.OwnerID,
-		LowerName:      "oldrepo1",
-		RedirectRepoID: repo.ID,
-	})
-}
-
-func TestNewRedirect2(t *testing.T) {
-	// redirect to previously used name
-	assert.NoError(t, unittest.PrepareTestDatabase())
-
-	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
-	assert.NoError(t, repo_model.NewRedirect(t.Context(), repo.OwnerID, repo.ID, repo.Name, "oldrepo1"))
-
-	unittest.AssertExistsAndLoadBean(t, &repo_model.Redirect{
-		OwnerID:        repo.OwnerID,
-		LowerName:      repo.LowerName,
-		RedirectRepoID: repo.ID,
-	})
-	unittest.AssertNotExistsBean(t, &repo_model.Redirect{
-		OwnerID:        repo.OwnerID,
-		LowerName:      "oldrepo1",
-		RedirectRepoID: repo.ID,
-	})
-}
-
-func TestNewRedirect3(t *testing.T) {
-	// redirect for a previously-unredirected repo
-	assert.NoError(t, unittest.PrepareTestDatabase())
-
-	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 2})
-	assert.NoError(t, repo_model.NewRedirect(t.Context(), repo.OwnerID, repo.ID, repo.Name, "newreponame"))
-
-	unittest.AssertExistsAndLoadBean(t, &repo_model.Redirect{
-		OwnerID:        repo.OwnerID,
-		LowerName:      repo.LowerName,
-		RedirectRepoID: repo.ID,
-	})
+			unittest.AssertExistsAndLoadBean(t, &repo_model.Redirect{
+				OwnerID:        repo.OwnerID,
+				LowerName:      repo.LowerName,
+				RedirectRepoID: repo.ID,
+			})
+			if tc.repoID == 1 {
+				redirect := &repo_model.Redirect{
+					OwnerID:        repo.OwnerID,
+					LowerName:      "oldrepo1",
+					RedirectRepoID: repo.ID,
+				}
+				if tc.newName == "oldrepo1" {
+					unittest.AssertNotExistsBean(t, redirect)
+				} else {
+					unittest.AssertExistsAndLoadBean(t, redirect)
+				}
+			}
+		})
+	}
 }

models/repo/release_test.go

@@ -30,75 +30,69 @@ func TestMigrate_InsertReleases(t *testing.T) {
 func Test_FindTagsByCommitIDs(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 
-	sha1Rels, err := FindTagsByCommitIDs(t.Context(), 1, "65f1bf27bc3bf70f64657658635e66094edbcb4d")
-	assert.NoError(t, err)
-	assert.Len(t, sha1Rels, 1)
-	rels := sha1Rels["65f1bf27bc3bf70f64657658635e66094edbcb4d"]
-	assert.Len(t, rels, 3)
-	assert.Equal(t, "v1.1", rels[0].TagName)
-	assert.Equal(t, "delete-tag", rels[1].TagName)
-	assert.Equal(t, "v1.0", rels[2].TagName)
-}
-
-func TestAddReleaseAttachmentsRejectsDifferentRepo(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-
-	uuid := "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a12" // attachment 2 belongs to repo 2
-	err := AddReleaseAttachments(t.Context(), 1, []string{uuid})
-	assert.Error(t, err)
-	assert.ErrorIs(t, err, util.ErrPermissionDenied)
-
-	attach, err := GetAttachmentByUUID(t.Context(), uuid)
-	assert.NoError(t, err)
-	assert.Zero(t, attach.ReleaseID, "attachment should not be linked to release on failure")
-}
-
-func TestAddReleaseAttachmentsRejectsIssueAttachment(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-
-	uuid := "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11"
-	err := AddReleaseAttachments(t.Context(), 1, []string{uuid})
-	assert.ErrorIs(t, err, util.ErrPermissionDenied)
-
-	attach, err := GetAttachmentByUUID(t.Context(), uuid)
-	assert.NoError(t, err)
-	assert.Zero(t, attach.ReleaseID)
-}
-
-func TestAddReleaseAttachmentsAllowsLegacyMissingRepoID(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-
-	legacyUUID := "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a20" // attachment 10 has repo_id 0
-	err := AddReleaseAttachments(t.Context(), 1, []string{legacyUUID})
-	assert.NoError(t, err)
-
-	attach, err := GetAttachmentByUUID(t.Context(), legacyUUID)
-	assert.NoError(t, err)
-	assert.EqualValues(t, 1, attach.RepoID)
-	assert.EqualValues(t, 1, attach.ReleaseID)
-}
-
-func TestAddReleaseAttachmentsRejectsRecentZeroRepoID(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-
-	recentUUID := "a0eebc99-9c0b-4ef8-bb6d-6bb9bd3800aa"
-	attachment := &Attachment{
-		UUID:        recentUUID,
-		RepoID:      0,
-		IssueID:     0,
-		ReleaseID:   0,
-		CommentID:   0,
-		Name:        "recent-zero",
-		CreatedUnix: LegacyAttachmentMissingRepoIDCutoff + 1,
-	}
-	assert.NoError(t, db.Insert(t.Context(), attachment))
-
-	err := AddReleaseAttachments(t.Context(), 1, []string{recentUUID})
-	assert.Error(t, err)
-	assert.ErrorIs(t, err, util.ErrPermissionDenied)
-
-	attach, err := GetAttachmentByUUID(t.Context(), recentUUID)
-	assert.NoError(t, err)
-	assert.Zero(t, attach.ReleaseID)
-	assert.Zero(t, attach.RepoID)
+	t.Run("_FindTagsByCommitIDs", func(t *testing.T) {
+		sha1Rels, err := FindTagsByCommitIDs(t.Context(), 1, "65f1bf27bc3bf70f64657658635e66094edbcb4d")
+		assert.NoError(t, err)
+		assert.Len(t, sha1Rels, 1)
+		rels := sha1Rels["65f1bf27bc3bf70f64657658635e66094edbcb4d"]
+		assert.Len(t, rels, 3)
+		assert.Equal(t, "v1.1", rels[0].TagName)
+		assert.Equal(t, "delete-tag", rels[1].TagName)
+		assert.Equal(t, "v1.0", rels[2].TagName)
+	})
+
+	t.Run("AddReleaseAttachmentsRejectsDifferentRepo", func(t *testing.T) {
+		uuid := "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a12" // attachment 2 belongs to repo 2
+		err := AddReleaseAttachments(t.Context(), 1, []string{uuid})
+		assert.Error(t, err)
+		assert.ErrorIs(t, err, util.ErrPermissionDenied)
+
+		attach, err := GetAttachmentByUUID(t.Context(), uuid)
+		assert.NoError(t, err)
+		assert.Zero(t, attach.ReleaseID, "attachment should not be linked to release on failure")
+	})
+
+	t.Run("AddReleaseAttachmentsRejectsIssueAttachment", func(t *testing.T) {
+		uuid := "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11"
+		err := AddReleaseAttachments(t.Context(), 1, []string{uuid})
+		assert.ErrorIs(t, err, util.ErrPermissionDenied)
+
+		attach, err := GetAttachmentByUUID(t.Context(), uuid)
+		assert.NoError(t, err)
+		assert.Zero(t, attach.ReleaseID)
+	})
+
+	t.Run("AddReleaseAttachmentsRejectsRecentZeroRepoID", func(t *testing.T) {
+		recentUUID := "a0eebc99-9c0b-4ef8-bb6d-6bb9bd3800aa"
+		attachment := &Attachment{
+			UUID:        recentUUID,
+			RepoID:      0,
+			IssueID:     0,
+			ReleaseID:   0,
+			CommentID:   0,
+			Name:        "recent-zero",
+			CreatedUnix: LegacyAttachmentMissingRepoIDCutoff + 1,
+		}
+		assert.NoError(t, db.Insert(t.Context(), attachment))
+
+		err := AddReleaseAttachments(t.Context(), 1, []string{recentUUID})
+		assert.Error(t, err)
+		assert.ErrorIs(t, err, util.ErrPermissionDenied)
+
+		attach, err := GetAttachmentByUUID(t.Context(), recentUUID)
+		assert.NoError(t, err)
+		assert.Zero(t, attach.ReleaseID)
+		assert.Zero(t, attach.RepoID)
+	})
+
+	t.Run("AddReleaseAttachmentsAllowsLegacyMissingRepoID", func(t *testing.T) {
+		legacyUUID := "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a20" // attachment 10 has repo_id 0
+		err := AddReleaseAttachments(t.Context(), 1, []string{legacyUUID})
+		assert.NoError(t, err)
+
+		attach, err := GetAttachmentByUUID(t.Context(), legacyUUID)
+		assert.NoError(t, err)
+		assert.EqualValues(t, 1, attach.RepoID)
+		assert.EqualValues(t, 1, attach.ReleaseID)
+	})
 }

models/repo/repo_test.go

@@ -96,27 +96,20 @@ func TestMetas(t *testing.T) {
 		},
 	}
 
-	testSuccess := func(expectedStyle string) {
+	for _, style := range []string{"", markup.IssueNameStyleAlphanumeric, markup.IssueNameStyleNumeric, markup.IssueNameStyleRegexp} {
+		externalTracker.ExternalTrackerConfig().ExternalTrackerStyle = style
 		repo.Units = []*RepoUnit{&externalTracker}
 		repo.commonRenderingMetas = nil
 		metas := repo.ComposeCommentMetas(t.Context())
-		assert.Equal(t, expectedStyle, metas["style"])
+		if style == "" {
+			style = markup.IssueNameStyleNumeric
+		}
+		assert.Equal(t, style, metas["style"])
 		assert.Equal(t, "testRepo", metas["repo"])
 		assert.Equal(t, "testOwner", metas["user"])
 		assert.Equal(t, "https://someurl.com/{user}/{repo}/{issue}", metas["externalTrackerLinkFormat"])
 	}
 
-	testSuccess(markup.IssueNameStyleNumeric)
-
-	externalTracker.ExternalTrackerConfig().ExternalTrackerStyle = markup.IssueNameStyleAlphanumeric
-	testSuccess(markup.IssueNameStyleAlphanumeric)
-
-	externalTracker.ExternalTrackerConfig().ExternalTrackerStyle = markup.IssueNameStyleNumeric
-	testSuccess(markup.IssueNameStyleNumeric)
-
-	externalTracker.ExternalTrackerConfig().ExternalTrackerStyle = markup.IssueNameStyleRegexp
-	testSuccess(markup.IssueNameStyleRegexp)
-
 	repo, err := GetRepositoryByID(t.Context(), 3)
 	assert.NoError(t, err)
 
@@ -211,29 +204,21 @@ func TestComposeSSHCloneURL(t *testing.T) {
 }
 
 func TestIsUsableRepoName(t *testing.T) {
-	assert.NoError(t, IsUsableRepoName("a"))
-	assert.NoError(t, IsUsableRepoName("-1_."))
-	assert.NoError(t, IsUsableRepoName(".profile"))
+	for _, name := range []string{"a", "-1_.", ".profile"} {
+		assert.NoError(t, IsUsableRepoName(name))
+	}
 
-	assert.Error(t, IsUsableRepoName("-"))
-	assert.Error(t, IsUsableRepoName("🌞"))
-	assert.Error(t, IsUsableRepoName("the/repo"))
-	assert.Error(t, IsUsableRepoName("the..repo"))
-	assert.Error(t, IsUsableRepoName("foo.wiki"))
-	assert.Error(t, IsUsableRepoName("foo.git"))
-	assert.Error(t, IsUsableRepoName("foo.RSS"))
+	for _, name := range []string{"-", "🌞", "the/repo", "the..repo", "foo.wiki", "foo.git", "foo.RSS"} {
+		assert.Error(t, IsUsableRepoName(name))
+	}
 }
 
 func TestIsValidSSHAccessRepoName(t *testing.T) {
-	assert.True(t, IsValidSSHAccessRepoName("a"))
-	assert.True(t, IsValidSSHAccessRepoName("-1_."))
-	assert.True(t, IsValidSSHAccessRepoName(".profile"))
-	assert.True(t, IsValidSSHAccessRepoName("foo.wiki"))
+	for _, name := range []string{"a", "-1_.", ".profile", "foo.wiki"} {
+		assert.True(t, IsValidSSHAccessRepoName(name))
+	}
 
-	assert.False(t, IsValidSSHAccessRepoName("-"))
-	assert.False(t, IsValidSSHAccessRepoName("🌞"))
-	assert.False(t, IsValidSSHAccessRepoName("the/repo"))
-	assert.False(t, IsValidSSHAccessRepoName("the..repo"))
-	assert.False(t, IsValidSSHAccessRepoName("foo.git"))
-	assert.False(t, IsValidSSHAccessRepoName("foo.RSS"))
+	for _, name := range []string{"-", "🌞", "the/repo", "the..repo", "foo.git", "foo.RSS"} {
+		assert.False(t, IsValidSSHAccessRepoName(name))
+	}
 }

models/repo/star_test.go

@@ -17,6 +17,29 @@ import (
 func TestStarRepo(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 
+	t.Run("IsStaring", func(t *testing.T) {
+		assert.True(t, repo_model.IsStaring(t.Context(), 2, 4))
+		assert.False(t, repo_model.IsStaring(t.Context(), 3, 4))
+	})
+
+	t.Run("Repository_GetStargazers", func(t *testing.T) {
+		// repo with stargazers
+		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 4})
+		gazers, err := repo_model.GetStargazers(t.Context(), repo, db.ListOptions{Page: 0})
+		assert.NoError(t, err)
+		if assert.Len(t, gazers, 1) {
+			assert.Equal(t, int64(2), gazers[0].ID)
+		}
+	})
+
+	t.Run("Repository_GetStargazers2", func(t *testing.T) {
+		// repo with stargazers
+		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 3})
+		gazers, err := repo_model.GetStargazers(t.Context(), repo, db.ListOptions{Page: 0})
+		assert.NoError(t, err)
+		assert.Empty(t, gazers)
+	})
+
 	user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
 	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
 
@@ -27,49 +50,21 @@ func TestStarRepo(t *testing.T) {
 	unittest.AssertExistsAndLoadBean(t, &repo_model.Star{UID: user.ID, RepoID: repo.ID})
 	assert.NoError(t, repo_model.StarRepo(t.Context(), user, repo, false))
 	unittest.AssertNotExistsBean(t, &repo_model.Star{UID: user.ID, RepoID: repo.ID})
-}
-
-func TestIsStaring(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	assert.True(t, repo_model.IsStaring(t.Context(), 2, 4))
-	assert.False(t, repo_model.IsStaring(t.Context(), 3, 4))
-}
-
-func TestRepository_GetStargazers(t *testing.T) {
-	// repo with stargazers
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 4})
-	gazers, err := repo_model.GetStargazers(t.Context(), repo, db.ListOptions{Page: 0})
-	assert.NoError(t, err)
-	if assert.Len(t, gazers, 1) {
-		assert.Equal(t, int64(2), gazers[0].ID)
-	}
-}
-
-func TestRepository_GetStargazers2(t *testing.T) {
-	// repo with stargazers
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 3})
-	gazers, err := repo_model.GetStargazers(t.Context(), repo, db.ListOptions{Page: 0})
-	assert.NoError(t, err)
-	assert.Empty(t, gazers)
-}
-
-func TestClearRepoStars(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-
-	user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
-	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
-
-	unittest.AssertNotExistsBean(t, &repo_model.Star{UID: user.ID, RepoID: repo.ID})
-	assert.NoError(t, repo_model.StarRepo(t.Context(), user, repo, true))
-	unittest.AssertExistsAndLoadBean(t, &repo_model.Star{UID: user.ID, RepoID: repo.ID})
-	assert.NoError(t, repo_model.StarRepo(t.Context(), user, repo, false))
-	unittest.AssertNotExistsBean(t, &repo_model.Star{UID: user.ID, RepoID: repo.ID})
-	assert.NoError(t, repo_model.ClearRepoStars(t.Context(), repo.ID))
-	unittest.AssertNotExistsBean(t, &repo_model.Star{UID: user.ID, RepoID: repo.ID})
-
-	gazers, err := repo_model.GetStargazers(t.Context(), repo, db.ListOptions{Page: 0})
-	assert.NoError(t, err)
-	assert.Empty(t, gazers)
+
+	t.Run("ClearRepoStars", func(t *testing.T) {
+		user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
+		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
+
+		unittest.AssertNotExistsBean(t, &repo_model.Star{UID: user.ID, RepoID: repo.ID})
+		assert.NoError(t, repo_model.StarRepo(t.Context(), user, repo, true))
+		unittest.AssertExistsAndLoadBean(t, &repo_model.Star{UID: user.ID, RepoID: repo.ID})
+		assert.NoError(t, repo_model.StarRepo(t.Context(), user, repo, false))
+		unittest.AssertNotExistsBean(t, &repo_model.Star{UID: user.ID, RepoID: repo.ID})
+		assert.NoError(t, repo_model.ClearRepoStars(t.Context(), repo.ID))
+		unittest.AssertNotExistsBean(t, &repo_model.Star{UID: user.ID, RepoID: repo.ID})
+
+		gazers, err := repo_model.GetStargazers(t.Context(), repo, db.ListOptions{Page: 0})
+		assert.NoError(t, err)
+		assert.Empty(t, gazers)
+	})
 }

models/repo/watch_test.go

@@ -72,47 +72,26 @@ func TestWatchIfAuto(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Len(t, watchers, repo.NumWatches)
 
-	setting.Service.AutoWatchOnChanges = false
-
 	prevCount := repo.NumWatches
-
-	// Must not add watch
-	assert.NoError(t, repo_model.WatchIfAuto(t.Context(), 8, 1, true))
-	watchers, err = repo_model.GetRepoWatchers(t.Context(), repo.ID, db.ListOptions{Page: 1})
-	assert.NoError(t, err)
-	assert.Len(t, watchers, prevCount)
-
-	// Should not add watch
-	assert.NoError(t, repo_model.WatchIfAuto(t.Context(), 10, 1, true))
-	watchers, err = repo_model.GetRepoWatchers(t.Context(), repo.ID, db.ListOptions{Page: 1})
-	assert.NoError(t, err)
-	assert.Len(t, watchers, prevCount)
-
-	setting.Service.AutoWatchOnChanges = true
-
-	// Must not add watch (user 8 has "don't watch" set)
-	assert.NoError(t, repo_model.WatchIfAuto(t.Context(), 8, 1, true))
-	watchers, err = repo_model.GetRepoWatchers(t.Context(), repo.ID, db.ListOptions{Page: 1})
-	assert.NoError(t, err)
-	assert.Len(t, watchers, prevCount)
-
-	// Should not add watch (read operation)
-	assert.NoError(t, repo_model.WatchIfAuto(t.Context(), 12, 1, false))
-	watchers, err = repo_model.GetRepoWatchers(t.Context(), repo.ID, db.ListOptions{Page: 1})
-	assert.NoError(t, err)
-	assert.Len(t, watchers, prevCount)
-
-	// Should add watch (write operation)
-	assert.NoError(t, repo_model.WatchIfAuto(t.Context(), 12, 1, true))
-	watchers, err = repo_model.GetRepoWatchers(t.Context(), repo.ID, db.ListOptions{Page: 1})
-	assert.NoError(t, err)
-	assert.Len(t, watchers, prevCount+1)
-
-	// Should not add watch (system user should not be able to watch)
-	assert.NoError(t, repo_model.WatchIfAuto(t.Context(), user_model.ActionsUserID, 1, true))
-	watchers, err = repo_model.GetRepoWatchers(t.Context(), repo.ID, db.ListOptions{Page: 1})
-	assert.NoError(t, err)
-	assert.Len(t, watchers, prevCount+1)
+	for _, test := range []struct {
+		autoWatch bool
+		userID    int64
+		isWrite   bool
+		count     int
+	}{
+		{false, 8, true, prevCount},                           // Must not add watch
+		{false, 10, true, prevCount},                          // Should not add watch
+		{true, 8, true, prevCount},                            // Must not add watch (user 8 has "don't watch" set)
+		{true, 12, false, prevCount},                          // Should not add watch (read operation)
+		{true, 12, true, prevCount + 1},                       // Should add watch (write operation)
+		{true, user_model.ActionsUserID, true, prevCount + 1}, // Should not add watch (system user should not be able to watch)
+	} {
+		setting.Service.AutoWatchOnChanges = test.autoWatch
+		assert.NoError(t, repo_model.WatchIfAuto(t.Context(), test.userID, 1, test.isWrite))
+		watchers, err = repo_model.GetRepoWatchers(t.Context(), repo.ID, db.ListOptions{Page: 1})
+		assert.NoError(t, err)
+		assert.Len(t, watchers, test.count)
+	}
 
 	// Should remove watch, inhibit from adding auto
 	assert.NoError(t, repo_model.WatchRepoAuto(t.Context(), user12, repo, false))