Add testifylint to lint checks (#4535)

go-require lint is ignored for now

Reviewed-on: https://codeberg.org/forgejo/forgejo/pulls/4535
Reviewed-by: Gusted <gusted@noreply.codeberg.org>
Co-authored-by: TheFox0x7 <thefox0x7@gmail.com>
Co-committed-by: TheFox0x7 <thefox0x7@gmail.com>

modules/actions/workflows_test.go

@@ -11,6 +11,7 @@ import (
 	webhook_module "code.gitea.io/gitea/modules/webhook"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestDetectMatched(t *testing.T) {
@@ -137,7 +138,7 @@ func TestDetectMatched(t *testing.T) {
 	for _, tc := range testCases {
 		t.Run(tc.desc, func(t *testing.T) {
 			evts, err := GetEventsFromContent([]byte(tc.yamlOn))
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Len(t, evts, 1)
 			assert.Equal(t, tc.expected, detectMatched(nil, tc.commit, tc.triggedEvent, tc.payload, evts[0]))
 		})

modules/activitypub/client_test.go

@@ -20,6 +20,7 @@ import (
 	"code.gitea.io/gitea/modules/setting"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	_ "github.com/mattn/go-sqlite3"
 )
@@ -27,8 +28,8 @@ import (
 func TestCurrentTime(t *testing.T) {
 	date := CurrentTime()
 	_, err := time.Parse(http.TimeFormat, date)
-	assert.NoError(t, err)
-	assert.Equal(t, date[len(date)-3:], "GMT")
+	require.NoError(t, err)
+	assert.Equal(t, "GMT", date[len(date)-3:])
 }
 
 /* ToDo: Set Up tests for http get requests
@@ -64,22 +65,22 @@ Set up a user called "me" for all tests
 */
 
 func TestNewClientReturnsClient(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
+	require.NoError(t, unittest.PrepareTestDatabase())
 	user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 1})
 	pubID := "myGpgId"
 	c, err := NewClient(db.DefaultContext, user, pubID)
 
 	log.Debug("Client: %v\nError: %v", c, err)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 /* TODO: bring this test to work or delete
 func TestActivityPubSignedGet(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
+	require.NoError(t, unittest.PrepareTestDatabase())
 	user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 1, Name: "me"})
 	pubID := "myGpgId"
 	c, err := NewClient(db.DefaultContext, user, pubID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	expected := "TestActivityPubSignedGet"
 
@@ -88,45 +89,45 @@ func TestActivityPubSignedGet(t *testing.T) {
 		assert.Contains(t, r.Header.Get("Signature"), pubID)
 		assert.Equal(t, r.Header.Get("Content-Type"), ActivityStreamsContentType)
 		body, err := io.ReadAll(r.Body)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, expected, string(body))
 		fmt.Fprint(w, expected)
 	}))
 	defer srv.Close()
 
 	r, err := c.Get(srv.URL)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer r.Body.Close()
 	body, err := io.ReadAll(r.Body)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, string(body))
 
 }
 */
 
 func TestActivityPubSignedPost(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
+	require.NoError(t, unittest.PrepareTestDatabase())
 	user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 1})
 	pubID := "https://example.com/pubID"
 	c, err := NewClient(db.DefaultContext, user, pubID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	expected := "BODY"
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		assert.Regexp(t, regexp.MustCompile("^"+setting.Federation.DigestAlgorithm), r.Header.Get("Digest"))
 		assert.Contains(t, r.Header.Get("Signature"), pubID)
-		assert.Equal(t, r.Header.Get("Content-Type"), ActivityStreamsContentType)
+		assert.Equal(t, ActivityStreamsContentType, r.Header.Get("Content-Type"))
 		body, err := io.ReadAll(r.Body)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, expected, string(body))
 		fmt.Fprint(w, expected)
 	}))
 	defer srv.Close()
 
 	r, err := c.Post([]byte(expected), srv.URL)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer r.Body.Close()
 	body, err := io.ReadAll(r.Body)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, string(body))
 }

modules/activitypub/user_settings_test.go

@@ -13,17 +13,18 @@ import (
 	_ "code.gitea.io/gitea/models" // https://discourse.gitea.io/t/testfixtures-could-not-clean-table-access-no-such-table-access/4137/4
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestUserSettings(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
+	require.NoError(t, unittest.PrepareTestDatabase())
 	user1 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 1})
 	pub, priv, err := GetKeyPair(db.DefaultContext, user1)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	pub1, err := GetPublicKey(db.DefaultContext, user1)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, pub, pub1)
 	priv1, err := GetPrivateKey(db.DefaultContext, user1)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, priv, priv1)
 }

modules/assetfs/layered_test.go

@@ -11,6 +11,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestLayered(t *testing.T) {
@@ -19,10 +20,10 @@ func TestLayered(t *testing.T) {
 	dir2 := filepath.Join(dir, "l2")
 
 	mkdir := func(elems ...string) {
-		assert.NoError(t, os.MkdirAll(filepath.Join(elems...), 0o755))
+		require.NoError(t, os.MkdirAll(filepath.Join(elems...), 0o755))
 	}
 	write := func(content string, elems ...string) {
-		assert.NoError(t, os.WriteFile(filepath.Join(elems...), []byte(content), 0o644))
+		require.NoError(t, os.WriteFile(filepath.Join(elems...), []byte(content), 0o644))
 	}
 
 	// d1 & f1: only in "l1"; d2 & f2: only in "l2"
@@ -49,18 +50,18 @@ func TestLayered(t *testing.T) {
 	assets := Layered(Local("l1", dir1), Local("l2", dir2))
 
 	f, err := assets.Open("f1")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	bs, err := io.ReadAll(f)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, "f1", string(bs))
 	_ = f.Close()
 
 	assertRead := func(expected string, expectedErr error, elems ...string) {
 		bs, err := assets.ReadFile(elems...)
 		if err != nil {
-			assert.ErrorAs(t, err, &expectedErr)
+			require.ErrorIs(t, err, expectedErr)
 		} else {
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, expected, string(bs))
 		}
 	}
@@ -75,27 +76,27 @@ func TestLayered(t *testing.T) {
 	assertRead("", fs.ErrNotExist, "no-such")
 
 	files, err := assets.ListFiles(".", true)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, []string{"f1", "f2", "fa"}, files)
 
 	files, err = assets.ListFiles(".", false)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, []string{"d1", "d2", "da"}, files)
 
 	files, err = assets.ListFiles(".")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, []string{"d1", "d2", "da", "f1", "f2", "fa"}, files)
 
 	files, err = assets.ListAllFiles(".", true)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, []string{"d1/f", "d2/f", "da/f", "f1", "f2", "fa"}, files)
 
 	files, err = assets.ListAllFiles(".", false)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, []string{"d1", "d2", "da", "da/sub1", "da/sub2"}, files)
 
 	files, err = assets.ListAllFiles(".")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, []string{
 		"d1", "d1/f",
 		"d2", "d2/f",

modules/auth/pam/pam_test.go

@@ -9,11 +9,12 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestPamAuth(t *testing.T) {
 	result, err := Auth("gitea", "user1", "false-pwd")
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.EqualError(t, err, "Authentication failure")
 	assert.Len(t, result, 0)
 }

modules/auth/password/hash/dummy_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestDummyHasher(t *testing.T) {
@@ -18,7 +19,7 @@ func TestDummyHasher(t *testing.T) {
 	password, salt := "password", "ZogKvWdyEx"
 
 	hash, err := dummy.Hash(password, salt)
-	assert.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, hash, salt+":"+password)
 
 	assert.True(t, dummy.VerifyPassword(password, hash, salt))

modules/auth/password/hash/hash_test.go

@@ -10,6 +10,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 type testSaltHasher string
@@ -29,7 +30,7 @@ func Test_registerHasher(t *testing.T) {
 		})
 	})
 
