Remove incorrect "db.DefaultContext" usages

cmd/admin_user_change_password_test.go

@@ -18,12 +18,12 @@ func TestChangePasswordCommand(t *testing.T) {
 	ctx := t.Context()
 
 	defer func() {
-		require.NoError(t, db.TruncateBeans(db.DefaultContext, &user_model.User{}))
+		require.NoError(t, db.TruncateBeans(t.Context(), &user_model.User{}))
 	}()
 
 	t.Run("change password successfully", func(t *testing.T) {
 		// defer func() {
-		// 	require.NoError(t, db.TruncateBeans(db.DefaultContext, &user_model.User{}))
+		// 	require.NoError(t, db.TruncateBeans(t.Context(), &user_model.User{}))
 		// }()
 		// Prepare test user
 		unittest.AssertNotExistsBean(t, &user_model.User{LowerName: "testuser"})

cmd/admin_user_create_test.go

@@ -19,9 +19,9 @@ import (
 
 func TestAdminUserCreate(t *testing.T) {
 	reset := func() {
-		require.NoError(t, db.TruncateBeans(db.DefaultContext, &user_model.User{}))
-		require.NoError(t, db.TruncateBeans(db.DefaultContext, &user_model.EmailAddress{}))
-		require.NoError(t, db.TruncateBeans(db.DefaultContext, &auth_model.AccessToken{}))
+		require.NoError(t, db.TruncateBeans(t.Context(), &user_model.User{}))
+		require.NoError(t, db.TruncateBeans(t.Context(), &user_model.EmailAddress{}))
+		require.NoError(t, db.TruncateBeans(t.Context(), &auth_model.AccessToken{}))
 	}
 
 	t.Run("MustChangePassword", func(t *testing.T) {

cmd/admin_user_delete_test.go

@@ -19,9 +19,9 @@ import (
 func TestAdminUserDelete(t *testing.T) {
 	ctx := t.Context()
 	defer func() {
-		require.NoError(t, db.TruncateBeans(db.DefaultContext, &user_model.User{}))
-		require.NoError(t, db.TruncateBeans(db.DefaultContext, &user_model.EmailAddress{}))
-		require.NoError(t, db.TruncateBeans(db.DefaultContext, &auth_model.AccessToken{}))
+		require.NoError(t, db.TruncateBeans(t.Context(), &user_model.User{}))
+		require.NoError(t, db.TruncateBeans(t.Context(), &user_model.EmailAddress{}))
+		require.NoError(t, db.TruncateBeans(t.Context(), &auth_model.AccessToken{}))
 	}()
 
 	setupTestUser := func(t *testing.T) {
@@ -104,8 +104,8 @@ func TestAdminUserDeleteFailure(t *testing.T) {
 			require.Contains(t, err.Error(), tc.expectedErr)
 		})
 
-		require.NoError(t, db.TruncateBeans(db.DefaultContext, &user_model.User{}))
-		require.NoError(t, db.TruncateBeans(db.DefaultContext, &user_model.EmailAddress{}))
-		require.NoError(t, db.TruncateBeans(db.DefaultContext, &auth_model.AccessToken{}))
+		require.NoError(t, db.TruncateBeans(t.Context(), &user_model.User{}))
+		require.NoError(t, db.TruncateBeans(t.Context(), &user_model.EmailAddress{}))
+		require.NoError(t, db.TruncateBeans(t.Context(), &auth_model.AccessToken{}))
 	}
 }

cmd/admin_user_must_change_password_test.go

@@ -16,7 +16,7 @@ import (
 
 func TestMustChangePassword(t *testing.T) {
 	defer func() {
-		require.NoError(t, db.TruncateBeans(db.DefaultContext, &user_model.User{}))
+		require.NoError(t, db.TruncateBeans(t.Context(), &user_model.User{}))
 	}()
 	err := microcmdUserCreate().Run(t.Context(), []string{"create", "--username", "testuser", "--email", "testuser@gitea.local", "--random-password"})
 	require.NoError(t, err)

cmd/migrate_storage_test.go

@@ -8,7 +8,6 @@ import (
 	"strings"
 	"testing"
 
-	"code.gitea.io/gitea/models/db"
 	"code.gitea.io/gitea/models/packages"
 	"code.gitea.io/gitea/models/unittest"
 	user_model "code.gitea.io/gitea/models/user"
@@ -30,7 +29,7 @@ func TestMigratePackages(t *testing.T) {
 	assert.NoError(t, err)
 	defer buf.Close()
 
-	v, f, err := packages_service.CreatePackageAndAddFile(db.DefaultContext, &packages_service.PackageCreationInfo{
+	v, f, err := packages_service.CreatePackageAndAddFile(t.Context(), &packages_service.PackageCreationInfo{
 		PackageInfo: packages_service.PackageInfo{
 			Owner:       creator,
 			PackageType: packages.TypeGeneric,

models/actions/runner_token_test.go

@@ -6,7 +6,6 @@ package actions
 import (
 	"testing"
 
-	"code.gitea.io/gitea/models/db"
 	"code.gitea.io/gitea/models/unittest"
 
 	"github.com/stretchr/testify/assert"
@@ -15,16 +14,16 @@ import (
 func TestGetLatestRunnerToken(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 	token := unittest.AssertExistsAndLoadBean(t, &ActionRunnerToken{ID: 3})
-	expectedToken, err := GetLatestRunnerToken(db.DefaultContext, 1, 0)
+	expectedToken, err := GetLatestRunnerToken(t.Context(), 1, 0)
 	assert.NoError(t, err)
 	assert.Equal(t, expectedToken, token)
 }
 
 func TestNewRunnerToken(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
-	token, err := NewRunnerToken(db.DefaultContext, 1, 0)
+	token, err := NewRunnerToken(t.Context(), 1, 0)
 	assert.NoError(t, err)
-	expectedToken, err := GetLatestRunnerToken(db.DefaultContext, 1, 0)
+	expectedToken, err := GetLatestRunnerToken(t.Context(), 1, 0)
 	assert.NoError(t, err)
 	assert.Equal(t, expectedToken, token)
 }
@@ -33,8 +32,8 @@ func TestUpdateRunnerToken(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 	token := unittest.AssertExistsAndLoadBean(t, &ActionRunnerToken{ID: 3})
 	token.IsActive = true
-	assert.NoError(t, UpdateRunnerToken(db.DefaultContext, token))
-	expectedToken, err := GetLatestRunnerToken(db.DefaultContext, 1, 0)
+	assert.NoError(t, UpdateRunnerToken(t.Context(), token))
+	expectedToken, err := GetLatestRunnerToken(t.Context(), 1, 0)
 	assert.NoError(t, err)
 	assert.Equal(t, expectedToken, token)
 }

models/activities/action_test.go

@@ -25,7 +25,7 @@ func TestAction_GetRepoPath(t *testing.T) {
 	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
 	owner := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: repo.OwnerID})
 	action := &activities_model.Action{RepoID: repo.ID}
-	assert.Equal(t, path.Join(owner.Name, repo.Name), action.GetRepoPath(db.DefaultContext))
+	assert.Equal(t, path.Join(owner.Name, repo.Name), action.GetRepoPath(t.Context()))
 }
 
 func TestAction_GetRepoLink(t *testing.T) {
@@ -37,9 +37,9 @@ func TestAction_GetRepoLink(t *testing.T) {
 	defer test.MockVariableValue(&setting.AppURL, "https://try.gitea.io/suburl/")()
 	defer test.MockVariableValue(&setting.AppSubURL, "/suburl")()
 	expected := path.Join(setting.AppSubURL, owner.Name, repo.Name)
-	assert.Equal(t, expected, action.GetRepoLink(db.DefaultContext))
-	assert.Equal(t, repo.HTMLURL(), action.GetRepoAbsoluteLink(db.DefaultContext))
-	assert.Equal(t, comment.HTMLURL(db.DefaultContext), action.GetCommentHTMLURL(db.DefaultContext))
+	assert.Equal(t, expected, action.GetRepoLink(t.Context()))
+	assert.Equal(t, repo.HTMLURL(), action.GetRepoAbsoluteLink(t.Context()))
+	assert.Equal(t, comment.HTMLURL(t.Context()), action.GetCommentHTMLURL(t.Context()))
 }
 
 func TestActivityReadable(t *testing.T) {
@@ -91,37 +91,37 @@ func TestConsistencyUpdateAction(t *testing.T) {
 	unittest.AssertExistsAndLoadBean(t, &activities_model.Action{
 		ID: int64(id),
 	})
-	_, err := db.GetEngine(db.DefaultContext).Exec(`UPDATE action SET created_unix = '' WHERE id = ?`, id)
+	_, err := db.GetEngine(t.Context()).Exec(`UPDATE action SET created_unix = '' WHERE id = ?`, id)
 	assert.NoError(t, err)
 	actions := make([]*activities_model.Action, 0, 1)
 	//
 	// XORM returns an error when created_unix is a string
 	//
-	err = db.GetEngine(db.DefaultContext).Where("id = ?", id).Find(&actions)
+	err = db.GetEngine(t.Context()).Where("id = ?", id).Find(&actions)
 	if assert.Error(t, err) {
 		assert.Contains(t, err.Error(), "type string to a int64: invalid syntax")
 	}
 	//
 	// Get rid of incorrectly set created_unix
 	//
-	count, err := activities_model.CountActionCreatedUnixString(db.DefaultContext)
+	count, err := activities_model.CountActionCreatedUnixString(t.Context())
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, count)
-	count, err = activities_model.FixActionCreatedUnixString(db.DefaultContext)
+	count, err = activities_model.FixActionCreatedUnixString(t.Context())
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, count)
 
-	count, err = activities_model.CountActionCreatedUnixString(db.DefaultContext)
+	count, err = activities_model.CountActionCreatedUnixString(t.Context())
 	assert.NoError(t, err)
 	assert.EqualValues(t, 0, count)
-	count, err = activities_model.FixActionCreatedUnixString(db.DefaultContext)
+	count, err = activities_model.FixActionCreatedUnixString(t.Context())
 	assert.NoError(t, err)
 	assert.EqualValues(t, 0, count)
 
 	//
 	// XORM must be happy now
 	//
-	assert.NoError(t, db.GetEngine(db.DefaultContext).Where("id = ?", id).Find(&actions))
+	assert.NoError(t, db.GetEngine(t.Context()).Where("id = ?", id).Find(&actions))
 	unittest.CheckConsistencyFor(t, &activities_model.Action{})
 }
 
@@ -133,19 +133,19 @@ func TestDeleteIssueActions(t *testing.T) {
 	assert.NotEqual(t, issue.ID, issue.Index) // it needs to use different ID/Index to test the DeleteIssueActions to delete some actions by IssueIndex
 
 	// insert a comment
-	err := db.Insert(db.DefaultContext, &issue_model.Comment{Type: issue_model.CommentTypeComment, IssueID: issue.ID})
+	err := db.Insert(t.Context(), &issue_model.Comment{Type: issue_model.CommentTypeComment, IssueID: issue.ID})
 	assert.NoError(t, err)
 	comment := unittest.AssertExistsAndLoadBean(t, &issue_model.Comment{Type: issue_model.CommentTypeComment, IssueID: issue.ID})
 
 	// truncate action table and insert some actions
-	err = db.TruncateBeans(db.DefaultContext, &activities_model.Action{})
+	err = db.TruncateBeans(t.Context(), &activities_model.Action{})
 	assert.NoError(t, err)
-	err = db.Insert(db.DefaultContext, &activities_model.Action{
+	err = db.Insert(t.Context(), &activities_model.Action{
 		OpType:    activities_model.ActionCommentIssue,
 		CommentID: comment.ID,
 	})
 	assert.NoError(t, err)
-	err = db.Insert(db.DefaultContext, &activities_model.Action{
+	err = db.Insert(t.Context(), &activities_model.Action{
 		OpType:  activities_model.ActionCreateIssue,
 		RepoID:  issue.RepoID,
 		Content: fmt.Sprintf("%d|content...", issue.Index),
@@ -154,6 +154,6 @@ func TestDeleteIssueActions(t *testing.T) {
 
 	// assert that the actions exist, then delete them
 	unittest.AssertCount(t, &activities_model.Action{}, 2)
-	assert.NoError(t, activities_model.DeleteIssueActions(db.DefaultContext, issue.RepoID, issue.ID, issue.Index))
+	assert.NoError(t, activities_model.DeleteIssueActions(t.Context(), issue.RepoID, issue.ID, issue.Index))
 	unittest.AssertCount(t, &activities_model.Action{}, 0)
 }

models/activities/notification_test.go

@@ -20,7 +20,7 @@ func TestCreateOrUpdateIssueNotifications(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 	issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 1})
 
-	assert.NoError(t, activities_model.CreateOrUpdateIssueNotifications(db.DefaultContext, issue.ID, 0, 2, 0))
+	assert.NoError(t, activities_model.CreateOrUpdateIssueNotifications(t.Context(), issue.ID, 0, 2, 0))
 
 	// User 9 is inactive, thus notifications for user 1 and 4 are created
 	notf := unittest.AssertExistsAndLoadBean(t, &activities_model.Notification{UserID: 1, IssueID: issue.ID})
@@ -34,7 +34,7 @@ func TestCreateOrUpdateIssueNotifications(t *testing.T) {
 func TestNotificationsForUser(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 	user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
-	notfs, err := db.Find[activities_model.Notification](db.DefaultContext, activities_model.FindNotificationOptions{
+	notfs, err := db.Find[activities_model.Notification](t.Context(), activities_model.FindNotificationOptions{
 		UserID: user.ID,
 		Status: []activities_model.NotificationStatus{
 			activities_model.NotificationStatusRead,
@@ -55,7 +55,7 @@ func TestNotificationsForUser(t *testing.T) {
 func TestNotification_GetRepo(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 	notf := unittest.AssertExistsAndLoadBean(t, &activities_model.Notification{RepoID: 1})
-	repo, err := notf.GetRepo(db.DefaultContext)
+	repo, err := notf.GetRepo(t.Context())
 	assert.NoError(t, err)
 	assert.Equal(t, repo, notf.Repository)
 	assert.Equal(t, notf.RepoID, repo.ID)
@@ -64,7 +64,7 @@ func TestNotification_GetRepo(t *testing.T) {
 func TestNotification_GetIssue(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 	notf := unittest.AssertExistsAndLoadBean(t, &activities_model.Notification{RepoID: 1})
-	issue, err := notf.GetIssue(db.DefaultContext)
+	issue, err := notf.GetIssue(t.Context())
 	assert.NoError(t, err)
 	assert.Equal(t, issue, notf.Issue)
 	assert.Equal(t, notf.IssueID, issue.ID)
@@ -73,7 +73,7 @@ func TestNotification_GetIssue(t *testing.T) {
 func TestGetNotificationCount(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 	user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 1})
-	cnt, err := db.Count[activities_model.Notification](db.DefaultContext, activities_model.FindNotificationOptions{
+	cnt, err := db.Count[activities_model.Notification](t.Context(), activities_model.FindNotificationOptions{
 		UserID: user.ID,
 		Status: []activities_model.NotificationStatus{
 			activities_model.NotificationStatusRead,
@@ -82,7 +82,7 @@ func TestGetNotificationCount(t *testing.T) {
 	assert.NoError(t, err)
 	assert.EqualValues(t, 0, cnt)
 
-	cnt, err = db.Count[activities_model.Notification](db.DefaultContext, activities_model.FindNotificationOptions{
+	cnt, err = db.Count[activities_model.Notification](t.Context(), activities_model.FindNotificationOptions{
 		UserID: user.ID,
 		Status: []activities_model.NotificationStatus{
 			activities_model.NotificationStatusUnread,
@@ -97,14 +97,14 @@ func TestSetNotificationStatus(t *testing.T) {
 	user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
 	notf := unittest.AssertExistsAndLoadBean(t,
 		&activities_model.Notification{UserID: user.ID, Status: activities_model.NotificationStatusRead})
-	_, err := activities_model.SetNotificationStatus(db.DefaultContext, notf.ID, user, activities_model.NotificationStatusPinned)
+	_, err := activities_model.SetNotificationStatus(t.Context(), notf.ID, user, activities_model.NotificationStatusPinned)
 	assert.NoError(t, err)
 	unittest.AssertExistsAndLoadBean(t,
 		&activities_model.Notification{ID: notf.ID, Status: activities_model.NotificationStatusPinned})
 
-	_, err = activities_model.SetNotificationStatus(db.DefaultContext, 1, user, activities_model.NotificationStatusRead)
+	_, err = activities_model.SetNotificationStatus(t.Context(), 1, user, activities_model.NotificationStatusRead)
 	assert.Error(t, err)
-	_, err = activities_model.SetNotificationStatus(db.DefaultContext, unittest.NonexistentID, user, activities_model.NotificationStatusRead)
+	_, err = activities_model.SetNotificationStatus(t.Context(), unittest.NonexistentID, user, activities_model.NotificationStatusRead)
 	assert.Error(t, err)
 }
 
@@ -117,7 +117,7 @@ func TestUpdateNotificationStatuses(t *testing.T) {
 		&activities_model.Notification{UserID: user.ID, Status: activities_model.NotificationStatusRead})
 	notfPinned := unittest.AssertExistsAndLoadBean(t,
 		&activities_model.Notification{UserID: user.ID, Status: activities_model.NotificationStatusPinned})
-	assert.NoError(t, activities_model.UpdateNotificationStatuses(db.DefaultContext, user, activities_model.NotificationStatusUnread, activities_model.NotificationStatusRead))
+	assert.NoError(t, activities_model.UpdateNotificationStatuses(t.Context(), user, activities_model.NotificationStatusUnread, activities_model.NotificationStatusRead))
 	unittest.AssertExistsAndLoadBean(t,
 		&activities_model.Notification{ID: notfUnread.ID, Status: activities_model.NotificationStatusRead})
 	unittest.AssertExistsAndLoadBean(t,
@@ -130,11 +130,11 @@ func TestSetIssueReadBy(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 	user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 1})
 	issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 1})
-	assert.NoError(t, db.WithTx(db.DefaultContext, func(ctx context.Context) error {
+	assert.NoError(t, db.WithTx(t.Context(), func(ctx context.Context) error {
 		return activities_model.SetIssueReadBy(ctx, issue.ID, user.ID)
 	}))
 
-	nt, err := activities_model.GetIssueNotification(db.DefaultContext, user.ID, issue.ID)
+	nt, err := activities_model.GetIssueNotification(t.Context(), user.ID, issue.ID)
 	assert.NoError(t, err)
 	assert.Equal(t, activities_model.NotificationStatusRead, nt.Status)
 }

models/activities/user_heatmap_test.go

@@ -8,7 +8,6 @@ import (
 	"time"
 
 	activities_model "code.gitea.io/gitea/models/activities"
-	"code.gitea.io/gitea/models/db"
 	"code.gitea.io/gitea/models/unittest"
 	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/json"
@@ -70,7 +69,7 @@ func TestGetUserHeatmapDataByUser(t *testing.T) {
 		}
 
 		// get the action for comparison
-		actions, count, err := activities_model.GetFeeds(db.DefaultContext, activities_model.GetFeedsOptions{
+		actions, count, err := activities_model.GetFeeds(t.Context(), activities_model.GetFeedsOptions{
 			RequestedUser:   user,
 			Actor:           doer,
 			IncludePrivate:  true,
@@ -80,7 +79,7 @@ func TestGetUserHeatmapDataByUser(t *testing.T) {
 		assert.NoError(t, err)
 
 		// Get the heatmap and compare
-		heatmap, err := activities_model.GetUserHeatmapDataByUser(db.DefaultContext, user, doer)
+		heatmap, err := activities_model.GetUserHeatmapDataByUser(t.Context(), user, doer)
 		var contributions int
 		for _, hm := range heatmap {
 			contributions += int(hm.Contributions)

models/asymkey/gpg_key_test.go

@@ -232,7 +232,7 @@ Q0KHb+QcycSgbDx0ZAvdIacuKvBBcbxrsmFUI4LR+oIup0G9gUc0roPvr014jYQL
 =zHo9
 -----END PGP PUBLIC KEY BLOCK-----`
 
-	keys, err := AddGPGKey(db.DefaultContext, 1, testEmailWithUpperCaseLetters, "", "")
+	keys, err := AddGPGKey(t.Context(), 1, testEmailWithUpperCaseLetters, "", "")
 	assert.NoError(t, err)
 	if assert.NotEmpty(t, keys) {
 		key := keys[0]
@@ -407,12 +407,12 @@ func TestTryGetKeyIDFromSignature(t *testing.T) {
 
 func TestParseGPGKey(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
-	assert.NoError(t, db.Insert(db.DefaultContext, &user_model.EmailAddress{UID: 1, Email: "email1@example.com", IsActivated: true}))
+	assert.NoError(t, db.Insert(t.Context(), &user_model.EmailAddress{UID: 1, Email: "email1@example.com", IsActivated: true}))
 
 	// create a key for test email
 	e, err := openpgp.NewEntity("name", "comment", "email1@example.com", nil)
 	require.NoError(t, err)
-	k, err := parseGPGKey(db.DefaultContext, 1, e, true)
+	k, err := parseGPGKey(t.Context(), 1, e, true)
 	require.NoError(t, err)
 	assert.NotEmpty(t, k.KeyID)
 	assert.NotEmpty(t, k.Emails) // the key is valid, matches the email
@@ -421,7 +421,7 @@ func TestParseGPGKey(t *testing.T) {
 	for _, id := range e.Identities {
 		id.Revocations = append(id.Revocations, &packet.Signature{RevocationReason: util.ToPointer(packet.KeyCompromised)})
 	}
-	k, err = parseGPGKey(db.DefaultContext, 1, e, true)
+	k, err = parseGPGKey(t.Context(), 1, e, true)
 	require.NoError(t, err)
 	assert.NotEmpty(t, k.KeyID)
 	assert.Empty(t, k.Emails) // the key is revoked, matches no email

models/asymkey/ssh_key_test.go

@@ -12,7 +12,6 @@ import (
 	"strings"
 	"testing"
 
-	"code.gitea.io/gitea/models/db"
 	"code.gitea.io/gitea/models/unittest"
 	"code.gitea.io/gitea/modules/setting"
 
@@ -476,7 +475,7 @@ func runErr(t *testing.T, stdin []byte, args ...string) {
 
 func Test_PublicKeysAreExternallyManaged(t *testing.T) {
 	key1 := unittest.AssertExistsAndLoadBean(t, &PublicKey{ID: 1})
-	externals, err := PublicKeysAreExternallyManaged(db.DefaultContext, []*PublicKey{key1})
+	externals, err := PublicKeysAreExternallyManaged(t.Context(), []*PublicKey{key1})
 	assert.NoError(t, err)
 	assert.Len(t, externals, 1)
 	assert.False(t, externals[0])