test: consolidate Go tests (#39962)

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

modules/setting/actions_test.go

@@ -15,89 +15,57 @@ import (
 )
 
 func Test_getStorageInheritNameSectionTypeForActions(t *testing.T) {
-	iniStr := `
+	for _, tc := range []struct {
+		iniStr, logType, artifactType string
+	}{
+		{`
 	[storage]
 	STORAGE_TYPE = minio
-	`
-	cfg, err := NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-	assert.NoError(t, loadActionsFrom(cfg))
-
-	assert.EqualValues(t, "minio", Actions.LogStorage.Type)
-	assert.Equal(t, "actions_log/", Actions.LogStorage.MinioConfig.BasePath)
-	assert.EqualValues(t, "minio", Actions.ArtifactStorage.Type)
-	assert.Equal(t, "actions_artifacts/", Actions.ArtifactStorage.MinioConfig.BasePath)
-
-	iniStr = `
+	`, "minio", "minio"},
+		{`
 [storage.actions_log]
 STORAGE_TYPE = minio
-`
-	cfg, err = NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-	assert.NoError(t, loadActionsFrom(cfg))
-
-	assert.EqualValues(t, "minio", Actions.LogStorage.Type)
-	assert.Equal(t, "actions_log/", Actions.LogStorage.MinioConfig.BasePath)
-	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
-	assert.Equal(t, "actions_artifacts", filepath.Base(Actions.ArtifactStorage.Path))
-
-	iniStr = `
+`, "minio", "local"},
+		{`
 [storage.actions_log]
 STORAGE_TYPE = my_storage
 
 [storage.my_storage]
 STORAGE_TYPE = minio
-`
-	cfg, err = NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-	assert.NoError(t, loadActionsFrom(cfg))
-
-	assert.EqualValues(t, "minio", Actions.LogStorage.Type)
-	assert.Equal(t, "actions_log/", Actions.LogStorage.MinioConfig.BasePath)
-	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
-	assert.Equal(t, "actions_artifacts", filepath.Base(Actions.ArtifactStorage.Path))
-
-	iniStr = `
+`, "minio", "local"},
+		{`
 [storage.actions_artifacts]
 STORAGE_TYPE = my_storage
 
 [storage.my_storage]
 STORAGE_TYPE = minio
-`
-	cfg, err = NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-	assert.NoError(t, loadActionsFrom(cfg))
-
-	assert.EqualValues(t, "local", Actions.LogStorage.Type)
-	assert.Equal(t, "actions_log", filepath.Base(Actions.LogStorage.Path))
-	assert.EqualValues(t, "minio", Actions.ArtifactStorage.Type)
-	assert.Equal(t, "actions_artifacts/", Actions.ArtifactStorage.MinioConfig.BasePath)
-
-	iniStr = `
+`, "local", "minio"},
+		{`
 [storage.actions_artifacts]
 STORAGE_TYPE = my_storage
 
 [storage.my_storage]
 STORAGE_TYPE = minio
-`
-	cfg, err = NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-	assert.NoError(t, loadActionsFrom(cfg))
+`, "local", "minio"},
+		{``, "local", "local"},
+	} {
+		cfg, err := NewConfigProviderFromData(tc.iniStr)
+		assert.NoError(t, err)
+		assert.NoError(t, loadActionsFrom(cfg))
 
-	assert.EqualValues(t, "local", Actions.LogStorage.Type)
-	assert.Equal(t, "actions_log", filepath.Base(Actions.LogStorage.Path))
-	assert.EqualValues(t, "minio", Actions.ArtifactStorage.Type)
-	assert.Equal(t, "actions_artifacts/", Actions.ArtifactStorage.MinioConfig.BasePath)
-
-	iniStr = ``
-	cfg, err = NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-	assert.NoError(t, loadActionsFrom(cfg))
-
-	assert.EqualValues(t, "local", Actions.LogStorage.Type)
-	assert.Equal(t, "actions_log", filepath.Base(Actions.LogStorage.Path))
-	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
-	assert.Equal(t, "actions_artifacts", filepath.Base(Actions.ArtifactStorage.Path))
+		assert.EqualValues(t, tc.logType, Actions.LogStorage.Type)
+		if tc.logType == "minio" {
+			assert.Equal(t, "actions_log/", Actions.LogStorage.MinioConfig.BasePath)
+		} else {
+			assert.Equal(t, "actions_log", filepath.Base(Actions.LogStorage.Path))
+		}
+		assert.EqualValues(t, tc.artifactType, Actions.ArtifactStorage.Type)
+		if tc.artifactType == "minio" {
+			assert.Equal(t, "actions_artifacts/", Actions.ArtifactStorage.MinioConfig.BasePath)
+		} else {
+			assert.Equal(t, "actions_artifacts", filepath.Base(Actions.ArtifactStorage.Path))
+		}
+	}
 }
 
 func Test_WorkflowDirs(t *testing.T) {

modules/setting/attachment_test.go

@@ -10,7 +10,10 @@ import (
 )
 
 func Test_getStorageCustomType(t *testing.T) {
-	iniStr := `
+	for _, tc := range []struct {
+		iniStr, endpoint, bucket string
+	}{
+		{`
 [attachment]
 STORAGE_TYPE = my_minio
 MINIO_BUCKET = gitea-attachment
@@ -18,20 +21,8 @@ MINIO_BUCKET = gitea-attachment
 [storage.my_minio]
 STORAGE_TYPE = minio
 MINIO_ENDPOINT = my_minio:9000
-`
-	cfg, err := NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-
-	assert.NoError(t, loadAttachmentFrom(cfg))
-
-	assert.EqualValues(t, "minio", Attachment.Storage.Type)
-	assert.Equal(t, "my_minio:9000", Attachment.Storage.MinioConfig.Endpoint)
-	assert.Equal(t, "gitea-attachment", Attachment.Storage.MinioConfig.Bucket)
-	assert.Equal(t, "attachments/", Attachment.Storage.MinioConfig.BasePath)
-}
-
-func Test_getStorageTypeSectionOverridesStorageSection(t *testing.T) {
-	iniStr := `
+`, "my_minio:9000", "gitea-attachment"},
+		{`
 [attachment]
 STORAGE_TYPE = minio
 
@@ -40,19 +31,8 @@ MINIO_BUCKET = gitea-minio
 
 [storage]
 MINIO_BUCKET = gitea
-`
-	cfg, err := NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-
-	assert.NoError(t, loadAttachmentFrom(cfg))
-
-	assert.EqualValues(t, "minio", Attachment.Storage.Type)
-	assert.Equal(t, "gitea-minio", Attachment.Storage.MinioConfig.Bucket)
-	assert.Equal(t, "attachments/", Attachment.Storage.MinioConfig.BasePath)
-}
-
-func Test_getStorageSpecificOverridesStorage(t *testing.T) {
-	iniStr := `
+`, "", "gitea-minio"},
+		{`
 [attachment]
 STORAGE_TYPE = minio
 MINIO_BUCKET = gitea-attachment
@@ -62,15 +42,19 @@ MINIO_BUCKET = gitea
 
 [storage]
 STORAGE_TYPE = local
-`
-	cfg, err := NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
+`, "", "gitea-attachment"},
+	} {
+		cfg, err := NewConfigProviderFromData(tc.iniStr)
+		assert.NoError(t, err)
+		assert.NoError(t, loadAttachmentFrom(cfg))
 
-	assert.NoError(t, loadAttachmentFrom(cfg))
-
-	assert.EqualValues(t, "minio", Attachment.Storage.Type)
-	assert.Equal(t, "gitea-attachment", Attachment.Storage.MinioConfig.Bucket)
-	assert.Equal(t, "attachments/", Attachment.Storage.MinioConfig.BasePath)
+		assert.EqualValues(t, "minio", Attachment.Storage.Type)
+		if tc.endpoint != "" {
+			assert.Equal(t, tc.endpoint, Attachment.Storage.MinioConfig.Endpoint)
+		}
+		assert.Equal(t, tc.bucket, Attachment.Storage.MinioConfig.Bucket)
+		assert.Equal(t, "attachments/", Attachment.Storage.MinioConfig.BasePath)
+	}
 }
 
 func Test_getStorageGetDefaults(t *testing.T) {

modules/setting/config_env_test.go

@@ -11,22 +11,20 @@ import (
 )
 
 func TestDecodeEnvSectionKey(t *testing.T) {
-	ok, section, key := decodeEnvSectionKey("SEC__KEY")
-	assert.True(t, ok)
-	assert.Equal(t, "sec", section)
-	assert.Equal(t, "KEY", key)
+	for _, tc := range []struct {
+		input, section, key string
+	}{
+		{"SEC__KEY", "sec", "KEY"},
+		{"sec__key", "sec", "key"},
+		{"LOG_0x2E_CONSOLE__STDERR", "log.console", "STDERR"},
+	} {
+		ok, section, key := decodeEnvSectionKey(tc.input)
+		assert.True(t, ok)
+		assert.Equal(t, tc.section, section)
+		assert.Equal(t, tc.key, key)
+	}
 
-	ok, section, key = decodeEnvSectionKey("sec__key")
-	assert.True(t, ok)
-	assert.Equal(t, "sec", section)
-	assert.Equal(t, "key", key)
-
-	ok, section, key = decodeEnvSectionKey("LOG_0x2E_CONSOLE__STDERR")
-	assert.True(t, ok)
-	assert.Equal(t, "log.console", section)
-	assert.Equal(t, "STDERR", key)
-
-	ok, section, key = decodeEnvSectionKey("SEC")
+	ok, section, key := decodeEnvSectionKey("SEC")
 	assert.False(t, ok)
 	assert.Empty(t, section)
 	assert.Empty(t, key)
@@ -36,19 +34,15 @@ func TestDecodeEnvironmentKey(t *testing.T) {
 	prefix := "GITEA__"
 	suffix := "__FILE"
 
-	ok, section, key, file := decodeEnvironmentKey(prefix, suffix, "SEC__KEY")
-	assert.False(t, ok)
-	assert.Empty(t, section)
-	assert.Empty(t, key)
-	assert.False(t, file)
+	for _, input := range []string{"SEC__KEY", "GITEA__SEC"} {
+		ok, section, key, file := decodeEnvironmentKey(prefix, suffix, input)
+		assert.False(t, ok)
+		assert.Empty(t, section)
+		assert.Empty(t, key)
+		assert.False(t, file)
+	}
 
-	ok, section, key, file = decodeEnvironmentKey(prefix, suffix, "GITEA__SEC")
-	assert.False(t, ok)
-	assert.Empty(t, section)
-	assert.Empty(t, key)
-	assert.False(t, file)
-
-	ok, section, key, file = decodeEnvironmentKey(prefix, suffix, "GITEA____KEY")
+	ok, section, key, file := decodeEnvironmentKey(prefix, suffix, "GITEA____KEY")
 	assert.True(t, ok)
 	assert.Empty(t, section)
 	assert.Equal(t, "KEY", key)
@@ -103,20 +97,18 @@ key = old
 	assert.True(t, changed)
 	assert.Equal(t, "value-from-file", cfg.Section("sec").Key("key").String())
 
-	cfg, _ = NewConfigProviderFromData("")
-	_ = os.WriteFile(tmpFile, []byte("value-from-file\n"), 0o644)
-	EnvironmentToConfig(cfg, []string{"GITEA__sec__key__FILE=" + tmpFile})
-	assert.Equal(t, "value-from-file", cfg.Section("sec").Key("key").String())
-
-	cfg, _ = NewConfigProviderFromData("")
-	_ = os.WriteFile(tmpFile, []byte("value-from-file\r\n"), 0o644)
-	EnvironmentToConfig(cfg, []string{"GITEA__sec__key__FILE=" + tmpFile})
-	assert.Equal(t, "value-from-file", cfg.Section("sec").Key("key").String())
-
-	cfg, _ = NewConfigProviderFromData("")
-	_ = os.WriteFile(tmpFile, []byte("value-from-file\n\n"), 0o644)
-	EnvironmentToConfig(cfg, []string{"GITEA__sec__key__FILE=" + tmpFile})
-	assert.Equal(t, "value-from-file\n", cfg.Section("sec").Key("key").String())
+	for _, tc := range []struct {
+		content, want string
+	}{
+		{"value-from-file\n", "value-from-file"},
+		{"value-from-file\r\n", "value-from-file"},
+		{"value-from-file\n\n", "value-from-file\n"},
+	} {
+		cfg, _ = NewConfigProviderFromData("")
+		_ = os.WriteFile(tmpFile, []byte(tc.content), 0o644)
+		EnvironmentToConfig(cfg, []string{"GITEA__sec__key__FILE=" + tmpFile})
+		assert.Equal(t, tc.want, cfg.Section("sec").Key("key").String())
+	}
 }
 
 func TestEnvironmentToConfigSubSecKey(t *testing.T) {

modules/setting/global_lock_test.go

@@ -12,63 +12,39 @@ import (
 )
 
 func TestLoadGlobalLockConfig(t *testing.T) {
-	t.Run("DefaultGlobalLockConfig", func(t *testing.T) {
-		defer test.MockVariableValue(&Redis)()
-		iniStr := ``
-		cfg, err := NewConfigProviderFromData(iniStr)
-		assert.NoError(t, err)
-		loadRedisFrom(cfg)
-		loadGlobalLockFrom(cfg)
-		assert.Equal(t, "memory", GlobalLock.ServiceType)
-	})
-
-	t.Run("RedisGlobalLockConfig", func(t *testing.T) {
-		defer test.MockVariableValue(&Redis)()
-		iniStr := `
+	for _, tt := range []struct {
+		name, config, serviceType, connStr string
+	}{
+		{"DefaultGlobalLockConfig", ``, "memory", ""},
+		{"RedisGlobalLockConfig", `
 [global_lock]
 SERVICE_TYPE = redis
 SERVICE_CONN_STR = addrs=127.0.0.1:6379 db=0
-`
-		cfg, err := NewConfigProviderFromData(iniStr)
-		assert.NoError(t, err)
-		loadRedisFrom(cfg)
-		loadGlobalLockFrom(cfg)
-		assert.Equal(t, "redis", GlobalLock.ServiceType)
-		assert.Equal(t, "addrs=127.0.0.1:6379 db=0", GlobalLock.ServiceConnStr)
-	})
-
-	t.Run("RedisGlobalLockFallsBackToSharedRedis", func(t *testing.T) {
-		defer test.MockVariableValue(&Redis)()
-		iniStr := `
+`, "redis", "addrs=127.0.0.1:6379 db=0"},
+		{"RedisGlobalLockFallsBackToSharedRedis", `
 [redis]
 CONN_STR = redis://127.0.0.1:6379/0
 [global_lock]
 SERVICE_TYPE = redis
-`
-		cfg, err := NewConfigProviderFromData(iniStr)
-		assert.NoError(t, err)
-
-		loadRedisFrom(cfg)
-		loadGlobalLockFrom(cfg)
-		assert.Equal(t, "redis", GlobalLock.ServiceType)
-		assert.Equal(t, "redis://127.0.0.1:6379/0", GlobalLock.ServiceConnStr)
-	})
-
-	t.Run("RedisGlobalLockOwnConnWinsOverSharedRedis", func(t *testing.T) {
-		defer test.MockVariableValue(&Redis)()
-		iniStr := `
+`, "redis", "redis://127.0.0.1:6379/0"},
+		{"RedisGlobalLockOwnConnWinsOverSharedRedis", `
 [redis]
 CONN_STR = redis://127.0.0.1:6379/0
 [global_lock]
 SERVICE_TYPE = redis
 SERVICE_CONN_STR = redis://10.0.0.1:6379/1
-`
-		cfg, err := NewConfigProviderFromData(iniStr)
-		assert.NoError(t, err)
-
-		loadRedisFrom(cfg)
-		loadGlobalLockFrom(cfg)
-		assert.Equal(t, "redis", GlobalLock.ServiceType)
-		assert.Equal(t, "redis://10.0.0.1:6379/1", GlobalLock.ServiceConnStr)
-	})
+`, "redis", "redis://10.0.0.1:6379/1"},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			defer test.MockVariableValue(&Redis)()
+			cfg, err := NewConfigProviderFromData(tt.config)
+			assert.NoError(t, err)
+			loadRedisFrom(cfg)
+			loadGlobalLockFrom(cfg)
+			assert.Equal(t, tt.serviceType, GlobalLock.ServiceType)
+			if tt.serviceType == "redis" {
+				assert.Equal(t, tt.connStr, GlobalLock.ServiceConnStr)
+			}
+		})
+	}
 }

modules/setting/lfs_test.go

@@ -12,82 +12,56 @@ import (
 )
 
 func Test_getStorageInheritNameSectionTypeForLFS(t *testing.T) {
-	iniStr := `
+	for _, tt := range []struct {
+		config, storageType, path string
+	}{
+		{`
 	[storage]
 	STORAGE_TYPE = minio
-	`
-	cfg, err := NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-	assert.NoError(t, loadLFSFrom(cfg))
-
-	assert.EqualValues(t, "minio", LFS.Storage.Type)
-	assert.Equal(t, "lfs/", LFS.Storage.MinioConfig.BasePath)
-
-	iniStr = `
+	`, "minio", "lfs/"},
+		{`
 [server]
 LFS_CONTENT_PATH = path_ignored
 [lfs]
 PATH = path_used
-`
-	cfg, err = NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-	applyDeprecatedKeys(cfg)
-	assert.NoError(t, loadLFSFrom(cfg))
-
-	assert.EqualValues(t, "local", LFS.Storage.Type)
-	assert.Contains(t, LFS.Storage.Path, "path_used")
-
-	iniStr = `
+`, "local", "path_used"},
+		{`
 [server]
 LFS_CONTENT_PATH = deprecatedpath
-`
-	cfg, err = NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-	applyDeprecatedKeys(cfg)
-	assert.NoError(t, loadLFSFrom(cfg))
-
-	assert.EqualValues(t, "local", LFS.Storage.Type)
-	assert.Contains(t, LFS.Storage.Path, "deprecatedpath")
-
-	iniStr = `
+`, "local", "deprecatedpath"},
+		{`
 [storage.lfs]
 STORAGE_TYPE = minio
-`
-	cfg, err = NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-	assert.NoError(t, loadLFSFrom(cfg))
-
-	assert.EqualValues(t, "minio", LFS.Storage.Type)
-	assert.Equal(t, "lfs/", LFS.Storage.MinioConfig.BasePath)
-
-	iniStr = `
+`, "minio", "lfs/"},
+		{`
 [lfs]
 STORAGE_TYPE = my_minio
 
 [storage.my_minio]
 STORAGE_TYPE = minio
-`
-	cfg, err = NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-	assert.NoError(t, loadLFSFrom(cfg))
-
-	assert.EqualValues(t, "minio", LFS.Storage.Type)
-	assert.Equal(t, "lfs/", LFS.Storage.MinioConfig.BasePath)
-
-	iniStr = `
+`, "minio", "lfs/"},
+		{`
 [lfs]
 STORAGE_TYPE = my_minio
 MINIO_BASE_PATH = my_lfs/
 
 [storage.my_minio]
 STORAGE_TYPE = minio
-`
-	cfg, err = NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-	assert.NoError(t, loadLFSFrom(cfg))
-
-	assert.EqualValues(t, "minio", LFS.Storage.Type)
-	assert.Equal(t, "my_lfs/", LFS.Storage.MinioConfig.BasePath)
+`, "minio", "my_lfs/"},
+	} {
+		cfg, err := NewConfigProviderFromData(tt.config)
+		assert.NoError(t, err)
+		if tt.storageType == "local" {
+			applyDeprecatedKeys(cfg)
+		}
+		assert.NoError(t, loadLFSFrom(cfg))
+		assert.EqualValues(t, tt.storageType, LFS.Storage.Type)
+		if tt.storageType == "local" {
+			assert.Contains(t, LFS.Storage.Path, tt.path)
+		} else {
+			assert.Equal(t, tt.path, LFS.Storage.MinioConfig.BasePath)
+		}
+	}
 }
 
 func Test_LFSStorage1(t *testing.T) {

modules/setting/log_test.go

@@ -36,9 +36,6 @@ func toJSON(v any) string {
 }
 
 func TestLogConfigDefault(t *testing.T) {
-	manager, managerClose := initLoggersByConfig(t, ``)
-	defer managerClose()
-
 	writerDump := `
 {
 	"console": {
@@ -57,95 +54,37 @@ func TestLogConfigDefault(t *testing.T) {
 }
 `
 
-	dump := manager.GetLogger(log.DEFAULT).DumpWriters()
-	require.JSONEq(t, writerDump, toJSON(dump))
-
-	dump = manager.GetLogger("access").DumpWriters()
-	require.JSONEq(t, "{}", toJSON(dump))
-
-	dump = manager.GetLogger("router").DumpWriters()
-	require.JSONEq(t, writerDump, toJSON(dump))
-
-	dump = manager.GetLogger("xorm").DumpWriters()
-	require.JSONEq(t, writerDump, toJSON(dump))
-}
-
-func TestLogConfigDisable(t *testing.T) {
-	manager, managerClose := initLoggersByConfig(t, `
+	for _, tt := range []struct {
+		name, config, routerDump string
+	}{
+		{"Default", ``, writerDump},
+		{"Disable", `
 [log]
 logger.router.MODE =
 logger.xorm.MODE =
-`)
-	defer managerClose()
-
-	writerDump := `
-{
-	"console": {
-		"BufferLen": 10000,
-		"Colorize": false,
-		"Expression": "",
-		"Flags": "stdflags",
-		"Level": "info",
-		"Prefix": "",
-		"StacktraceLevel": "none",
-		"WriterOption": {
-			"Stderr": false
-		},
-		"WriterType": "console"
-	}
-}
-`
-
-	dump := manager.GetLogger(log.DEFAULT).DumpWriters()
-	require.JSONEq(t, writerDump, toJSON(dump))
-
-	dump = manager.GetLogger("access").DumpWriters()
-	require.JSONEq(t, "{}", toJSON(dump))
-
-	dump = manager.GetLogger("router").DumpWriters()
-	require.JSONEq(t, "{}", toJSON(dump))
-
-	dump = manager.GetLogger("xorm").DumpWriters()
-	require.JSONEq(t, "{}", toJSON(dump))
-}
-
-func TestLogConfigLegacyDefault(t *testing.T) {
-	manager, managerClose := initLoggersByConfig(t, `
+`, "{}"},
+		{"LegacyDefault", `
 [log]
 MODE = console
-`)
-	defer managerClose()
+`, writerDump},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			manager, managerClose := initLoggersByConfig(t, tt.config)
+			defer managerClose()
 
-	writerDump := `
-{
-	"console": {
-		"BufferLen": 10000,
-		"Colorize": false,
-		"Expression": "",
-		"Flags": "stdflags",
-		"Level": "info",
-		"Prefix": "",
-		"StacktraceLevel": "none",
-		"WriterOption": {
-			"Stderr": false
-		},
-		"WriterType": "console"
+			for _, logger := range []struct {
+				name, expected string
+			}{
+				{log.DEFAULT, writerDump},
+				{"access", "{}"},
+				{"router", tt.routerDump},
+				{"xorm", tt.routerDump},
+			} {
+				require.JSONEq(t, logger.expected, toJSON(manager.GetLogger(logger.name).DumpWriters()))
+			}
+		})
 	}
 }
-`
-
-	dump := manager.GetLogger(log.DEFAULT).DumpWriters()
-	require.JSONEq(t, writerDump, toJSON(dump))
-
-	dump = manager.GetLogger("access").DumpWriters()
-	require.JSONEq(t, "{}", toJSON(dump))
-
-	dump = manager.GetLogger("router").DumpWriters()
-	require.JSONEq(t, writerDump, toJSON(dump))
-
-	dump = manager.GetLogger("xorm").DumpWriters()
-	require.JSONEq(t, writerDump, toJSON(dump))
-}
 
 func TestLogConfigLegacyMode(t *testing.T) {
 	tempDir := t.TempDir()

modules/setting/packages_test.go

@@ -31,168 +31,98 @@ func TestMustBytes(t *testing.T) {
 }
 
 func Test_getStorageInheritNameSectionTypeForPackages(t *testing.T) {
-	// packages storage inherits from storage if nothing configured
-	iniStr := `
+	for _, testcase := range []struct {
+		iniStr, basePath string
+	}{
+		// packages storage inherits from storage if nothing configured
+		{`
 [storage]
 STORAGE_TYPE = minio
-`
-	cfg, err := NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-	assert.NoError(t, loadPackagesFrom(cfg))
-
-	assert.EqualValues(t, "minio", Packages.Storage.Type)
-	assert.Equal(t, "packages/", Packages.Storage.MinioConfig.BasePath)
-
-	// we can also configure packages storage directly
-	iniStr = `
+`, "packages/"},
+		// we can also configure packages storage directly
+		{`
 [storage.packages]
 STORAGE_TYPE = minio
-`
-	cfg, err = NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-	assert.NoError(t, loadPackagesFrom(cfg))
-
-	assert.EqualValues(t, "minio", Packages.Storage.Type)
-	assert.Equal(t, "packages/", Packages.Storage.MinioConfig.BasePath)
-
-	// or we can indicate the storage type in the packages section
-	iniStr = `
+`, "packages/"},
+		// or we can indicate the storage type in the packages section
+		{`
 [packages]
 STORAGE_TYPE = my_minio
 
 [storage.my_minio]
 STORAGE_TYPE = minio
-`
-	cfg, err = NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-	assert.NoError(t, loadPackagesFrom(cfg))
-
-	assert.EqualValues(t, "minio", Packages.Storage.Type)
-	assert.Equal(t, "packages/", Packages.Storage.MinioConfig.BasePath)
-
-	// or we can indicate the storage type  and minio base path in the packages section
-	iniStr = `
+`, "packages/"},
+		// or we can indicate the storage type  and minio base path in the packages section
+		{`
 [packages]
 STORAGE_TYPE = my_minio
 MINIO_BASE_PATH = my_packages/
 
 [storage.my_minio]
 STORAGE_TYPE = minio
-`
-	cfg, err = NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-	assert.NoError(t, loadPackagesFrom(cfg))
+`, "my_packages/"},
+	} {
+		cfg, err := NewConfigProviderFromData(testcase.iniStr)
+		assert.NoError(t, err)
+		assert.NoError(t, loadPackagesFrom(cfg))
 
-	assert.EqualValues(t, "minio", Packages.Storage.Type)
-	assert.Equal(t, "my_packages/", Packages.Storage.MinioConfig.BasePath)
+		assert.EqualValues(t, "minio", Packages.Storage.Type)
+		assert.Equal(t, testcase.basePath, Packages.Storage.MinioConfig.BasePath)
+	}
 }
 