-	assert.Error(t, Register("Test_registerHasher", func(config string) testSaltHasher {
+	require.Error(t, Register("Test_registerHasher", func(config string) testSaltHasher {
 		return testSaltHasher(config)
 	}))
 
@@ -76,10 +77,10 @@ func TestHashing(t *testing.T) {
 			t.Run(algorithmName, func(t *testing.T) {
 				output, err := Parse(algorithmName).Hash(password, salt)
 				if shouldPass {
-					assert.NoError(t, err)
+					require.NoError(t, err)
 					assert.NotEmpty(t, output, "output for %s was empty", algorithmName)
 				} else {
-					assert.Error(t, err)
+					require.Error(t, err)
 				}
 
 				assert.Equal(t, Parse(algorithmName).VerifyPassword(password, output, salt), shouldPass)

modules/auth/password/password_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestComplexity_IsComplexEnough(t *testing.T) {
@@ -52,7 +53,7 @@ func TestComplexity_Generate(t *testing.T) {
 		testComplextity(modes)
 		for i := 0; i < maxCount; i++ {
 			pwd, err := Generate(pwdLen)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Len(t, pwd, pwdLen)
 			assert.True(t, IsComplexEnough(pwd), "Failed complexities with modes %+v for generated: %s", modes, pwd)
 		}

modules/auth/password/pwn/pwn_test.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/h2non/gock"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 var client = New(WithHTTP(&http.Client{
@@ -20,31 +21,31 @@ func TestPassword(t *testing.T) {
 	defer gock.Off()
 
 	count, err := client.CheckPassword("", false)
-	assert.ErrorIs(t, err, ErrEmptyPassword, "blank input should return ErrEmptyPassword")
+	require.ErrorIs(t, err, ErrEmptyPassword, "blank input should return ErrEmptyPassword")
 	assert.Equal(t, -1, count)
 
 	gock.New("https://api.pwnedpasswords.com").Get("/range/5c1d8").Times(1).Reply(200).BodyString("EAF2F254732680E8AC339B84F3266ECCBB5:1\r\nFC446EB88938834178CB9322C1EE273C2A7:2")
 	count, err = client.CheckPassword("pwned", false)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 1, count)
 
 	gock.New("https://api.pwnedpasswords.com").Get("/range/ba189").Times(1).Reply(200).BodyString("FD4CB34F0378BCB15D23F6FFD28F0775C9E:3\r\nFDF342FCD8C3611DAE4D76E8A992A3E4169:4")
 	count, err = client.CheckPassword("notpwned", false)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 0, count)
 
 	gock.New("https://api.pwnedpasswords.com").Get("/range/a1733").Times(1).Reply(200).BodyString("C4CE0F1F0062B27B9E2F41AF0C08218017C:1\r\nFC446EB88938834178CB9322C1EE273C2A7:2\r\nFE81480327C992FE62065A827429DD1318B:0")
 	count, err = client.CheckPassword("paddedpwned", true)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 1, count)
 
 	gock.New("https://api.pwnedpasswords.com").Get("/range/5617b").Times(1).Reply(200).BodyString("FD4CB34F0378BCB15D23F6FFD28F0775C9E:3\r\nFDF342FCD8C3611DAE4D76E8A992A3E4169:4\r\nFE81480327C992FE62065A827429DD1318B:0")
 	count, err = client.CheckPassword("paddednotpwned", true)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 0, count)
 
 	gock.New("https://api.pwnedpasswords.com").Get("/range/79082").Times(1).Reply(200).BodyString("FDF342FCD8C3611DAE4D76E8A992A3E4169:4\r\nFE81480327C992FE62065A827429DD1318B:0\r\nAFEF386F56EB0B4BE314E07696E5E6E6536:0")
 	count, err = client.CheckPassword("paddednotpwnedzero", true)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 0, count)
 }

modules/avatar/avatar_test.go

@@ -13,19 +13,20 @@ import (
 	"code.gitea.io/gitea/modules/setting"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func Test_RandomImageSize(t *testing.T) {
 	_, err := RandomImageSize(0, []byte("gitea@local"))
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, err = RandomImageSize(64, []byte("gitea@local"))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func Test_RandomImage(t *testing.T) {
 	_, err := RandomImage([]byte("gitea@local"))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func Test_ProcessAvatarPNG(t *testing.T) {
@@ -33,10 +34,10 @@ func Test_ProcessAvatarPNG(t *testing.T) {
 	setting.Avatar.MaxHeight = 4096
 
 	data, err := os.ReadFile("testdata/avatar.png")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	_, err = processAvatarImage(data, 262144)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func Test_ProcessAvatarJPEG(t *testing.T) {
@@ -44,10 +45,10 @@ func Test_ProcessAvatarJPEG(t *testing.T) {
 	setting.Avatar.MaxHeight = 4096
 
 	data, err := os.ReadFile("testdata/avatar.jpeg")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	_, err = processAvatarImage(data, 262144)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func Test_ProcessAvatarInvalidData(t *testing.T) {
@@ -63,7 +64,7 @@ func Test_ProcessAvatarInvalidImageSize(t *testing.T) {
 	setting.Avatar.MaxHeight = 5
 
 	data, err := os.ReadFile("testdata/avatar.png")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	_, err = processAvatarImage(data, 12800)
 	assert.EqualError(t, err, "image width is too large: 10 > 5")
@@ -83,54 +84,54 @@ func Test_ProcessAvatarImage(t *testing.T) {
 		img := image.NewRGBA(image.Rect(0, 0, width, height))
 		bs := bytes.Buffer{}
 		err := png.Encode(&bs, img)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		return bs.Bytes()
 	}
 
 	// if origin image canvas is too large, crop and resize it
 	origin := newImgData(500, 600)
 	result, err := processAvatarImage(origin, 0)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotEqual(t, origin, result)
 	decoded, err := png.Decode(bytes.NewReader(result))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, scaledSize, decoded.Bounds().Max.X)
 	assert.EqualValues(t, scaledSize, decoded.Bounds().Max.Y)
 
 	// if origin image is smaller than the default size, use the origin image
 	origin = newImgData(1)
 	result, err = processAvatarImage(origin, 0)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, origin, result)
 
 	// use the origin image if the origin is smaller
 	origin = newImgData(scaledSize + 100)
 	result, err = processAvatarImage(origin, 0)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Less(t, len(result), len(origin))
 
 	// still use the origin image if the origin doesn't exceed the max-origin-size
 	origin = newImgData(scaledSize + 100)
 	result, err = processAvatarImage(origin, 262144)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, origin, result)
 
 	// allow to use known image format (eg: webp) if it is small enough
 	origin, err = os.ReadFile("testdata/animated.webp")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	result, err = processAvatarImage(origin, 262144)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, origin, result)
 
 	// do not support unknown image formats, eg: SVG may contain embedded JS
 	origin = []byte("<svg></svg>")
 	_, err = processAvatarImage(origin, 262144)
-	assert.ErrorContains(t, err, "image: unknown format")
+	require.ErrorContains(t, err, "image: unknown format")
 
 	// make sure the canvas size limit works
 	setting.Avatar.MaxWidth = 5
 	setting.Avatar.MaxHeight = 5
 	origin = newImgData(10)
 	_, err = processAvatarImage(origin, 262144)
-	assert.ErrorContains(t, err, "image width is too large: 10 > 5")
+	require.ErrorContains(t, err, "image width is too large: 10 > 5")
 }

modules/avatar/identicon/identicon_test.go

@@ -12,7 +12,7 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestGenerate(t *testing.T) {
@@ -24,17 +24,16 @@ func TestGenerate(t *testing.T) {
 
 	backColor := color.White
 	imgMaker, err := New(64, backColor, DarkColors...)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	for i := 0; i < 100; i++ {
 		s := strconv.Itoa(i)
 		img := imgMaker.Make([]byte(s))
 
 		f, err := os.Create(dir + "/" + s + ".png")
-		if !assert.NoError(t, err) {
-			continue
-		}
+		require.NoError(t, err)
+
 		defer f.Close()
 		err = png.Encode(f, img)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 }

modules/base/tool_test.go

@@ -13,6 +13,7 @@ import (
 	"code.gitea.io/gitea/modules/test"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestEncodeSha256(t *testing.T) {
@@ -31,15 +32,15 @@ func TestBasicAuthDecode(t *testing.T) {
 	assert.Equal(t, "illegal base64 data at input byte 0", err.Error())
 
 	user, pass, err := BasicAuthDecode("Zm9vOmJhcg==")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "foo", user)
 	assert.Equal(t, "bar", pass)
 
 	_, _, err = BasicAuthDecode("aW52YWxpZA==")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, _, err = BasicAuthDecode("invalid")
-	assert.Error(t, err)
+	require.Error(t, err)
 }
 
 func TestVerifyTimeLimitCode(t *testing.T) {
@@ -143,7 +144,7 @@ func TestTruncateString(t *testing.T) {
 func TestStringsToInt64s(t *testing.T) {
 	testSuccess := func(input []string, expected []int64) {
 		result, err := StringsToInt64s(input)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, expected, result)
 	}
 	testSuccess(nil, nil)
@@ -152,8 +153,8 @@ func TestStringsToInt64s(t *testing.T) {
 	testSuccess([]string{"1", "4", "16", "64", "256"}, []int64{1, 4, 16, 64, 256})
 
 	ints, err := StringsToInt64s([]string{"-1", "a"})
-	assert.Len(t, ints, 0)
-	assert.Error(t, err)
+	assert.Empty(t, ints)
+	require.Error(t, err)
 }
 
 func TestInt64sToStrings(t *testing.T) {

modules/cache/cache_test.go

@@ -11,6 +11,7 @@ import (
 	"code.gitea.io/gitea/modules/setting"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func createTestCache() {
@@ -22,7 +23,7 @@ func createTestCache() {
 }
 
 func TestNewContext(t *testing.T) {
-	assert.NoError(t, Init())
+	require.NoError(t, Init())
 
 	setting.CacheService.Cache = setting.Cache{Adapter: "redis", Conn: "some random string"}
 	con, err := newCache(setting.Cache{
@@ -30,7 +31,7 @@ func TestNewContext(t *testing.T) {
 		Conn:     "false conf",
 		Interval: 100,
 	})
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.Nil(t, con)
 }
 
@@ -46,32 +47,32 @@ func TestGetString(t *testing.T) {
 	data, err := GetString("key", func() (string, error) {
 		return "", fmt.Errorf("some error")
 	})
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.Equal(t, "", data)
 
 	data, err = GetString("key", func() (string, error) {
 		return "", nil
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "", data)
 
 	data, err = GetString("key", func() (string, error) {
 		return "some data", nil
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "", data)
 	Remove("key")
 
 	data, err = GetString("key", func() (string, error) {
 		return "some data", nil
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "some data", data)
 
 	data, err = GetString("key", func() (string, error) {
 		return "", fmt.Errorf("some error")
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "some data", data)
 	Remove("key")
 }
@@ -82,32 +83,32 @@ func TestGetInt(t *testing.T) {
 	data, err := GetInt("key", func() (int, error) {
 		return 0, fmt.Errorf("some error")
 	})
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.Equal(t, 0, data)
 
 	data, err = GetInt("key", func() (int, error) {
 		return 0, nil
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 0, data)
 
 	data, err = GetInt("key", func() (int, error) {
 		return 100, nil
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 0, data)
 	Remove("key")
 
 	data, err = GetInt("key", func() (int, error) {
 		return 100, nil
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 100, data)
 
 	data, err = GetInt("key", func() (int, error) {
 		return 0, fmt.Errorf("some error")
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 100, data)
 	Remove("key")
 }
@@ -118,32 +119,32 @@ func TestGetInt64(t *testing.T) {
 	data, err := GetInt64("key", func() (int64, error) {
 		return 0, fmt.Errorf("some error")
 	})
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.EqualValues(t, 0, data)
 
 	data, err = GetInt64("key", func() (int64, error) {
 		return 0, nil
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, 0, data)
 
 	data, err = GetInt64("key", func() (int64, error) {
 		return 100, nil
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, 0, data)
 	Remove("key")
 
 	data, err = GetInt64("key", func() (int64, error) {
 		return 100, nil
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, 100, data)
 
 	data, err = GetInt64("key", func() (int64, error) {
 		return 0, fmt.Errorf("some error")
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, 100, data)
 	Remove("key")
 }

modules/cache/context_test.go

@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestWithCacheContext(t *testing.T) {
@@ -34,7 +35,7 @@ func TestWithCacheContext(t *testing.T) {
 	vInt, err := GetWithContextCache(ctx, field, "my_config1", func() (int, error) {
 		return 1, nil
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, 1, vInt)
 
 	v = GetContextData(ctx, field, "my_config1")

modules/charset/charset_test.go

@@ -12,6 +12,7 @@ import (
 	"code.gitea.io/gitea/modules/setting"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func resetDefaultCharsetsOrder() {
@@ -48,12 +49,12 @@ func TestToUTF8(t *testing.T) {
 	// depend on particular conversions but in expected behaviors.
 
 	res, err = ToUTF8([]byte{0x41, 0x42, 0x43}, ConvertOpts{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "ABC", res)
 
 	// "áéíóú"
 	res, err = ToUTF8([]byte{0xc3, 0xa1, 0xc3, 0xa9, 0xc3, 0xad, 0xc3, 0xb3, 0xc3, 0xba}, ConvertOpts{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []byte{0xc3, 0xa1, 0xc3, 0xa9, 0xc3, 0xad, 0xc3, 0xb3, 0xc3, 0xba}, []byte(res))
 
 	// "áéíóú"
@@ -61,14 +62,14 @@ func TestToUTF8(t *testing.T) {
 		0xef, 0xbb, 0xbf, 0xc3, 0xa1, 0xc3, 0xa9, 0xc3, 0xad, 0xc3, 0xb3,
 		0xc3, 0xba,
 	}, ConvertOpts{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []byte{0xc3, 0xa1, 0xc3, 0xa9, 0xc3, 0xad, 0xc3, 0xb3, 0xc3, 0xba}, []byte(res))
 
 	res, err = ToUTF8([]byte{
 		0x48, 0x6F, 0x6C, 0x61, 0x2C, 0x20, 0x61, 0x73, 0xED, 0x20, 0x63,
 		0xF3, 0x6D, 0x6F, 0x20, 0xF1, 0x6F, 0x73, 0x41, 0x41, 0x41, 0x2e,
 	}, ConvertOpts{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	stringMustStartWith(t, "Hola,", res)
 	stringMustEndWith(t, "AAA.", res)
 
@@ -76,7 +77,7 @@ func TestToUTF8(t *testing.T) {
 		0x48, 0x6F, 0x6C, 0x61, 0x2C, 0x20, 0x61, 0x73, 0xED, 0x20, 0x63,
 		0xF3, 0x6D, 0x6F, 0x20, 0x07, 0xA4, 0x6F, 0x73, 0x41, 0x41, 0x41, 0x2e,
 	}, ConvertOpts{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	stringMustStartWith(t, "Hola,", res)
 	stringMustEndWith(t, "AAA.", res)
 
@@ -84,7 +85,7 @@ func TestToUTF8(t *testing.T) {
 		0x48, 0x6F, 0x6C, 0x61, 0x2C, 0x20, 0x61, 0x73, 0xED, 0x20, 0x63,
 		0xF3, 0x6D, 0x6F, 0x20, 0x81, 0xA4, 0x6F, 0x73, 0x41, 0x41, 0x41, 0x2e,
 	}, ConvertOpts{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	stringMustStartWith(t, "Hola,", res)
 	stringMustEndWith(t, "AAA.", res)
 
@@ -94,7 +95,7 @@ func TestToUTF8(t *testing.T) {
 		0x93, 0xFA, 0x91, 0xAE, 0x94, 0xE9, 0x82, 0xBC, 0x82, 0xB5, 0x82,
 		0xBF, 0x82, 0xE3, 0x81, 0x42,
 	}, ConvertOpts{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []byte{
 		0xE6, 0x97, 0xA5, 0xE5, 0xB1, 0x9E, 0xE7, 0xA7, 0x98, 0xE3,
 		0x81, 0x9E, 0xE3, 0x81, 0x97, 0xE3, 0x81, 0xA1, 0xE3, 0x82, 0x85, 0xE3, 0x80, 0x82,
@@ -102,7 +103,7 @@ func TestToUTF8(t *testing.T) {
 		[]byte(res))
 
 	res, err = ToUTF8([]byte{0x00, 0x00, 0x00, 0x00}, ConvertOpts{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []byte{0x00, 0x00, 0x00, 0x00}, []byte(res))
 }
 
@@ -199,7 +200,7 @@ func TestDetectEncoding(t *testing.T) {
 	resetDefaultCharsetsOrder()
 	testSuccess := func(b []byte, expected string) {
 		encoding, err := DetectEncoding(b)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, expected, encoding)
 	}
 	// utf-8
@@ -217,7 +218,7 @@ func TestDetectEncoding(t *testing.T) {
 	// iso-8859-1: d<accented e>cor<newline>
 	b = []byte{0x44, 0xe9, 0x63, 0x6f, 0x72, 0x0a}
 	encoding, err := DetectEncoding(b)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Contains(t, encoding, "ISO-8859-1")
 
 	old := setting.Repository.AnsiCharset
@@ -230,7 +231,7 @@ func TestDetectEncoding(t *testing.T) {
 	// invalid bytes
 	b = []byte{0xfa}
 	_, err = DetectEncoding(b)
-	assert.Error(t, err)
+	require.Error(t, err)
 }
 
 func stringMustStartWith(t *testing.T, expected, value string) {

modules/charset/escape_test.go

@@ -13,6 +13,7 @@ import (
 	"code.gitea.io/gitea/modules/translation"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 var testContext = escapeContext("test")
@@ -163,7 +164,7 @@ func TestEscapeControlReader(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			output := &strings.Builder{}
 			status, err := EscapeControlReader(strings.NewReader(tt.text), output, &translation.MockLocale{}, testContext)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, tt.status, *status)
 			assert.Equal(t, tt.result, output.String())
 		})

modules/csv/csv_test.go

@@ -16,6 +16,7 @@ import (
 	"code.gitea.io/gitea/modules/translation"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestCreateReader(t *testing.T) {
@@ -27,7 +28,7 @@ func decodeSlashes(t *testing.T, s string) string {
 	s = strings.ReplaceAll(s, "\n", "\\n")
 	s = strings.ReplaceAll(s, "\"", "\\\"")
 	decoded, err := strconv.Unquote(`"` + s + `"`)
-	assert.NoError(t, err, "unable to decode string")
+	require.NoError(t, err, "unable to decode string")
 	return decoded
 }
 
@@ -99,10 +100,10 @@ j, ,\x20
 
 	for n, c := range cases {
 		rd, err := CreateReaderAndDetermineDelimiter(nil, strings.NewReader(decodeSlashes(t, c.csv)))
-		assert.NoError(t, err, "case %d: should not throw error: %v\n", n, err)
+		require.NoError(t, err, "case %d: should not throw error: %v\n", n, err)
 		assert.EqualValues(t, c.expectedDelimiter, rd.Comma, "case %d: delimiter should be '%c', got '%c'", n, c.expectedDelimiter, rd.Comma)
 		rows, err := rd.ReadAll()
-		assert.NoError(t, err, "case %d: should not throw error: %v\n", n, err)
+		require.NoError(t, err, "case %d: should not throw error: %v\n", n, err)
 		assert.EqualValues(t, c.expectedRows, rows, "case %d: rows should be equal", n)
 	}
 }
@@ -115,8 +116,8 @@ func (r *mockReader) Read(buf []byte) (int, error) {
 
 func TestDetermineDelimiterShortBufferError(t *testing.T) {
 	rd, err := CreateReaderAndDetermineDelimiter(nil, &mockReader{})
-	assert.Error(t, err, "CreateReaderAndDetermineDelimiter() should throw an error")
-	assert.ErrorIs(t, err, io.ErrShortBuffer)
+	require.Error(t, err, "CreateReaderAndDetermineDelimiter() should throw an error")
+	require.ErrorIs(t, err, io.ErrShortBuffer)
 	assert.Nil(t, rd, "CSV reader should be mnil")
 }
 
@@ -127,11 +128,11 @@ func TestDetermineDelimiterReadAllError(t *testing.T) {
 	f	g
 	h|i
 	jkl`))
-	assert.NoError(t, err, "CreateReaderAndDetermineDelimiter() shouldn't throw error")
+	require.NoError(t, err, "CreateReaderAndDetermineDelimiter() shouldn't throw error")
 	assert.NotNil(t, rd, "CSV reader should not be mnil")
 	rows, err := rd.ReadAll()
-	assert.Error(t, err, "RaadAll() should throw error")
-	assert.ErrorIs(t, err, csv.ErrFieldCount)
+	require.Error(t, err, "RaadAll() should throw error")
+	require.ErrorIs(t, err, csv.ErrFieldCount)
 	assert.Empty(t, rows, "rows should be empty")
 }
 
@@ -580,9 +581,9 @@ func TestFormatError(t *testing.T) {
 	for n, c := range cases {
 		message, err := FormatError(c.err, &translation.MockLocale{})
 		if c.expectsError {
-			assert.Error(t, err, "case %d: expected an error to be returned", n)
+			require.Error(t, err, "case %d: expected an error to be returned", n)
 		} else {
-			assert.NoError(t, err, "case %d: no error was expected, got error: %v", n, err)
+			require.NoError(t, err, "case %d: no error was expected, got error: %v", n, err)
 			assert.EqualValues(t, c.expectedMessage, message, "case %d: messages should be equal, expected '%s' got '%s'", n, c.expectedMessage, message)
 		}
 	}

modules/generate/generate_test.go

@@ -9,26 +9,27 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestDecodeJwtSecret(t *testing.T) {
 	_, err := DecodeJwtSecret("abcd")
-	assert.ErrorContains(t, err, "invalid base64 decoded length")
+	require.ErrorContains(t, err, "invalid base64 decoded length")
 	_, err = DecodeJwtSecret(strings.Repeat("a", 64))
-	assert.ErrorContains(t, err, "invalid base64 decoded length")
+	require.ErrorContains(t, err, "invalid base64 decoded length")
 
 	str32 := strings.Repeat("x", 32)
 	encoded32 := base64.RawURLEncoding.EncodeToString([]byte(str32))
 	decoded32, err := DecodeJwtSecret(encoded32)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, str32, string(decoded32))
 }
 
 func TestNewJwtSecret(t *testing.T) {
 	secret, encoded, err := NewJwtSecret()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, secret, 32)
 	decoded, err := DecodeJwtSecret(encoded)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, secret, decoded)
 }

modules/git/blame_sha256_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestReadingBlameOutputSha256(t *testing.T) {
@@ -18,11 +19,11 @@ func TestReadingBlameOutputSha256(t *testing.T) {
 
 	t.Run("Without .git-blame-ignore-revs", func(t *testing.T) {
 		repo, err := OpenRepository(ctx, "./tests/repos/repo5_pulls_sha256")
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		defer repo.Close()
 
 		commit, err := repo.GetCommit("0b69b7bb649b5d46e14cabb6468685e5dd721290acc7ffe604d37cde57927345")
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		parts := []*BlamePart{
 			{
@@ -42,7 +43,7 @@ func TestReadingBlameOutputSha256(t *testing.T) {
 
 		for _, bypass := range []bool{false, true} {
 			blameReader, err := CreateBlameReader(ctx, Sha256ObjectFormat, "./tests/repos/repo5_pulls_sha256", commit, "README.md", bypass)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.NotNil(t, blameReader)
 			defer blameReader.Close()
 
@@ -50,20 +51,20 @@ func TestReadingBlameOutputSha256(t *testing.T) {
 
 			for _, part := range parts {
 				actualPart, err := blameReader.NextPart()
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, part, actualPart)
 			}
 
 			// make sure all parts have been read
 			actualPart, err := blameReader.NextPart()
 			assert.Nil(t, actualPart)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 		}
 	})
 
 	t.Run("With .git-blame-ignore-revs", func(t *testing.T) {
 		repo, err := OpenRepository(ctx, "./tests/repos/repo6_blame_sha256")
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		defer repo.Close()
 
 		full := []*BlamePart{
@@ -121,12 +122,12 @@ func TestReadingBlameOutputSha256(t *testing.T) {
 		}
 
 		objectFormat, err := repo.GetObjectFormat()
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		for _, c := range cases {
 			commit, err := repo.GetCommit(c.CommitID)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			blameReader, err := CreateBlameReader(ctx, objectFormat, "./tests/repos/repo6_blame_sha256", commit, "blame.txt", c.Bypass)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.NotNil(t, blameReader)
 			defer blameReader.Close()
 
@@ -134,14 +135,14 @@ func TestReadingBlameOutputSha256(t *testing.T) {
 
 			for _, part := range c.Parts {
 				actualPart, err := blameReader.NextPart()
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, part, actualPart)
 			}
 
 			// make sure all parts have been read
 			actualPart, err := blameReader.NextPart()
 			assert.Nil(t, actualPart)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 		}
 	})
 }

modules/git/blame_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestReadingBlameOutput(t *testing.T) {
@@ -16,11 +17,11 @@ func TestReadingBlameOutput(t *testing.T) {
 
 	t.Run("Without .git-blame-ignore-revs", func(t *testing.T) {
 		repo, err := OpenRepository(ctx, "./tests/repos/repo5_pulls")
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		defer repo.Close()
 
 		commit, err := repo.GetCommit("f32b0a9dfd09a60f616f29158f772cedd89942d2")
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		parts := []*BlamePart{
 			{
@@ -40,7 +41,7 @@ func TestReadingBlameOutput(t *testing.T) {
 
 		for _, bypass := range []bool{false, true} {
 			blameReader, err := CreateBlameReader(ctx, Sha1ObjectFormat, "./tests/repos/repo5_pulls", commit, "README.md", bypass)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.NotNil(t, blameReader)
 			defer blameReader.Close()
 
@@ -48,20 +49,20 @@ func TestReadingBlameOutput(t *testing.T) {
 
 			for _, part := range parts {
 				actualPart, err := blameReader.NextPart()
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, part, actualPart)
 			}
 
 			// make sure all parts have been read
 			actualPart, err := blameReader.NextPart()
 			assert.Nil(t, actualPart)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 		}
 	})
 
 	t.Run("With .git-blame-ignore-revs", func(t *testing.T) {
 		repo, err := OpenRepository(ctx, "./tests/repos/repo6_blame")
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		defer repo.Close()
 
 		full := []*BlamePart{
@@ -119,13 +120,13 @@ func TestReadingBlameOutput(t *testing.T) {
 		}
 
 		objectFormat, err := repo.GetObjectFormat()
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		for _, c := range cases {
 			commit, err := repo.GetCommit(c.CommitID)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			blameReader, err := CreateBlameReader(ctx, objectFormat, "./tests/repos/repo6_blame", commit, "blame.txt", c.Bypass)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.NotNil(t, blameReader)
 			defer blameReader.Close()
 
@@ -133,14 +134,14 @@ func TestReadingBlameOutput(t *testing.T) {
 
 			for _, part := range c.Parts {
 				actualPart, err := blameReader.NextPart()
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, part, actualPart)
 			}
 
 			// make sure all parts have been read
 			actualPart, err := blameReader.NextPart()
 			assert.Nil(t, actualPart)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 		}
 	})
 }

modules/git/blob_test.go

@@ -17,22 +17,21 @@ func TestBlob_Data(t *testing.T) {
 	output := "file2\n"
 	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
 	repo, err := openRepositoryWithDefaultContext(bareRepo1Path)
-	if !assert.NoError(t, err) {
-		t.Fatal()
-	}
+	require.NoError(t, err)
+
 	defer repo.Close()
 
 	testBlob, err := repo.GetBlob("6c493ff740f9380390d5c9ddef4af18697ac9375")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	r, err := testBlob.DataAsync()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	require.NotNil(t, r)
 
 	data, err := io.ReadAll(r)
-	assert.NoError(t, r.Close())
+	require.NoError(t, r.Close())
 
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, output, string(data))
 }
 

modules/git/command_test.go

@@ -8,12 +8,13 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestRunWithContextStd(t *testing.T) {
 	cmd := NewCommand(context.Background(), "--version")
 	stdout, stderr, err := cmd.RunStdString(&RunOpts{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Empty(t, stderr)
 	assert.Contains(t, stdout, "git version")
 
@@ -28,16 +29,16 @@ func TestRunWithContextStd(t *testing.T) {
 
 	cmd = NewCommand(context.Background())
 	cmd.AddDynamicArguments("-test")
-	assert.ErrorIs(t, cmd.Run(&RunOpts{}), ErrBrokenCommand)
+	require.ErrorIs(t, cmd.Run(&RunOpts{}), ErrBrokenCommand)
 
 	cmd = NewCommand(context.Background())
 	cmd.AddDynamicArguments("--test")
-	assert.ErrorIs(t, cmd.Run(&RunOpts{}), ErrBrokenCommand)
+	require.ErrorIs(t, cmd.Run(&RunOpts{}), ErrBrokenCommand)
 
 	subCmd := "version"
 	cmd = NewCommand(context.Background()).AddDynamicArguments(subCmd) // for test purpose only, the sub-command should never be dynamic for production
 	stdout, stderr, err = cmd.RunStdString(&RunOpts{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Empty(t, stderr)
 	assert.Contains(t, stdout, "git version")
 }

modules/git/commit_info_test.go

@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const (
@@ -57,7 +58,7 @@ func testGetCommitsInfo(t *testing.T, repo1 *Repository) {
 	for _, testCase := range testCases {
 		commit, err := repo1.GetCommit(testCase.CommitID)
 		if err != nil {
-			assert.NoError(t, err, "Unable to get commit: %s from testcase due to error: %v", testCase.CommitID, err)
+			require.NoError(t, err, "Unable to get commit: %s from testcase due to error: %v", testCase.CommitID, err)
 			// no point trying to do anything else for this test.
 			continue
 		}
@@ -67,7 +68,7 @@ func testGetCommitsInfo(t *testing.T, repo1 *Repository) {
 
 		tree, err := commit.Tree.SubTree(testCase.Path)
 		if err != nil {
-			assert.NoError(t, err, "Unable to get subtree: %s of commit: %s from testcase due to error: %v", testCase.Path, testCase.CommitID, err)
+			require.NoError(t, err, "Unable to get subtree: %s of commit: %s from testcase due to error: %v", testCase.Path, testCase.CommitID, err)
 			// no point trying to do anything else for this test.
 			continue
 		}
@@ -77,14 +78,14 @@ func testGetCommitsInfo(t *testing.T, repo1 *Repository) {
 
 		entries, err := tree.ListEntries()
 		if err != nil {
-			assert.NoError(t, err, "Unable to get entries of subtree: %s in commit: %s from testcase due to error: %v", testCase.Path, testCase.CommitID, err)
+			require.NoError(t, err, "Unable to get entries of subtree: %s in commit: %s from testcase due to error: %v", testCase.Path, testCase.CommitID, err)
 			// no point trying to do anything else for this test.
 			continue
 		}
 
 		// FIXME: Context.TODO() - if graceful has started we should use its Shutdown context otherwise use install signals in TestMain.
 		commitsInfo, treeCommit, err := entries.GetCommitsInfo(context.TODO(), commit, testCase.Path)
-		assert.NoError(t, err, "Unable to get commit information for entries of subtree: %s in commit: %s from testcase due to error: %v", testCase.Path, testCase.CommitID, err)
+		require.NoError(t, err, "Unable to get commit information for entries of subtree: %s in commit: %s from testcase due to error: %v", testCase.Path, testCase.CommitID, err)
 		if err != nil {
 			t.FailNow()
 		}
@@ -105,18 +106,18 @@ func testGetCommitsInfo(t *testing.T, repo1 *Repository) {
 func TestEntries_GetCommitsInfo(t *testing.T) {
 	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
 	bareRepo1, err := openRepositoryWithDefaultContext(bareRepo1Path)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer bareRepo1.Close()
 
 	testGetCommitsInfo(t, bareRepo1)
 
 	clonedPath, err := cloneRepo(t, bareRepo1Path)
 	if err != nil {
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 	clonedRepo1, err := openRepositoryWithDefaultContext(clonedPath)
 	if err != nil {
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 	defer clonedRepo1.Close()
 

modules/git/commit_sha256_test.go

@@ -11,6 +11,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestCommitsCountSha256(t *testing.T) {
@@ -24,7 +25,7 @@ func TestCommitsCountSha256(t *testing.T) {
 			Revision: []string{"f004f41359117d319dedd0eaab8c5259ee2263da839dcba33637997458627fdc"},
 		})
 
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, int64(3), commitsCount)
 }
 
@@ -40,7 +41,7 @@ func TestCommitsCountWithoutBaseSha256(t *testing.T) {
 			Revision: []string{"branch1"},
 		})
 
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, int64(2), commitsCount)
 }
 
@@ -50,7 +51,7 @@ func TestGetFullCommitIDSha256(t *testing.T) {
 	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare_sha256")
 
 	id, err := GetFullCommitID(DefaultContext, bareRepo1Path, "f004f4")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "f004f41359117d319dedd0eaab8c5259ee2263da839dcba33637997458627fdc", id)
 }
 
@@ -98,12 +99,12 @@ signed commit`
 		0x5d, 0x3e, 0x69, 0xd3, 0x1b, 0x78, 0x60, 0x87, 0x77, 0x5e, 0x28, 0xc6, 0xb6, 0x39, 0x9d, 0xf0,
 	}
 	gitRepo, err := openRepositoryWithDefaultContext(filepath.Join(testReposDir, "repo1_bare_sha256"))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, gitRepo)
 	defer gitRepo.Close()
 
 	commitFromReader, err := CommitFromReader(gitRepo, sha, strings.NewReader(commitString))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	if !assert.NotNil(t, commitFromReader) {
 		return
 	}
@@ -134,7 +135,7 @@ signed commit`, commitFromReader.Signature.Payload)
 	assert.EqualValues(t, "Adam Majer <amajer@suse.de>", commitFromReader.Author.String())
 
 	commitFromReader2, err := CommitFromReader(gitRepo, sha, strings.NewReader(commitString+"\n\n"))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	commitFromReader.CommitMessage += "\n\n"
 	commitFromReader.Signature.Payload += "\n\n"
 	assert.EqualValues(t, commitFromReader, commitFromReader2)
@@ -146,30 +147,30 @@ func TestHasPreviousCommitSha256(t *testing.T) {
 	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare_sha256")
 
 	repo, err := openRepositoryWithDefaultContext(bareRepo1Path)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer repo.Close()
 
 	commit, err := repo.GetCommit("f004f41359117d319dedd0eaab8c5259ee2263da839dcba33637997458627fdc")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	objectFormat, err := repo.GetObjectFormat()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	parentSHA := MustIDFromString("b0ec7af4547047f12d5093e37ef8f1b3b5415ed8ee17894d43a34d7d34212e9c")
 	notParentSHA := MustIDFromString("42e334efd04cd36eea6da0599913333c26116e1a537ca76e5b6e4af4dda00236")
-	assert.Equal(t, objectFormat, parentSHA.Type())
-	assert.Equal(t, objectFormat.Name(), "sha256")
+	assert.Equal(t, parentSHA.Type(), objectFormat)
+	assert.Equal(t, "sha256", objectFormat.Name())
 
 	haz, err := commit.HasPreviousCommit(parentSHA)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, haz)
 
 	hazNot, err := commit.HasPreviousCommit(notParentSHA)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.False(t, hazNot)
 
 	selfNot, err := commit.HasPreviousCommit(commit.ID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.False(t, selfNot)
 }
 
@@ -179,7 +180,7 @@ func TestGetCommitFileStatusMergesSha256(t *testing.T) {
 	bareRepo1Path := filepath.Join(testReposDir, "repo6_merge_sha256")
 
 	commitFileStatus, err := GetCommitFileStatus(DefaultContext, bareRepo1Path, "d2e5609f630dd8db500f5298d05d16def282412e3e66ed68cc7d0833b29129a1")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	expected := CommitFileStatus{
 		[]string{
@@ -204,7 +205,7 @@ func TestGetCommitFileStatusMergesSha256(t *testing.T) {
 	}
 
 	commitFileStatus, err = GetCommitFileStatus(DefaultContext, bareRepo1Path, "da1ded40dc8e5b7c564171f4bf2fc8370487decfb1cb6a99ef28f3ed73d09172")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, expected.Added, commitFileStatus.Added)
 	assert.Equal(t, expected.Removed, commitFileStatus.Removed)

modules/git/commit_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestCommitsCount(t *testing.T) {
@@ -20,7 +21,7 @@ func TestCommitsCount(t *testing.T) {
 			Revision: []string{"8006ff9adbf0cb94da7dad9e537e53817f9fa5c0"},
 		})
 
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, int64(3), commitsCount)
 }
 
@@ -34,7 +35,7 @@ func TestCommitsCountWithoutBase(t *testing.T) {
 			Revision: []string{"branch1"},
 		})
 
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, int64(2), commitsCount)
 }
 
@@ -42,7 +43,7 @@ func TestGetFullCommitID(t *testing.T) {
 	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
 
 	id, err := GetFullCommitID(DefaultContext, bareRepo1Path, "8006ff9a")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "8006ff9adbf0cb94da7dad9e537e53817f9fa5c0", id)
 }
 
@@ -83,15 +84,13 @@ empty commit`
 
 	sha := &Sha1Hash{0xfe, 0xaf, 0x4b, 0xa6, 0xbc, 0x63, 0x5f, 0xec, 0x44, 0x2f, 0x46, 0xdd, 0xd4, 0x51, 0x24, 0x16, 0xec, 0x43, 0xc2, 0xc2}
 	gitRepo, err := openRepositoryWithDefaultContext(filepath.Join(testReposDir, "repo1_bare"))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, gitRepo)
 	defer gitRepo.Close()
 
 	commitFromReader, err := CommitFromReader(gitRepo, sha, strings.NewReader(commitString))
-	assert.NoError(t, err)
-	if !assert.NotNil(t, commitFromReader) {
-		return
-	}
+	require.NoError(t, err)
+	require.NotNil(t, commitFromReader)
 	assert.EqualValues(t, sha, commitFromReader.ID)
 	assert.EqualValues(t, `-----BEGIN PGP SIGNATURE-----
 
@@ -119,7 +118,7 @@ empty commit`, commitFromReader.Signature.Payload)
 	assert.EqualValues(t, "silverwind <me@silverwind.io>", commitFromReader.Author.String())
 
 	commitFromReader2, err := CommitFromReader(gitRepo, sha, strings.NewReader(commitString+"\n\n"))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	commitFromReader.CommitMessage += "\n\n"
 	commitFromReader.Signature.Payload += "\n\n"
 	assert.EqualValues(t, commitFromReader, commitFromReader2)
@@ -133,7 +132,7 @@ author KN4CK3R <admin@oldschoolhack.me> 1711702962 +0100
 committer KN4CK3R <admin@oldschoolhack.me> 1711702962 +0100
 encoding ISO-8859-1
 gpgsig -----BEGIN PGP SIGNATURE-----
- 
+` + " " + `
  iQGzBAABCgAdFiEE9HRrbqvYxPT8PXbefPSEkrowAa8FAmYGg7IACgkQfPSEkrow
  Aa9olwv+P0HhtCM6CRvlUmPaqswRsDPNR4i66xyXGiSxdI9V5oJL7HLiQIM7KrFR
  gizKa2COiGtugv8fE+TKqXKaJx6uJUJEjaBd8E9Af9PrAzjWj+A84lU6/PgPS8hq
@@ -151,15 +150,13 @@ ISO-8859-1`
 
 	sha := &Sha1Hash{0xfe, 0xaf, 0x4b, 0xa6, 0xbc, 0x63, 0x5f, 0xec, 0x44, 0x2f, 0x46, 0xdd, 0xd4, 0x51, 0x24, 0x16, 0xec, 0x43, 0xc2, 0xc2}
 	gitRepo, err := openRepositoryWithDefaultContext(filepath.Join(testReposDir, "repo1_bare"))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, gitRepo)
 	defer gitRepo.Close()
 
 	commitFromReader, err := CommitFromReader(gitRepo, sha, strings.NewReader(commitString))
-	assert.NoError(t, err)
-	if !assert.NotNil(t, commitFromReader) {
-		return
-	}
+	require.NoError(t, err)
+	require.NotNil(t, commitFromReader)
 	assert.EqualValues(t, sha, commitFromReader.ID)
 	assert.EqualValues(t, `-----BEGIN PGP SIGNATURE-----
 
@@ -186,7 +183,7 @@ ISO-8859-1`, commitFromReader.Signature.Payload)
 	assert.EqualValues(t, "KN4CK3R <admin@oldschoolhack.me>", commitFromReader.Author.String())
 
 	commitFromReader2, err := CommitFromReader(gitRepo, sha, strings.NewReader(commitString+"\n\n"))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	commitFromReader.CommitMessage += "\n\n"
 	commitFromReader.Signature.Payload += "\n\n"
 	assert.EqualValues(t, commitFromReader, commitFromReader2)
@@ -196,25 +193,25 @@ func TestHasPreviousCommit(t *testing.T) {
 	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
 
 	repo, err := openRepositoryWithDefaultContext(bareRepo1Path)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer repo.Close()
 
 	commit, err := repo.GetCommit("8006ff9adbf0cb94da7dad9e537e53817f9fa5c0")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	parentSHA := MustIDFromString("8d92fc957a4d7cfd98bc375f0b7bb189a0d6c9f2")
 	notParentSHA := MustIDFromString("2839944139e0de9737a044f78b0e4b40d989a9e3")
 
 	haz, err := commit.HasPreviousCommit(parentSHA)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, haz)
 
 	hazNot, err := commit.HasPreviousCommit(notParentSHA)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.False(t, hazNot)
 
 	selfNot, err := commit.HasPreviousCommit(commit.ID)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.False(t, selfNot)
 }
 
@@ -327,7 +324,7 @@ func TestGetCommitFileStatusMerges(t *testing.T) {
 	bareRepo1Path := filepath.Join(testReposDir, "repo6_merge")
 
 	commitFileStatus, err := GetCommitFileStatus(DefaultContext, bareRepo1Path, "022f4ce6214973e018f02bf363bf8a2e3691f699")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	expected := CommitFileStatus{
 		[]string{
@@ -341,9 +338,9 @@ func TestGetCommitFileStatusMerges(t *testing.T) {
 		},
 	}
 
-	assert.Equal(t, commitFileStatus.Added, expected.Added)
-	assert.Equal(t, commitFileStatus.Removed, expected.Removed)
-	assert.Equal(t, commitFileStatus.Modified, expected.Modified)
+	assert.Equal(t, expected.Added, commitFileStatus.Added)
+	assert.Equal(t, expected.Removed, commitFileStatus.Removed)
+	assert.Equal(t, expected.Modified, commitFileStatus.Modified)
 }
 
 func TestParseCommitRenames(t *testing.T) {

modules/git/diff_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const exampleDiff = `diff --git a/README.md b/README.md
@@ -81,7 +82,7 @@ index d46c152..a7d2d55 100644
 
 func TestCutDiffAroundLineIssue17875(t *testing.T) {
 	result, err := CutDiffAroundLine(strings.NewReader(issue17875Diff), 23, false, 3)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	expected := `diff --git a/Geschäftsordnung.md b/Geschäftsordnung.md
 --- a/Geschäftsordnung.md
 +++ b/Geschäftsordnung.md
@@ -94,7 +95,7 @@ func TestCutDiffAroundLineIssue17875(t *testing.T) {
 
 func TestCutDiffAroundLine(t *testing.T) {
 	result, err := CutDiffAroundLine(strings.NewReader(exampleDiff), 4, false, 3)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	resultByLine := strings.Split(result, "\n")
 	assert.Len(t, resultByLine, 7)
 	// Check if headers got transferred
@@ -108,25 +109,25 @@ func TestCutDiffAroundLine(t *testing.T) {
 
 	// Must be same result as before since old line 3 == new line 5
 	newResult, err := CutDiffAroundLine(strings.NewReader(exampleDiff), 3, true, 3)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, result, newResult, "Must be same result as before since old line 3 == new line 5")
 
 	newResult, err = CutDiffAroundLine(strings.NewReader(exampleDiff), 6, false, 300)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, exampleDiff, newResult)
 
 	emptyResult, err := CutDiffAroundLine(strings.NewReader(exampleDiff), 6, false, 0)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Empty(t, emptyResult)
 
 	// Line is out of scope
 	emptyResult, err = CutDiffAroundLine(strings.NewReader(exampleDiff), 434, false, 0)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Empty(t, emptyResult)
 
 	// Handle minus diffs properly
 	minusDiff, err := CutDiffAroundLine(strings.NewReader(breakingDiff), 2, false, 4)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	expected := `diff --git a/aaa.sql b/aaa.sql
 --- a/aaa.sql
@@ -139,7 +140,7 @@ func TestCutDiffAroundLine(t *testing.T) {
 
 	// Handle minus diffs properly
 	minusDiff, err = CutDiffAroundLine(strings.NewReader(breakingDiff), 3, false, 4)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	expected = `diff --git a/aaa.sql b/aaa.sql
 --- a/aaa.sql

modules/git/git_test.go

@@ -14,6 +14,7 @@ import (
 	"code.gitea.io/gitea/modules/util"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func testRun(m *testing.M) error {
@@ -52,33 +53,33 @@ func gitConfigContains(sub string) bool {
 func TestGitConfig(t *testing.T) {
 	assert.False(t, gitConfigContains("key-a"))
 
-	assert.NoError(t, configSetNonExist("test.key-a", "val-a"))
+	require.NoError(t, configSetNonExist("test.key-a", "val-a"))
 	assert.True(t, gitConfigContains("key-a = val-a"))
 
-	assert.NoError(t, configSetNonExist("test.key-a", "val-a-changed"))
+	require.NoError(t, configSetNonExist("test.key-a", "val-a-changed"))
 	assert.False(t, gitConfigContains("key-a = val-a-changed"))
 
-	assert.NoError(t, configSet("test.key-a", "val-a-changed"))
+	require.NoError(t, configSet("test.key-a", "val-a-changed"))
 	assert.True(t, gitConfigContains("key-a = val-a-changed"))
 
-	assert.NoError(t, configAddNonExist("test.key-b", "val-b"))
+	require.NoError(t, configAddNonExist("test.key-b", "val-b"))
 	assert.True(t, gitConfigContains("key-b = val-b"))
 
-	assert.NoError(t, configAddNonExist("test.key-b", "val-2b"))
+	require.NoError(t, configAddNonExist("test.key-b", "val-2b"))
 	assert.True(t, gitConfigContains("key-b = val-b"))
 	assert.True(t, gitConfigContains("key-b = val-2b"))
 
-	assert.NoError(t, configUnsetAll("test.key-b", "val-b"))
+	require.NoError(t, configUnsetAll("test.key-b", "val-b"))
 	assert.False(t, gitConfigContains("key-b = val-b"))
 	assert.True(t, gitConfigContains("key-b = val-2b"))
 
-	assert.NoError(t, configUnsetAll("test.key-b", "val-2b"))
+	require.NoError(t, configUnsetAll("test.key-b", "val-2b"))
 	assert.False(t, gitConfigContains("key-b = val-2b"))
 
-	assert.NoError(t, configSet("test.key-x", "*"))
+	require.NoError(t, configSet("test.key-x", "*"))
 	assert.True(t, gitConfigContains("key-x = *"))
-	assert.NoError(t, configSetNonExist("test.key-x", "*"))
-	assert.NoError(t, configUnsetAll("test.key-x", "*"))
+	require.NoError(t, configSetNonExist("test.key-x", "*"))
+	require.NoError(t, configUnsetAll("test.key-x", "*"))
 	assert.False(t, gitConfigContains("key-x = *"))
 }
 
@@ -89,7 +90,7 @@ func TestSyncConfig(t *testing.T) {
 	}()
 
 	setting.GitConfig.Options["sync-test.cfg-key-a"] = "CfgValA"
-	assert.NoError(t, syncGitConfig())
+	require.NoError(t, syncGitConfig())
 	assert.True(t, gitConfigContains("[sync-test]"))
 	assert.True(t, gitConfigContains("cfg-key-a = CfgValA"))
 }

modules/git/grep_test.go

@@ -12,15 +12,16 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestGrepSearch(t *testing.T) {
 	repo, err := openRepositoryWithDefaultContext(filepath.Join(testReposDir, "language_stats_repo"))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer repo.Close()
 
 	res, err := GrepSearch(context.Background(), repo, "void", GrepOptions{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []*GrepResult{
 		{
 			Filename:    "java-hello/main.java",
@@ -35,7 +36,7 @@ func TestGrepSearch(t *testing.T) {
 	}, res)
 
 	res, err = GrepSearch(context.Background(), repo, "void", GrepOptions{MaxResultLimit: 1})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []*GrepResult{
 		{
 			Filename:    "java-hello/main.java",
@@ -45,7 +46,7 @@ func TestGrepSearch(t *testing.T) {
 	}, res)
 
 	res, err = GrepSearch(context.Background(), repo, "world", GrepOptions{MatchesPerFile: 1})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []*GrepResult{
 		{
 			Filename:    "i-am-a-python.p",
@@ -70,34 +71,34 @@ func TestGrepSearch(t *testing.T) {
 	}, res)
 
 	res, err = GrepSearch(context.Background(), repo, "no-such-content", GrepOptions{})
-	assert.NoError(t, err)
-	assert.Len(t, res, 0)
+	require.NoError(t, err)
+	assert.Empty(t, res)
 
 	res, err = GrepSearch(context.Background(), &Repository{Path: "no-such-git-repo"}, "no-such-content", GrepOptions{})
-	assert.Error(t, err)
-	assert.Len(t, res, 0)
+	require.Error(t, err)
+	assert.Empty(t, res)
 }
 
 func TestGrepLongFiles(t *testing.T) {
 	tmpDir := t.TempDir()
 
 	err := InitRepository(DefaultContext, tmpDir, false, Sha1ObjectFormat.Name())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	gitRepo, err := openRepositoryWithDefaultContext(tmpDir)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer gitRepo.Close()
 
-	assert.NoError(t, os.WriteFile(path.Join(tmpDir, "README.md"), bytes.Repeat([]byte{'a'}, 65*1024), 0o666))
+	require.NoError(t, os.WriteFile(path.Join(tmpDir, "README.md"), bytes.Repeat([]byte{'a'}, 65*1024), 0o666))
 
 	err = AddChanges(tmpDir, true)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = CommitChanges(tmpDir, CommitChangesOptions{Message: "Long file"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	res, err := GrepSearch(context.Background(), gitRepo, "a", GrepOptions{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, res, 1)
 	assert.Len(t, res[0].LineCodes[0], 65*1024)
 }
@@ -106,28 +107,28 @@ func TestGrepRefs(t *testing.T) {
 	tmpDir := t.TempDir()
 
 	err := InitRepository(DefaultContext, tmpDir, false, Sha1ObjectFormat.Name())
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	gitRepo, err := openRepositoryWithDefaultContext(tmpDir)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer gitRepo.Close()
 
-	assert.NoError(t, os.WriteFile(path.Join(tmpDir, "README.md"), []byte{'A'}, 0o666))
-	assert.NoError(t, AddChanges(tmpDir, true))
+	require.NoError(t, os.WriteFile(path.Join(tmpDir, "README.md"), []byte{'A'}, 0o666))
+	require.NoError(t, AddChanges(tmpDir, true))
 
 	err = CommitChanges(tmpDir, CommitChangesOptions{Message: "add A"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
-	assert.NoError(t, gitRepo.CreateTag("v1", "HEAD"))
+	require.NoError(t, gitRepo.CreateTag("v1", "HEAD"))
 
-	assert.NoError(t, os.WriteFile(path.Join(tmpDir, "README.md"), []byte{'A', 'B', 'C', 'D'}, 0o666))
-	assert.NoError(t, AddChanges(tmpDir, true))
+	require.NoError(t, os.WriteFile(path.Join(tmpDir, "README.md"), []byte{'A', 'B', 'C', 'D'}, 0o666))
+	require.NoError(t, AddChanges(tmpDir, true))
 
 	err = CommitChanges(tmpDir, CommitChangesOptions{Message: "add BCD"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	res, err := GrepSearch(context.Background(), gitRepo, "a", GrepOptions{RefName: "v1"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, res, 1)
-	assert.Equal(t, res[0].LineCodes[0], "A")
+	assert.Equal(t, "A", res[0].LineCodes[0])
 }

modules/git/notes_test.go

@@ -9,17 +9,18 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestGetNotes(t *testing.T) {
 	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
 	bareRepo1, err := openRepositoryWithDefaultContext(bareRepo1Path)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer bareRepo1.Close()
 
 	note := Note{}
 	err = GetNote(context.Background(), bareRepo1, "95bb4d39648ee7e325106df01a621c530863a653", &note)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []byte("Note contents\n"), note.Message)
 	assert.Equal(t, "Vladimir Panteleev", note.Commit.Author.Name)
 }
@@ -27,26 +28,26 @@ func TestGetNotes(t *testing.T) {
 func TestGetNestedNotes(t *testing.T) {
 	repoPath := filepath.Join(testReposDir, "repo3_notes")
 	repo, err := openRepositoryWithDefaultContext(repoPath)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer repo.Close()
 
 	note := Note{}
 	err = GetNote(context.Background(), repo, "3e668dbfac39cbc80a9ff9c61eb565d944453ba4", &note)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []byte("Note 2"), note.Message)
 	err = GetNote(context.Background(), repo, "ba0a96fa63532d6c5087ecef070b0250ed72fa47", &note)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []byte("Note 1"), note.Message)
 }
 
 func TestGetNonExistentNotes(t *testing.T) {
 	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
 	bareRepo1, err := openRepositoryWithDefaultContext(bareRepo1Path)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer bareRepo1.Close()
 
 	note := Note{}
 	err = GetNote(context.Background(), bareRepo1, "non_existent_sha", &note)
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.IsType(t, ErrNotExist{}, err)
 }

modules/git/parse_gogit_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/go-git/go-git/v5/plumbing/filemode"
 	"github.com/go-git/go-git/v5/plumbing/object"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestParseTreeEntries(t *testing.T) {
@@ -68,7 +69,7 @@ func TestParseTreeEntries(t *testing.T) {
 
 	for _, testCase := range testCases {
 		entries, err := ParseTreeEntries([]byte(testCase.Input))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		if len(entries) > 1 {
 			fmt.Println(testCase.Expected[0].ID)
 			fmt.Println(entries[0].ID)

modules/git/parse_nogogit_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestParseTreeEntriesLong(t *testing.T) {
@@ -55,7 +56,7 @@ func TestParseTreeEntriesLong(t *testing.T) {
 	}
 	for _, testCase := range testCases {
 		entries, err := ParseTreeEntries([]byte(testCase.Input))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Len(t, entries, len(testCase.Expected))
 		for i, entry := range entries {
 			assert.EqualValues(t, testCase.Expected[i], entry)
@@ -88,7 +89,7 @@ func TestParseTreeEntriesShort(t *testing.T) {
 	}
 	for _, testCase := range testCases {
 		entries, err := ParseTreeEntries([]byte(testCase.Input))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Len(t, entries, len(testCase.Expected))
 		for i, entry := range entries {
 			assert.EqualValues(t, testCase.Expected[i], entry)
@@ -99,6 +100,6 @@ func TestParseTreeEntriesShort(t *testing.T) {
 func TestParseTreeEntriesInvalid(t *testing.T) {
 	// there was a panic: "runtime error: slice bounds out of range" when the input was invalid: #20315
 	entries, err := ParseTreeEntries([]byte("100644 blob ea0d83c9081af9500ac9f804101b3fd0a5c293af"))
-	assert.Error(t, err)
-	assert.Len(t, entries, 0)
+	require.Error(t, err)
+	assert.Empty(t, entries)
 }

modules/git/repo_attribute_test.go

@@ -30,14 +30,14 @@ func TestNewCheckAttrStdoutReader(t *testing.T) {
 
 		// first read
 		attr, err := read()
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, map[string]GitAttribute{
 			"linguist-vendored": GitAttribute("unspecified"),
 		}, attr)
 
 		// second read
 		attr, err = read()
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, map[string]GitAttribute{
 			"linguist-vendored": GitAttribute("specified"),
 		}, attr)
@@ -59,21 +59,21 @@ func TestNewCheckAttrStdoutReader(t *testing.T) {
 
 		// first read
 		attr, err := read()
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, map[string]GitAttribute{
 			"linguist-vendored": GitAttribute("set"),
 		}, attr)
 
 		// second read
 		attr, err = read()
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, map[string]GitAttribute{
 			"linguist-generated": GitAttribute("unspecified"),
 		}, attr)
 
 		// third read
 		attr, err = read()
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, map[string]GitAttribute{
 			"linguist-language": GitAttribute("unspecified"),
 		}, attr)
@@ -95,32 +95,32 @@ func TestGitAttributeBareNonBare(t *testing.T) {
 		"341fca5b5ea3de596dc483e54c2db28633cd2f97",
 	} {
 		bareStats, err := gitRepo.GitAttributes(commitID, "i-am-a-python.p", LinguistAttributes...)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		defer test.MockVariableValue(&SupportCheckAttrOnBare, false)()
 		cloneStats, err := gitRepo.GitAttributes(commitID, "i-am-a-python.p", LinguistAttributes...)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		assert.EqualValues(t, cloneStats, bareStats)
 		refStats := cloneStats
 
 		t.Run("GitAttributeChecker/"+commitID+"/SupportBare", func(t *testing.T) {
 			bareChecker, err := gitRepo.GitAttributeChecker(commitID, LinguistAttributes...)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			defer bareChecker.Close()
 
 			bareStats, err := bareChecker.CheckPath("i-am-a-python.p")
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.EqualValues(t, refStats, bareStats)
 		})
 		t.Run("GitAttributeChecker/"+commitID+"/NoBareSupport", func(t *testing.T) {
 			defer test.MockVariableValue(&SupportCheckAttrOnBare, false)()
 			cloneChecker, err := gitRepo.GitAttributeChecker(commitID, LinguistAttributes...)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			defer cloneChecker.Close()
 
 			cloneStats, err := cloneChecker.CheckPath("i-am-a-python.p")
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			assert.EqualValues(t, refStats, cloneStats)
 		})
@@ -134,7 +134,7 @@ func TestGitAttributes(t *testing.T) {
 	defer gitRepo.Close()
 
 	attr, err := gitRepo.GitAttributes("8fee858da5796dfb37704761701bb8e800ad9ef3", "i-am-a-python.p", LinguistAttributes...)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, map[string]GitAttribute{
 		"gitlab-language":        "unspecified",
 		"linguist-detectable":    "unspecified",
@@ -145,7 +145,7 @@ func TestGitAttributes(t *testing.T) {
 	}, attr)
 
 	attr, err = gitRepo.GitAttributes("341fca5b5ea3de596dc483e54c2db28633cd2f97", "i-am-a-python.p", LinguistAttributes...)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, map[string]GitAttribute{
 		"gitlab-language":        "unspecified",
 		"linguist-detectable":    "unspecified",
@@ -164,19 +164,19 @@ func TestGitAttributeFirst(t *testing.T) {
 
 	t.Run("first is specified", func(t *testing.T) {
 		language, err := gitRepo.GitAttributeFirst("8fee858da5796dfb37704761701bb8e800ad9ef3", "i-am-a-python.p", "linguist-language", "gitlab-language")
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, "Python", language.String())
 	})
 
 	t.Run("second is specified", func(t *testing.T) {
 		language, err := gitRepo.GitAttributeFirst("8fee858da5796dfb37704761701bb8e800ad9ef3", "i-am-a-python.p", "gitlab-language", "linguist-language")
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, "Python", language.String())
 	})
 
 	t.Run("none is specified", func(t *testing.T) {
 		language, err := gitRepo.GitAttributeFirst("8fee858da5796dfb37704761701bb8e800ad9ef3", "i-am-a-python.p", "linguist-detectable", "gitlab-language", "non-existing")
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, "", language.String())
 	})
 }
@@ -208,13 +208,13 @@ func TestGitAttributeCheckerError(t *testing.T) {
 		gitRepo := prepareRepo(t)
 		defer gitRepo.Close()
 
-		assert.NoError(t, os.RemoveAll(gitRepo.Path))
+		require.NoError(t, os.RemoveAll(gitRepo.Path))
 
 		ac, err := gitRepo.GitAttributeChecker("", "linguist-language")
 		require.NoError(t, err)
 
 		_, err = ac.CheckPath("i-am-a-python.p")
-		assert.Error(t, err)
+		require.Error(t, err)
 		assert.Contains(t, err.Error(), `git check-attr (stderr: ""):`)
 	})
 
@@ -226,7 +226,7 @@ func TestGitAttributeCheckerError(t *testing.T) {
 		require.NoError(t, err)
 
 		// calling CheckPath before would allow git to cache part of it and successfully return later
-		assert.NoError(t, os.RemoveAll(gitRepo.Path))
+		require.NoError(t, os.RemoveAll(gitRepo.Path))
 
 		_, err = ac.CheckPath("i-am-a-python.p")
 		if err == nil {
@@ -254,7 +254,7 @@ func TestGitAttributeCheckerError(t *testing.T) {
 		require.NoError(t, err)
 
 		_, err = ac.CheckPath("i-am-a-python.p")
-		assert.ErrorIs(t, err, context.Canceled)
+		require.ErrorIs(t, err, context.Canceled)
 	})
 
 	t.Run("Cancelled/DuringRun", func(t *testing.T) {
@@ -268,7 +268,7 @@ func TestGitAttributeCheckerError(t *testing.T) {
 		require.NoError(t, err)
 
 		attr, err := ac.CheckPath("i-am-a-python.p")
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, "Python", attr["linguist-language"].String())
 
 		errCh := make(chan error)
@@ -286,7 +286,7 @@ func TestGitAttributeCheckerError(t *testing.T) {
 		case <-time.After(time.Second):
 			t.Error("CheckPath did not complete within 1s")
 		case err = <-errCh:
-			assert.ErrorIs(t, err, context.Canceled)
+			require.ErrorIs(t, err, context.Canceled)
 		}
 	})
 
@@ -297,10 +297,10 @@ func TestGitAttributeCheckerError(t *testing.T) {
 		ac, err := gitRepo.GitAttributeChecker("8fee858da5796dfb37704761701bb8e800ad9ef3", "linguist-language")
 		require.NoError(t, err)
 
-		assert.NoError(t, ac.Close())
+		require.NoError(t, ac.Close())
 
 		_, err = ac.CheckPath("i-am-a-python.p")
-		assert.ErrorIs(t, err, fs.ErrClosed)
+		require.ErrorIs(t, err, fs.ErrClosed)
 	})
 
 	t.Run("Closed/DuringRun", func(t *testing.T) {
@@ -311,13 +311,13 @@ func TestGitAttributeCheckerError(t *testing.T) {
 		require.NoError(t, err)
 
 		attr, err := ac.CheckPath("i-am-a-python.p")
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, "Python", attr["linguist-language"].String())
 
-		assert.NoError(t, ac.Close())
+		require.NoError(t, ac.Close())
 
 		_, err = ac.CheckPath("i-am-a-python.p")
-		assert.ErrorIs(t, err, fs.ErrClosed)
+		require.ErrorIs(t, err, fs.ErrClosed)
 	})
 }
 

modules/git/repo_blob_test.go

@@ -10,12 +10,13 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestRepository_GetBlob_Found(t *testing.T) {
 	repoPath := filepath.Join(testReposDir, "repo1_bare")
 	r, err := openRepositoryWithDefaultContext(repoPath)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer r.Close()
 
 	testCases := []struct {
@@ -28,14 +29,14 @@ func TestRepository_GetBlob_Found(t *testing.T) {
 
 	for _, testCase := range testCases {
 		blob, err := r.GetBlob(testCase.OID)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		dataReader, err := blob.DataAsync()
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		data, err := io.ReadAll(dataReader)
-		assert.NoError(t, dataReader.Close())
-		assert.NoError(t, err)
+		require.NoError(t, dataReader.Close())
+		require.NoError(t, err)
 		assert.Equal(t, testCase.Data, data)
 	}
 }
@@ -43,7 +44,7 @@ func TestRepository_GetBlob_Found(t *testing.T) {
 func TestRepository_GetBlob_NotExist(t *testing.T) {
 	repoPath := filepath.Join(testReposDir, "repo1_bare")
 	r, err := openRepositoryWithDefaultContext(repoPath)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer r.Close()
 
 	testCase := "0000000000000000000000000000000000000000"
@@ -57,7 +58,7 @@ func TestRepository_GetBlob_NotExist(t *testing.T) {
 func TestRepository_GetBlob_NoId(t *testing.T) {
 	repoPath := filepath.Join(testReposDir, "repo1_bare")
 	r, err := openRepositoryWithDefaultContext(repoPath)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer r.Close()
 
 	testCase := ""

modules/git/repo_branch_test.go

@@ -8,32 +8,33 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestRepository_GetBranches(t *testing.T) {
 	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
 	bareRepo1, err := openRepositoryWithDefaultContext(bareRepo1Path)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer bareRepo1.Close()
 
 	branches, countAll, err := bareRepo1.GetBranchNames(0, 2)
 
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, branches, 2)
 	assert.EqualValues(t, 3, countAll)
 	assert.ElementsMatch(t, []string{"master", "branch2"}, branches)
 
 	branches, countAll, err = bareRepo1.GetBranchNames(0, 0)
 
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, branches, 3)
 	assert.EqualValues(t, 3, countAll)
 	assert.ElementsMatch(t, []string{"master", "branch2", "branch1"}, branches)
 
 	branches, countAll, err = bareRepo1.GetBranchNames(5, 1)
 
-	assert.NoError(t, err)
-	assert.Len(t, branches, 0)
+	require.NoError(t, err)
+	assert.Empty(t, branches)
 	assert.EqualValues(t, 3, countAll)
 	assert.ElementsMatch(t, []string{}, branches)
 }
@@ -64,20 +65,20 @@ func TestGetRefsBySha(t *testing.T) {
 
 	// do not exist
 	branches, err := bareRepo5.GetRefsBySha("8006ff9adbf0cb94da7dad9e537e53817f9fa5c0", "")
-	assert.NoError(t, err)
-	assert.Len(t, branches, 0)
+	require.NoError(t, err)
+	assert.Empty(t, branches)
 
 	// refs/pull/1/head
 	branches, err = bareRepo5.GetRefsBySha("c83380d7056593c51a699d12b9c00627bd5743e9", PullPrefix)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, []string{"refs/pull/1/head"}, branches)
 
 	branches, err = bareRepo5.GetRefsBySha("d8e0bbb45f200e67d9a784ce55bd90821af45ebd", BranchPrefix)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, []string{"refs/heads/master", "refs/heads/master-clone"}, branches)
 
 	branches, err = bareRepo5.GetRefsBySha("58a4bcc53ac13e7ff76127e0fb518b5262bf09af", BranchPrefix)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, []string{"refs/heads/test-patch-1"}, branches)
 }
 

modules/git/repo_commit_test.go

@@ -8,12 +8,13 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestRepository_GetCommitBranches(t *testing.T) {
 	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
 	bareRepo1, err := openRepositoryWithDefaultContext(bareRepo1Path)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer bareRepo1.Close()
 
 	// these test case are specific to the repo1_bare test repo
@@ -30,9 +31,9 @@ func TestRepository_GetCommitBranches(t *testing.T) {
 	}
 	for _, testCase := range testCases {
 		commit, err := bareRepo1.GetCommit(testCase.CommitID)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		branches, err := bareRepo1.getBranches(commit, 2)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, testCase.ExpectedBranches, branches)
 	}
 }
@@ -40,12 +41,12 @@ func TestRepository_GetCommitBranches(t *testing.T) {
 func TestGetTagCommitWithSignature(t *testing.T) {
 	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
 	bareRepo1, err := openRepositoryWithDefaultContext(bareRepo1Path)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer bareRepo1.Close()
 
 	// both the tag and the commit are signed here, this validates only the commit signature
 	commit, err := bareRepo1.GetCommit("28b55526e7100924d864dd89e35c1ea62e7a5a32")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, commit)
 	assert.NotNil(t, commit.Signature)
 	// test that signature is not in message
@@ -55,34 +56,34 @@ func TestGetTagCommitWithSignature(t *testing.T) {
 func TestGetCommitWithBadCommitID(t *testing.T) {
 	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
 	bareRepo1, err := openRepositoryWithDefaultContext(bareRepo1Path)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer bareRepo1.Close()
 
 	commit, err := bareRepo1.GetCommit("bad_branch")
 	assert.Nil(t, commit)
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.True(t, IsErrNotExist(err))
 }
 
 func TestIsCommitInBranch(t *testing.T) {
 	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
 	bareRepo1, err := openRepositoryWithDefaultContext(bareRepo1Path)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer bareRepo1.Close()
 
 	result, err := bareRepo1.IsCommitInBranch("2839944139e0de9737a044f78b0e4b40d989a9e3", "branch1")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, result)
 
 	result, err = bareRepo1.IsCommitInBranch("2839944139e0de9737a044f78b0e4b40d989a9e3", "branch2")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.False(t, result)
 }
 
 func TestRepository_CommitsBetweenIDs(t *testing.T) {
 	bareRepo1Path := filepath.Join(testReposDir, "repo4_commitsbetween")
 	bareRepo1, err := openRepositoryWithDefaultContext(bareRepo1Path)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer bareRepo1.Close()
 
 	cases := []struct {
@@ -96,7 +97,7 @@ func TestRepository_CommitsBetweenIDs(t *testing.T) {
 	}
 	for i, c := range cases {
 		commits, err := bareRepo1.CommitsBetweenIDs(c.NewID, c.OldID)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Len(t, commits, c.ExpectedCommits, "case %d", i)
 	}
 }

modules/git/repo_compare_test.go

@@ -10,19 +10,20 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestGetFormatPatch(t *testing.T) {
 	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
 	clonedPath, err := cloneRepo(t, bareRepo1Path)
 	if err != nil {
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		return
 	}
 
 	repo, err := openRepositoryWithDefaultContext(clonedPath)
 	if err != nil {
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		return
 	}
 	defer repo.Close()
@@ -30,13 +31,13 @@ func TestGetFormatPatch(t *testing.T) {
 	rd := &bytes.Buffer{}
 	err = repo.GetPatch("8d92fc95^", "8d92fc95", rd)
 	if err != nil {
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		return
 	}
 
 	patchb, err := io.ReadAll(rd)
 	if err != nil {
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		return
 	}
 
@@ -50,29 +51,29 @@ func TestReadPatch(t *testing.T) {
 	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
 	repo, err := openRepositoryWithDefaultContext(bareRepo1Path)
 	if err != nil {
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		return
 	}
 	defer repo.Close()
 	// This patch doesn't exist
 	noFile, err := repo.ReadPatchCommit(0)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	// This patch is an empty one (sometimes it's a 404)
 	noCommit, err := repo.ReadPatchCommit(1)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	// This patch is legit and should return a commit
 	oldCommit, err := repo.ReadPatchCommit(2)
 	if err != nil {
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		return
 	}
 
 	assert.Empty(t, noFile)
 	assert.Empty(t, noCommit)
 	assert.Len(t, oldCommit, 40)
-	assert.True(t, oldCommit == "6e8e2a6f9efd71dbe6917816343ed8415ad696c3")
+	assert.Equal(t, "6e8e2a6f9efd71dbe6917816343ed8415ad696c3", oldCommit)
 }
 
 func TestReadWritePullHead(t *testing.T) {
@@ -82,52 +83,52 @@ func TestReadWritePullHead(t *testing.T) {
 	// As we are writing we should clone the repository first
 	clonedPath, err := cloneRepo(t, bareRepo1Path)
 	if err != nil {
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		return
 	}
 
 	repo, err := openRepositoryWithDefaultContext(clonedPath)
 	if err != nil {
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		return
 	}
 	defer repo.Close()
 
 	// Try to open non-existing Pull
 	_, err = repo.GetRefCommitID(PullPrefix + "0/head")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	// Write a fake sha1 with only 40 zeros
 	newCommit := "feaf4ba6bc635fec442f46ddd4512416ec43c2c2"
 	err = repo.SetReference(PullPrefix+"1/head", newCommit)
 	if err != nil {
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		return
 	}
 
 	// Read the file created
 	headContents, err := repo.GetRefCommitID(PullPrefix + "1/head")
 	if err != nil {
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		return
 	}
 
 	assert.Len(t, headContents, 40)
-	assert.True(t, headContents == newCommit)
+	assert.Equal(t, newCommit, headContents)
 
 	// Remove file after the test
 	err = repo.RemoveReference(PullPrefix + "1/head")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestGetCommitFilesChanged(t *testing.T) {
 	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
 	repo, err := openRepositoryWithDefaultContext(bareRepo1Path)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer repo.Close()
 
 	objectFormat, err := repo.GetObjectFormat()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	testCases := []struct {
 		base, head string
@@ -157,7 +158,7 @@ func TestGetCommitFilesChanged(t *testing.T) {
 
 	for _, tc := range testCases {
 		changedFiles, err := repo.GetFilesChangedBetween(tc.base, tc.head)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.ElementsMatch(t, tc.files, changedFiles)
 	}
 }

modules/git/repo_language_stats_test.go

@@ -10,20 +10,18 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestRepository_GetLanguageStats(t *testing.T) {
 	repoPath := filepath.Join(testReposDir, "language_stats_repo")
 	gitRepo, err := openRepositoryWithDefaultContext(repoPath)
-	if !assert.NoError(t, err) {
-		t.Fatal()
-	}
+	require.NoError(t, err)
+
 	defer gitRepo.Close()
 
 	stats, err := gitRepo.GetLanguageStats("8fee858da5796dfb37704761701bb8e800ad9ef3")
-	if !assert.NoError(t, err) {
-		t.Fatal()
-	}
+	require.NoError(t, err)
 
 	assert.EqualValues(t, map[string]int64{
 		"Python": 134,

modules/git/repo_ref_test.go

@@ -8,17 +8,18 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestRepository_GetRefs(t *testing.T) {
 	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
 	bareRepo1, err := openRepositoryWithDefaultContext(bareRepo1Path)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer bareRepo1.Close()
 
 	refs, err := bareRepo1.GetRefs()
 
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, refs, 6)
 
 	expectedRefs := []string{
@@ -38,12 +39,12 @@ func TestRepository_GetRefs(t *testing.T) {
 func TestRepository_GetRefsFiltered(t *testing.T) {
 	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
 	bareRepo1, err := openRepositoryWithDefaultContext(bareRepo1Path)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer bareRepo1.Close()
 
 	refs, err := bareRepo1.GetRefsFiltered(TagPrefix)
 
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	if assert.Len(t, refs, 2) {
 		assert.Equal(t, TagPrefix+"signed-tag", refs[0].Name)
 		assert.Equal(t, "tag", refs[0].Type)

modules/git/repo_stats_test.go

@@ -9,19 +9,20 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestRepository_GetCodeActivityStats(t *testing.T) {
 	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
 	bareRepo1, err := openRepositoryWithDefaultContext(bareRepo1Path)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer bareRepo1.Close()
 
 	timeFrom, err := time.Parse(time.RFC3339, "2016-01-01T00:00:00+00:00")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	code, err := bareRepo1.GetCodeActivityStats(timeFrom, "")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, code)
 
 	assert.EqualValues(t, 10, code.CommitCount)

modules/git/repo_tag_test.go

@@ -15,14 +15,14 @@ func TestRepository_GetTags(t *testing.T) {
 	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
 	bareRepo1, err := openRepositoryWithDefaultContext(bareRepo1Path)
 	if err != nil {
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		return
 	}
 	defer bareRepo1.Close()
 
 	tags, total, err := bareRepo1.GetTagInfos(0, 0)
 	if err != nil {
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		return
 	}
 	assert.Len(t, tags, 2)
@@ -40,13 +40,13 @@ func TestRepository_GetTag(t *testing.T) {
 
 	clonedPath, err := cloneRepo(t, bareRepo1Path)
 	if err != nil {
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		return
 	}
 
 	bareRepo1, err := openRepositoryWithDefaultContext(clonedPath)
 	if err != nil {
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		return
 	}
 	defer bareRepo1.Close()
@@ -58,14 +58,14 @@ func TestRepository_GetTag(t *testing.T) {
 	// Create the lightweight tag
 	err = bareRepo1.CreateTag(lTagName, lTagCommitID)
 	if err != nil {
-		assert.NoError(t, err, "Unable to create the lightweight tag: %s for ID: %s. Error: %v", lTagName, lTagCommitID, err)
+		require.NoError(t, err, "Unable to create the lightweight tag: %s for ID: %s. Error: %v", lTagName, lTagCommitID, err)
 		return
 	}
 
 	// and try to get the Tag for lightweight tag
 	lTag, err := bareRepo1.GetTag(lTagName)
 	if err != nil {
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		return
 	}
 	if lTag == nil {
@@ -85,20 +85,20 @@ func TestRepository_GetTag(t *testing.T) {
 	// Create the annotated tag
 	err = bareRepo1.CreateAnnotatedTag(aTagName, aTagMessage, aTagCommitID)
 	if err != nil {
-		assert.NoError(t, err, "Unable to create the annotated tag: %s for ID: %s. Error: %v", aTagName, aTagCommitID, err)
+		require.NoError(t, err, "Unable to create the annotated tag: %s for ID: %s. Error: %v", aTagName, aTagCommitID, err)
 		return
 	}
 
 	// Now try to get the tag for the annotated Tag
 	aTagID, err := bareRepo1.GetTagID(aTagName)
 	if err != nil {
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		return
 	}
 
 	aTag, err := bareRepo1.GetTag(aTagName)
 	if err != nil {
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		return
 	}
 	if aTag == nil {
@@ -118,20 +118,20 @@ func TestRepository_GetTag(t *testing.T) {
 
 	err = bareRepo1.CreateTag(rTagName, rTagCommitID)
 	if err != nil {
-		assert.NoError(t, err, "Unable to create the  tag: %s for ID: %s. Error: %v", rTagName, rTagCommitID, err)
+		require.NoError(t, err, "Unable to create the  tag: %s for ID: %s. Error: %v", rTagName, rTagCommitID, err)
 		return
 	}
 
 	rTagID, err := bareRepo1.GetTagID(rTagName)
 	if err != nil {
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		return
 	}
 	assert.EqualValues(t, rTagCommitID, rTagID)
 
 	oTagID, err := bareRepo1.GetTagID(lTagName)
 	if err != nil {
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		return
 	}
 	assert.EqualValues(t, lTagCommitID, oTagID)
@@ -142,13 +142,13 @@ func TestRepository_GetAnnotatedTag(t *testing.T) {
 
 	clonedPath, err := cloneRepo(t, bareRepo1Path)
 	if err != nil {
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		return
 	}
 
 	bareRepo1, err := openRepositoryWithDefaultContext(clonedPath)
 	if err != nil {
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		return
 	}
 	defer bareRepo1.Close()
@@ -166,7 +166,7 @@ func TestRepository_GetAnnotatedTag(t *testing.T) {
 	// Try an annotated tag
 	tag, err := bareRepo1.GetAnnotatedTag(aTagID)
 	if err != nil {
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		return
 	}
 	assert.NotNil(t, tag)
@@ -176,19 +176,19 @@ func TestRepository_GetAnnotatedTag(t *testing.T) {
 
 	// Annotated tag's Commit ID should fail
 	tag2, err := bareRepo1.GetAnnotatedTag(aTagCommitID)
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.True(t, IsErrNotExist(err))
 	assert.Nil(t, tag2)
 
 	// Annotated tag's name should fail
 	tag3, err := bareRepo1.GetAnnotatedTag(aTagName)
-	assert.Error(t, err)
-	assert.Errorf(t, err, "Length must be 40: %d", len(aTagName))
+	require.Error(t, err)
+	require.Errorf(t, err, "Length must be 40: %d", len(aTagName))
 	assert.Nil(t, tag3)
 
 	// Lightweight Tag should fail
 	tag4, err := bareRepo1.GetAnnotatedTag(lTagCommitID)
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.True(t, IsErrNotExist(err))
 	assert.Nil(t, tag4)
 }

modules/git/repo_test.go

@@ -9,12 +9,13 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestGetLatestCommitTime(t *testing.T) {
 	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
 	lct, err := GetLatestCommitTime(DefaultContext, bareRepo1Path)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	// Time is Sun Nov 13 16:40:14 2022 +0100
 	// which is the time of commit
 	// ce064814f4a0d337b333e646ece456cd39fab612 (refs/heads/master)
@@ -24,31 +25,31 @@ func TestGetLatestCommitTime(t *testing.T) {
 func TestRepoIsEmpty(t *testing.T) {
 	emptyRepo2Path := filepath.Join(testReposDir, "repo2_empty")
 	repo, err := openRepositoryWithDefaultContext(emptyRepo2Path)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer repo.Close()
 	isEmpty, err := repo.IsEmpty()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, isEmpty)
 }
 
 func TestRepoGetDivergingCommits(t *testing.T) {
 	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
 	do, err := GetDivergingCommits(context.Background(), bareRepo1Path, "master", "branch2")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, DivergeObject{
 		Ahead:  1,
 		Behind: 5,
 	}, do)
 
 	do, err = GetDivergingCommits(context.Background(), bareRepo1Path, "master", "master")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, DivergeObject{
 		Ahead:  0,
 		Behind: 0,
 	}, do)
 
 	do, err = GetDivergingCommits(context.Background(), bareRepo1Path, "master", "test")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, DivergeObject{
 		Ahead:  0,
 		Behind: 2,

modules/git/tag_test.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func Test_parseTagData(t *testing.T) {
@@ -85,7 +86,7 @@ v0
 
 	for _, test := range testData {
 		tag, err := parseTagData(Sha1ObjectFormat, test.data)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.EqualValues(t, test.tag.ID, tag.ID)
 		assert.EqualValues(t, test.tag.Object, tag.Object)
 		assert.EqualValues(t, test.tag.Name, tag.Name)

modules/git/tree_entry_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/go-git/go-git/v5/plumbing/filemode"
 	"github.com/go-git/go-git/v5/plumbing/object"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func getTestEntries() Entries {
@@ -56,47 +57,47 @@ func TestEntriesCustomSort(t *testing.T) {
 
 func TestFollowLink(t *testing.T) {
 	r, err := openRepositoryWithDefaultContext("tests/repos/repo1_bare")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer r.Close()
 
 	commit, err := r.GetCommit("37991dec2c8e592043f47155ce4808d4580f9123")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// get the symlink
 	lnk, err := commit.Tree.GetTreeEntryByPath("foo/bar/link_to_hello")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, lnk.IsLink())
 
 	// should be able to dereference to target
 	target, err := lnk.FollowLink()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "hello", target.Name())
 	assert.False(t, target.IsLink())
 	assert.Equal(t, "b14df6442ea5a1b382985a6549b85d435376c351", target.ID.String())
 
 	// should error when called on normal file
 	target, err = commit.Tree.GetTreeEntryByPath("file1.txt")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	_, err = target.FollowLink()
 	assert.EqualError(t, err, "file1.txt: not a symlink")
 
 	// should error for broken links
 	target, err = commit.Tree.GetTreeEntryByPath("foo/broken_link")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, target.IsLink())
 	_, err = target.FollowLink()
 	assert.EqualError(t, err, "broken_link: broken link")
 
 	// should error for external links
 	target, err = commit.Tree.GetTreeEntryByPath("foo/outside_repo")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, target.IsLink())
 	_, err = target.FollowLink()
 	assert.EqualError(t, err, "outside_repo: points outside of repo")
 
 	// testing fix for short link bug
 	target, err = commit.Tree.GetTreeEntryByPath("foo/link_short")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	_, err = target.FollowLink()
 	assert.EqualError(t, err, "link_short: broken link")
 }

modules/git/tree_test.go

@@ -8,20 +8,21 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestSubTree_Issue29101(t *testing.T) {
 	repo, err := openRepositoryWithDefaultContext(filepath.Join(testReposDir, "repo1_bare"))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer repo.Close()
 
 	commit, err := repo.GetCommit("ce064814f4a0d337b333e646ece456cd39fab612")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// old code could produce a different error if called multiple times
 	for i := 0; i < 10; i++ {
 		_, err = commit.SubTree("file1.txt")
-		assert.Error(t, err)
+		require.Error(t, err)
 		assert.True(t, IsErrNotExist(err))
 	}
 }

modules/git/url/url_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestParseGitURLs(t *testing.T) {
@@ -158,7 +159,7 @@ func TestParseGitURLs(t *testing.T) {
 	for _, kase := range kases {
 		t.Run(kase.kase, func(t *testing.T) {
 			u, err := Parse(kase.kase)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.EqualValues(t, kase.expected.extraMark, u.extraMark)
 			assert.EqualValues(t, *kase.expected, *u)
 		})

modules/graceful/releasereopen/releasereopen_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 type testReleaseReopener struct {
@@ -29,14 +30,14 @@ func TestManager(t *testing.T) {
 	c2 := m.Register(t2)
 	_ = m.Register(t3)
 
-	assert.NoError(t, m.ReleaseReopen())
+	require.NoError(t, m.ReleaseReopen())
 	assert.EqualValues(t, 1, t1.count)
 	assert.EqualValues(t, 1, t2.count)
 	assert.EqualValues(t, 1, t3.count)
 
 	c2()
 
-	assert.NoError(t, m.ReleaseReopen())
+	require.NoError(t, m.ReleaseReopen())
 	assert.EqualValues(t, 2, t1.count)
 	assert.EqualValues(t, 1, t2.count)
 	assert.EqualValues(t, 2, t3.count)

modules/highlight/highlight_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func lines(s string) (out []template.HTML) {
@@ -113,7 +114,7 @@ c=2
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			out, lexerName, err := File(tt.name, "", []byte(tt.code))
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.EqualValues(t, tt.want, out)
 			assert.Equal(t, tt.lexerName, lexerName)
 		})

modules/httplib/serve_test.go

@@ -13,6 +13,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestServeContentByReader(t *testing.T) {
@@ -61,7 +62,7 @@ func TestServeContentByReadSeeker(t *testing.T) {
 	data := "0123456789abcdef"
 	tmpFile := t.TempDir() + "/test"
 	err := os.WriteFile(tmpFile, []byte(data), 0o644)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	test := func(t *testing.T, expectedStatusCode int, expectedContent string) {
 		_, rangeStr, _ := strings.Cut(t.Name(), "_range_")
@@ -71,9 +72,8 @@ func TestServeContentByReadSeeker(t *testing.T) {
 		}
 
 		seekReader, err := os.OpenFile(tmpFile, os.O_RDONLY, 0o644)
-		if !assert.NoError(t, err) {
-			return
-		}
+		require.NoError(t, err)
+
 		defer seekReader.Close()
 
 		w := httptest.NewRecorder()

modules/indexer/code/indexer_test.go

@@ -20,6 +20,7 @@ import (
 	_ "code.gitea.io/gitea/models/activities"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestMain(m *testing.M) {
@@ -30,7 +31,7 @@ func testIndexer(name string, t *testing.T, indexer internal.Indexer) {
 	t.Run(name, func(t *testing.T) {
 		var repoID int64 = 1
 		err := index(git.DefaultContext, indexer, repoID)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		keywords := []struct {
 			RepoIDs []int64
 			Keyword string
@@ -86,7 +87,7 @@ func testIndexer(name string, t *testing.T, indexer internal.Indexer) {
 					},
 					IsKeywordFuzzy: true,
 				})
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Len(t, kw.IDs, int(total))
 				assert.Len(t, langs, kw.Langs)
 
@@ -99,7 +100,7 @@ func testIndexer(name string, t *testing.T, indexer internal.Indexer) {
 			})
 		}
 
-		assert.NoError(t, indexer.Delete(context.Background(), repoID))
+		require.NoError(t, indexer.Delete(context.Background(), repoID))
 	})
 }
 

modules/indexer/internal/bleve/metadata_test.go

@@ -9,19 +9,20 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestMetadata(t *testing.T) {
 	dir := t.TempDir()
 
 	meta, err := readIndexMetadata(dir)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, &IndexMetadata{}, meta)
 
 	meta.Version = 24
-	assert.NoError(t, writeIndexMetadata(dir, meta))
+	require.NoError(t, writeIndexMetadata(dir, meta))
 
 	meta, err = readIndexMetadata(dir)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, 24, meta.Version)
 }

modules/indexer/issues/indexer_test.go

@@ -19,6 +19,7 @@ import (
 	_ "code.gitea.io/gitea/models/activities"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestMain(m *testing.M) {
@@ -26,7 +27,7 @@ func TestMain(m *testing.M) {
 }
 
 func TestDBSearchIssues(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
+	require.NoError(t, unittest.PrepareTestDatabase())
 
 	setting.Indexer.IssueType = "db"
 	InitIssueIndexer(true)
@@ -81,9 +82,8 @@ func searchIssueWithKeyword(t *testing.T) {
 
 	for _, test := range tests {
 		issueIDs, _, err := SearchIssues(context.TODO(), &test.opts)
-		if !assert.NoError(t, err) {
-			return
-		}
+		require.NoError(t, err)
+
 		assert.Equal(t, test.expectedIDs, issueIDs)
 	}
 }
@@ -127,9 +127,8 @@ func searchIssueInRepo(t *testing.T) {
 
 	for _, test := range tests {
 		issueIDs, _, err := SearchIssues(context.TODO(), &test.opts)
-		if !assert.NoError(t, err) {
-			return
-		}
+		require.NoError(t, err)
+
 		assert.Equal(t, test.expectedIDs, issueIDs)
 	}
 }
@@ -199,9 +198,7 @@ func searchIssueByID(t *testing.T) {
 
 	for _, test := range tests {
 		issueIDs, _, err := SearchIssues(context.TODO(), &test.opts)
-		if !assert.NoError(t, err) {
-			return
-		}
+		require.NoError(t, err)
 		assert.Equal(t, test.expectedIDs, issueIDs)
 	}
 }
@@ -226,9 +223,8 @@ func searchIssueIsPull(t *testing.T) {
 	}
 	for _, test := range tests {
 		issueIDs, _, err := SearchIssues(context.TODO(), &test.opts)
-		if !assert.NoError(t, err) {
-			return
-		}
+		require.NoError(t, err)
+
 		assert.Equal(t, test.expectedIDs, issueIDs)
 	}
 }
@@ -253,9 +249,7 @@ func searchIssueIsClosed(t *testing.T) {
 	}
 	for _, test := range tests {
 		issueIDs, _, err := SearchIssues(context.TODO(), &test.opts)
-		if !assert.NoError(t, err) {
-			return
-		}
+		require.NoError(t, err)
 		assert.Equal(t, test.expectedIDs, issueIDs)
 	}
 }
@@ -280,9 +274,8 @@ func searchIssueByMilestoneID(t *testing.T) {
 	}
 	for _, test := range tests {
 		issueIDs, _, err := SearchIssues(context.TODO(), &test.opts)
-		if !assert.NoError(t, err) {
-			return
-		}
+		require.NoError(t, err)
+
 		assert.Equal(t, test.expectedIDs, issueIDs)
 	}
 }
@@ -313,9 +306,8 @@ func searchIssueByLabelID(t *testing.T) {
 	}
 	for _, test := range tests {
 		issueIDs, _, err := SearchIssues(context.TODO(), &test.opts)
-		if !assert.NoError(t, err) {
-			return
-		}
+		require.NoError(t, err)
+
 		assert.Equal(t, test.expectedIDs, issueIDs)
 	}
 }
@@ -334,9 +326,8 @@ func searchIssueByTime(t *testing.T) {
 	}
 	for _, test := range tests {
 		issueIDs, _, err := SearchIssues(context.TODO(), &test.opts)
-		if !assert.NoError(t, err) {
-			return
-		}
+		require.NoError(t, err)
+
 		assert.Equal(t, test.expectedIDs, issueIDs)
 	}
 }
@@ -355,9 +346,8 @@ func searchIssueWithOrder(t *testing.T) {
 	}
 	for _, test := range tests {
 		issueIDs, _, err := SearchIssues(context.TODO(), &test.opts)
-		if !assert.NoError(t, err) {
-			return
-		}
+		require.NoError(t, err)
+
 		assert.Equal(t, test.expectedIDs, issueIDs)
 	}
 }
@@ -388,9 +378,8 @@ func searchIssueInProject(t *testing.T) {
 	}
 	for _, test := range tests {
 		issueIDs, _, err := SearchIssues(context.TODO(), &test.opts)
-		if !assert.NoError(t, err) {
-			return
-		}
+		require.NoError(t, err)
+
 		assert.Equal(t, test.expectedIDs, issueIDs)
 	}
 }
@@ -413,9 +402,8 @@ func searchIssueWithPaginator(t *testing.T) {
 	}
 	for _, test := range tests {
 		issueIDs, total, err := SearchIssues(context.TODO(), &test.opts)
-		if !assert.NoError(t, err) {
-			return
-		}
+		require.NoError(t, err)
+
 		assert.Equal(t, test.expectedIDs, issueIDs)
 		assert.Equal(t, test.expectedTotal, total)
 	}

modules/indexer/issues/internal/tests/tests.go

@@ -113,7 +113,7 @@ var cases = []*testIndexerCase{
 			},
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, 5, len(result.Hits))
+			assert.Len(t, result.Hits, 5)
 			assert.Equal(t, len(data), int(result.Total))
 		},
 	},
@@ -190,7 +190,7 @@ var cases = []*testIndexerCase{
 			IsPull: optional.Some(false),
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, 5, len(result.Hits))
+			assert.Len(t, result.Hits, 5)
 			for _, v := range result.Hits {
 				assert.False(t, data[v.ID].IsPull)
 			}
@@ -206,7 +206,7 @@ var cases = []*testIndexerCase{
 			IsPull: optional.Some(true),
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, 5, len(result.Hits))
+			assert.Len(t, result.Hits, 5)
 			for _, v := range result.Hits {
 				assert.True(t, data[v.ID].IsPull)
 			}
@@ -222,7 +222,7 @@ var cases = []*testIndexerCase{
 			IsClosed: optional.Some(false),
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, 5, len(result.Hits))
+			assert.Len(t, result.Hits, 5)
 			for _, v := range result.Hits {
 				assert.False(t, data[v.ID].IsClosed)
 			}
@@ -238,7 +238,7 @@ var cases = []*testIndexerCase{
 			IsClosed: optional.Some(true),
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, 5, len(result.Hits))
+			assert.Len(t, result.Hits, 5)
 			for _, v := range result.Hits {
 				assert.True(t, data[v.ID].IsClosed)
 			}
@@ -288,7 +288,7 @@ var cases = []*testIndexerCase{
 			MilestoneIDs: []int64{1, 2, 6},
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, 5, len(result.Hits))
+			assert.Len(t, result.Hits, 5)
 			for _, v := range result.Hits {
 				assert.Contains(t, []int64{1, 2, 6}, data[v.ID].MilestoneID)
 			}
@@ -306,7 +306,7 @@ var cases = []*testIndexerCase{
 			MilestoneIDs: []int64{0},
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, 5, len(result.Hits))
+			assert.Len(t, result.Hits, 5)
 			for _, v := range result.Hits {
 				assert.Equal(t, int64(0), data[v.ID].MilestoneID)
 			}
@@ -324,7 +324,7 @@ var cases = []*testIndexerCase{
 			ProjectID: optional.Some(int64(1)),
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, 5, len(result.Hits))
+			assert.Len(t, result.Hits, 5)
 			for _, v := range result.Hits {
 				assert.Equal(t, int64(1), data[v.ID].ProjectID)
 			}
@@ -342,7 +342,7 @@ var cases = []*testIndexerCase{
 			ProjectID: optional.Some(int64(0)),
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, 5, len(result.Hits))
+			assert.Len(t, result.Hits, 5)
 			for _, v := range result.Hits {
 				assert.Equal(t, int64(0), data[v.ID].ProjectID)
 			}
@@ -360,7 +360,7 @@ var cases = []*testIndexerCase{
 			ProjectColumnID: optional.Some(int64(1)),
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, 5, len(result.Hits))
+			assert.Len(t, result.Hits, 5)
 			for _, v := range result.Hits {
 				assert.Equal(t, int64(1), data[v.ID].ProjectColumnID)
 			}
@@ -378,7 +378,7 @@ var cases = []*testIndexerCase{
 			ProjectColumnID: optional.Some(int64(0)),
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, 5, len(result.Hits))
+			assert.Len(t, result.Hits, 5)
 			for _, v := range result.Hits {
 				assert.Equal(t, int64(0), data[v.ID].ProjectColumnID)
 			}
@@ -396,7 +396,7 @@ var cases = []*testIndexerCase{
 			PosterID: optional.Some(int64(1)),
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, 5, len(result.Hits))
+			assert.Len(t, result.Hits, 5)
 			for _, v := range result.Hits {
 				assert.Equal(t, int64(1), data[v.ID].PosterID)
 			}
@@ -414,7 +414,7 @@ var cases = []*testIndexerCase{
 			AssigneeID: optional.Some(int64(1)),
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, 5, len(result.Hits))
+			assert.Len(t, result.Hits, 5)
 			for _, v := range result.Hits {
 				assert.Equal(t, int64(1), data[v.ID].AssigneeID)
 			}
@@ -432,7 +432,7 @@ var cases = []*testIndexerCase{
 			AssigneeID: optional.Some(int64(0)),
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, 5, len(result.Hits))
+			assert.Len(t, result.Hits, 5)
 			for _, v := range result.Hits {
 				assert.Equal(t, int64(0), data[v.ID].AssigneeID)
 			}
@@ -450,7 +450,7 @@ var cases = []*testIndexerCase{
 			MentionID: optional.Some(int64(1)),
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, 5, len(result.Hits))
+			assert.Len(t, result.Hits, 5)
 			for _, v := range result.Hits {
 				assert.Contains(t, data[v.ID].MentionIDs, int64(1))
 			}
@@ -468,7 +468,7 @@ var cases = []*testIndexerCase{
 			ReviewedID: optional.Some(int64(1)),
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, 5, len(result.Hits))
+			assert.Len(t, result.Hits, 5)
 			for _, v := range result.Hits {
 				assert.Contains(t, data[v.ID].ReviewedIDs, int64(1))
 			}
@@ -486,7 +486,7 @@ var cases = []*testIndexerCase{
 			ReviewRequestedID: optional.Some(int64(1)),
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, 5, len(result.Hits))
+			assert.Len(t, result.Hits, 5)
 			for _, v := range result.Hits {
 				assert.Contains(t, data[v.ID].ReviewRequestedIDs, int64(1))
 			}
@@ -504,7 +504,7 @@ var cases = []*testIndexerCase{
 			SubscriberID: optional.Some(int64(1)),
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, 5, len(result.Hits))
+			assert.Len(t, result.Hits, 5)
 			for _, v := range result.Hits {
 				assert.Contains(t, data[v.ID].SubscriberIDs, int64(1))
 			}
@@ -523,7 +523,7 @@ var cases = []*testIndexerCase{
 			UpdatedBeforeUnix: optional.Some(int64(30)),
 		},
 		Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) {
-			assert.Equal(t, 5, len(result.Hits))
+			assert.Len(t, result.Hits, 5)
 			for _, v := range result.Hits {
 				assert.GreaterOrEqual(t, data[v.ID].UpdatedUnix, int64(20))
 				assert.LessOrEqual(t, data[v.ID].UpdatedUnix, int64(30))

modules/indexer/issues/meilisearch/meilisearch_test.go

@@ -15,6 +15,7 @@ import (
 
 	"github.com/meilisearch/meilisearch-go"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestMeilisearchIndexer(t *testing.T) {
@@ -58,7 +59,7 @@ func TestConvertHits(t *testing.T) {
 	_, err := convertHits(&meilisearch.SearchResponse{
 		Hits: []any{"aa", "bb", "cc", "dd"},
 	})
-	assert.ErrorIs(t, err, ErrMalformedResponse)
+	require.ErrorIs(t, err, ErrMalformedResponse)
 
 	validResponse := &meilisearch.SearchResponse{
 		Hits: []any{
@@ -83,7 +84,7 @@ func TestConvertHits(t *testing.T) {
 		},
 	}
 	hits, err := convertHits(validResponse)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, []internal.Match{{ID: 11}, {ID: 22}, {ID: 33}}, hits)
 }
 

modules/indexer/stats/indexer_test.go

@@ -19,6 +19,7 @@ import (
 	_ "code.gitea.io/gitea/models/activities"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestMain(m *testing.M) {
@@ -26,26 +27,26 @@ func TestMain(m *testing.M) {
 }
 
 func TestRepoStatsIndex(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
+	require.NoError(t, unittest.PrepareTestDatabase())
 	setting.CfgProvider, _ = setting.NewConfigProviderFromData("")
 
 	setting.LoadQueueSettings()
 
 	err := Init()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	repo, err := repo_model.GetRepositoryByID(db.DefaultContext, 1)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = UpdateRepoIndexer(repo)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
-	assert.NoError(t, queue.GetManager().FlushAll(context.Background(), 5*time.Second))
+	require.NoError(t, queue.GetManager().FlushAll(context.Background(), 5*time.Second))
 
 	status, err := repo_model.GetIndexerStatus(db.DefaultContext, repo, repo_model.RepoIndexerTypeStats)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "65f1bf27bc3bf70f64657658635e66094edbcb4d", status.CommitSha)
 	langs, err := repo_model.GetTopLanguageStats(db.DefaultContext, repo, 5)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Empty(t, langs)
 }

modules/lfs/http_client_test.go

@@ -14,6 +14,7 @@ import (
 	"code.gitea.io/gitea/modules/json"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 type RoundTripFunc func(req *http.Request) *http.Response
@@ -170,7 +171,7 @@ func TestHTTPClientDownload(t *testing.T) {
 
 		var batchRequest BatchRequest
 		err := json.NewDecoder(req.Body).Decode(&batchRequest)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		assert.Equal(t, "download", batchRequest.Operation)
 		assert.Len(t, batchRequest.Objects, 1)
@@ -261,14 +262,14 @@ func TestHTTPClientDownload(t *testing.T) {
 				return objectError
 			}
 			b, err := io.ReadAll(content)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, []byte("dummy"), b)
 			return nil
 		})
 		if len(c.expectederror) > 0 {
 			assert.True(t, strings.Contains(err.Error(), c.expectederror), "case %d: '%s' should contain '%s'", n, err.Error(), c.expectederror)
 		} else {
-			assert.NoError(t, err, "case %d", n)
+			require.NoError(t, err, "case %d", n)
 		}
 	}
 }
@@ -283,7 +284,7 @@ func TestHTTPClientUpload(t *testing.T) {
 
 		var batchRequest BatchRequest
 		err := json.NewDecoder(req.Body).Decode(&batchRequest)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		assert.Equal(t, "upload", batchRequest.Operation)
 		assert.Len(t, batchRequest.Objects, 1)
@@ -370,7 +371,7 @@ func TestHTTPClientUpload(t *testing.T) {
 		if len(c.expectederror) > 0 {
 			assert.True(t, strings.Contains(err.Error(), c.expectederror), "case %d: '%s' should contain '%s'", n, err.Error(), c.expectederror)
 		} else {
-			assert.NoError(t, err, "case %d", n)
+			require.NoError(t, err, "case %d", n)
 		}
 	}
 }

modules/lfs/pointer_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestStringContent(t *testing.T) {
@@ -45,7 +46,7 @@ func TestIsValid(t *testing.T) {
 
 func TestGeneratePointer(t *testing.T) {
 	p, err := GeneratePointer(strings.NewReader("Gitea"))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, p.IsValid())
 	assert.Equal(t, "94cb57646c54a297c9807697e80a30946f79a4b82cb079d2606847825b1812cc", p.Oid)
 	assert.Equal(t, int64(5), p.Size)
@@ -53,41 +54,41 @@ func TestGeneratePointer(t *testing.T) {
 
 func TestReadPointerFromBuffer(t *testing.T) {
 	p, err := ReadPointerFromBuffer([]byte{})
-	assert.ErrorIs(t, err, ErrMissingPrefix)
+	require.ErrorIs(t, err, ErrMissingPrefix)
 	assert.False(t, p.IsValid())
 
 	p, err = ReadPointerFromBuffer([]byte("test"))
-	assert.ErrorIs(t, err, ErrMissingPrefix)
+	require.ErrorIs(t, err, ErrMissingPrefix)
 	assert.False(t, p.IsValid())
 
 	p, err = ReadPointerFromBuffer([]byte("version https://git-lfs.github.com/spec/v1\n"))
-	assert.ErrorIs(t, err, ErrInvalidStructure)
+	require.ErrorIs(t, err, ErrInvalidStructure)
 	assert.False(t, p.IsValid())
 
 	p, err = ReadPointerFromBuffer([]byte("version https://git-lfs.github.com/spec/v1\noid sha256:4d7a\nsize 1234\n"))
-	assert.ErrorIs(t, err, ErrInvalidOIDFormat)
+	require.ErrorIs(t, err, ErrInvalidOIDFormat)
 	assert.False(t, p.IsValid())
 
 	p, err = ReadPointerFromBuffer([]byte("version https://git-lfs.github.com/spec/v1\noid sha256:4d7a2146z4ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393\nsize 1234\n"))
-	assert.ErrorIs(t, err, ErrInvalidOIDFormat)
+	require.ErrorIs(t, err, ErrInvalidOIDFormat)
 	assert.False(t, p.IsValid())
 
 	p, err = ReadPointerFromBuffer([]byte("version https://git-lfs.github.com/spec/v1\noid sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393\ntest 1234\n"))
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.False(t, p.IsValid())
 
 	p, err = ReadPointerFromBuffer([]byte("version https://git-lfs.github.com/spec/v1\noid sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393\nsize test\n"))
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.False(t, p.IsValid())
 
 	p, err = ReadPointerFromBuffer([]byte("version https://git-lfs.github.com/spec/v1\noid sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393\nsize 1234\n"))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, p.IsValid())
 	assert.Equal(t, "4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393", p.Oid)
 	assert.Equal(t, int64(1234), p.Size)
 
 	p, err = ReadPointerFromBuffer([]byte("version https://git-lfs.github.com/spec/v1\noid sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393\nsize 1234\ntest"))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, p.IsValid())
 	assert.Equal(t, "4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393", p.Oid)
 	assert.Equal(t, int64(1234), p.Size)
@@ -95,7 +96,7 @@ func TestReadPointerFromBuffer(t *testing.T) {
 
 func TestReadPointer(t *testing.T) {
 	p, err := ReadPointer(strings.NewReader("version https://git-lfs.github.com/spec/v1\noid sha256:4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393\nsize 1234\n"))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, p.IsValid())
 	assert.Equal(t, "4d7a214614ab2935c943f9e0ff69d22eadbb8f32b1258daaa5e2ca24d17e2393", p.Oid)
 	assert.Equal(t, int64(1234), p.Size)

modules/lfs/transferadapter_test.go

@@ -14,6 +14,7 @@ import (
 	"code.gitea.io/gitea/modules/json"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestBasicTransferAdapterName(t *testing.T) {
@@ -39,7 +40,7 @@ func TestBasicTransferAdapter(t *testing.T) {
 			assert.Equal(t, "application/octet-stream", req.Header.Get("Content-Type"))
 
 			b, err := io.ReadAll(req.Body)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, "dummy", string(b))
 
 			return &http.Response{StatusCode: http.StatusOK}
@@ -49,7 +50,7 @@ func TestBasicTransferAdapter(t *testing.T) {
 
 			var vp Pointer
 			err := json.NewDecoder(req.Body).Decode(&vp)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, p.Oid, vp.Oid)
 			assert.Equal(t, p.Size, vp.Size)
 
@@ -98,7 +99,7 @@ func TestBasicTransferAdapter(t *testing.T) {
 			if len(c.expectederror) > 0 {
 				assert.True(t, strings.Contains(err.Error(), c.expectederror), "case %d: '%s' should contain '%s'", n, err.Error(), c.expectederror)
 			} else {
-				assert.NoError(t, err, "case %d", n)
+				require.NoError(t, err, "case %d", n)
 			}
 		}
 	})
@@ -131,7 +132,7 @@ func TestBasicTransferAdapter(t *testing.T) {
 			if len(c.expectederror) > 0 {
 				assert.True(t, strings.Contains(err.Error(), c.expectederror), "case %d: '%s' should contain '%s'", n, err.Error(), c.expectederror)
 			} else {
-				assert.NoError(t, err, "case %d", n)
+				require.NoError(t, err, "case %d", n)
 			}
 		}
 	})
@@ -164,7 +165,7 @@ func TestBasicTransferAdapter(t *testing.T) {
 			if len(c.expectederror) > 0 {
 				assert.True(t, strings.Contains(err.Error(), c.expectederror), "case %d: '%s' should contain '%s'", n, err.Error(), c.expectederror)
 			} else {
-				assert.NoError(t, err, "case %d", n)
+				require.NoError(t, err, "case %d", n)
 			}
 		}
 	})

modules/log/event_writer_conn_test.go

@@ -14,15 +14,16 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func listenReadAndClose(t *testing.T, l net.Listener, expected string) {
 	conn, err := l.Accept()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer conn.Close()
 	written, err := io.ReadAll(conn)
 
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, string(written))
 }
 

modules/log/flags_test.go

@@ -9,6 +9,7 @@ import (
 	"code.gitea.io/gitea/modules/json"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestFlags(t *testing.T) {
@@ -22,9 +23,9 @@ func TestFlags(t *testing.T) {
 	assert.EqualValues(t, "medfile", FlagsFromString("medfile").String())
 
 	bs, err := json.Marshal(FlagsFromString("utc,level"))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, `"level,utc"`, string(bs))
 	var flags Flags
-	assert.NoError(t, json.Unmarshal(bs, &flags))
+	require.NoError(t, json.Unmarshal(bs, &flags))
 	assert.EqualValues(t, LUTC|Llevel, flags.Bits())
 }

modules/log/level_test.go

@@ -10,6 +10,7 @@ import (
 	"code.gitea.io/gitea/modules/json"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 type testLevel struct {
@@ -20,34 +21,34 @@ func TestLevelMarshalUnmarshalJSON(t *testing.T) {
 	levelBytes, err := json.Marshal(testLevel{
 		Level: INFO,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, string(makeTestLevelBytes(INFO.String())), string(levelBytes))
 
 	var testLevel testLevel
 	err = json.Unmarshal(levelBytes, &testLevel)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, INFO, testLevel.Level)
 
 	err = json.Unmarshal(makeTestLevelBytes(`FOFOO`), &testLevel)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, INFO, testLevel.Level)
 
 	err = json.Unmarshal([]byte(fmt.Sprintf(`{"level":%d}`, 2)), &testLevel)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, INFO, testLevel.Level)
 
 	err = json.Unmarshal([]byte(fmt.Sprintf(`{"level":%d}`, 10012)), &testLevel)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, INFO, testLevel.Level)
 
 	err = json.Unmarshal([]byte(`{"level":{}}`), &testLevel)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, INFO, testLevel.Level)
 
 	assert.Equal(t, INFO.String(), Level(1001).String())
 
 	err = json.Unmarshal([]byte(`{"level":{}`), &testLevel.Level)
-	assert.Error(t, err)
+	require.Error(t, err)
 }
 
 func makeTestLevelBytes(level string) []byte {

modules/log/logger_test.go

@@ -56,7 +56,7 @@ func TestLogger(t *testing.T) {
 	logger := NewLoggerWithWriters(context.Background(), "test")
 
 	dump := logger.DumpWriters()
-	assert.EqualValues(t, 0, len(dump))
+	assert.Empty(t, dump)
 	assert.EqualValues(t, NONE, logger.GetLevel())
 	assert.False(t, logger.IsEnabled())
 
@@ -69,7 +69,7 @@ func TestLogger(t *testing.T) {
 	assert.EqualValues(t, DEBUG, logger.GetLevel())
 
 	dump = logger.DumpWriters()
-	assert.EqualValues(t, 2, len(dump))
+	assert.Len(t, dump, 2)
 
 	logger.Trace("trace-level") // this level is not logged
 	logger.Debug("debug-level")

modules/log/manager_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestSharedWorker(t *testing.T) {
@@ -16,7 +17,7 @@ func TestSharedWorker(t *testing.T) {
 
 	m := NewManager()
 	_, err := m.NewSharedWriter("dummy-1", "dummy", WriterMode{Level: DEBUG, Flags: FlagsFromBits(0)})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	w := m.GetSharedWriter("dummy-1")
 	assert.NotNil(t, w)

modules/markup/console/console_test.go

@@ -11,6 +11,7 @@ import (
 	"code.gitea.io/gitea/modules/markup"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestRenderConsole(t *testing.T) {
@@ -26,7 +27,7 @@ func TestRenderConsole(t *testing.T) {
 
 		err := render.Render(&markup.RenderContext{Ctx: git.DefaultContext},
 			strings.NewReader(k), &buf)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.EqualValues(t, v, buf.String())
 	}
 }

modules/markup/csv/csv_test.go

@@ -11,6 +11,7 @@ import (
 	"code.gitea.io/gitea/modules/markup"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestRenderCSV(t *testing.T) {
@@ -26,7 +27,7 @@ func TestRenderCSV(t *testing.T) {
 		var buf strings.Builder
 		err := render.Render(&markup.RenderContext{Ctx: git.DefaultContext},
 			strings.NewReader(k), &buf)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.EqualValues(t, v, buf.String())
 	}
 }

modules/markup/html_internal_test.go

@@ -14,6 +14,7 @@ import (
 	"code.gitea.io/gitea/modules/util"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const (
@@ -294,7 +295,7 @@ func testRenderIssueIndexPattern(t *testing.T, input, expected string, ctx *Rend
 
 	var buf strings.Builder
 	err := postProcess(ctx, []processor{issueIndexPatternProcessor}, strings.NewReader(input), &buf)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, buf.String(), "input=%q", input)
 }
 
@@ -310,7 +311,7 @@ func TestRender_AutoLink(t *testing.T) {
 			},
 			Metas: localMetas,
 		}, strings.NewReader(input), &buffer)
-		assert.Equal(t, err, nil)
+		require.NoError(t, err, nil)
 		assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(buffer.String()))
 
 		buffer.Reset()
@@ -322,7 +323,7 @@ func TestRender_AutoLink(t *testing.T) {
 			Metas:  localMetas,
 			IsWiki: true,
 		}, strings.NewReader(input), &buffer)
-		assert.Equal(t, err, nil)
+		require.NoError(t, err)
 		assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(buffer.String()))
 	}
 
@@ -353,7 +354,7 @@ func TestRender_FullIssueURLs(t *testing.T) {
 			},
 			Metas: localMetas,
 		}, []processor{fullIssuePatternProcessor}, strings.NewReader(input), &result)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, expected, result.String())
 	}
 	test("Here is a link https://git.osgeo.org/gogs/postgis/postgis/pulls/6",

modules/markup/html_test.go

@@ -51,7 +51,7 @@ func TestRender_Commits(t *testing.T) {
 			},
 			Metas: localMetas,
 		}, input)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(buffer))
 	}
 
@@ -105,7 +105,7 @@ func TestRender_CrossReferences(t *testing.T) {
 			},
 			Metas: localMetas,
 		}, input)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(buffer))
 	}
 
@@ -146,7 +146,7 @@ func TestRender_links(t *testing.T) {
 				Base: markup.TestRepoURL,
 			},
 		}, input)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(buffer))
 	}
 	// Text that should be turned into URL
@@ -248,7 +248,7 @@ func TestRender_email(t *testing.T) {
 				Base: markup.TestRepoURL,
 			},
 		}, input)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(res))
 	}
 	// Text that should be turned into email link
@@ -321,7 +321,7 @@ func TestRender_emoji(t *testing.T) {
 				Base: markup.TestRepoURL,
 			},
 		}, input)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(buffer))
 	}
 
@@ -387,7 +387,7 @@ func TestRender_ShortLinks(t *testing.T) {
 				BranchPath: "master",
 			},
 		}, input)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(buffer)))
 		buffer, err = markdown.RenderString(&markup.RenderContext{
 			Ctx: git.DefaultContext,
@@ -397,7 +397,7 @@ func TestRender_ShortLinks(t *testing.T) {
 			Metas:  localMetas,
 			IsWiki: true,
 		}, input)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, strings.TrimSpace(expectedWiki), strings.TrimSpace(string(buffer)))
 	}
 
@@ -500,7 +500,7 @@ func TestRender_RelativeImages(t *testing.T) {
 			},
 			Metas: localMetas,
 		}, input)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(buffer)))
 		buffer, err = markdown.RenderString(&markup.RenderContext{
 			Ctx: git.DefaultContext,
@@ -510,7 +510,7 @@ func TestRender_RelativeImages(t *testing.T) {
 			Metas:  localMetas,
 			IsWiki: true,
 		}, input)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, strings.TrimSpace(expectedWiki), strings.TrimSpace(string(buffer)))
 	}
 
@@ -546,7 +546,7 @@ func Test_ParseClusterFuzz(t *testing.T) {
 		},
 		Metas: localMetas,
 	}, strings.NewReader(data), &res)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotContains(t, res.String(), "<html")
 
 	data = "<!DOCTYPE html>\n<A><maTH><tr><MN><bodY ÿ><temPlate></template><tH><tr></A><tH><d<bodY "
@@ -560,7 +560,7 @@ func Test_ParseClusterFuzz(t *testing.T) {
 		Metas: localMetas,
 	}, strings.NewReader(data), &res)
 
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotContains(t, res.String(), "<html")
 }
 
@@ -584,7 +584,7 @@ func TestPostProcess_RenderDocument(t *testing.T) {
 			},
 			Metas: localMetas,
 		}, strings.NewReader(input), &res)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(res.String()))
 	}
 
@@ -624,7 +624,7 @@ func TestIssue16020(t *testing.T) {
 		Ctx:   git.DefaultContext,
 		Metas: localMetas,
 	}, strings.NewReader(data), &res)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, data, res.String())
 }
 
@@ -640,7 +640,7 @@ func BenchmarkEmojiPostprocess(b *testing.B) {
 			Ctx:   git.DefaultContext,
 			Metas: localMetas,
 		}, strings.NewReader(data), &res)
-		assert.NoError(b, err)
+		require.NoError(b, err)
 	}
 }
 
@@ -659,7 +659,7 @@ func TestFuzz(t *testing.T) {
 
 	err := markup.PostProcess(&renderContext, strings.NewReader(s), io.Discard)
 
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestIssue18471(t *testing.T) {
@@ -671,7 +671,7 @@ func TestIssue18471(t *testing.T) {
 		Metas: localMetas,
 	}, strings.NewReader(data), &res)
 
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "<a href=\"http://domain/org/repo/compare/783b039...da951ce\" class=\"compare\"><code class=\"nohighlight\">783b039...da951ce</code></a>", res.String())
 }
 
@@ -707,7 +707,7 @@ func TestRender_FilePreview(t *testing.T) {
 			RelativePath: ".md",
 			Metas:        metas,
 		}, input)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(buffer))
 	}
 

modules/markup/markdown/markdown_test.go

@@ -20,6 +20,7 @@ import (
 	"code.gitea.io/gitea/modules/util"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const (
@@ -57,7 +58,7 @@ func TestRender_StandardLinks(t *testing.T) {
 				Base: FullURL,
 			},
 		}, input)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(buffer)))
 
 		buffer, err = markdown.RenderString(&markup.RenderContext{
@@ -67,7 +68,7 @@ func TestRender_StandardLinks(t *testing.T) {
 			},
 			IsWiki: true,
 		}, input)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, strings.TrimSpace(expectedWiki), strings.TrimSpace(string(buffer)))
 	}
 
@@ -91,7 +92,7 @@ func TestRender_Images(t *testing.T) {
 				Base: FullURL,
 			},
 		}, input)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(buffer)))
 	}
 
@@ -300,7 +301,7 @@ func TestTotal_RenderWiki(t *testing.T) {
 			Metas:  localMetas,
 			IsWiki: true,
 		}, sameCases[i])
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, template.HTML(answers[i]), line)
 	}
 
@@ -325,7 +326,7 @@ func TestTotal_RenderWiki(t *testing.T) {
 			},
 			IsWiki: true,
 		}, testCases[i])
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, template.HTML(testCases[i+1]), line)
 	}
 }
@@ -344,7 +345,7 @@ func TestTotal_RenderString(t *testing.T) {
 			},
 			Metas: localMetas,
 		}, sameCases[i])
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, template.HTML(answers[i]), line)
 	}
 
@@ -357,7 +358,7 @@ func TestTotal_RenderString(t *testing.T) {
 				Base: FullURL,
 			},
 		}, testCases[i])
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, template.HTML(testCases[i+1]), line)
 	}
 }
@@ -365,17 +366,17 @@ func TestTotal_RenderString(t *testing.T) {
 func TestRender_RenderParagraphs(t *testing.T) {
 	test := func(t *testing.T, str string, cnt int) {
 		res, err := markdown.RenderRawString(&markup.RenderContext{Ctx: git.DefaultContext}, str)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, cnt, strings.Count(res, "<p"), "Rendered result for unix should have %d paragraph(s) but has %d:\n%s\n", cnt, strings.Count(res, "<p"), res)
 
 		mac := strings.ReplaceAll(str, "\n", "\r")
 		res, err = markdown.RenderRawString(&markup.RenderContext{Ctx: git.DefaultContext}, mac)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, cnt, strings.Count(res, "<p"), "Rendered result for mac should have %d paragraph(s) but has %d:\n%s\n", cnt, strings.Count(res, "<p"), res)
 
 		dos := strings.ReplaceAll(str, "\n", "\r\n")
 		res, err = markdown.RenderRawString(&markup.RenderContext{Ctx: git.DefaultContext}, dos)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, cnt, strings.Count(res, "<p"), "Rendered result for windows should have %d paragraph(s) but has %d:\n%s\n", cnt, strings.Count(res, "<p"), res)
 	}
 
@@ -403,7 +404,7 @@ func TestMarkdownRenderRaw(t *testing.T) {
 	for _, testcase := range testcases {
 		log.Info("Test markdown render error with fuzzy data: %x, the following errors can be recovered", testcase)
 		_, err := markdown.RenderRawString(&markup.RenderContext{Ctx: git.DefaultContext}, string(testcase))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 }
 
@@ -415,7 +416,7 @@ func TestRenderSiblingImages_Issue12925(t *testing.T) {
 <a href="/image2" target="_blank" rel="nofollow noopener"><img src="/image2" alt="image2"></a></p>
 `
 	res, err := markdown.RenderRawString(&markup.RenderContext{Ctx: git.DefaultContext}, testcase)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, res)
 }
 
@@ -424,7 +425,7 @@ func TestRenderEmojiInLinks_Issue12331(t *testing.T) {
 	expected := `<p><a href="https://gitea.io" rel="nofollow">Link with emoji <span class="emoji" aria-label="waxing gibbous moon">🌔</span> in text</a></p>
 `
 	res, err := markdown.RenderString(&markup.RenderContext{Ctx: git.DefaultContext}, testcase)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, template.HTML(expected), res)
 }
 
@@ -458,7 +459,7 @@ func TestColorPreview(t *testing.T) {
 
 	for _, test := range positiveTests {
 		res, err := markdown.RenderString(&markup.RenderContext{Ctx: git.DefaultContext}, test.testcase)
-		assert.NoError(t, err, "Unexpected error in testcase: %q", test.testcase)
+		require.NoError(t, err, "Unexpected error in testcase: %q", test.testcase)
 		assert.Equal(t, template.HTML(test.expected), res, "Unexpected result in testcase %q", test.testcase)
 	}
 
@@ -477,7 +478,7 @@ func TestColorPreview(t *testing.T) {
 
 	for _, test := range negativeTests {
 		res, err := markdown.RenderString(&markup.RenderContext{Ctx: git.DefaultContext}, test)
-		assert.NoError(t, err, "Unexpected error in testcase: %q", test)
+		require.NoError(t, err, "Unexpected error in testcase: %q", test)
 		assert.NotContains(t, res, `<span class="color-preview" style="background-color: `, "Unexpected result in testcase %q", test)
 	}
 }
@@ -564,7 +565,7 @@ func TestMathBlock(t *testing.T) {
 
 	for _, test := range testcases {
 		res, err := markdown.RenderString(&markup.RenderContext{Ctx: git.DefaultContext}, test.testcase)
-		assert.NoError(t, err, "Unexpected error in testcase: %q", test.testcase)
+		require.NoError(t, err, "Unexpected error in testcase: %q", test.testcase)
 		assert.Equal(t, template.HTML(test.expected), res, "Unexpected result in testcase %q", test.testcase)
 	}
 }
@@ -762,7 +763,7 @@ Citation needed[^0].`,
 	}
 	for _, test := range testcases {
 		res, err := markdown.RenderString(&markup.RenderContext{Ctx: git.DefaultContext}, test.testcase)
-		assert.NoError(t, err, "Unexpected error in testcase: %q", test.testcase)
+		require.NoError(t, err, "Unexpected error in testcase: %q", test.testcase)
 		assert.Equal(t, test.expected, string(res), "Unexpected result in testcase %q", test.testcase)
 	}
 }
@@ -799,7 +800,7 @@ foo: bar
 
 	for _, test := range testcases {
 		res, err := markdown.RenderString(&markup.RenderContext{Ctx: git.DefaultContext}, test.testcase)
-		assert.NoError(t, err, "Unexpected error in testcase: %q", test.testcase)
+		require.NoError(t, err, "Unexpected error in testcase: %q", test.testcase)
 		assert.Equal(t, template.HTML(test.expected), res, "Unexpected result in testcase %q", test.testcase)
 	}
 }
@@ -1190,7 +1191,7 @@ space</p>
 
 	for i, c := range cases {
 		result, err := markdown.RenderString(&markup.RenderContext{Ctx: context.Background(), Links: c.Links, IsWiki: c.IsWiki}, input)
-		assert.NoError(t, err, "Unexpected error in testcase: %v", i)
+		require.NoError(t, err, "Unexpected error in testcase: %v", i)
 		assert.Equal(t, template.HTML(c.Expected), result, "Unexpected result in testcase %v", i)
 	}
 }
@@ -1207,7 +1208,7 @@ func TestCustomMarkdownURL(t *testing.T) {
 				BranchPath: "branch/main",
 			},
 		}, input)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(buffer)))
 	}
 
@@ -1226,7 +1227,7 @@ func TestYAMLMeta(t *testing.T) {
 		buffer, err := markdown.RenderString(&markup.RenderContext{
 			Ctx: git.DefaultContext,
 		}, input)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(buffer)))
 	}
 
@@ -1350,7 +1351,7 @@ func TestCallout(t *testing.T) {
 		buffer, err := markdown.RenderString(&markup.RenderContext{
 			Ctx: git.DefaultContext,
 		}, input)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(string(buffer)))
 	}
 

modules/markup/markdown/meta_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 /*
@@ -31,7 +32,7 @@ func TestExtractMetadata(t *testing.T) {
 	t.Run("ValidFrontAndBody", func(t *testing.T) {
 		var meta IssueTemplate
 		body, err := ExtractMetadata(fmt.Sprintf("%s\n%s\n%s\n%s", sepTest, frontTest, sepTest, bodyTest), &meta)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, bodyTest, body)
 		assert.Equal(t, metaTest, meta)
 		assert.True(t, meta.Valid())
@@ -40,19 +41,19 @@ func TestExtractMetadata(t *testing.T) {
 	t.Run("NoFirstSeparator", func(t *testing.T) {
 		var meta IssueTemplate
 		_, err := ExtractMetadata(fmt.Sprintf("%s\n%s\n%s", frontTest, sepTest, bodyTest), &meta)
-		assert.Error(t, err)
+		require.Error(t, err)
 	})
 
 	t.Run("NoLastSeparator", func(t *testing.T) {
 		var meta IssueTemplate
 		_, err := ExtractMetadata(fmt.Sprintf("%s\n%s\n%s", sepTest, frontTest, bodyTest), &meta)
-		assert.Error(t, err)
+		require.Error(t, err)
 	})
 
 	t.Run("NoBody", func(t *testing.T) {
 		var meta IssueTemplate
 		body, err := ExtractMetadata(fmt.Sprintf("%s\n%s\n%s", sepTest, frontTest, sepTest), &meta)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, "", body)
 		assert.Equal(t, metaTest, meta)
 		assert.True(t, meta.Valid())
@@ -63,7 +64,7 @@ func TestExtractMetadataBytes(t *testing.T) {
 	t.Run("ValidFrontAndBody", func(t *testing.T) {
 		var meta IssueTemplate
 		body, err := ExtractMetadataBytes([]byte(fmt.Sprintf("%s\n%s\n%s\n%s", sepTest, frontTest, sepTest, bodyTest)), &meta)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, bodyTest, string(body))
 		assert.Equal(t, metaTest, meta)
 		assert.True(t, meta.Valid())
@@ -72,19 +73,19 @@ func TestExtractMetadataBytes(t *testing.T) {
 	t.Run("NoFirstSeparator", func(t *testing.T) {
 		var meta IssueTemplate
 		_, err := ExtractMetadataBytes([]byte(fmt.Sprintf("%s\n%s\n%s", frontTest, sepTest, bodyTest)), &meta)
-		assert.Error(t, err)
+		require.Error(t, err)
 	})
 
 	t.Run("NoLastSeparator", func(t *testing.T) {
 		var meta IssueTemplate
 		_, err := ExtractMetadataBytes([]byte(fmt.Sprintf("%s\n%s\n%s", sepTest, frontTest, bodyTest)), &meta)
-		assert.Error(t, err)
+		require.Error(t, err)
 	})
 
 	t.Run("NoBody", func(t *testing.T) {
 		var meta IssueTemplate
 		body, err := ExtractMetadataBytes([]byte(fmt.Sprintf("%s\n%s\n%s", sepTest, frontTest, sepTest)), &meta)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, "", string(body))
 		assert.Equal(t, metaTest, meta)
 		assert.True(t, meta.Valid())

modules/markup/orgmode/orgmode_test.go

@@ -13,6 +13,7 @@ import (
 	"code.gitea.io/gitea/modules/util"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const (
@@ -32,7 +33,7 @@ func TestRender_StandardLinks(t *testing.T) {
 				Base: setting.AppSubURL,
 			},
 		}, input)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(buffer))
 	}
 
@@ -60,7 +61,7 @@ func TestRender_BaseLinks(t *testing.T) {
 				BranchPath: "branch/main",
 			},
 		}, input)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(buffer))
 	}
 
@@ -73,7 +74,7 @@ func TestRender_BaseLinks(t *testing.T) {
 				TreePath:   "deep/nested/folder",
 			},
 		}, input)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(buffer))
 	}
 
@@ -99,7 +100,7 @@ func TestRender_Media(t *testing.T) {
 				Base: setting.AppSubURL,
 			},
 		}, input)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(buffer))
 	}
 
@@ -140,7 +141,7 @@ func TestRender_Source(t *testing.T) {
 		buffer, err := RenderString(&markup.RenderContext{
 			Ctx: git.DefaultContext,
 		}, input)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, strings.TrimSpace(expected), strings.TrimSpace(buffer))
 	}
 

modules/migration/file_format_test.go

@@ -9,14 +9,15 @@ import (
 
 	"github.com/santhosh-tekuri/jsonschema/v6"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestMigrationJSON_IssueOK(t *testing.T) {
 	issues := make([]*Issue, 0, 10)
 	err := Load("file_format_testdata/issue_a.json", &issues, true)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = Load("file_format_testdata/issue_a.yml", &issues, true)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestMigrationJSON_IssueFail(t *testing.T) {
@@ -34,5 +35,5 @@ func TestMigrationJSON_IssueFail(t *testing.T) {
 func TestMigrationJSON_MilestoneOK(t *testing.T) {
 	milestones := make([]*Milestone, 0, 10)
 	err := Load("file_format_testdata/milestones.json", &milestones, true)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }

modules/optional/serialization_test.go

@@ -11,6 +11,7 @@ import (
 	"code.gitea.io/gitea/modules/optional"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"gopkg.in/yaml.v3"
 )
 
@@ -50,11 +51,11 @@ func TestOptionalToJson(t *testing.T) {
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 			b, err := json.Marshal(tc.obj)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.EqualValues(t, tc.want, string(b), "gitea json module returned unexpected")
 
 			b, err = std_json.Marshal(tc.obj)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.EqualValues(t, tc.want, string(b), "std json module returned unexpected")
 		})
 	}
@@ -88,12 +89,12 @@ func TestOptionalFromJson(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			var obj1 testSerializationStruct
 			err := json.Unmarshal([]byte(tc.data), &obj1)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.EqualValues(t, tc.want, obj1, "gitea json module returned unexpected")
 
 			var obj2 testSerializationStruct
 			err = std_json.Unmarshal([]byte(tc.data), &obj2)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.EqualValues(t, tc.want, obj2, "std json module returned unexpected")
 		})
 	}
@@ -134,7 +135,7 @@ optional_two_string: null
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 			b, err := yaml.Marshal(tc.obj)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.EqualValues(t, tc.want, string(b), "yaml module returned unexpected")
 		})
 	}
@@ -183,7 +184,7 @@ optional_twostring: null
 		t.Run(tc.name, func(t *testing.T) {
 			var obj testSerializationStruct
 			err := yaml.Unmarshal([]byte(tc.data), &obj)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.EqualValues(t, tc.want, obj, "yaml module returned unexpected")
 		})
 	}

modules/packages/alpine/metadata_test.go

@@ -11,6 +11,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const (
@@ -77,7 +78,7 @@ func TestParsePackage(t *testing.T) {
 
 		pp, err := ParsePackage(data)
 		assert.Nil(t, pp)
-		assert.ErrorIs(t, err, ErrMissingPKGINFOFile)
+		require.ErrorIs(t, err, ErrMissingPKGINFOFile)
 	})
 
 	t.Run("InvalidPKGINFOFile", func(t *testing.T) {
@@ -85,14 +86,14 @@ func TestParsePackage(t *testing.T) {
 
 		pp, err := ParsePackage(data)
 		assert.Nil(t, pp)
-		assert.ErrorIs(t, err, ErrInvalidName)
+		require.ErrorIs(t, err, ErrInvalidName)
 	})
 
 	t.Run("Valid", func(t *testing.T) {
 		data := createPackage(".PKGINFO", createPKGINFOContent(packageName, packageVersion))
 
 		p, err := ParsePackage(data)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.NotNil(t, p)
 
 		assert.Equal(t, "Q1SRYURM5+uQDqfHSwTnNIOIuuDVQ=", p.FileMetadata.Checksum)
@@ -105,7 +106,7 @@ func TestParsePackageInfo(t *testing.T) {
 
 		p, err := ParsePackageInfo(bytes.NewReader(data))
 		assert.Nil(t, p)
-		assert.ErrorIs(t, err, ErrInvalidName)
+		require.ErrorIs(t, err, ErrInvalidName)
 	})
 
 	t.Run("InvalidVersion", func(t *testing.T) {
@@ -113,14 +114,14 @@ func TestParsePackageInfo(t *testing.T) {
 
 		p, err := ParsePackageInfo(bytes.NewReader(data))
 		assert.Nil(t, p)
-		assert.ErrorIs(t, err, ErrInvalidVersion)
+		require.ErrorIs(t, err, ErrInvalidVersion)
 	})
 
 	t.Run("Valid", func(t *testing.T) {
 		data := createPKGINFOContent(packageName, packageVersion)
 
 		p, err := ParsePackageInfo(bytes.NewReader(data))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.NotNil(t, p)
 
 		assert.Equal(t, packageName, p.Name)

modules/packages/cargo/parser_test.go

@@ -11,6 +11,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const (
@@ -51,7 +52,7 @@ func TestParsePackage(t *testing.T) {
 
 			cp, err := ParsePackage(data)
 			assert.Nil(t, cp)
-			assert.ErrorIs(t, err, ErrInvalidName)
+			require.ErrorIs(t, err, ErrInvalidName)
 		}
 	})
 
@@ -61,7 +62,7 @@ func TestParsePackage(t *testing.T) {
 
 			cp, err := ParsePackage(data)
 			assert.Nil(t, cp)
-			assert.ErrorIs(t, err, ErrInvalidVersion)
+			require.ErrorIs(t, err, ErrInvalidVersion)
 		}
 	})
 
@@ -70,7 +71,7 @@ func TestParsePackage(t *testing.T) {
 
 		cp, err := ParsePackage(data)
 		assert.NotNil(t, cp)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		assert.Equal(t, "test", cp.Name)
 		assert.Equal(t, "1.0.0", cp.Version)

modules/packages/chef/metadata_test.go

@@ -11,6 +11,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const (
@@ -31,7 +32,7 @@ func TestParsePackage(t *testing.T) {
 
 		p, err := ParsePackage(&buf)
 		assert.Nil(t, p)
-		assert.ErrorIs(t, err, ErrMissingMetadataFile)
+		require.ErrorIs(t, err, ErrMissingMetadataFile)
 	})
 
 	t.Run("Valid", func(t *testing.T) {
@@ -53,7 +54,7 @@ func TestParsePackage(t *testing.T) {
 		zw.Close()
 
 		p, err := ParsePackage(&buf)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.NotNil(t, p)
 		assert.Equal(t, packageName, p.Name)
 		assert.Equal(t, packageVersion, p.Version)
@@ -66,7 +67,7 @@ func TestParseChefMetadata(t *testing.T) {
 		for _, name := range []string{" test", "test "} {
 			p, err := ParseChefMetadata(strings.NewReader(`{"name":"` + name + `","version":"1.0.0"}`))
 			assert.Nil(t, p)
-			assert.ErrorIs(t, err, ErrInvalidName)
+			require.ErrorIs(t, err, ErrInvalidName)
 		}
 	})
 
@@ -74,14 +75,14 @@ func TestParseChefMetadata(t *testing.T) {
 		for _, version := range []string{"1", "1.2.3.4", "1.0.0 "} {
 			p, err := ParseChefMetadata(strings.NewReader(`{"name":"test","version":"` + version + `"}`))
 			assert.Nil(t, p)
-			assert.ErrorIs(t, err, ErrInvalidVersion)
+			require.ErrorIs(t, err, ErrInvalidVersion)
 		}
 	})
 
 	t.Run("Valid", func(t *testing.T) {
 		p, err := ParseChefMetadata(strings.NewReader(`{"name":"` + packageName + `","version":"` + packageVersion + `","description":"` + packageDescription + `","maintainer":"` + packageAuthor + `","source_url":"` + packageRepositoryURL + `"}`))
 		assert.NotNil(t, p)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		assert.Equal(t, packageName, p.Name)
 		assert.Equal(t, packageVersion, p.Version)

modules/packages/composer/metadata_test.go

@@ -12,6 +12,7 @@ import (
 	"code.gitea.io/gitea/modules/json"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const (
@@ -49,20 +50,20 @@ const composerContent = `{
 
 func TestLicenseUnmarshal(t *testing.T) {
 	var l Licenses
-	assert.NoError(t, json.NewDecoder(strings.NewReader(`["MIT"]`)).Decode(&l))
+	require.NoError(t, json.NewDecoder(strings.NewReader(`["MIT"]`)).Decode(&l))
 	assert.Len(t, l, 1)
 	assert.Equal(t, "MIT", l[0])
-	assert.NoError(t, json.NewDecoder(strings.NewReader(`"MIT"`)).Decode(&l))
+	require.NoError(t, json.NewDecoder(strings.NewReader(`"MIT"`)).Decode(&l))
 	assert.Len(t, l, 1)
 	assert.Equal(t, "MIT", l[0])
 }
 
 func TestCommentsUnmarshal(t *testing.T) {
 	var c Comments
-	assert.NoError(t, json.NewDecoder(strings.NewReader(`["comment"]`)).Decode(&c))
+	require.NoError(t, json.NewDecoder(strings.NewReader(`["comment"]`)).Decode(&c))
 	assert.Len(t, c, 1)
 	assert.Equal(t, "comment", c[0])
-	assert.NoError(t, json.NewDecoder(strings.NewReader(`"comment"`)).Decode(&c))
+	require.NoError(t, json.NewDecoder(strings.NewReader(`"comment"`)).Decode(&c))
 	assert.Len(t, c, 1)
 	assert.Equal(t, "comment", c[0])
 }
@@ -84,7 +85,7 @@ func TestParsePackage(t *testing.T) {
 
 		cp, err := ParsePackage(bytes.NewReader(data), int64(len(data)))
 		assert.Nil(t, cp)
-		assert.ErrorIs(t, err, ErrMissingComposerFile)
+		require.ErrorIs(t, err, ErrMissingComposerFile)
 	})
 
 	t.Run("MissingComposerFileInRoot", func(t *testing.T) {
@@ -92,7 +93,7 @@ func TestParsePackage(t *testing.T) {
 
 		cp, err := ParsePackage(bytes.NewReader(data), int64(len(data)))
 		assert.Nil(t, cp)
-		assert.ErrorIs(t, err, ErrMissingComposerFile)
+		require.ErrorIs(t, err, ErrMissingComposerFile)
 	})
 
 	t.Run("InvalidComposerFile", func(t *testing.T) {
@@ -100,7 +101,7 @@ func TestParsePackage(t *testing.T) {
 
 		cp, err := ParsePackage(bytes.NewReader(data), int64(len(data)))
 		assert.Nil(t, cp)
-		assert.Error(t, err)
+		require.Error(t, err)
 	})
 
 	t.Run("InvalidPackageName", func(t *testing.T) {
@@ -108,7 +109,7 @@ func TestParsePackage(t *testing.T) {
 
 		cp, err := ParsePackage(bytes.NewReader(data), int64(len(data)))
 		assert.Nil(t, cp)
-		assert.ErrorIs(t, err, ErrInvalidName)
+		require.ErrorIs(t, err, ErrInvalidName)
 	})
 
 	t.Run("InvalidPackageVersion", func(t *testing.T) {
@@ -116,14 +117,14 @@ func TestParsePackage(t *testing.T) {
 
 		cp, err := ParsePackage(bytes.NewReader(data), int64(len(data)))
 		assert.Nil(t, cp)
-		assert.ErrorIs(t, err, ErrInvalidVersion)
+		require.ErrorIs(t, err, ErrInvalidVersion)
 	})
 
 	t.Run("InvalidReadmePath", func(t *testing.T) {
 		data := createArchive(map[string]string{"composer.json": `{"name": "gitea/composer-package", "readme": "sub/README.md"}`})
 
 		cp, err := ParsePackage(bytes.NewReader(data), int64(len(data)))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.NotNil(t, cp)
 
 		assert.Empty(t, cp.Metadata.Readme)
@@ -133,7 +134,7 @@ func TestParsePackage(t *testing.T) {
 		data := createArchive(map[string]string{"composer.json": composerContent, "README.md": readme})
 
 		cp, err := ParsePackage(bytes.NewReader(data), int64(len(data)))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.NotNil(t, cp)
 
 		assert.Equal(t, name, cp.Name)

modules/packages/conan/conanfile_parser_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const (
@@ -40,7 +41,7 @@ class ConanPackageConan(ConanFile):
 
 func TestParseConanfile(t *testing.T) {
 	metadata, err := ParseConanfile(strings.NewReader(contentConanfile))
-	assert.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, license, metadata.License)
 	assert.Equal(t, author, metadata.Author)
 	assert.Equal(t, homepage, metadata.ProjectURL)

modules/packages/conan/conaninfo_parser_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const (
@@ -50,7 +51,7 @@ const (
 func TestParseConaninfo(t *testing.T) {
 	info, err := ParseConaninfo(strings.NewReader(contentConaninfo))
 	assert.NotNil(t, info)
-	assert.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(
 		t,
 		map[string]string{

modules/packages/conan/reference_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestNewRecipeReference(t *testing.T) {
@@ -40,53 +41,53 @@ func TestNewRecipeReference(t *testing.T) {
 	for i, c := range cases {
 		rref, err := NewRecipeReference(c.Name, c.Version, c.User, c.Channel, c.Revision)
 		if c.IsValid {
-			assert.NoError(t, err, "case %d, should be invalid", i)
+			require.NoError(t, err, "case %d, should be invalid", i)
 			assert.NotNil(t, rref, "case %d, should not be nil", i)
 		} else {
-			assert.Error(t, err, "case %d, should be valid", i)
+			require.Error(t, err, "case %d, should be valid", i)
 		}
 	}
 }
 
 func TestRecipeReferenceRevisionOrDefault(t *testing.T) {
 	rref, err := NewRecipeReference("name", "1.0", "", "", "")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, DefaultRevision, rref.RevisionOrDefault())
 
 	rref, err = NewRecipeReference("name", "1.0", "", "", DefaultRevision)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, DefaultRevision, rref.RevisionOrDefault())
 
 	rref, err = NewRecipeReference("name", "1.0", "", "", "Az09")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "Az09", rref.RevisionOrDefault())
 }
 
 func TestRecipeReferenceString(t *testing.T) {
 	rref, err := NewRecipeReference("name", "1.0", "", "", "")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "name/1.0", rref.String())
 
 	rref, err = NewRecipeReference("name", "1.0", "user", "channel", "")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "name/1.0@user/channel", rref.String())
 
 	rref, err = NewRecipeReference("name", "1.0", "user", "channel", "Az09")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "name/1.0@user/channel#Az09", rref.String())
 }
 
 func TestRecipeReferenceLinkName(t *testing.T) {
 	rref, err := NewRecipeReference("name", "1.0", "", "", "")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "name/1.0/_/_/0", rref.LinkName())
 
 	rref, err = NewRecipeReference("name", "1.0", "user", "channel", "")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "name/1.0/user/channel/0", rref.LinkName())
 
 	rref, err = NewRecipeReference("name", "1.0", "user", "channel", "Az09")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "name/1.0/user/channel/Az09", rref.LinkName())
 }
 
@@ -110,10 +111,10 @@ func TestNewPackageReference(t *testing.T) {
 	for i, c := range cases {
 		pref, err := NewPackageReference(c.Recipe, c.Reference, c.Revision)
 		if c.IsValid {
-			assert.NoError(t, err, "case %d, should be invalid", i)
+			require.NoError(t, err, "case %d, should be invalid", i)
 			assert.NotNil(t, pref, "case %d, should not be nil", i)
 		} else {
-			assert.Error(t, err, "case %d, should be valid", i)
+			require.Error(t, err, "case %d, should be valid", i)
 		}
 	}
 }
@@ -122,15 +123,15 @@ func TestPackageReferenceRevisionOrDefault(t *testing.T) {
 	rref, _ := NewRecipeReference("name", "1.0", "", "", "")
 
 	pref, err := NewPackageReference(rref, "ref", "")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, DefaultRevision, pref.RevisionOrDefault())
 
 	pref, err = NewPackageReference(rref, "ref", DefaultRevision)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, DefaultRevision, pref.RevisionOrDefault())
 
 	pref, err = NewPackageReference(rref, "ref", "Az09")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "Az09", pref.RevisionOrDefault())
 }
 
@@ -138,10 +139,10 @@ func TestPackageReferenceLinkName(t *testing.T) {
 	rref, _ := NewRecipeReference("name", "1.0", "", "", "")
 
 	pref, err := NewPackageReference(rref, "ref", "")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "ref/0", pref.LinkName())
 
 	pref, err = NewPackageReference(rref, "ref", "Az09")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "ref/Az09", pref.LinkName())
 }

modules/packages/conda/metadata_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/dsnet/compress/bzip2"
 	"github.com/klauspost/compress/zstd"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const (
@@ -46,7 +47,7 @@ func TestParsePackage(t *testing.T) {
 
 		p, err := parsePackageTar(buf)
 		assert.Nil(t, p)
-		assert.ErrorIs(t, err, ErrInvalidStructure)
+		require.ErrorIs(t, err, ErrInvalidStructure)
 	})
 
 	t.Run("MissingAboutFile", func(t *testing.T) {
@@ -54,7 +55,7 @@ func TestParsePackage(t *testing.T) {
 
 		p, err := parsePackageTar(buf)
 		assert.NotNil(t, p)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		assert.Equal(t, "name", p.Name)
 		assert.Equal(t, "1.0", p.Version)
@@ -67,7 +68,7 @@ func TestParsePackage(t *testing.T) {
 
 			p, err := parsePackageTar(buf)
 			assert.Nil(t, p)
-			assert.ErrorIs(t, err, ErrInvalidName)
+			require.ErrorIs(t, err, ErrInvalidName)
 		}
 	})
 
@@ -77,7 +78,7 @@ func TestParsePackage(t *testing.T) {
 
 			p, err := parsePackageTar(buf)
 			assert.Nil(t, p)
-			assert.ErrorIs(t, err, ErrInvalidVersion)
+			require.ErrorIs(t, err, ErrInvalidVersion)
 		}
 	})
 
@@ -89,7 +90,7 @@ func TestParsePackage(t *testing.T) {
 
 		p, err := parsePackageTar(buf)
 		assert.NotNil(t, p)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		assert.Equal(t, packageName, p.Name)
 		assert.Equal(t, packageVersion, p.Version)
@@ -114,7 +115,7 @@ func TestParsePackage(t *testing.T) {
 
 		p, err := ParsePackageBZ2(br)
 		assert.NotNil(t, p)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		assert.Equal(t, packageName, p.Name)
 		assert.Equal(t, packageVersion, p.Version)
@@ -141,7 +142,7 @@ func TestParsePackage(t *testing.T) {
 
 		p, err := ParsePackageConda(br, int64(br.Len()))
 		assert.NotNil(t, p)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		assert.Equal(t, packageName, p.Name)
 		assert.Equal(t, packageVersion, p.Version)

modules/packages/container/metadata_test.go

@@ -11,6 +11,7 @@ import (
 
 	oci "github.com/opencontainers/image-spec/specs-go/v1"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestParseImageConfig(t *testing.T) {
@@ -24,7 +25,7 @@ func TestParseImageConfig(t *testing.T) {
 	configOCI := `{"config": {"labels": {"` + labelAuthors + `": "` + author + `", "` + labelLicenses + `": "` + license + `", "` + labelURL + `": "` + projectURL + `", "` + labelSource + `": "` + repositoryURL + `", "` + labelDocumentation + `": "` + documentationURL + `", "` + labelDescription + `": "` + description + `"}}, "history": [{"created_by": "do it 1"}, {"created_by": "dummy #(nop) do it 2"}]}`
 
 	metadata, err := ParseImageConfig(oci.MediaTypeImageManifest, strings.NewReader(configOCI))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, TypeOCI, metadata.Type)
 	assert.Equal(t, description, metadata.Description)
@@ -51,7 +52,7 @@ func TestParseImageConfig(t *testing.T) {
 	configHelm := `{"description":"` + description + `", "home": "` + projectURL + `", "sources": ["` + repositoryURL + `"], "maintainers":[{"name":"` + author + `"}]}`
 
 	metadata, err = ParseImageConfig(helm.ConfigMediaType, strings.NewReader(configHelm))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, TypeHelm, metadata.Type)
 	assert.Equal(t, description, metadata.Description)

modules/packages/cran/metadata_test.go

@@ -12,6 +12,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const (
@@ -62,7 +63,7 @@ func TestParsePackage(t *testing.T) {
 
 			p, err := ParsePackage(buf, buf.Size())
 			assert.Nil(t, p)
-			assert.ErrorIs(t, err, ErrMissingDescriptionFile)
+			require.ErrorIs(t, err, ErrMissingDescriptionFile)
 		})
 
 		t.Run("Valid", func(t *testing.T) {
@@ -74,7 +75,7 @@ func TestParsePackage(t *testing.T) {
 			p, err := ParsePackage(buf, buf.Size())
 
 			assert.NotNil(t, p)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			assert.Equal(t, packageName, p.Name)
 			assert.Equal(t, packageVersion, p.Version)
@@ -99,7 +100,7 @@ func TestParsePackage(t *testing.T) {
 
 			p, err := ParsePackage(buf, buf.Size())
 			assert.Nil(t, p)
-			assert.ErrorIs(t, err, ErrMissingDescriptionFile)
+			require.ErrorIs(t, err, ErrMissingDescriptionFile)
 		})
 
 		t.Run("Valid", func(t *testing.T) {
@@ -110,7 +111,7 @@ func TestParsePackage(t *testing.T) {
 
 			p, err := ParsePackage(buf, buf.Size())
 			assert.NotNil(t, p)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			assert.Equal(t, packageName, p.Name)
 			assert.Equal(t, packageVersion, p.Version)
@@ -123,7 +124,7 @@ func TestParseDescription(t *testing.T) {
 		for _, name := range []string{"123abc", "ab-cd", "ab cd", "ab/cd"} {
 			p, err := ParseDescription(createDescription(name, packageVersion))
 			assert.Nil(t, p)
-			assert.ErrorIs(t, err, ErrInvalidName)
+			require.ErrorIs(t, err, ErrInvalidName)
 		}
 	})
 
@@ -131,13 +132,13 @@ func TestParseDescription(t *testing.T) {
 		for _, version := range []string{"1", "1 0", "1.2.3.4.5", "1-2-3-4-5", "1.", "1.0.", "1-", "1-0-"} {
 			p, err := ParseDescription(createDescription(packageName, version))
 			assert.Nil(t, p)
-			assert.ErrorIs(t, err, ErrInvalidVersion)
+			require.ErrorIs(t, err, ErrInvalidVersion)
 		}
 	})
 
 	t.Run("Valid", func(t *testing.T) {
 		p, err := ParseDescription(createDescription(packageName, packageVersion))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.NotNil(t, p)
 
 		assert.Equal(t, packageName, p.Name)

modules/packages/debian/metadata_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/blakesmith/ar"
 	"github.com/klauspost/compress/zstd"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"github.com/ulikunitz/xz"
 )
 
@@ -47,7 +48,7 @@ func TestParsePackage(t *testing.T) {
 
 		p, err := ParsePackage(data)
 		assert.Nil(t, p)
-		assert.ErrorIs(t, err, ErrMissingControlFile)
+		require.ErrorIs(t, err, ErrMissingControlFile)
 	})
 
 	t.Run("Compression", func(t *testing.T) {
@@ -56,7 +57,7 @@ func TestParsePackage(t *testing.T) {
 
 			p, err := ParsePackage(data)
 			assert.Nil(t, p)
-			assert.ErrorIs(t, err, ErrUnsupportedCompression)
+			require.ErrorIs(t, err, ErrUnsupportedCompression)
 		})
 
 		var buf bytes.Buffer
@@ -112,7 +113,7 @@ func TestParsePackage(t *testing.T) {
 
 				p, err := ParsePackage(data)
 				assert.NotNil(t, p)
-				assert.NoError(t, err)
+				require.NoError(t, err)
 				assert.Equal(t, "gitea", p.Name)
 
 				t.Run("TrailingSlash", func(t *testing.T) {
@@ -120,7 +121,7 @@ func TestParsePackage(t *testing.T) {
 
 					p, err := ParsePackage(data)
 					assert.NotNil(t, p)
-					assert.NoError(t, err)
+					require.NoError(t, err)
 					assert.Equal(t, "gitea", p.Name)
 				})
 			})
@@ -147,7 +148,7 @@ func TestParseControlFile(t *testing.T) {
 		for _, name := range []string{"", "-cd"} {
 			p, err := ParseControlFile(buildContent(name, packageVersion, packageArchitecture))
 			assert.Nil(t, p)
-			assert.ErrorIs(t, err, ErrInvalidName)
+			require.ErrorIs(t, err, ErrInvalidName)
 		}
 	})
 
@@ -155,14 +156,14 @@ func TestParseControlFile(t *testing.T) {
 		for _, version := range []string{"", "1-", ":1.0", "1_0"} {
 			p, err := ParseControlFile(buildContent(packageName, version, packageArchitecture))
 			assert.Nil(t, p)
-			assert.ErrorIs(t, err, ErrInvalidVersion)
+			require.ErrorIs(t, err, ErrInvalidVersion)
 		}
 	})
 
 	t.Run("InvalidArchitecture", func(t *testing.T) {
 		p, err := ParseControlFile(buildContent(packageName, packageVersion, ""))
 		assert.Nil(t, p)
-		assert.ErrorIs(t, err, ErrInvalidArchitecture)
+		require.ErrorIs(t, err, ErrInvalidArchitecture)
 	})
 
 	t.Run("Valid", func(t *testing.T) {
@@ -170,7 +171,7 @@ func TestParseControlFile(t *testing.T) {
 		full := content.String()
 
 		p, err := ParseControlFile(content)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.NotNil(t, p)
 
 		assert.Equal(t, packageName, p.Name)

modules/packages/goproxy/metadata_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const (
@@ -33,7 +34,7 @@ func TestParsePackage(t *testing.T) {
 
 		p, err := ParsePackage(data, int64(data.Len()))
 		assert.Nil(t, p)
-		assert.ErrorIs(t, err, ErrInvalidStructure)
+		require.ErrorIs(t, err, ErrInvalidStructure)
 	})
 
 	t.Run("InvalidNameOrVersionStructure", func(t *testing.T) {
@@ -43,7 +44,7 @@ func TestParsePackage(t *testing.T) {
 
 		p, err := ParsePackage(data, int64(data.Len()))
 		assert.Nil(t, p)
-		assert.ErrorIs(t, err, ErrInvalidStructure)
+		require.ErrorIs(t, err, ErrInvalidStructure)
 	})
 
 	t.Run("GoModFileInWrongDirectory", func(t *testing.T) {
@@ -53,7 +54,7 @@ func TestParsePackage(t *testing.T) {
 
 		p, err := ParsePackage(data, int64(data.Len()))
 		assert.NotNil(t, p)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, packageName, p.Name)
 		assert.Equal(t, packageVersion, p.Version)
 		assert.Equal(t, "module gitea.com/go-gitea/gitea", p.GoMod)
@@ -67,7 +68,7 @@ func TestParsePackage(t *testing.T) {
 
 		p, err := ParsePackage(data, int64(data.Len()))
 		assert.NotNil(t, p)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, packageName, p.Name)
 		assert.Equal(t, packageVersion, p.Version)
 		assert.Equal(t, "valid", p.GoMod)

modules/packages/hashed_buffer_test.go

@@ -10,6 +10,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestHashedBuffer(t *testing.T) {
@@ -27,12 +28,12 @@ func TestHashedBuffer(t *testing.T) {
 
 	for _, c := range cases {
 		buf, err := CreateHashedBufferFromReaderWithSize(strings.NewReader(c.Data), c.MaxMemorySize)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		assert.EqualValues(t, len(c.Data), buf.Size())
 
 		data, err := io.ReadAll(buf)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, c.Data, string(data))
 
 		hashMD5, hashSHA1, hashSHA256, hashSHA512 := buf.Sums()
@@ -41,6 +42,6 @@ func TestHashedBuffer(t *testing.T) {
 		assert.Equal(t, c.HashSHA256, hex.EncodeToString(hashSHA256))
 		assert.Equal(t, c.HashSHA512, hex.EncodeToString(hashSHA512))
 
-		assert.NoError(t, buf.Close())
+		require.NoError(t, buf.Close())
 	}
 }

modules/packages/maven/metadata_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"golang.org/x/text/encoding/charmap"
 )
 
@@ -50,12 +51,12 @@ func TestParsePackageMetaData(t *testing.T) {
 	t.Run("InvalidFile", func(t *testing.T) {
 		m, err := ParsePackageMetaData(strings.NewReader(""))
 		assert.Nil(t, m)
-		assert.Error(t, err)
+		require.Error(t, err)
 	})
 
 	t.Run("Valid", func(t *testing.T) {
 		m, err := ParsePackageMetaData(strings.NewReader(pomContent))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.NotNil(t, m)
 
 		assert.Equal(t, groupID, m.GroupID)
@@ -80,10 +81,10 @@ func TestParsePackageMetaData(t *testing.T) {
 				`<?xml version="1.0" encoding="ISO-8859-1"?>`,
 			),
 		)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		m, err := ParsePackageMetaData(strings.NewReader(pomContent8859_1))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.NotNil(t, m)
 	})
 }

modules/packages/multi_hasher_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const (
@@ -35,11 +36,11 @@ func TestMultiHasherSums(t *testing.T) {
 		h.Write([]byte("git"))
 
 		state, err := h.MarshalBinary()
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		h2 := NewMultiHasher()
 		err = h2.UnmarshalBinary(state)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		h2.Write([]byte("ea"))
 

modules/packages/npm/creator_test.go

@@ -13,6 +13,7 @@ import (
 	"code.gitea.io/gitea/modules/json"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestParsePackage(t *testing.T) {
@@ -34,14 +35,14 @@ func TestParsePackage(t *testing.T) {
 	t.Run("InvalidUpload", func(t *testing.T) {
 		p, err := ParsePackage(bytes.NewReader([]byte{0}))
 		assert.Nil(t, p)
-		assert.Error(t, err)
+		require.Error(t, err)
 	})
 
 	t.Run("InvalidUploadNoData", func(t *testing.T) {
 		b, _ := json.Marshal(packageUpload{})
 		p, err := ParsePackage(bytes.NewReader(b))
 		assert.Nil(t, p)
-		assert.ErrorIs(t, err, ErrInvalidPackage)
+		require.ErrorIs(t, err, ErrInvalidPackage)
 	})
 
 	t.Run("InvalidPackageName", func(t *testing.T) {
@@ -60,7 +61,7 @@ func TestParsePackage(t *testing.T) {
 
 			p, err := ParsePackage(bytes.NewReader(b))
 			assert.Nil(t, p)
-			assert.ErrorIs(t, err, ErrInvalidPackageName)
+			require.ErrorIs(t, err, ErrInvalidPackageName)
 		}
 
 		test(t, " test ")
@@ -99,7 +100,7 @@ func TestParsePackage(t *testing.T) {
 
 			p, err := ParsePackage(bytes.NewReader(b))
 			assert.Nil(t, p)
-			assert.ErrorIs(t, err, ErrInvalidPackageVersion)
+			require.ErrorIs(t, err, ErrInvalidPackageVersion)
 		}
 
 		test(t, "test")
@@ -131,7 +132,7 @@ func TestParsePackage(t *testing.T) {
 
 		p, err := ParsePackage(bytes.NewReader(b))
 		assert.Nil(t, p)
-		assert.ErrorIs(t, err, ErrInvalidPackageVersion)
+		require.ErrorIs(t, err, ErrInvalidPackageVersion)
 	})
 
 	t.Run("InvalidAttachment", func(t *testing.T) {
@@ -153,7 +154,7 @@ func TestParsePackage(t *testing.T) {
 
 		p, err := ParsePackage(bytes.NewReader(b))
 		assert.Nil(t, p)
-		assert.ErrorIs(t, err, ErrInvalidAttachment)
+		require.ErrorIs(t, err, ErrInvalidAttachment)
 	})
 
 	t.Run("InvalidData", func(t *testing.T) {
@@ -178,7 +179,7 @@ func TestParsePackage(t *testing.T) {
 
 		p, err := ParsePackage(bytes.NewReader(b))
 		assert.Nil(t, p)
-		assert.ErrorIs(t, err, ErrInvalidAttachment)
+		require.ErrorIs(t, err, ErrInvalidAttachment)
 	})
 
 	t.Run("InvalidIntegrity", func(t *testing.T) {
@@ -206,7 +207,7 @@ func TestParsePackage(t *testing.T) {
 
 		p, err := ParsePackage(bytes.NewReader(b))
 		assert.Nil(t, p)
-		assert.ErrorIs(t, err, ErrInvalidIntegrity)
+		require.ErrorIs(t, err, ErrInvalidIntegrity)
 	})
 
 	t.Run("InvalidIntegrity2", func(t *testing.T) {
@@ -234,7 +235,7 @@ func TestParsePackage(t *testing.T) {
 
 		p, err := ParsePackage(bytes.NewReader(b))
 		assert.Nil(t, p)
-		assert.ErrorIs(t, err, ErrInvalidIntegrity)
+		require.ErrorIs(t, err, ErrInvalidIntegrity)
 	})
 
 	t.Run("Valid", func(t *testing.T) {
@@ -277,7 +278,7 @@ func TestParsePackage(t *testing.T) {
 
 		p, err := ParsePackage(bytes.NewReader(b))
 		assert.NotNil(t, p)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		assert.Equal(t, packageFullName, p.Name)
 		assert.Equal(t, packageVersion, p.Version)

modules/packages/nuget/metadata_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const (
@@ -77,7 +78,7 @@ func TestParsePackageMetaData(t *testing.T) {
 
 		np, err := ParsePackageMetaData(bytes.NewReader(data), int64(len(data)))
 		assert.Nil(t, np)
-		assert.ErrorIs(t, err, ErrMissingNuspecFile)
+		require.ErrorIs(t, err, ErrMissingNuspecFile)
 	})
 
 	t.Run("MissingNuspecFileInRoot", func(t *testing.T) {
@@ -85,7 +86,7 @@ func TestParsePackageMetaData(t *testing.T) {
 
 		np, err := ParsePackageMetaData(bytes.NewReader(data), int64(len(data)))
 		assert.Nil(t, np)
-		assert.ErrorIs(t, err, ErrMissingNuspecFile)
+		require.ErrorIs(t, err, ErrMissingNuspecFile)
 	})
 
 	t.Run("InvalidNuspecFile", func(t *testing.T) {
@@ -93,7 +94,7 @@ func TestParsePackageMetaData(t *testing.T) {
 
 		np, err := ParsePackageMetaData(bytes.NewReader(data), int64(len(data)))
 		assert.Nil(t, np)
-		assert.Error(t, err)
+		require.Error(t, err)
 	})
 
 	t.Run("InvalidPackageId", func(t *testing.T) {
@@ -104,7 +105,7 @@ func TestParsePackageMetaData(t *testing.T) {
 
 		np, err := ParsePackageMetaData(bytes.NewReader(data), int64(len(data)))
 		assert.Nil(t, np)
-		assert.ErrorIs(t, err, ErrNuspecInvalidID)
+		require.ErrorIs(t, err, ErrNuspecInvalidID)
 	})
 
 	t.Run("InvalidPackageVersion", func(t *testing.T) {
@@ -117,14 +118,14 @@ func TestParsePackageMetaData(t *testing.T) {
 
 		np, err := ParsePackageMetaData(bytes.NewReader(data), int64(len(data)))
 		assert.Nil(t, np)
-		assert.ErrorIs(t, err, ErrNuspecInvalidVersion)
+		require.ErrorIs(t, err, ErrNuspecInvalidVersion)
 	})
 
 	t.Run("MissingReadme", func(t *testing.T) {
 		data := createArchive(map[string]string{"package.nuspec": nuspecContent})
 
 		np, err := ParsePackageMetaData(bytes.NewReader(data), int64(len(data)))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.NotNil(t, np)
 		assert.Empty(t, np.Metadata.Readme)
 	})
@@ -136,7 +137,7 @@ func TestParsePackageMetaData(t *testing.T) {
 		})
 
 		np, err := ParsePackageMetaData(bytes.NewReader(data), int64(len(data)))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.NotNil(t, np)
 		assert.Equal(t, DependencyPackage, np.PackageType)
 
@@ -165,7 +166,7 @@ func TestParsePackageMetaData(t *testing.T) {
 				</package>`})
 
 			np, err := ParsePackageMetaData(bytes.NewReader(data), int64(len(data)))
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.NotNil(t, np)
 			assert.Equal(t, "1.4.5.2-rc.1", np.Version)
 		})
@@ -175,7 +176,7 @@ func TestParsePackageMetaData(t *testing.T) {
 		data := createArchive(map[string]string{"package.nuspec": symbolsNuspecContent})
 
 		np, err := ParsePackageMetaData(bytes.NewReader(data), int64(len(data)))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.NotNil(t, np)
 		assert.Equal(t, SymbolsPackage, np.PackageType)
 

modules/packages/nuget/symbol_extractor_test.go

@@ -10,6 +10,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const pdbContent = `QlNKQgEAAQAAAAAADAAAAFBEQiB2MS4wAAAAAAAABgB8AAAAWAAAACNQZGIAAAAA1AAAAAgBAAAj
@@ -31,7 +32,7 @@ func TestExtractPortablePdb(t *testing.T) {
 		zip.NewWriter(&buf).Close()
 
 		pdbs, err := ExtractPortablePdb(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
-		assert.ErrorIs(t, err, ErrMissingPdbFiles)
+		require.ErrorIs(t, err, ErrMissingPdbFiles)
 		assert.Empty(t, pdbs)
 	})
 
@@ -39,7 +40,7 @@ func TestExtractPortablePdb(t *testing.T) {
 		data := createArchive("sub/test.bin", []byte{})
 
 		pdbs, err := ExtractPortablePdb(bytes.NewReader(data), int64(len(data)))
-		assert.ErrorIs(t, err, ErrInvalidFiles)
+		require.ErrorIs(t, err, ErrInvalidFiles)
 		assert.Empty(t, pdbs)
 	})
 
@@ -48,7 +49,7 @@ func TestExtractPortablePdb(t *testing.T) {
 		data := createArchive("test.pdb", b)
 
 		pdbs, err := ExtractPortablePdb(bytes.NewReader(data), int64(len(data)))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Len(t, pdbs, 1)
 		assert.Equal(t, "test.pdb", pdbs[0].Name)
 		assert.Equal(t, "d910bb6948bd4c6cb40155bcf52c3c94", pdbs[0].ID)
@@ -59,7 +60,7 @@ func TestExtractPortablePdb(t *testing.T) {
 func TestParseDebugHeaderID(t *testing.T) {
 	t.Run("InvalidPdbMagicNumber", func(t *testing.T) {
 		id, err := ParseDebugHeaderID(bytes.NewReader([]byte{0, 0, 0, 0}))
-		assert.ErrorIs(t, err, ErrInvalidPdbMagicNumber)
+		require.ErrorIs(t, err, ErrInvalidPdbMagicNumber)
 		assert.Empty(t, id)
 	})
 
@@ -67,7 +68,7 @@ func TestParseDebugHeaderID(t *testing.T) {
 		b, _ := base64.StdEncoding.DecodeString(`QlNKQgEAAQAAAAAADAAAAFBEQiB2MS4wAAAAAAAAAQB8AAAAWAAAACNVUwA=`)
 
 		id, err := ParseDebugHeaderID(bytes.NewReader(b))
-		assert.ErrorIs(t, err, ErrMissingPdbStream)
+		require.ErrorIs(t, err, ErrMissingPdbStream)
 		assert.Empty(t, id)
 	})
 
@@ -75,7 +76,7 @@ func TestParseDebugHeaderID(t *testing.T) {
 		b, _ := base64.StdEncoding.DecodeString(pdbContent)
 
 		id, err := ParseDebugHeaderID(bytes.NewReader(b))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, "d910bb6948bd4c6cb40155bcf52c3c94", id)
 	})
 }

modules/packages/pub/metadata_test.go

@@ -12,6 +12,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const (
@@ -65,7 +66,7 @@ func TestParsePackage(t *testing.T) {
 
 		pp, err := ParsePackage(data)
 		assert.Nil(t, pp)
-		assert.ErrorIs(t, err, ErrMissingPubspecFile)
+		require.ErrorIs(t, err, ErrMissingPubspecFile)
 	})
 
 	t.Run("PubspecFileTooLarge", func(t *testing.T) {
@@ -73,7 +74,7 @@ func TestParsePackage(t *testing.T) {
 
 		pp, err := ParsePackage(data)
 		assert.Nil(t, pp)
-		assert.ErrorIs(t, err, ErrPubspecFileTooLarge)
+		require.ErrorIs(t, err, ErrPubspecFileTooLarge)
 	})
 
 	t.Run("InvalidPubspecFile", func(t *testing.T) {
@@ -81,14 +82,14 @@ func TestParsePackage(t *testing.T) {
 
 		pp, err := ParsePackage(data)
 		assert.Nil(t, pp)
-		assert.Error(t, err)
+		require.Error(t, err)
 	})
 
 	t.Run("Valid", func(t *testing.T) {
 		data := createArchive(map[string][]byte{"pubspec.yaml": []byte(pubspecContent)})
 
 		pp, err := ParsePackage(data)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.NotNil(t, pp)
 		assert.Empty(t, pp.Metadata.Readme)
 	})
@@ -97,7 +98,7 @@ func TestParsePackage(t *testing.T) {
 		data := createArchive(map[string][]byte{"pubspec.yaml": []byte(pubspecContent), "README.md": []byte("readme")})
 
 		pp, err := ParsePackage(data)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.NotNil(t, pp)
 		assert.Equal(t, "readme", pp.Metadata.Readme)
 	})
@@ -108,7 +109,7 @@ func TestParsePubspecMetadata(t *testing.T) {
 		for _, name := range []string{"123abc", "ab-cd"} {
 			pp, err := ParsePubspecMetadata(strings.NewReader(`name: ` + name))
 			assert.Nil(t, pp)
-			assert.ErrorIs(t, err, ErrInvalidName)
+			require.ErrorIs(t, err, ErrInvalidName)
 		}
 	})
 
@@ -116,12 +117,12 @@ func TestParsePubspecMetadata(t *testing.T) {
 		pp, err := ParsePubspecMetadata(strings.NewReader(`name: dummy
 version: invalid`))
 		assert.Nil(t, pp)
-		assert.ErrorIs(t, err, ErrInvalidVersion)
+		require.ErrorIs(t, err, ErrInvalidVersion)
 	})
 
 	t.Run("Valid", func(t *testing.T) {
 		pp, err := ParsePubspecMetadata(strings.NewReader(pubspecContent))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.NotNil(t, pp)
 
 		assert.Equal(t, packageName, pp.Name)

modules/packages/rpm/metadata_test.go

@@ -10,6 +10,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestParsePackage(t *testing.T) {
@@ -42,14 +43,14 @@ Mu0UFYgZ/bYnuvn/vz4wtCz8qMwsHUvP0PX3tbYFUctAPdrY6tiiDtcCddDECahx7SuVNP5dpmb5
 7tpp/pEjDS7cGPZ6BY430+7danDq6f42Nw49b9F7zp6BiKpJb9s5P0AYN2+L159cnrur636rx+v1
 7ae1K28QbMMcqI8CqwIrgwg9nTOp8Oj9q81plUY7ZuwXN8Vvs8wbAAA=`
 	rpmPackageContent, err := base64.StdEncoding.DecodeString(base64RpmPackageContent)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	zr, err := gzip.NewReader(bytes.NewReader(rpmPackageContent))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	p, err := ParsePackage(zr)
 	assert.NotNil(t, p)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, "gitea-test", p.Name)
 	assert.Equal(t, "1.0.2-1", p.Version)

modules/packages/rubygems/marshal_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestMinimalEncoder(t *testing.T) {
@@ -92,7 +93,7 @@ func TestMinimalEncoder(t *testing.T) {
 	for i, c := range cases {
 		var b bytes.Buffer
 		err := NewMarshalEncoder(&b).Encode(c.Value)
-		assert.ErrorIs(t, err, c.Error)
+		require.ErrorIs(t, err, c.Error)
 		assert.Equal(t, c.Expected, b.Bytes(), "case %d", i)
 	}
 }

modules/packages/rubygems/metadata_test.go

@@ -11,6 +11,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestParsePackageMetaData(t *testing.T) {
@@ -32,7 +33,7 @@ func TestParsePackageMetaData(t *testing.T) {
 		data := createArchive("dummy.txt", []byte{0})
 
 		rp, err := ParsePackageMetaData(data)
-		assert.ErrorIs(t, err, ErrMissingMetadataFile)
+		require.ErrorIs(t, err, ErrMissingMetadataFile)
 		assert.Nil(t, rp)
 	})
 
@@ -41,7 +42,7 @@ func TestParsePackageMetaData(t *testing.T) {
 		data := createArchive("metadata.gz", content)
 
 		rp, err := ParsePackageMetaData(data)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.NotNil(t, rp)
 	})
 }
@@ -58,7 +59,7 @@ dVoR6hj07u0HZgAl3SRS8G/fmXcRK20jyq6rDMSYQFgidamqkXbbuspLXE/0k7GphtKqe67GuRC/
 yjAbmt9LsOMp8xMamFkSQ38fP5EFjdz8LA4do2C69VvqWXAJgrPbKZb58/xZXrKoW6ttW13Bhvzi
 4ftn7/yUxd4YGcglvTmmY8aGY3ZwRn4CqcWcidUGAAA=`)
 	rp, err := parseMetadataFile(bytes.NewReader(content))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, rp)
 
 	assert.Equal(t, "gitea", rp.Name)

modules/packages/swift/metadata_test.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/hashicorp/go-version"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const (
@@ -39,7 +40,7 @@ func TestParsePackage(t *testing.T) {
 
 		p, err := ParsePackage(data, data.Size(), nil)
 		assert.Nil(t, p)
-		assert.ErrorIs(t, err, ErrMissingManifestFile)
+		require.ErrorIs(t, err, ErrMissingManifestFile)
 	})
 
 	t.Run("ManifestFileTooLarge", func(t *testing.T) {
@@ -49,7 +50,7 @@ func TestParsePackage(t *testing.T) {
 
 		p, err := ParsePackage(data, data.Size(), nil)
 		assert.Nil(t, p)
-		assert.ErrorIs(t, err, ErrManifestFileTooLarge)
+		require.ErrorIs(t, err, ErrManifestFileTooLarge)
 	})
 
 	t.Run("WithoutMetadata", func(t *testing.T) {
@@ -63,7 +64,7 @@ func TestParsePackage(t *testing.T) {
 
 		p, err := ParsePackage(data, data.Size(), nil)
 		assert.NotNil(t, p)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		assert.NotNil(t, p.Metadata)
 		assert.Empty(t, p.RepositoryURLs)
@@ -87,7 +88,7 @@ func TestParsePackage(t *testing.T) {
 			strings.NewReader(`{"name":"`+packageName+`","version":"`+packageVersion+`","description":"`+packageDescription+`","keywords":["swift","package"],"license":"`+packageLicense+`","codeRepository":"`+packageRepositoryURL+`","author":{"givenName":"`+packageAuthor+`"},"repositoryURLs":["`+packageRepositoryURL+`"]}`),
 		)
 		assert.NotNil(t, p)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		assert.NotNil(t, p.Metadata)
 		assert.Len(t, p.Metadata.Manifests, 1)

modules/packages/vagrant/metadata_test.go

@@ -13,6 +13,7 @@ import (
 	"code.gitea.io/gitea/modules/json"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const (
@@ -46,7 +47,7 @@ func TestParseMetadataFromBox(t *testing.T) {
 
 		metadata, err := ParseMetadataFromBox(data)
 		assert.NotNil(t, metadata)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	})
 
 	t.Run("Valid", func(t *testing.T) {
@@ -56,13 +57,13 @@ func TestParseMetadataFromBox(t *testing.T) {
 			"website":     projectURL,
 			"repository":  repositoryURL,
 		})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		data := createArchive(map[string][]byte{"info.json": content})
 
 		metadata, err := ParseMetadataFromBox(data)
 		assert.NotNil(t, metadata)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		assert.Equal(t, author, metadata.Author)
 		assert.Equal(t, description, metadata.Description)
@@ -77,11 +78,11 @@ func TestParseInfoFile(t *testing.T) {
 			"package": "",
 			"dummy":   "",
 		})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		metadata, err := ParseInfoFile(bytes.NewReader(content))
 		assert.NotNil(t, metadata)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		assert.Empty(t, metadata.Author)
 		assert.Empty(t, metadata.Description)
@@ -96,11 +97,11 @@ func TestParseInfoFile(t *testing.T) {
 			"website":     projectURL,
 			"repository":  repositoryURL,
 		})
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		metadata, err := ParseInfoFile(bytes.NewReader(content))
 		assert.NotNil(t, metadata)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		assert.Equal(t, author, metadata.Author)
 		assert.Equal(t, description, metadata.Description)

modules/queue/base_levelqueue_test.go

@@ -11,15 +11,16 @@ import (
 
 	"gitea.com/lunny/levelqueue"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"github.com/syndtr/goleveldb/leveldb"
 )
 
 func TestBaseLevelDB(t *testing.T) {
 	_, err := newBaseLevelQueueGeneric(&BaseConfig{ConnStr: "redis://"}, false)
-	assert.ErrorContains(t, err, "invalid leveldb connection string")
+	require.ErrorContains(t, err, "invalid leveldb connection string")
 
 	_, err = newBaseLevelQueueGeneric(&BaseConfig{DataFullDir: "relative"}, false)
-	assert.ErrorContains(t, err, "invalid leveldb data dir")
+	require.ErrorContains(t, err, "invalid leveldb data dir")
 
 	testQueueBasic(t, newBaseLevelQueueSimple, toBaseConfig("baseLevelQueue", setting.QueueSettings{Datadir: t.TempDir() + "/queue-test", Length: 10}), false)
 	testQueueBasic(t, newBaseLevelQueueUnique, toBaseConfig("baseLevelQueueUnique", setting.QueueSettings{ConnStr: "leveldb://" + t.TempDir() + "/queue-test", Length: 10}), true)
@@ -29,22 +30,21 @@ func TestCorruptedLevelQueue(t *testing.T) {
 	// sometimes the levelqueue could be in a corrupted state, this test is to make sure it can recover from it
 	dbDir := t.TempDir() + "/levelqueue-test"
 	db, err := leveldb.OpenFile(dbDir, nil)
-	if !assert.NoError(t, err) {
-		return
-	}
+	require.NoError(t, err)
+
 	defer db.Close()
 
-	assert.NoError(t, db.Put([]byte("other-key"), []byte("other-value"), nil))
+	require.NoError(t, db.Put([]byte("other-key"), []byte("other-value"), nil))
 
 	nameQueuePrefix := []byte("queue_name")
 	nameSetPrefix := []byte("set_name")
 	lq, err := levelqueue.NewUniqueQueue(db, nameQueuePrefix, nameSetPrefix, false)
-	assert.NoError(t, err)
-	assert.NoError(t, lq.RPush([]byte("item-1")))
+	require.NoError(t, err)
+	require.NoError(t, lq.RPush([]byte("item-1")))
 
 	itemKey := lqinternal.QueueItemKeyBytes(nameQueuePrefix, 1)
 	itemValue, err := db.Get(itemKey, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []byte("item-1"), itemValue)
 
 	// there should be 5 keys in db: queue low, queue high, 1 queue item, 1 set item, and "other-key"
@@ -52,11 +52,11 @@ func TestCorruptedLevelQueue(t *testing.T) {
 	assert.Len(t, keys, 5)
 
 	// delete the queue item key, to corrupt the queue
-	assert.NoError(t, db.Delete(itemKey, nil))
+	require.NoError(t, db.Delete(itemKey, nil))
 	// now the queue is corrupted, it never works again
 	_, err = lq.LPop()
-	assert.ErrorIs(t, err, levelqueue.ErrNotFound)
-	assert.NoError(t, lq.Close())
+	require.ErrorIs(t, err, levelqueue.ErrNotFound)
+	require.NoError(t, lq.Close())
 
 	// remove all the queue related keys to reset the queue
 	lqinternal.RemoveLevelQueueKeys(db, nameQueuePrefix)
@@ -68,11 +68,11 @@ func TestCorruptedLevelQueue(t *testing.T) {
 
 	// re-create a queue from db
 	lq, err = levelqueue.NewUniqueQueue(db, nameQueuePrefix, nameSetPrefix, false)
-	assert.NoError(t, err)
-	assert.NoError(t, lq.RPush([]byte("item-new-1")))
+	require.NoError(t, err)
+	require.NoError(t, lq.RPush([]byte("item-new-1")))
 	// now the queue works again
 	itemValue, err = lq.LPop()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []byte("item-new-1"), itemValue)
-	assert.NoError(t, lq.Close())
+	require.NoError(t, lq.Close())
 }

modules/queue/base_test.go

@@ -10,89 +10,90 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func testQueueBasic(t *testing.T, newFn func(cfg *BaseConfig) (baseQueue, error), cfg *BaseConfig, isUnique bool) {
 	t.Run(fmt.Sprintf("testQueueBasic-%s-unique:%v", cfg.ManagedName, isUnique), func(t *testing.T) {
 		q, err := newFn(cfg)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		ctx := context.Background()
 		_ = q.RemoveAll(ctx)
 		cnt, err := q.Len(ctx)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.EqualValues(t, 0, cnt)
 
 		// push the first item
 		err = q.PushItem(ctx, []byte("foo"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		cnt, err = q.Len(ctx)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.EqualValues(t, 1, cnt)
 
 		// push a duplicate item
 		err = q.PushItem(ctx, []byte("foo"))
 		if !isUnique {
-			assert.NoError(t, err)
+			require.NoError(t, err)
 		} else {
-			assert.ErrorIs(t, err, ErrAlreadyInQueue)
+			require.ErrorIs(t, err, ErrAlreadyInQueue)
 		}
 
 		// check the duplicate item
 		cnt, err = q.Len(ctx)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		has, err := q.HasItem(ctx, []byte("foo"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		if !isUnique {
 			assert.EqualValues(t, 2, cnt)
-			assert.EqualValues(t, false, has) // non-unique queues don't check for duplicates
+			assert.False(t, has) // non-unique queues don't check for duplicates
 		} else {
 			assert.EqualValues(t, 1, cnt)
-			assert.EqualValues(t, true, has)
+			assert.True(t, has)
 		}
 
 		// push another item
 		err = q.PushItem(ctx, []byte("bar"))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		// pop the first item (and the duplicate if non-unique)
 		it, err := q.PopItem(ctx)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.EqualValues(t, "foo", string(it))
 
 		if !isUnique {
 			it, err = q.PopItem(ctx)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.EqualValues(t, "foo", string(it))
 		}
 
 		// pop another item
 		it, err = q.PopItem(ctx)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.EqualValues(t, "bar", string(it))
 
 		// pop an empty queue (timeout, cancel)
 		ctxTimed, cancel := context.WithTimeout(ctx, 10*time.Millisecond)
 		it, err = q.PopItem(ctxTimed)
-		assert.ErrorIs(t, err, context.DeadlineExceeded)
+		require.ErrorIs(t, err, context.DeadlineExceeded)
 		assert.Nil(t, it)
 		cancel()
 
 		ctxTimed, cancel = context.WithTimeout(ctx, 10*time.Millisecond)
 		cancel()
 		it, err = q.PopItem(ctxTimed)
-		assert.ErrorIs(t, err, context.Canceled)
+		require.ErrorIs(t, err, context.Canceled)
 		assert.Nil(t, it)
 
 		// test blocking push if queue is full
 		for i := 0; i < cfg.Length; i++ {
 			err = q.PushItem(ctx, []byte(fmt.Sprintf("item-%d", i)))
-			assert.NoError(t, err)
+			require.NoError(t, err)
 		}
 		ctxTimed, cancel = context.WithTimeout(ctx, 10*time.Millisecond)
 		err = q.PushItem(ctxTimed, []byte("item-full"))
-		assert.ErrorIs(t, err, context.DeadlineExceeded)
+		require.ErrorIs(t, err, context.DeadlineExceeded)
 		cancel()
 
 		// test blocking push if queue is full (with custom pushBlockTime)
@@ -100,41 +101,41 @@ func testQueueBasic(t *testing.T, newFn func(cfg *BaseConfig) (baseQueue, error)
 		timeStart := time.Now()
 		pushBlockTime = 30 * time.Millisecond
 		err = q.PushItem(ctx, []byte("item-full"))
-		assert.ErrorIs(t, err, context.DeadlineExceeded)
-		assert.True(t, time.Since(timeStart) >= pushBlockTime*2/3)
+		require.ErrorIs(t, err, context.DeadlineExceeded)
+		assert.GreaterOrEqual(t, time.Since(timeStart), pushBlockTime*2/3)
 		pushBlockTime = oldPushBlockTime
 
 		// remove all
 		cnt, err = q.Len(ctx)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.EqualValues(t, cfg.Length, cnt)
 
 		_ = q.RemoveAll(ctx)
 
 		cnt, err = q.Len(ctx)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.EqualValues(t, 0, cnt)
 	})
 }
 
 func TestBaseDummy(t *testing.T) {
 	q, err := newBaseDummy(&BaseConfig{}, true)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	ctx := context.Background()
-	assert.NoError(t, q.PushItem(ctx, []byte("foo")))
+	require.NoError(t, q.PushItem(ctx, []byte("foo")))
 
 	cnt, err := q.Len(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, 0, cnt)
 
 	has, err := q.HasItem(ctx, []byte("foo"))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.False(t, has)
 
 	it, err := q.PopItem(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Nil(t, it)
 
-	assert.NoError(t, q.RemoveAll(ctx))
+	require.NoError(t, q.RemoveAll(ctx))
 }

modules/queue/manager_test.go

@@ -11,6 +11,7 @@ import (
 	"code.gitea.io/gitea/modules/setting"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestManager(t *testing.T) {
@@ -38,11 +39,11 @@ func TestManager(t *testing.T) {
 DATADIR = temp-dir
 CONN_STR = redis://
 `)
-	assert.ErrorContains(t, err, "invalid leveldb connection string")
+	require.ErrorContains(t, err, "invalid leveldb connection string")
 
 	// test default config
 	q, err := newQueueFromConfig("default", "")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "default", q.GetName())
 	assert.Equal(t, "level", q.GetType())
 	assert.Equal(t, filepath.Join(setting.AppDataPath, "queues/common"), q.baseConfig.DataFullDir)
@@ -78,7 +79,7 @@ SET_NAME = _u2
 MAX_WORKERS = 123
 `)
 
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	q1 := createWorkerPoolQueue[string](context.Background(), "no-such", cfgProvider, nil, false)
 	assert.Equal(t, "no-such", q1.GetName())
@@ -118,7 +119,7 @@ MAX_WORKERS = 123
 	assert.Equal(t, 120, q1.workerMaxNum)
 
 	stop := runWorkerPoolQueue(q2)
-	assert.NoError(t, GetManager().GetManagedQueue(qid2).FlushWithContext(context.Background(), 0))
-	assert.NoError(t, GetManager().FlushAll(context.Background(), 0))
+	require.NoError(t, GetManager().GetManagedQueue(qid2).FlushWithContext(context.Background(), 0))
+	require.NoError(t, GetManager().FlushAll(context.Background(), 0))
 	stop()
 }

modules/queue/workerqueue_test.go

@@ -57,9 +57,9 @@ func TestWorkerPoolQueueUnhandled(t *testing.T) {
 		stop := runWorkerPoolQueue(q)
 		for i := 0; i < queueSetting.Length; i++ {
 			testRecorder.Record("push:%v", i)
-			assert.NoError(t, q.Push(i))
+			require.NoError(t, q.Push(i))
 		}
-		assert.NoError(t, q.FlushWithContext(context.Background(), 0))
+		require.NoError(t, q.FlushWithContext(context.Background(), 0))
 		stop()
 
 		ok := true
@@ -167,7 +167,7 @@ func testWorkerPoolQueuePersistence(t *testing.T, queueSetting setting.QueueSett
 
 		q, _ := newWorkerPoolQueueForTest("pr_patch_checker_test", queueSetting, testHandler, true)
 		stop := runWorkerPoolQueue(q)
-		assert.NoError(t, q.FlushWithContext(context.Background(), 0))
+		require.NoError(t, q.FlushWithContext(context.Background(), 0))
 		stop()
 	}
 
@@ -189,7 +189,7 @@ func TestWorkerPoolQueueActiveWorkers(t *testing.T) {
 	q, _ := newWorkerPoolQueueForTest("test-workpoolqueue", setting.QueueSettings{Type: "channel", BatchLength: 1, MaxWorkers: 1, Length: 100}, handler, false)
 	stop := runWorkerPoolQueue(q)
 	for i := 0; i < 5; i++ {
-		assert.NoError(t, q.Push(i))
+		require.NoError(t, q.Push(i))
 	}
 
 	time.Sleep(50 * time.Millisecond)
@@ -205,7 +205,7 @@ func TestWorkerPoolQueueActiveWorkers(t *testing.T) {
 	q, _ = newWorkerPoolQueueForTest("test-workpoolqueue", setting.QueueSettings{Type: "channel", BatchLength: 1, MaxWorkers: 3, Length: 100}, handler, false)
 	stop = runWorkerPoolQueue(q)
 	for i := 0; i < 15; i++ {
-		assert.NoError(t, q.Push(i))
+		require.NoError(t, q.Push(i))
 	}
 
 	time.Sleep(50 * time.Millisecond)
@@ -238,7 +238,7 @@ func TestWorkerPoolQueueShutdown(t *testing.T) {
 	q, _ := newWorkerPoolQueueForTest("test-workpoolqueue", qs, handler, false)
 	stop := runWorkerPoolQueue(q)
 	for i := 0; i < qs.Length; i++ {
-		assert.NoError(t, q.Push(i))
+		require.NoError(t, q.Push(i))
 	}
 	<-handlerCalled
 	time.Sleep(200 * time.Millisecond) // wait for a while to make sure all workers are active
@@ -266,7 +266,7 @@ func TestWorkerPoolQueueWorkerIdleReset(t *testing.T) {
 
 	const workloadSize = 12
 	for i := 0; i < workloadSize; i++ {
-		assert.NoError(t, q.Push(i))
+		require.NoError(t, q.Push(i))
 	}
 
 	workerIDs := make(map[string]struct{})

modules/references/references_test.go

@@ -529,7 +529,7 @@ func TestCustomizeCloseKeywords(t *testing.T) {
 
 func TestParseCloseKeywords(t *testing.T) {
 	// Test parsing of CloseKeywords and ReopenKeywords
-	assert.Len(t, parseKeywords([]string{""}), 0)
+	assert.Empty(t, parseKeywords([]string{""}))
 	assert.Len(t, parseKeywords([]string{"  aa  ", " bb  ", "99", "#", "", "this is", "cc"}), 3)
 
 	for _, test := range []struct {