-func Test_PackageStorage1(t *testing.T) {
-	iniStr := `
+func Test_PackageStorage(t *testing.T) {
+	const storageConfig = `STORAGE_TYPE            = minio
+MINIO_ENDPOINT          = s3.my-domain.net
+MINIO_BUCKET            = gitea
+MINIO_LOCATION          = homenet
+MINIO_USE_SSL           = true
+MINIO_ACCESS_KEY_ID     = correct_key
+MINIO_SECRET_ACCESS_KEY = correct_key
+`
+	for _, testcase := range []struct {
+		iniStr, basePath string
+	}{
+		{`
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 [packages]
 MINIO_BASE_PATH = packages/
 SERVE_DIRECT = true
 [storage]
-STORAGE_TYPE            = minio
-MINIO_ENDPOINT          = s3.my-domain.net
-MINIO_BUCKET            = gitea
-MINIO_LOCATION          = homenet
-MINIO_USE_SSL           = true
-MINIO_ACCESS_KEY_ID     = correct_key
-MINIO_SECRET_ACCESS_KEY = correct_key
-`
-	cfg, err := NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-
-	assert.NoError(t, loadPackagesFrom(cfg))
-	storage := Packages.Storage
-
-	assert.EqualValues(t, "minio", storage.Type)
-	assert.Equal(t, "gitea", storage.MinioConfig.Bucket)
-	assert.Equal(t, "packages/", storage.MinioConfig.BasePath)
-	assert.True(t, storage.MinioConfig.ServeDirect)
-}
-
-func Test_PackageStorage2(t *testing.T) {
-	iniStr := `
+`, "packages/"},
+		{`
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 [storage.packages]
 MINIO_BASE_PATH = packages/
 SERVE_DIRECT = true
 [storage]
-STORAGE_TYPE            = minio
-MINIO_ENDPOINT          = s3.my-domain.net
-MINIO_BUCKET            = gitea
-MINIO_LOCATION          = homenet
-MINIO_USE_SSL           = true
-MINIO_ACCESS_KEY_ID     = correct_key
-MINIO_SECRET_ACCESS_KEY = correct_key
-`
-	cfg, err := NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-
-	assert.NoError(t, loadPackagesFrom(cfg))
-	storage := Packages.Storage
-
-	assert.EqualValues(t, "minio", storage.Type)
-	assert.Equal(t, "gitea", storage.MinioConfig.Bucket)
-	assert.Equal(t, "packages/", storage.MinioConfig.BasePath)
-	assert.True(t, storage.MinioConfig.ServeDirect)
-}
-
-func Test_PackageStorage3(t *testing.T) {
-	iniStr := `
+`, "packages/"},
+		{`
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 [packages]
 STORAGE_TYPE            = my_cfg
 MINIO_BASE_PATH = my_packages/
 SERVE_DIRECT = true
 [storage.my_cfg]
-STORAGE_TYPE            = minio
-MINIO_ENDPOINT          = s3.my-domain.net
-MINIO_BUCKET            = gitea
-MINIO_LOCATION          = homenet
-MINIO_USE_SSL           = true
-MINIO_ACCESS_KEY_ID     = correct_key
-MINIO_SECRET_ACCESS_KEY = correct_key
-`
-	cfg, err := NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-
-	assert.NoError(t, loadPackagesFrom(cfg))
-	storage := Packages.Storage
-
-	assert.EqualValues(t, "minio", storage.Type)
-	assert.Equal(t, "gitea", storage.MinioConfig.Bucket)
-	assert.Equal(t, "my_packages/", storage.MinioConfig.BasePath)
-	assert.True(t, storage.MinioConfig.ServeDirect)
-}
-
-func Test_PackageStorage4(t *testing.T) {
-	iniStr := `
+`, "my_packages/"},
+		{`
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 [storage.packages]
 STORAGE_TYPE            = my_cfg
 MINIO_BASE_PATH = my_packages/
 SERVE_DIRECT = true
 [storage.my_cfg]
-STORAGE_TYPE            = minio
-MINIO_ENDPOINT          = s3.my-domain.net
-MINIO_BUCKET            = gitea
-MINIO_LOCATION          = homenet
-MINIO_USE_SSL           = true
-MINIO_ACCESS_KEY_ID     = correct_key
-MINIO_SECRET_ACCESS_KEY = correct_key
-`
-	cfg, err := NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
+`, "my_packages/"},
+	} {
+		cfg, err := NewConfigProviderFromData(testcase.iniStr + storageConfig)
+		assert.NoError(t, err)
 
-	assert.NoError(t, loadPackagesFrom(cfg))
-	storage := Packages.Storage
+		assert.NoError(t, loadPackagesFrom(cfg))
+		storage := Packages.Storage
 
-	assert.EqualValues(t, "minio", storage.Type)
-	assert.Equal(t, "gitea", storage.MinioConfig.Bucket)
-	assert.Equal(t, "my_packages/", storage.MinioConfig.BasePath)
-	assert.True(t, storage.MinioConfig.ServeDirect)
+		assert.EqualValues(t, "minio", storage.Type)
+		assert.Equal(t, "gitea", storage.MinioConfig.Bucket)
+		assert.Equal(t, testcase.basePath, storage.MinioConfig.BasePath)
+		assert.True(t, storage.MinioConfig.ServeDirect)
+	}
 }

modules/setting/repository_archive_test.go

@@ -10,64 +10,49 @@ import (
 )
 
 func Test_getStorageInheritNameSectionTypeForRepoArchive(t *testing.T) {
-	// packages storage inherits from storage if nothing configured
-	iniStr := `
+	for _, tc := range []struct {
+		ini, basePath string
+	}{
+		// packages storage inherits from storage if nothing configured
+		{`
 [storage]
 STORAGE_TYPE = minio
-`
-	cfg, err := NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-	assert.NoError(t, loadRepoArchiveFrom(cfg))
-
-	assert.EqualValues(t, "minio", RepoArchive.Storage.Type)
-	assert.Equal(t, "repo-archive/", RepoArchive.Storage.MinioConfig.BasePath)
-
-	// we can also configure packages storage directly
-	iniStr = `
+`, "repo-archive/"},
+		// we can also configure packages storage directly
+		{`
 [storage.repo-archive]
 STORAGE_TYPE = minio
-`
-	cfg, err = NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-	assert.NoError(t, loadRepoArchiveFrom(cfg))
-
-	assert.EqualValues(t, "minio", RepoArchive.Storage.Type)
-	assert.Equal(t, "repo-archive/", RepoArchive.Storage.MinioConfig.BasePath)
-
-	// or we can indicate the storage type in the packages section
-	iniStr = `
+`, "repo-archive/"},
+		// or we can indicate the storage type in the packages section
+		{`
 [repo-archive]
 STORAGE_TYPE = my_minio
 
 [storage.my_minio]
 STORAGE_TYPE = minio
-`
-	cfg, err = NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-	assert.NoError(t, loadRepoArchiveFrom(cfg))
-
-	assert.EqualValues(t, "minio", RepoArchive.Storage.Type)
-	assert.Equal(t, "repo-archive/", RepoArchive.Storage.MinioConfig.BasePath)
-
-	// or we can indicate the storage type  and minio base path in the packages section
-	iniStr = `
+`, "repo-archive/"},
+		// or we can indicate the storage type  and minio base path in the packages section
+		{`
 [repo-archive]
 STORAGE_TYPE = my_minio
 MINIO_BASE_PATH = my_archive/
 
 [storage.my_minio]
 STORAGE_TYPE = minio
-`
-	cfg, err = NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-	assert.NoError(t, loadRepoArchiveFrom(cfg))
+`, "my_archive/"},
+	} {
+		cfg, err := NewConfigProviderFromData(tc.ini)
+		assert.NoError(t, err)
+		assert.NoError(t, loadRepoArchiveFrom(cfg))
 
-	assert.EqualValues(t, "minio", RepoArchive.Storage.Type)
-	assert.Equal(t, "my_archive/", RepoArchive.Storage.MinioConfig.BasePath)
+		assert.EqualValues(t, "minio", RepoArchive.Storage.Type)
+		assert.Equal(t, tc.basePath, RepoArchive.Storage.MinioConfig.BasePath)
+	}
 }
 
 func Test_RepoArchiveStorage(t *testing.T) {
-	iniStr := `
+	for _, ini := range []string{
+		`
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 [storage]
 STORAGE_TYPE            = minio
@@ -77,17 +62,8 @@ MINIO_LOCATION          = homenet
 MINIO_USE_SSL           = true
 MINIO_ACCESS_KEY_ID     = correct_key
 MINIO_SECRET_ACCESS_KEY = correct_key
-`
-	cfg, err := NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-
-	assert.NoError(t, loadRepoArchiveFrom(cfg))
-	storage := RepoArchive.Storage
-
-	assert.EqualValues(t, "minio", storage.Type)
-	assert.Equal(t, "gitea", storage.MinioConfig.Bucket)
-
-	iniStr = `
+`,
+		`
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 [storage.repo-archive]
 STORAGE_TYPE = s3
@@ -99,13 +75,15 @@ MINIO_LOCATION          = homenet
 MINIO_USE_SSL           = true
 MINIO_ACCESS_KEY_ID     = correct_key
 MINIO_SECRET_ACCESS_KEY = correct_key
-`
-	cfg, err = NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
+`,
+	} {
+		cfg, err := NewConfigProviderFromData(ini)
+		assert.NoError(t, err)
 
-	assert.NoError(t, loadRepoArchiveFrom(cfg))
-	storage = RepoArchive.Storage
+		assert.NoError(t, loadRepoArchiveFrom(cfg))
+		storage := RepoArchive.Storage
 
-	assert.EqualValues(t, "minio", storage.Type)
-	assert.Equal(t, "gitea", storage.MinioConfig.Bucket)
+		assert.EqualValues(t, "minio", storage.Type)
+		assert.Equal(t, "gitea", storage.MinioConfig.Bucket)
+	}
 }

modules/setting/service_test.go

@@ -54,77 +54,57 @@ func TestLoadServiceVisibilityModes(t *testing.T) {
 		}
 		return ret
 	}
-	testCases := map[string]func(){
+	testCases := map[string]struct {
+		defaultMode  structs.VisibleType
+		allowedModes []structs.VisibilityString
+	}{
 		`
 [service]
 DEFAULT_USER_VISIBILITY = public
 ALLOWED_USER_VISIBILITY_MODES = public,limited,private
-`: func() {
-			assert.Equal(t, structs.VisibleTypePublic, Service.DefaultUserVisibilityMode)
-			assert.Equal(t, visibleTypeSlice("public", "limited", "private"), Service.AllowedUserVisibilityModesSlice.ToVisibleTypeSlice())
-		},
+`: {structs.VisibleTypePublic, []structs.VisibilityString{"public", "limited", "private"}},
 		`
 		[service]
 		DEFAULT_USER_VISIBILITY = public
-		`: func() {
-			assert.Equal(t, structs.VisibleTypePublic, Service.DefaultUserVisibilityMode)
-			assert.Equal(t, visibleTypeSlice("public", "limited", "private"), Service.AllowedUserVisibilityModesSlice.ToVisibleTypeSlice())
-		},
+		`: {structs.VisibleTypePublic, []structs.VisibilityString{"public", "limited", "private"}},
 		`
 		[service]
 		DEFAULT_USER_VISIBILITY = limited
-		`: func() {
-			assert.Equal(t, structs.VisibleTypeLimited, Service.DefaultUserVisibilityMode)
-			assert.Equal(t, visibleTypeSlice("public", "limited", "private"), Service.AllowedUserVisibilityModesSlice.ToVisibleTypeSlice())
-		},
+		`: {structs.VisibleTypeLimited, []structs.VisibilityString{"public", "limited", "private"}},
 		`
 [service]
 ALLOWED_USER_VISIBILITY_MODES = public,limited,private
-`: func() {
-			assert.Equal(t, structs.VisibleTypePublic, Service.DefaultUserVisibilityMode)
-			assert.Equal(t, visibleTypeSlice("public", "limited", "private"), Service.AllowedUserVisibilityModesSlice.ToVisibleTypeSlice())
-		},
+`: {structs.VisibleTypePublic, []structs.VisibilityString{"public", "limited", "private"}},
 		`
 [service]
 DEFAULT_USER_VISIBILITY = public
 ALLOWED_USER_VISIBILITY_MODES = limited,private
-`: func() {
-			assert.Equal(t, structs.VisibleTypeLimited, Service.DefaultUserVisibilityMode)
-			assert.Equal(t, visibleTypeSlice("limited", "private"), Service.AllowedUserVisibilityModesSlice.ToVisibleTypeSlice())
-		},
+`: {structs.VisibleTypeLimited, []structs.VisibilityString{"limited", "private"}},
 		`
 [service]
 DEFAULT_USER_VISIBILITY = my_type
 ALLOWED_USER_VISIBILITY_MODES = limited,private
-`: func() {
-			assert.Equal(t, structs.VisibleTypeLimited, Service.DefaultUserVisibilityMode)
-			assert.Equal(t, visibleTypeSlice("limited", "private"), Service.AllowedUserVisibilityModesSlice.ToVisibleTypeSlice())
-		},
+`: {structs.VisibleTypeLimited, []structs.VisibilityString{"limited", "private"}},
 		`
 [service]
 DEFAULT_USER_VISIBILITY = my_type
-`: func() {
-			assert.Equal(t, structs.VisibleTypePublic, Service.DefaultUserVisibilityMode)
-			assert.Equal(t, visibleTypeSlice("public", "limited", "private"), Service.AllowedUserVisibilityModesSlice.ToVisibleTypeSlice())
-		},
+`: {structs.VisibleTypePublic, []structs.VisibilityString{"public", "limited", "private"}},
 		`
 [service]
 DEFAULT_USER_VISIBILITY = public
 ALLOWED_USER_VISIBILITY_MODES = public, limit, privated
-`: func() {
-			assert.Equal(t, structs.VisibleTypePublic, Service.DefaultUserVisibilityMode)
-			assert.Equal(t, visibleTypeSlice("public"), Service.AllowedUserVisibilityModesSlice.ToVisibleTypeSlice())
-		},
+`: {structs.VisibleTypePublic, []structs.VisibilityString{"public"}},
 	}
 
-	for tc, fn := range testCases {
+	for tc, expected := range testCases {
 		t.Run(tc, func(t *testing.T) {
 			Service.AllowedUserVisibilityModesSlice = []bool{true, true, true}
 			Service.DefaultUserVisibilityMode = structs.VisibleTypePublic
 			cfg, err := NewConfigProviderFromData(tc)
 			assert.NoError(t, err)
 			loadServiceFrom(cfg)
-			fn()
+			assert.Equal(t, expected.defaultMode, Service.DefaultUserVisibilityMode)
+			assert.Equal(t, visibleTypeSlice(expected.allowedModes...), Service.AllowedUserVisibilityModesSlice.ToVisibleTypeSlice())
 		})
 	}
 }

modules/setting/storage_test.go

@@ -156,185 +156,85 @@ func testLocalStoragePath(t *testing.T, appDataPath, iniStr string, cases []test
 }
 
 func Test_getStorageInheritStorageTypeLocal(t *testing.T) {
-	testLocalStoragePath(t, "/appdata", `
+	for _, tc := range []struct {
+		name, ini, basePath, archivePath string
+	}{
+		{"Default", `
 [storage]
 STORAGE_TYPE = local
-`, []testLocalStoragePathCase{
-		{loadAttachmentFrom, &Attachment.Storage, "/appdata/attachments"},
-		{loadLFSFrom, &LFS.Storage, "/appdata/lfs"},
-		{loadActionsFrom, &Actions.ArtifactStorage, "/appdata/actions_artifacts"},
-		{loadPackagesFrom, &Packages.Storage, "/appdata/packages"},
-		{loadRepoArchiveFrom, &RepoArchive.Storage, "/appdata/repo-archive"},
-		{loadActionsFrom, &Actions.LogStorage, "/appdata/actions_log"},
-		{loadAvatarsFrom, &Avatar.Storage, "/appdata/avatars"},
-		{loadRepoAvatarFrom, &RepoAvatar.Storage, "/appdata/repo-avatars"},
-	})
-}
-
-func Test_getStorageInheritStorageTypeLocalPath(t *testing.T) {
-	testLocalStoragePath(t, "/appdata", `
+`, "/appdata", "/appdata/repo-archive"},
+		{"Path", `
 [storage]
 STORAGE_TYPE = local
 PATH = /data/gitea
-`, []testLocalStoragePathCase{
-		{loadAttachmentFrom, &Attachment.Storage, "/data/gitea/attachments"},
-		{loadLFSFrom, &LFS.Storage, "/data/gitea/lfs"},
-		{loadActionsFrom, &Actions.ArtifactStorage, "/data/gitea/actions_artifacts"},
-		{loadPackagesFrom, &Packages.Storage, "/data/gitea/packages"},
-		{loadRepoArchiveFrom, &RepoArchive.Storage, "/data/gitea/repo-archive"},
-		{loadActionsFrom, &Actions.LogStorage, "/data/gitea/actions_log"},
-		{loadAvatarsFrom, &Avatar.Storage, "/data/gitea/avatars"},
-		{loadRepoAvatarFrom, &RepoAvatar.Storage, "/data/gitea/repo-avatars"},
-	})
-}
-
-func Test_getStorageInheritStorageTypeLocalRelativePath(t *testing.T) {
-	testLocalStoragePath(t, "/appdata", `
+`, "/data/gitea", "/data/gitea/repo-archive"},
+		{"RelativePath", `
 [storage]
 STORAGE_TYPE = local
 PATH = storages
-`, []testLocalStoragePathCase{
-		{loadAttachmentFrom, &Attachment.Storage, "/appdata/storages/attachments"},
-		{loadLFSFrom, &LFS.Storage, "/appdata/storages/lfs"},
-		{loadActionsFrom, &Actions.ArtifactStorage, "/appdata/storages/actions_artifacts"},
-		{loadPackagesFrom, &Packages.Storage, "/appdata/storages/packages"},
-		{loadRepoArchiveFrom, &RepoArchive.Storage, "/appdata/storages/repo-archive"},
-		{loadActionsFrom, &Actions.LogStorage, "/appdata/storages/actions_log"},
-		{loadAvatarsFrom, &Avatar.Storage, "/appdata/storages/avatars"},
-		{loadRepoAvatarFrom, &RepoAvatar.Storage, "/appdata/storages/repo-avatars"},
-	})
-}
-
-func Test_getStorageInheritStorageTypeLocalPathOverride(t *testing.T) {
-	testLocalStoragePath(t, "/appdata", `
+`, "/appdata/storages", "/appdata/storages/repo-archive"},
+		{"PathOverride", `
 [storage]
 STORAGE_TYPE = local
 PATH = /data/gitea
 
 [repo-archive]
 PATH = /data/gitea/the-archives-dir
-`, []testLocalStoragePathCase{
-		{loadAttachmentFrom, &Attachment.Storage, "/data/gitea/attachments"},
-		{loadLFSFrom, &LFS.Storage, "/data/gitea/lfs"},
-		{loadActionsFrom, &Actions.ArtifactStorage, "/data/gitea/actions_artifacts"},
-		{loadPackagesFrom, &Packages.Storage, "/data/gitea/packages"},
-		{loadRepoArchiveFrom, &RepoArchive.Storage, "/data/gitea/the-archives-dir"},
-		{loadActionsFrom, &Actions.LogStorage, "/data/gitea/actions_log"},
-		{loadAvatarsFrom, &Avatar.Storage, "/data/gitea/avatars"},
-		{loadRepoAvatarFrom, &RepoAvatar.Storage, "/data/gitea/repo-avatars"},
-	})
-}
-
-func Test_getStorageInheritStorageTypeLocalPathOverrideEmpty(t *testing.T) {
-	testLocalStoragePath(t, "/appdata", `
+`, "/data/gitea", "/data/gitea/the-archives-dir"},
+		{"PathOverrideEmpty", `
 [storage]
 STORAGE_TYPE = local
 PATH = /data/gitea
 
 [repo-archive]
-`, []testLocalStoragePathCase{
-		{loadAttachmentFrom, &Attachment.Storage, "/data/gitea/attachments"},
-		{loadLFSFrom, &LFS.Storage, "/data/gitea/lfs"},
-		{loadActionsFrom, &Actions.ArtifactStorage, "/data/gitea/actions_artifacts"},
-		{loadPackagesFrom, &Packages.Storage, "/data/gitea/packages"},
-		{loadRepoArchiveFrom, &RepoArchive.Storage, "/data/gitea/repo-archive"},
-		{loadActionsFrom, &Actions.LogStorage, "/data/gitea/actions_log"},
-		{loadAvatarsFrom, &Avatar.Storage, "/data/gitea/avatars"},
-		{loadRepoAvatarFrom, &RepoAvatar.Storage, "/data/gitea/repo-avatars"},
-	})
-}
-
-func Test_getStorageInheritStorageTypeLocalRelativePathOverride(t *testing.T) {
-	testLocalStoragePath(t, "/appdata", `
+`, "/data/gitea", "/data/gitea/repo-archive"},
+		{"RelativePathOverride", `
 [storage]
 STORAGE_TYPE = local
 PATH = /data/gitea
 
 [repo-archive]
 PATH = the-archives-dir
-`, []testLocalStoragePathCase{
-		{loadAttachmentFrom, &Attachment.Storage, "/data/gitea/attachments"},
-		{loadLFSFrom, &LFS.Storage, "/data/gitea/lfs"},
-		{loadActionsFrom, &Actions.ArtifactStorage, "/data/gitea/actions_artifacts"},
-		{loadPackagesFrom, &Packages.Storage, "/data/gitea/packages"},
-		{loadRepoArchiveFrom, &RepoArchive.Storage, "/data/gitea/the-archives-dir"},
-		{loadActionsFrom, &Actions.LogStorage, "/data/gitea/actions_log"},
-		{loadAvatarsFrom, &Avatar.Storage, "/data/gitea/avatars"},
-		{loadRepoAvatarFrom, &RepoAvatar.Storage, "/data/gitea/repo-avatars"},
-	})
-}
-
-func Test_getStorageInheritStorageTypeLocalPathOverride3(t *testing.T) {
-	testLocalStoragePath(t, "/appdata", `
+`, "/data/gitea", "/data/gitea/the-archives-dir"},
+		{"PathOverride3", `
 [storage.repo-archive]
 STORAGE_TYPE = local
 PATH = /data/gitea/archives
-`, []testLocalStoragePathCase{
-		{loadAttachmentFrom, &Attachment.Storage, "/appdata/attachments"},
-		{loadLFSFrom, &LFS.Storage, "/appdata/lfs"},
-		{loadActionsFrom, &Actions.ArtifactStorage, "/appdata/actions_artifacts"},
-		{loadPackagesFrom, &Packages.Storage, "/appdata/packages"},
-		{loadRepoArchiveFrom, &RepoArchive.Storage, "/data/gitea/archives"},
-		{loadActionsFrom, &Actions.LogStorage, "/appdata/actions_log"},
-		{loadAvatarsFrom, &Avatar.Storage, "/appdata/avatars"},
-		{loadRepoAvatarFrom, &RepoAvatar.Storage, "/appdata/repo-avatars"},
-	})
-}
-
-func Test_getStorageInheritStorageTypeLocalPathOverride3_5(t *testing.T) {
-	testLocalStoragePath(t, "/appdata", `
+`, "/appdata", "/data/gitea/archives"},
+		{"PathOverride3_5", `
 [storage.repo-archive]
 STORAGE_TYPE = local
 PATH = a-relative-path
-`, []testLocalStoragePathCase{
-		{loadAttachmentFrom, &Attachment.Storage, "/appdata/attachments"},
-		{loadLFSFrom, &LFS.Storage, "/appdata/lfs"},
-		{loadActionsFrom, &Actions.ArtifactStorage, "/appdata/actions_artifacts"},
-		{loadPackagesFrom, &Packages.Storage, "/appdata/packages"},
-		{loadRepoArchiveFrom, &RepoArchive.Storage, "/appdata/a-relative-path"},
-		{loadActionsFrom, &Actions.LogStorage, "/appdata/actions_log"},
-		{loadAvatarsFrom, &Avatar.Storage, "/appdata/avatars"},
-		{loadRepoAvatarFrom, &RepoAvatar.Storage, "/appdata/repo-avatars"},
-	})
-}
-
-func Test_getStorageInheritStorageTypeLocalPathOverride4(t *testing.T) {
-	testLocalStoragePath(t, "/appdata", `
+`, "/appdata", "/appdata/a-relative-path"},
+		{"PathOverride4", `
 [storage.repo-archive]
 STORAGE_TYPE = local
 PATH = /data/gitea/archives
 
 [repo-archive]
 PATH = /tmp/gitea/archives
-`, []testLocalStoragePathCase{
-		{loadAttachmentFrom, &Attachment.Storage, "/appdata/attachments"},
-		{loadLFSFrom, &LFS.Storage, "/appdata/lfs"},
-		{loadActionsFrom, &Actions.ArtifactStorage, "/appdata/actions_artifacts"},
-		{loadPackagesFrom, &Packages.Storage, "/appdata/packages"},
-		{loadRepoArchiveFrom, &RepoArchive.Storage, "/tmp/gitea/archives"},
-		{loadActionsFrom, &Actions.LogStorage, "/appdata/actions_log"},
-		{loadAvatarsFrom, &Avatar.Storage, "/appdata/avatars"},
-		{loadRepoAvatarFrom, &RepoAvatar.Storage, "/appdata/repo-avatars"},
-	})
-}
-
-func Test_getStorageInheritStorageTypeLocalPathOverride5(t *testing.T) {
-	testLocalStoragePath(t, "/appdata", `
+`, "/appdata", "/tmp/gitea/archives"},
+		{"PathOverride5", `
 [storage.repo-archive]
 STORAGE_TYPE = local
 PATH = /data/gitea/archives
 
 [repo-archive]
-`, []testLocalStoragePathCase{
-		{loadAttachmentFrom, &Attachment.Storage, "/appdata/attachments"},
-		{loadLFSFrom, &LFS.Storage, "/appdata/lfs"},
-		{loadActionsFrom, &Actions.ArtifactStorage, "/appdata/actions_artifacts"},
-		{loadPackagesFrom, &Packages.Storage, "/appdata/packages"},
-		{loadRepoArchiveFrom, &RepoArchive.Storage, "/data/gitea/archives"},
-		{loadActionsFrom, &Actions.LogStorage, "/appdata/actions_log"},
-		{loadAvatarsFrom, &Avatar.Storage, "/appdata/avatars"},
-		{loadRepoAvatarFrom, &RepoAvatar.Storage, "/appdata/repo-avatars"},
-	})
+`, "/appdata", "/data/gitea/archives"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			testLocalStoragePath(t, "/appdata", tc.ini, []testLocalStoragePathCase{
+				{loadAttachmentFrom, &Attachment.Storage, tc.basePath + "/attachments"},
+				{loadLFSFrom, &LFS.Storage, tc.basePath + "/lfs"},
+				{loadActionsFrom, &Actions.ArtifactStorage, tc.basePath + "/actions_artifacts"},
+				{loadPackagesFrom, &Packages.Storage, tc.basePath + "/packages"},
+				{loadRepoArchiveFrom, &RepoArchive.Storage, tc.archivePath},
+				{loadActionsFrom, &Actions.LogStorage, tc.basePath + "/actions_log"},
+				{loadAvatarsFrom, &Avatar.Storage, tc.basePath + "/avatars"},
+				{loadRepoAvatarFrom, &RepoAvatar.Storage, tc.basePath + "/repo-avatars"},
+			})
+		})
+	}
 }
 
 func Test_getStorageInheritStorageTypeLocalPathOverride72(t *testing.T) {